class Aws::Xml::Parser

def decode_string(value)
  case value['encoding']
  when 'base64' then Base64.decode64(value['__content__'])
  else value['__content__']
  end
end

def flat?(shape)
  !!shape.metadata('flattened')
end

def initialize(shape)
  @shape = shape
end

def list(list, values)
  unless flat?(list)
    values = values[list.member.location_name || 'member']
  end
  values = [values] unless values.is_a?(Array)
  values.collect { |value| parse_shape(list.member, value) }
end

def map(map, entries)
  data = {}
  entries = entries['entry'] unless flat?(map)
  entries = [entries] unless entries.is_a?(Array)
  entries.each do |entry|
    key = entry[map.key.location_name || 'key']
    value = entry[map.value.location_name || 'value']
    data[parse_shape(map.key, key)] = parse_shape(map.value, value)
  end
  data
end

def member_key(shape)
  if Seahorse::Model::Shapes::List === shape && flat?(shape)
    shape.member.location_name || shape.location_name
  else
    shape.location_name
  end
end

def parse(xml, target = nil, &block)
  xml = MultiXml.parse(xml).values.first || {}
  yield(xml) if block_given?
  structure(@shape, xml, target)
end

def parse_shape(shape, value)
  if value.nil?
    case shape
    when Seahorse::Model::Shapes::Structure then structure(shape, {})
    when Seahorse::Model::Shapes::Map then {}
    when Seahorse::Model::Shapes::List then []
    when Seahorse::Model::Shapes::String then ''
    else nil
    end
  else
    case shape
    when Seahorse::Model::Shapes::String then string(shape, value)
    when Seahorse::Model::Shapes::Structure then structure(shape, value)
    when Seahorse::Model::Shapes::List then list(shape, value)
    when Seahorse::Model::Shapes::Map then map(shape, value)
    when Seahorse::Model::Shapes::Boolean then value == 'true'
    when Seahorse::Model::Shapes::Integer then value.to_i
    when Seahorse::Model::Shapes::Float then value.to_f
    when Seahorse::Model::Shapes::Timestamp then timestamp(value)
    when Seahorse::Model::Shapes::Blob then Base64.decode64(value)
    else
      raise "unhandled shape type: `#{shape.type}'"
    end
  end
end

def string(shape, value)
  if value.is_a?(Hash)
    decode_string(value)
  else
    value
  end
end

def structure(structure, values, target = nil)
  target = Structure.new(structure.member_names) if target.nil?
  structure.members.each do |member_name, member_shape|
    value_key = member_key(member_shape) || member_name.to_s
    if values.key?(value_key)
      target[member_name] = parse_shape(member_shape, values[value_key])
    elsif member_shape.is_a?(Seahorse::Model::Shapes::List)
      target[member_name] = DefaultList.new
    end
  end
  target
end

def timestamp(value)
  case value
  when nil then nil
  when /^\d+$/ then Time.at(value.to_i)
  else
    begin
      Time.parse(value)
    rescue ArgumentError
      raise "unhandled timestamp format `#{value}'"
    end
  end
end