defmodule Zig.Nif.Basic do
  @moduledoc """
  Architecture:

  Synchronous has two different cases.  The first case is that the nif can be called
  directly.  In this case, the function is mapped directly to function name.  In the
  case that the nif needs marshalling, the function is mapped to `marshalled-<nifname>`.
  and the called function contains wrapping logic.

  To understand wrapping logic, see `Zig.Nif.Marshaller`
  """

  alias Zig.ErrorProng
  alias Zig.Nif
  alias Zig.Nif.DirtyCpu
  alias Zig.Nif.DirtyIo
  alias Zig.Nif.Synchronous
  alias Zig.Type

  import Zig.QuoteErl

  # marshalling setup

  defp needs_marshal?(nif) do
    Enum.any?(nif.type.params, &Type.marshals_param?/1) or
      Type.marshals_return?(nif.type.return) or
      error_prongs(nif) !== []
  end

  defp error_prongs(nif) do
    nif.type.params
    |> Enum.map(&Type.error_prongs(&1, :argument))
    |> List.insert_at(0, Type.error_prongs(nif.type.return, :return))
    |> List.flatten()
  end

  defp marshal_name(nif), do: :"marshalled-#{nif.type.name}"

  def entrypoint(nif) do
    if needs_marshal?(nif), do: marshal_name(nif), else: nif.type.name
  end

  def render_elixir(%{type: type} = nif) do
    {empty_params, used_params} =
      case type.arity do
        0 ->
          {[], []}

        n ->
          1..n
          |> Enum.map(&{{:"_arg#{&1}", [], Elixir}, {:"arg#{&1}", [], Elixir}})
          |> Enum.unzip()
      end

    error_text = "nif for function #{type.name}/#{type.arity} not bound"

    def_or_defp = if nif.export, do: :def, else: :defp

    if needs_marshal?(nif) do
      render_elixir_marshalled(nif, def_or_defp, empty_params, used_params, error_text)
    else
      quote context: Elixir do
        unquote(def_or_defp)(unquote(type.name)(unquote_splicing(empty_params))) do
          :erlang.nif_error(unquote(error_text))
        end
      end
    end
  end

  defp render_elixir_marshalled(
         %{type: type} = nif,
         def_or_defp,
         empty_params,
         used_params,
         error_text
       ) do
    marshal_name = marshal_name(nif)

    error_prongs =
      nif
      |> error_prongs()
      |> Enum.flat_map(&apply(ErrorProng, &1, [:elixir, []]))

    marshal_params =
      type.params
      |> Enum.zip(used_params)
      |> Enum.with_index()
      |> Enum.flat_map(fn {{param_type, param}, index} ->
        List.wrap(
          if Type.marshals_param?(param_type) do
            Type.marshal_param(param_type, param, index, :elixir)
          end
        )
      end)

    return =
      quote do
        return
      end

    marshal_return =
      if Type.marshals_return?(type.return) do
        Type.marshal_return(type.return, return, :elixir)
      else
        return
      end

    quote do
      unquote(def_or_defp)(unquote(type.name)(unquote_splicing(used_params))) do
        unquote_splicing(marshal_params)
        return = unquote(marshal_name)(unquote_splicing(used_params))
        unquote(marshal_return)
      catch
        unquote(error_prongs)
      end

      defp unquote(marshal_name)(unquote_splicing(empty_params)) do
        :erlang.nif_error(unquote(error_text))
      end
    end
  end

  def render_erlang(%{type: type} = nif) do
    {unused_vars, used_vars} =
      case type.arity do
        0 ->
          {[], []}

        n ->
          1..n
          |> Enum.map(&{{:var, :"_X#{&1}"}, {:var, :"X#{&1}"}})
          |> Enum.unzip()
      end

    error_text = ~c'nif for function #{type.name}/#{type.arity} not bound'

    if needs_marshal?(nif) do
      error_prongs =
        nif
        |> error_prongs()
        |> Enum.flat_map(&apply(ErrorProng, &1, [:erlang, []]))

      {marshalled_vars, marshal_code} =
        type.params
        |> Enum.zip(used_vars)
        |> Enum.map_reduce([], fn {param_type, {:var, var}}, so_far ->
          if Type.marshals_param?(param_type) do
            {{:var, :"#{var}_m"}, [so_far, Type.marshal_param(param_type, var, nil, :erlang)]}
          else
            {{:var, var}, so_far}
          end
        end)

      result_code =
        if Type.marshals_param?(type.return) do
          Type.marshal_return(type.return, :Result, :erlang)
        else
          "Result"
        end

      quote_erl(
        """
        unquote(function_name)(unquote(...used_vars)) ->

          #{marshal_code}

          try unquote(marshal_name)(unquote(...marshalled_vars)) of
            Result ->
              #{result_code}
          catch
            splice_prongs(error_prongs)
          end.

        unquote(marshal_name)(unquote(...unused_vars)) ->
          erlang:nif_error(unquote(error_text)).
        """,
        function_name: type.name,
        used_vars: used_vars,
        unused_vars: unused_vars,
        marshalled_vars: marshalled_vars,
        marshal_name: marshal_name(nif),
        error_text: error_text,
        error_prongs: error_prongs
      )
    else
      quote_erl(
        """
        unquote(function_name)(unquote(...vars)) ->
          erlang:nif_error(unquote(error_text)).
        """,
        function_name: type.name,
        vars: unused_vars,
        error_text: error_text
      )
    end
  end

  require EEx

  basic = Path.join(__DIR__, "../templates/basic.zig.eex")
  EEx.function_from_file(:defp, :basic, basic, [:assigns])

  raw_beam = Path.join(__DIR__, "../templates/raw_beam.zig.eex")
  EEx.function_from_file(:defp, :raw_beam, raw_beam, [:assigns])

  raw_erl_nif = Path.join(__DIR__, "../templates/raw_erl_nif.zig.eex")
  EEx.function_from_file(:defp, :raw_erl_nif, raw_erl_nif, [:assigns])

  def render_zig(%{raw: :beam} = nif), do: raw_beam(nif)

  def render_zig(%{raw: :erl_nif} = nif), do: raw_erl_nif(nif)

  # note a raw "c" function does not need to have any changes made.
  def render_zig(%{raw: :c}), do: ""
  def render_zig(nif), do: basic(nif)

  def context(DirtyCpu), do: :dirty
  def context(DirtyIo), do: :dirty
  def context(Synchronous), do: :synchronous

  def resources(_), do: []

  # TODO: move this to "nif"
  def cleanup_for(nil, param_type, index) do
    type_cleanup(param_type, index)
  end

  def cleanup_for(arg_opts, param_type, index) do
    arg_opts
    |> Enum.at(index)
    |> Keyword.get(:cleanup, true)
    |> if do
      type_cleanup(param_type, index)
    else
      "null,"
    end
  end

  def type_cleanup(param_type, index) do
    if Type.missing_size?(param_type) do
      ".{.size = size#{index}},"
    else
      ".{},"
    end
  end
end