#
# MIT License
#
# Copyright (c) 2021 Matthew Evans
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#

defmodule Curry do
  @moduledoc """

  A simple module to do currying and partial application using Variadic functions
  to start partial evaluation (i.e. no lists needed).

  ## Currying example:

      iex> import Curry

      iex> curry_fun = curry(&Curry.test3/3)
      #Function<0.51120925/1 in Curry.curry/1>

      iex> next_fun = curry_fun.(1)
      #Function<1.51120925/1 in Curry.do_generate_next/3>

      iex> next_fun = next_fun.(77)
      #Function<1.51120925/1 in Curry.do_generate_next/3>

      iex)> next_fun_or_result = next_fun.(10)
      {88, {1, 77, 10}}

      iex> info(curry_fun)
      [
        function: &Curry.test3/3,
        type: "Currying",
        function_arity: 3,
        args_still_needed: 3,
        args_collected: 0
      ]

  ## Partial application example:

      iex> partial_fun = partial(&Curry.test5/5, 1, 2)
      #Function<19.126501267/3 in :erl_eval.expr/5>

      iex> info(partial_fun)
      [
        function: &Curry.test5/5,
        type: "Partial application",
        function_arity: 5,
        args_still_needed: 3,
        args_collected: 2
      ]

      iex> partial_fun.(3, 4, 5)
      {15, {1, 2, 3, 4, 5}}

  """

  import Variadic

  @doc """
  Does currying of the supplied function (capture)

  ## Example:

      iex> curry_fun = curry(&Curry.test3/3)
      #Function<0.82106290/1 in Curry.curry/1>
      iex> curry_fun.(1).(2).(3)
      {6, {1, 2, 3}}

  ## Example:

      iex> curry_fun = Curry.~>(&Curry.test3/3)
      #Function<0.82106290/1 in Curry.curry/1>
      iex> last = curry_fun.(1).(2)
      #Function<1.82106290/1 in Curry.do_generate_next/3>
      iex> last.(3)
      {6, {1, 2, 3}}
  """
  def curry(fun), do:
    fn arg -> do_generate_next(fun, [arg], :curry) end

  @doc false
  def unquote(:~>)(fun), do: curry(fun)

  @doc """
  Does partial application

  ## Example:

      iex> partial_fun = Curry.partial(&Curry.test5/5, 1, 2)
      #Function<19.126501267/3 in :erl_eval.expr/5>
      iex> partial_fun.(3, 4, 5)
      {15, {1, 2, 3, 4, 5}}

  ## Example:

      iex> partial_fun = Curry.~>>(&Curry.test5/5, 1, 2)
      #Function<19.126501267/3 in :erl_eval.expr/5>
      iex> partial_fun.(3, 4, 5)
      {15, {1, 2, 3, 4, 5}}
  """

  def partial(args)

  @doc false
  defv :partial do
    [fun|arguments] = args_to_list(binding())
    do_generate_next(fun, arguments, :partial)
  end

  @doc false
  defv :~>> do
    [fun|arguments] = args_to_list(binding())
    do_generate_next(fun, arguments, :partial)
  end

  @doc """
  Generates the next lambda or the result

  """
  def do_generate_next(fun, args, type) do
    {_, arity} = Function.info(fun, :arity)

    case arity - length(args) do
      0 ->
        Kernel.apply(fun, args)

      val when val > 0 and type == :curry ->
        ## We are currying, return a function that takes a single argument
        fn arg -> do_generate_next(fun, args ++ [arg], type) end

      1 ->
        ## We are doing partial application and need 1 more argument
        fn arg1 -> do_generate_next(fun, args ++ [arg1], type) end

      2 ->
        ## We are doing partial application and need 2 more arguments
        fn arg1, arg2 -> do_generate_next(fun, args ++ [arg1, arg2], type) end

      arity when arity > 0 ->
        ## Still doing partial application, so we don't get a crazy long case statement
        ## we can actually make our own function. A bit slower to make than doing directly, but still pretty fast
        make_lambda(arity, fun, args, type)

      _ ->
        raise(%RuntimeError{message: "Bad arity. Should be #{arity} but got #{length(args)}"})
    end
  end

  @doc """
  Gets information about the lambda/fn

  ## Example:

      iex> Curry.info(partial_fun)
      [
        function: &Curry.test5/5,
        type: "Partial application",
        function_arity: 5,
        args_still_needed: 3,
        args_collected: 2
      ]
  """
  def info(fun) do
    {_, env} = Function.info(fun, :env)
    {_, module} = Function.info(fun, :module)

    {tfun, args, type} = case module do
      Curry ->
        [f|a] = env
        t = Enum.find(a, fn e -> is_atom(e) end)
        a = List.flatten(a) |> Enum.filter(fn e -> not is_atom(e) end)
        {f, a, t}

      _ ->
        [{plist, _, _, _}] = env
        [{_,a}|_] = Enum.filter(plist, fn {_,e} -> is_list(e) end)
        [{_,f}|_] = Enum.filter(plist, fn {_,e} -> is_function(e) end)
        [{_,t}|_] = Enum.filter(plist, fn {_,e} -> is_atom(e) end)
        {f, a, t}
    end

    type = if type == :partial do "Partial application" else "Currying" end

    {_, arity} = Function.info(tfun, :arity)
    args_collected = length(List.flatten(args))

    [
      function: tfun,
      type: type,
      function_arity: arity,
      args_still_needed: arity - args_collected,
      args_collected: args_collected
    ]
  end

  defp make_lambda(arity, fun, args, type) do
    arg_list = for arg <- 1..arity do
      last_arg = if arg != arity do ", " else "" end
      "arg" <> to_string(arg) <> last_arg
    end

    arg_list = List.to_string(arg_list)
    fun_cmd = "fn(" <> arg_list <> ") -> Curry.do_generate_next(fun, args ++ [" <> arg_list <> "], type) end"

    {lambda, _} = Code.eval_string(fun_cmd, fun: fun, args: args, type: type)

    lambda
  end

  ##
  ## Some test functions
  ##
  @doc false
  def test0(), do: :hello

  @doc false
  def test1(a), do: {a * 5, a}

  @doc false
  def test2(a, b), do: {a + b, {a, b}}

  @doc false
  def test3(a, b, c), do: {a + b + c, {a, b, c}}

  @doc false
  def test4(a, b, c, d), do: {a + b + c + d, {a, b, c, d}}

  @doc false
  def test5(a, b, c, d, e), do: {a + b + c + d + e, {a, b, c, d, e}}

end