class Seahorse::Client::ParamConverter

def add(shape_class, value_class, converter = nil, &block)
  @converters[shape_class][value_class] = converter || block
end

def c(shape, value)
  self.class.c(shape.class, value)
end

def c(shape, value)
  if converter = converter_for(shape, value)
    converter.call(value)
  else
    value
  end
end

def convert(params)
  structure(@shape, params)
end

def convert(shape, params)
  new(shape).convert(params)
end

def converter_for(shape_class, value)
  unless @converters[shape_class].key?(value.class)
    @mutex.synchronize {
      unless @converters[shape_class].key?(value.class)
        @converters[shape_class][value.class] = find(shape_class, value)
      end
    }
  end
  @converters[shape_class][value.class]
end

def each_base_class(shape_class, &block)
  shape_class.ancestors.each do |ancestor|
    yield(ancestor) if @converters.key?(ancestor)
  end
end

def find(shape_class, value)
  converter = nil
  each_base_class(shape_class) do |klass|
    @converters[klass].each do |value_class, block|
      if value_class === value
        converter = block
        break
      end
    end
    break if converter
  end
  converter
end

def initialize(shape)
  @shape = shape
end

def list(list, values)
  values = c(list, values)
  if values.is_a?(Array)
    values.map { |v| member(list.member, v) }
  else
    values
  end
end

def map(map, values)
  values = c(map, values)
  if values.is_a?(Hash)
    values.each.with_object({}) do |(key, value), hash|
      hash[member(map.key, key)] = member(map.value, value)
    end
  else
    values
  end
end

def member(shape, value)
  case shape
  when Model::Shapes::Structure then structure(shape, value)
  when Model::Shapes::List then list(shape, value)
  when Model::Shapes::Map then map(shape, value)
  else c(shape, value)
  end
end

def structure(structure, values)
  values = c(structure, values)
  if values.is_a?(Hash)
    values.each do |k, v|
      unless v.nil?
        if structure.member?(k)
          values[k] = member(structure.member(k), v)
        end
      end
    end
  end
  values
end