class AWS::ELB::InstanceCollection

def [] instance_id
  load_balancer = self.load_balancer
  instance = EC2.new(:config => config).instances[instance_id]
  Core::MetaUtils.extend_method(instance, :load_balancer) do
    load_balancer
  end
  Core::MetaUtils.extend_method(instance, :elb_health) do
    health = load_balancer.instances.health(id).first
    health.delete(:instance)
    health
  end
  Core::MetaUtils.extend_method(instance, :remove_from_load_balancer) do
    load_balancer.instances.deregister(self)
  end
  instance
  
end

def _each_item options = {}
  load_balancer.instance_descriptions.each do |instance|
    instance = self[instance.instance_id]
    yield(instance)
  end
end

def deregister *instances
  client.deregister_instances_from_load_balancer(
    :load_balancer_name => load_balancer.name,
    :instances => instance_ids(instances))
  nil
end

def health *instances
  instance_ids = instance_ids(instances)
  opts = {}
  opts[:load_balancer_name] = load_balancer.name
  opts[:instances] = instance_ids unless instance_ids.empty?
  client.describe_instance_health(opts).instance_states.map do |state|
    {
      :instance => self[state.instance_id],
      :description => state.description,
      :state => state.state,
      :reason_code => state.reason_code,
    }
  end
end

def initialize load_balancer, options = {}
  @load_balancer = load_balancer
  super
end

def instance_ids instances
  instances.flatten.collect do |instance|
    case instance
    when EC2::Instance then { :instance_id => instance.id }
    else { :instance_id => instance }
    end
  end
end

def register *instances
  client.register_instances_with_load_balancer(
    :load_balancer_name => load_balancer.name,
    :instances => instance_ids(instances))
  nil
end