class Seahorse::Client::HandlerList

def add(handler_class, options = {})
  @mutex.synchronize do
    add_entry(
      HandlerListEntry.new(options.merge(
        handler_class: handler_class,
        inserted: next_index
      ))
    )
  end
  handler_class
end

def add_entries(entries)
  @mutex.synchronize do
    entries.each { |entry| add_entry(entry) }
  end
end

def add_entry(entry)
  key = entry.step == :send ? :send : entry.object_id
  @entries[key] = entry
end

def copy_from(source_list, &block)
  entries = []
  source_list.entries.each do |entry|
    if block_given?
      entries << entry.copy(inserted: next_index) if yield(entry)
    else
      entries << entry.copy(inserted: next_index)
    end
  end
  add_entries(entries)
end

def each(&block)
  entries.sort.each do |entry|
    yield(entry.handler_class) if entry.operations.nil?
  end
end

def entries
  @mutex.synchronize do
    @entries.values
  end
end

def filter(operation)
  entries.inject([]) do |filtered, entry|
    if entry.operations.nil?
      filtered << entry.copy
    elsif entry.operations.include?(operation)
      filtered << entry.copy(operations: nil)
    end
    filtered
  end
end

def for(operation)
  HandlerList.new(index: @index, entries: filter(operation.to_s))
end

def initialize(options = {})
  @index = options[:index] || 0
  @entries = {}
  @mutex = Mutex.new
  entries = options[:entries] || []
  add_entries(entries) unless entries.empty?
end

def next_index
  @index += 1
end

def remove(handler_class)
  @entries.each do |key, entry|
    @entries.delete(key) if entry.handler_class == handler_class
  end
end

def to_stack
  inject(nil) { |stack, handler| handler.new(stack) }
end