class HTTP::Headers

def ==(other)
  return false unless other.respond_to? :to_a
  @pile == other.to_a
end

def [](name)
  values = get(name)
  case values.count
  when 0 then nil
  when 1 then values.first
  else        values
  end
end

def add(name, value)
  name = normalize_header name.to_s
  Array(value).each { |v| @pile << [name, v.to_s] }
end

def coerce(object)
  unless object.is_a? self
    object = case
             when object.respond_to?(:to_hash) then object.to_hash
             when object.respond_to?(:to_h)    then object.to_h
             when object.respond_to?(:to_a)    then object.to_a
             else raise Error, "Can't coerce #{object.inspect} to Headers"
             end
  end
  headers = new
  object.each { |k, v| headers.add k, v }
  headers
end

def delete(name)
  name = normalize_header name.to_s
  @pile.delete_if { |k, _| k == name }
end

def each
  return to_enum(__method__) unless block_given?
  @pile.each { |arr| yield(arr) }
  self
end

def get(name)
  name = normalize_header name.to_s
  @pile.select { |k, _| k == name }.map { |_, v| v }
end

def initialize
  @pile = []
end

def initialize_copy(orig)
  super
  @pile = to_a
end

def inspect
  "#<#{self.class} #{to_h.inspect}>"
end

def keys
  @pile.map { |k, _| k }.uniq
end

def merge(other)
  dup.tap { |dupped| dupped.merge! other }
end

def merge!(other)
  self.class.coerce(other).to_h.each { |name, values| set name, values }
end

def normalize_header(name)
  return name if name =~ CANONICAL_NAME_RE
  normalized = name.split(/[\-_]/).each(&:capitalize!).join("-")
  return normalized if normalized =~ COMPLIANT_NAME_RE
  raise InvalidHeaderNameError, "Invalid HTTP header field name: #{name.inspect}"
end

def set(name, value)
  delete(name)
  add(name, value)
end

def to_a
  @pile.map { |pair| pair.map(&:dup) }
end

def to_h
  Hash[keys.map { |k| [k, self[k]] }]
end