class Aws::Api::Docs::ParamFormatter

def apply_comments(ref, text)
  lines = text.lines.to_a
  if lines[0].match(/\n$/)
    lines[0] = lines[0].sub(/\n$/, comments(ref) + "\n")
  else
    lines[0] += comments(ref)
  end
  lines.join
end

def comments(ref)
  comments = []
  if ref[:response_target]
    comments << 'where to write response data, file path, or IO object'
  end
  if ref[:streaming]
    comments << 'file/IO object, or string data'
  end
  if ref.required
    comments << 'required'
  end
  if enum = enum_values(ref)
    comments << "accepts #{enum.to_a.join(', ')}"
  end
  if ddb_av?(ref)
    comments << 'value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>'
  end
  comments == [] ? '' : " # #{comments.join(', ')}"
end

def complex?(ref)
  if StructureShape === ref.shape
    !ddb_av?(ref)
  else
    ListShape === ref.shape || MapShape === ref.shape
  end
end

def complex_list(ref, i, visited)
  "[\n#{i}  #{ref_value(ref, i + '  ', visited)},\n#{i}]"
end

def ddb_av?(ref)
  case ref.shape
  when ListShape then ddb_av?(ref.shape.member)
  when StructureShape then ref.shape.name == 'AttributeValue'
  else false
  end
end

def enum_values(ref)
  case ref.shape
  when ListShape then enum_values(ref.shape.member)
  when StringShape then ref.shape.enum
  else nil
  end
end

def format
  if @shape_ref && @shape_ref.shape.member_names.count > 0
    ref_value(@shape_ref, '', [])
  else
    ''
  end
end

def initialize(shape_ref)
  @shape_ref = shape_ref
  @recursive_shapes = compute_recursive_shapes(@shape_ref)
end

def list(ref, i, visited)
  if complex?(ref.shape.member)
    complex_list(ref.shape.member, i, visited)
  else
    scalar_list(ref.shape.member, i, visited)
  end
end

def map(ref, i, visited)
  key = string(ref.shape.key)
  value = ref_value(ref.shape.value, i + '  ', visited)
  "{\n#{i}  #{key} => #{value},#{comments(ref.shape.value)}\n#{i}}"
end

def recursive?(ref)
  @recursive_shapes.include?(ref.shape)
end

def ref_value(ref, i, visited)
  if visited.include?(ref.shape)
    return "{\n#{i}  # recursive #{ref.shape.name}\n#{i}}"
  else
    visited  = visited + [ref.shape]
  end
  case ref.shape
  when StructureShape
    if ref.shape.name == 'AttributeValue'
      '"value"'
    else
      struct(ref, i, visited)
    end
  when BlobShape
    if ref[:response_target]
      '"/path/to/file"'
    elsif ref[:streaming]
      'source_file'
    else
      '"data"'
    end
  when ListShape then list(ref, i, visited)
  when MapShape then map(ref, i, visited)
  when BooleanShape then "false"
  when IntegerShape then '1'
  when FloatShape then '1.0'
  when StringShape then string(ref)
  when TimestampShape then 'Time.now'
  else raise "unsupported shape #{ref.shape.class.name}"
  end
end

def scalar_list(ref, i, visited)
  "[#{ref_value(ref, i, visited)}]"
end

def string(ref)
  if ref.shape.enum
    ref.shape.enum.first.inspect
  elsif ref.shape.name
    ref.shape.name.inspect
  else
    '"string"'
  end
end

def struct(ref, i, visited)
  lines = ['{']
  ref.shape.members.each do |member_name, member_ref|
    lines << struct_member(member_name, member_ref, i, visited)
  end
  lines << "#{i}}"
  lines.join("\n")
end

def struct_member(member_name, member_ref, i, visited)
  entry = "#{i}  #{member_name}: #{ref_value(member_ref, i + '  ', visited)},"
  apply_comments(member_ref, entry)
end