require "json"
require "markdown"
require "optparse"

def parse_type(rs_type)
  if rs_type.has_key?("primitive")
    return parse_primitive_type(rs_type["primitive"])
  elsif rs_type.has_key?("generic")
    return parse_generic_type(rs_type["generic"])
  elsif rs_type.has_key?("tuple")
    return parse_tuple_type(rs_type["tuple"])
  elsif rs_type.has_key?("array")
    return parse_array_type(rs_type["array"])
  elsif rs_type.has_key?("dyn_trait")
    return parse_array_type(rs_type["dyn_trait"])
  elsif rs_type.has_key?("raw_pointer")
    return parse_array_type(rs_type["raw_pointer"])
  elsif rs_type.has_key?("slice")
    return parse_slice_type(rs_type["slice"])
  elsif rs_type.has_key?("synthetic")
    return parse_synthetic_type(rs_type["synthetic"])
  elsif rs_type.has_key?("borrowed_ref")
    return parse_borrowed_ref_type(rs_type["borrowed_ref"])
  elsif rs_type.has_key?("bounds")
    return parse_bounds_type(rs_type["bounds"])
  elsif rs_type.has_key?("resolved_path")
    return parse_resolved_path_type(rs_type["resolved_path"])
  elsif rs_type.has_key?("qualified_path")
    return parse_qualified_path_type(rs_type["qualified_path"])
  else
    warn "Error parsing type: Unknown type kind"
    exit 1
  end
end

def parse_bounds(bounds)
  outlives_parsed = parse_trail_outlives(bouds.fetch('outlives', nil))
  trait_parsed = parse_bound_trait(bounds.fetch('trait_bound', nil))

  return { :outlives => outlives_parsed, :trait => trait_parsed }
end

def parse_function_decl(fn_decl)
  params_parsed = parse_function_params(fn_decl['inputs'])
  output_parsed = parse_type(fn_decl['output'])

  return {
    :params => params_parsed,
    :output => output_parsed,
    :is_variadic? => fn_decl['c_variadic']
  }
end

def parse_generic_param(param)
  param_name = param['name']
  param_kind = parse_generic_param_kind(param['kind'])

  return { :name => param_name, :kind => param_kind }
end

def parse_generics(fn_generics)
  params_parsed = parse_generic_params(fn_generics['params'])
  preds_parsed = parse_generic_predicates(fn_generics['where_predicates'])

  return { :params => params_parsed, :preds => preds_parsed }
end

def parse_function_headers(headers)
  return {
           :abi => headers['abi'],
           :asyn? => headers['async'],
           :const? => headers['const'],
           :unsafe? => headers['unsafe']
         }
end

def parse_function(function)
  decl = parse_function_decl(function['decl'])
  generics = parse_generics(function['generics'])
  headers = parse_function_headers(function['headers'])

  return { :decl => decl, :generics => generics, :headers => headers, :has_body? => function['has_body'] }
end


def parse_assoc_const(assoc_const)
  const_default_value = assoc_const["default"]
  const_default_type = parse_type(assoc_const["type"])

  return { :default_value => const_default_value, :default_type => const_default_type }
end

def parse_assoc_type(assoc_type)
  type_generics


def parse_constant(constant)
  const_type = parse_type(constant['type'])
  const_expr = constant['expr']
  const_value = constant['value']

  return {
    :type => const_type,
    :expr => const_expr,
    :value = >const_value,
    :is_literal? => constant['is_literal']
  }
end

def parse_enum(enum)
  parsed_generics = parse_generics(enum['generics'])
  parsed_impls = seek_items(enum['impls'])
  parsed_variants = seek_items(enum['variants'])

  return {
    :generics => parsed_generics,
    :impls => parsed_impls,
    :variants => parsed_variants,
    :variants_are_sripped? => enum['variants_stripped']
  }
end

def parse_impl(impl)
  parsed_generics = parse_generics(impl.fetch('generics', nil))
  parsed_for = parse_impl_for(impl.fetch('for', nil))
  parsed_items = parse_impl_items(impl.fetch('items', nil))
  parsed_methods = parse_impl_methods(impl.fetch('provided_trait_methods', nil))
  parsed_trait = parse_traits(impl.fetch('trait', nil))

  return {
    :generics => parsed_generics,
    :for => parsed_for,
    :items => parsed_items,
    :methods => parsed_items,
    :trait => parsed_traits,
    :is_unsafe? => impl['is_unsafe'],
    :negative? => impl['negative'],
    :synthetic => impl['synthetic'],
  }
end

def parse_macro(macro)
  return { :macro_lit => macro }
end

def parse_module(mod)
  items = seek_items(mod['itmes'])

  return {
    :items => items,
    :is_crate? => mod['is_crate'],
    :is_stripped? => mod['is_stripped'],
  }
end

def parse_struct(struct)
  fields_parsed = seek_items(struct['fields'])
  generics_parsed = parse_generics(struct.fetch('generics', nil))
  impls_parsed = seek_items(struct.fetch('impls', nil))

  return {
    :fields => fields_parsed,
    :generics => generics_parsed,
    :impls => impls_parsed,
  }
end

def parse_trait(trait)
  args_parsed = parse_trait_args(trait['args'])
  bounds_parsed = parse_trait_bounds(trait['bounds'])
  generics_parsed = parse_trait_generics(trait['generics'])
  items_parsed = parse_trait_items(traint['items'])
end

def make_manpages(obj)
  obj.each do |key, value|
    if value['inner'].has_key?('function')
      parse_function_decl(value['inner']['function']['decl'])
    end
  end
end




def read_json_file(path)
  return JSON.parse(File.read(path))
end

def main()
  options = {}

  OptionParser.new do |parser|
    parser.banner = "Usage: mk_rustman.rb [options] JSON_FILE"

      parser.on("-s", "--structure", "Dump the structure of the JSON file") do |name|
      options[:structure] = name
    end

    parser.on("-h", "--help", "Show this help message") do
      warn parser
      exit 1
    end
  end.parse!

  if ARGV.empty?
    warn "You must pass a JSON file"
    exit 1
  end

  json_file = ARGV[0]
  object = read_json_file(json_file)

  if options[:structure]
    print_structure_and_types(object)
    exit
  else
    if object.has_key?("index")
      make_manpages(object["index"])
    end
  end
end