class Outfit < ApplicationRecord
  has_many :item_outfit_relationships, :dependent => :destroy
  has_many :worn_item_outfit_relationships, -> { where(is_worn: true) },
    class_name: 'ItemOutfitRelationship'
  has_many :worn_items, through: :worn_item_outfit_relationships, source: :item

  belongs_to :alt_style, optional: true
  belongs_to :pet_state, optional: true # We validate presence below!
  belongs_to :user, optional: true

  validates :name, :presence => {:if => :user_id}, :uniqueness => {:scope => :user_id, :if => :user_id}
  validates :pet_state, presence: {
    message: ->(object, _) do
      if object.biology
        "does not exist for " +
          "species ##{object.biology[:species_id]}, " +
          "color ##{object.biology[:color_id]}, " +
          "pose #{object.biology[:pose]}"
      else
        "must exist"
      end
    end
  }

  before_validation :ensure_unique_name, if: :user_id?

  attr_reader :biology
  delegate :color, to: :pet_state

  scope :wardrobe_order, -> { order('starred DESC', :name) }
  
  class OutfitImage
    def initialize(image_versions)
      @image_versions = image_versions  
    end

    def url
      @image_versions[:large]
    end
    
    def large
      Version.new(@image_versions[:large])
    end
    
    def medium
      Version.new(@image_versions[:medium])
    end
    
    def small
      Version.new(@image_versions[:small])
    end
    
    Version = Struct.new(:url)
  end
  
  def image?
    true
  end
  
  def image
    OutfitImage.new(image_versions)
  end
  
  IMAGE_URL_TEMPLATE = Addressable::Template.new(
    Rails.configuration.impress_2020_origin + 
    "/api/outfitImage{?id,size,updatedAt}"
  )
  def image_versions
    if Rails.env.production?
      # Now, instead of using the saved outfit to S3, we're using out the
      # DTI 2020 API + CDN cache version. We use openneo-assets.net to get
      # around a bug on Neopets petpages with openneo.net URLs.
      base_url = "https://outfits.openneo-assets.net/outfits" +
        "/#{CGI.escape id.to_s}" +
        "/v/#{CGI.escape updated_at.to_i.to_s}"
      {
        large: "#{base_url}/600.png",
        medium: "#{base_url}/300.png",
        small: "#{base_url}/150.png",
      }
    else
      # In development, just talk to our local Impress 2020 directly.
      build_url = -> size {
        IMAGE_URL_TEMPLATE.expand(
          id: id, size: size, updatedAt: updated_at.to_i
        ).to_s
      }
      {
        large: build_url.call("600"),
        medium: build_url.call("300"),
        small: build_url.call("150"),
      }
    end

    # NOTE: Below is the previous code that uses the saved outfits!
    # {}.tap do |versions|
    #   versions[:large] = image.url
    #   image.versions.each { |name, version| versions[name] = version.url }
    # end
  end
  
  def as_json(more_options={})
    serializable_hash(
      only: [:id, :name, :pet_state_id, :starred, :created_at, :updated_at,
        :alt_style_id],
      methods: [:color_id, :species_id, :pose, :item_ids, :user]
    )
  end

  def color_id
    pet_state.pet_type.color_id
  end

  def species_id
    pet_state.pet_type.species_id
  end

  def pose
    pet_state.pose
  end

  def biology=(biology)
    @biology = biology.slice(:species_id, :color_id, :pose, :pet_state_id)

    begin
      if @biology[:pet_state_id]
        self.pet_state = PetState.find(@biology[:pet_state_id])
      else
        pet_type = PetType.where(
          species_id: @biology[:species_id],
          color_id: @biology[:color_id],
        ).first!
        self.pet_state = pet_type.pet_states.with_pose(@biology[:pose]).
          emotion_order.first!
      end
    rescue ActiveRecord::RecordNotFound
      # If there's no such pet state (which shouldn't happen normally in-app),
      # we don't set `pet_state` but we keep `@biology` for validation.
    end
  end

  def item_ids
    rels = item_outfit_relationships
    {
      worn: rels.filter { |r| r.is_worn? }.map { |r| r.item_id },
      closeted: rels.filter { |r| !r.is_worn? }.map { |r| r.item_id }
    }
  end

  def item_ids=(item_ids)
    # Ensure there are no duplicates between the worn/closeted IDs. If an ID is
    # present in both, it's kept in `worn` and removed from `closeted`.
    worn_item_ids = item_ids.fetch(:worn, []).uniq
    closeted_item_ids = item_ids.fetch(:closeted, []).uniq
    closeted_item_ids.reject! { |id| worn_item_ids.include?(id) }

    # Set the worn and closeted item outfit relationships. If there are any
    # others attached to this outfit, they are implicitly deleted.
    new_relationships = []
    new_relationships += worn_item_ids.map do |item_id|
      ItemOutfitRelationship.new(item_id: item_id, is_worn: true)
    end
    new_relationships += closeted_item_ids.map do |item_id|
      ItemOutfitRelationship.new(item_id: item_id, is_worn: false)
    end
    self.item_outfit_relationships = new_relationships
  end

  def ensure_unique_name
    # If no name was provided, start with "Untitled outfit".
    self.name = "Untitled outfit" if name.blank?

    # Strip whitespace from the name.
    self.name.strip!

    # Get the base name of the provided name, without any "(1)" suffixes.
    base_name = name.sub(/\s*\([0-9]+\)$/, '')

    # Find the user's other outfits that start with the same base name, and get
    # *their* names, with whitespace stripped.
    existing_outfits = self.user.outfits.
      where("name LIKE ?", Outfit.sanitize_sql_like(base_name) + "%")
    existing_outfits = existing_outfits.where("id != ?", id) unless id.nil?
    existing_names = existing_outfits.map(&:name).map(&:strip)

    # Try the provided name first, but if it's taken, add a "(1)" suffix and
    # keep incrementing it until it's not.
    i = 1
    while existing_names.include?(name)
      self.name = "#{base_name} (#{i})"
      i += 1
    end
  end
end