#===============================================================================
# Core Inventory - Instance Items patch
# 
# This script allows you to use the Core Inventory script with instance items.
# The order of the scripts should be
#
#    Instance Items
#    Core Inventory
#       Instance Items Patch
#===============================================================================
$imported = {} if $imported.nil?
$imported[:TH_CoreInventory_InstanceItemPatch] = true
class Game_Inventory
  
  alias :th_instance_items_init_all_items :init_all_items
  def init_all_items
    p  'init'
    th_instance_items_init_all_items
    @item_list = []
    @weapon_list = []
    @armor_list = []
  end
  
  #-----------------------------------------------------------------------------
  # Overwrite. We already keep a list of weapons
  #-----------------------------------------------------------------------------
  alias :th_instance_items_weapons :weapons
  def weapons
    TH::Instance_Items::Enable_Weapons ? @weapon_list : th_instance_items_weapons
  end
  
  #-----------------------------------------------------------------------------
  # Overwrite.
  #-----------------------------------------------------------------------------
  alias :th_instance_items_items :items
  def items
    TH::Instance_Items::Enable_Items ? @item_list : th_instance_items_items
  end

  #-----------------------------------------------------------------------------
  # Overwrite.
  #-----------------------------------------------------------------------------
  alias :th_instance_items_armors :armors
  def armors
    TH::Instance_Items::Enable_Armors ? @armor_list : th_instance_items_armors
  end
  
  #-----------------------------------------------------------------------------
  # Returns true if the item type supports instances
  #-----------------------------------------------------------------------------
  def instance_enabled?(item)
    return InstanceManager.instance_enabled?(item)
  end
  
  #-----------------------------------------------------------------------------
  # Returns an instance for the given item. If it is already an instance, then
  # we just return that. If it's a template, we create a new instance.
  #-----------------------------------------------------------------------------
  def get_instance(item)
    return InstanceManager.get_instance(item)
  end
  
  #-----------------------------------------------------------------------------
  # Returns the template for the given item
  #-----------------------------------------------------------------------------
  def get_template(item)
    return InstanceManager.get_template(item)
  end
  
  #-----------------------------------------------------------------------------
  # The gain item method performs various checks on the item that you want to
  # add to the inventory. Namely, it checks whether it is a template item or
  # an instance item, updates the item counts, and so on.
  #-----------------------------------------------------------------------------
  alias :th_instance_items_gain_item :gain_item
  def gain_item(item, amount, include_equip = false)
    # special check for normal items
    if !instance_enabled?(item)
      th_instance_items_gain_item(item, amount, include_equip)
    else
      if item
        if amount > 0
          amount.times do |i|
            new_item = get_instance(item)
            add_instance_item(new_item)
          end
        else
          amount.abs.times do |i|
            item_template = get_template(item)
            if item.is_template?
              # remove using template rules. If an item was lost, then decrease
              # template count by 1.
              lose_template_item(item, include_equip)
            else
              # remove the instance item, and decrease template count by 1
              lose_instance_item(item)
            end
          end
        end
      else
        th_instance_items_gain_item(item, amount, include_equip)
      end
    end
  end
  
  #-----------------------------------------------------------------------------
  # New. Returns the appropriate container list
  #-----------------------------------------------------------------------------
  def item_container_list(item)
    return @item_list if item.is_a?(RPG::Item)
    return @weapon_list if item.is_a?(RPG::Weapon)
    return @armor_list if item.is_a?(RPG::Armor)
  end
  
  #-----------------------------------------------------------------------------
  # New. Adds the instance item to the appropriate list
  #-----------------------------------------------------------------------------
  def add_instance_item(item)
    container = item_container(item.class)
    container[item.template_id] ||= 0
    container[item.template_id] += 1
    container[item.id] = 1
    container_list = item_container_list(item)
    container_list.push(item)
  end
  
  #-----------------------------------------------------------------------------
  # New. Returns an instance item that matches the template. If it doesn't
  # exist, returns nil
  #-----------------------------------------------------------------------------
  def find_instance_item(template_item)
    container_list = item_container_list(template_item)
    p @weapon_list
    return container_list.find {|obj| obj.template_id == template_item.template_id }
  end
  
  #-----------------------------------------------------------------------------
  # New. Lose an instance item. Simply delete it from the appropriate container
  # list
  #-----------------------------------------------------------------------------
  def lose_instance_item(item)
    container = item_container(item.class)
    container[item.template_id] ||= 0
    container[item.template_id] -= 1
    container[item.id] = 0
    container_list = item_container_list(item)
    container_list.delete(item)
  end
  
  #-----------------------------------------------------------------------------
  # New. Lose a template item. This looks for a
  #-----------------------------------------------------------------------------
  def lose_template_item(item, include_equip)
    container_list = item_container_list(item)
    item_lost = container_list.find {|obj| obj.template_id == item.template_id }
    if item_lost
      container = item_container(item.class)
      container[item.template_id] ||= 0
      container[item.template_id] -= 1
      container_list.delete(item_lost)
    elsif include_equip
      discard_members_template_equip(item, 1)
    end
    return item_lost
  end

  #-----------------------------------------------------------------------------
  # New. Same as discarding equips, except we follow template discard rules
  #-----------------------------------------------------------------------------  
end

class Game_PartyInventory < Game_Inventory
  alias :th_core_inventory_patch_instance_items_gain_item :gain_item
  def gain_item(item, amount, include_equip = false)
    # special check for normal items
    if !instance_enabled?(item)
      th_core_inventory_patch_instance_items_gain_item(item, amount, include_equip)
    else
      if item
        if amount > 0
          amount.times do |i|
            new_item = get_instance(item)
            add_instance_item(new_item)
          end
        else
          amount.abs.times do |i|
            item_template = get_template(item)
            if item.is_template?
              # remove using template rules. If an item was lost, then decrease
              # template count by 1.
              lose_template_item(item, include_equip)
            else
              # remove the instance item, and decrease template count by 1
              lose_instance_item(item)
            end
          end
        end
      else
        th_core_inventory_patch_instance_items_gain_item(item, amount, include_equip)
      end
    end
  end
  
  def discard_members_template_equip(item, amount)
    n = amount
    $game_party.members.each do |actor|
      item = actor.equips.find {|obj| obj && obj.template_id == item.template_id }
      while n > 0 && item
        actor.discard_equip(item)
        n -= 1
      end
    end
  end
end

class Game_Party < Game_Unit
  def find_instance_item(*args)
    @inventory.find_instance_item(*args)
  end
  
  def lose_instance_item(*args)
    @inventory.lose_instance_item(*args)
  end
  
  def lose_template_item(*args)
    @inventory.lose_template_item(*args)
  end
  
  def discard_members_template_equip(*args)
    @inventory.discard_members_template_equip(*args)
  end
end