impress/app/models/outfit.rb

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 :pose, to: :pet_state
  delegate :pet_type, to: :pet_state
  delegate :color, to: :pet_type
  delegate :color_id, to: :pet_type
  delegate :species, to: :pet_type
  delegate :species_id, to: :pet_type

  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 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 item_appearances(...)
    Item.appearances_for(worn_items, pet_type, ...).values
  end

  def visible_layers
    item_appearances = item_appearances(swf_asset_includes: [:zone])

    pet_layers = pet_state.swf_assets.includes(:zone).to_a
    item_layers = item_appearances.map(&:swf_assets).flatten

    pet_restricted_zone_ids = pet_layers.map(&:restricted_zone_ids).
      flatten.to_set
    item_restricted_zone_ids = item_appearances.
      map(&:restricted_zone_ids).flatten.to_set

    # When an item restricts a zone, it hides pet layers of the same zone.
    # We use this to e.g. make a hat hide a hair ruff.
    #
    # NOTE: Items' restricted layers also affect what items you can wear at
    #       the same time. We don't enforce anything about that here, and
    #       instead assume that the input by this point is valid!
    pet_layers.reject! { |sa| item_restricted_zone_ids.include?(sa.zone_id) }

    # When a pet appearance restricts a zone, or when the pet is Unconverted,
    # it makes body-specific items incompatible. We use this to disallow UCs
    # from wearing certain body-specific Biology Effects, Statics, etc, while
    # still allowing non-body-specific items in those zones! (I think this
    # happens for some Invisible pet stuff, too?)
    #
    # TODO: We shouldn't be *hiding* these zones, like we do with items; we
    #       should be doing this way earlier, to prevent the item from even
    #       showing up even in search results!
    #
    # NOTE: This can result in both pet layers and items occupying the same
    #       zone, like Static, so long as the item isn't body-specific! That's
    #       correct, and the item layer should be on top! (Here, we implement
    #       it by placing item layers second in the list, and rely on JS sort
    #       stability, and *then* rely on the UI to respect that ordering when
    #       rendering them by depth. Not great! 😅)
    #
    # NOTE: We used to also include the pet appearance's *occupied* zones in
    #       this condition, not just the restricted zones, as a sensible
    #       defensive default, even though we weren't aware of any relevant
    #       items. But now we know that actually the "Bruce Brucey B Mouth"
    #       occupies the real Mouth zone, and still should be visible and
    #       above pet layers! So, we now only check *restricted* zones.
    #
    # NOTE: UCs used to implement their restrictions by listing specific
    #       zones, but it seems that the logic has changed to just be about
    #       UC-ness and body-specific-ness, and not necessarily involve the
    #       set of restricted zones at all. (This matters because e.g. UCs
    #       shouldn't show _any_ part of the Rainy Day Umbrella, but most UCs
    #       don't restrict Right-Hand Item (Zone 49).) Still, I'm keeping the
    #       zone restriction case running too, because I don't think it
    #       _hurts_ anything, and I'm not confident enough in this conclusion.
    #
    # TODO: Do Invisibles follow this new rule like UCs, too? Or do they still
    #       use zone restrictions?
    if pet_state.pose === "UNCONVERTED"
      item_layers.reject! { |sa| sa.body_specific? }
    else
      item_layers.reject! { |sa| sa.body_specific? &&
        pet_restricted_zone_ids.include?(sa.zone_id) }
    end

    # A pet appearance can also restrict its own zones. The Wraith Uni is an
    # interesting example: it has a horn, but its zone restrictions hide it!
    pet_layers.reject! { |sa| pet_restricted_zone_ids.include?(sa.zone_id) }

    (pet_layers + item_layers).sort_by(&:depth)
  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]+\)\z/, '')

    # 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