zigler

defmodule Zig.Parser.Imports do
  @moduledoc """
  For parsing, looking for imports, cimports, and usingnamespace directives.

  To be completed later
  """

  import NimbleParsec

  defstruct imports: [], identifier: nil, pub: false

  @typep identifier_t :: :usingnamespace | String.t
  @type t :: %__MODULE__{
    imports: [{identifier_t, Path.t} | {:pub, identifier_t, Path.t}],
    identifier: atom,
    pub: boolean
  }

  # designed to ninja in this struct as necessary.
  @type line_info :: {non_neg_integer, non_neg_integer}
  @type parsec_retval :: {[String.t], t}
  initialize = post_traverse(empty(), :initializer)
  @spec initializer(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval
  defp initializer(_, _, context, _, _), do: {[], struct(__MODULE__, context)}

  whitespace = ascii_string([?\s, ?\n], min: 1)
  filename = ascii_string([not: ?"], min: 1)
  identifier = ascii_char([?a..?z, ?A..?Z, ?_])
  |> optional(ascii_string([?a..?z, ?A..?Z, ?0..?9, ?_], min: 1))
  |> reduce({IO, :iodata_to_binary, []})

  usingnamespace = optional(
    string("pub")
    |> concat(ignore(whitespace)))
  |> string("usingnamespace")
  |> ignore(whitespace)

  import_const = optional(
    string("pub")
    |> concat(ignore(whitespace)))
  |> ignore(
    string("const")
    |> concat(whitespace))
  |> concat(identifier)
  |> ignore(
    optional(whitespace)
    |> string("=")
    |> optional(whitespace))

  prefix = choice(
    [usingnamespace, import_const])
  |> post_traverse(:register_identifier)

  import_stmt =
    prefix
    |> ignore(
      string("@import")
      |> optional(whitespace)
      |> string("(")
      |> optional(whitespace)
      |> string("\""))
    |> concat(filename)
    |> ignore(
      string("\"")
      |> optional(whitespace)
      |> string(")"))
    |> post_traverse(:register_import)

  include_stmt =
    ignore(
      string("@cInclude")
      |> optional(whitespace)
      |> string("(")
      |> optional(whitespace)
      |> string("\""))
    |> concat(filename)
    |> ignore(
      string("\"")
      |> optional(whitespace)
      |> string(")"))
    |> post_traverse(:register_include)

  defp register_identifier(_rest, ["usingnamespace" | rest], context, _, _) do
    {[], %{context | identifier: :usingnamespace, pub: pub?(rest)}}
  end
  defp register_identifier(_rest, [identifier | rest], context, _, _) do
    {[], %{context | identifier: identifier, pub: pub?(rest)}}
  end

  defp pub?([]), do: false
  defp pub?(["pub"]), do: true

  defp register_import(_rest, [path], context, _, _) do
    {[],
    %{context |
      imports: [make_identifier(path, context) | context.imports],
      identifier: nil,
      pub: false}}
  end

  defp make_identifier(path, context) do
    if context.pub do
      {:pub, context.identifier, path}
    else
      {context.identifier, path}
    end
  end

  defp register_include(_rest, [path], context, _, _) do
    {[], %{context | imports: [{:cinclude, path} | context.imports]}}
  end

  if Mix.env == :test do
    defparsec :parse_import_const, concat(initialize, import_const)
    defparsec :parse_import_stmt, concat(initialize, import_stmt)
    defparsec :parse_include_stmt, concat(initialize, include_stmt)
  end

  parse_imports =
    initialize
    |> repeat(choice([
      import_stmt,
      include_stmt,
      ascii_char([0..255])
    ]))

  defparsec :parse_imports, parse_imports

  def parse(code) do
    {:ok, _, _, %Zig.Parser.Imports{imports: imports}, _, _} = parse_imports(code)
    imports
  end

end