class Aws::ParamConverter

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

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

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

def close_opened_files
  @opened_files.each(&:close)
  @opened_files = []
end

def convert(params)
  if @rules
    structure(@rules, params)
  else
    params
  end
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 ensure_open(file, converter)
  if file.closed?
    new_file = File.open(file.path, 'rb')
    converter.opened_files << new_file
    new_file
  else
    file
  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(rules)
  @rules = rules
  @opened_files = []
end

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

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

def member(ref, value)
  case ref.shape
  when StructureShape then structure(ref, value)
  when ListShape then list(ref, value)
  when MapShape then map(ref, value)
  else c(ref, value)
  end
end

def structure(ref, values)
  values = c(ref, values)
  if Struct === values || Hash === values
    values.each_pair do |k, v|
      unless v.nil?
        if ref.shape.member?(k)
          values[k] = member(ref.shape.member(k), v)
        end
      end
    end
  end
  values
end