defmodule Formula do
  @moduledoc """
  Documentation for `Formula`.
  """
  alias Formula.Errors.InvalidFormulaError
  alias Formula.Evaluator
  alias Formula.Lexer

  @doc """
  Evaluate the formula given the data
  """
  @spec evaluate(map(), String.t()) :: term()
  def evaluate(data, formula) when is_binary(formula) do
    data
    |> Map.merge(%{"result" => "=" <> formula})
    |> evaluate()
    |> Map.get("result")
  end

  def evaluate(_data, _formula) do
    {:error, InvalidFormulaError.exception(message: "formula must be a string")}
  end

  @doc """
  Evaluate a given map that contains function
  """
  @spec evaluate(map()) :: map()
  def evaluate(data) do
    case parse(data) do
      {:error, error} -> {:error, error}
      parsed_data -> Evaluator.evaluate(parsed_data)
    end
  end

  @doc """
  Parse a given map into functions and symbols
  """
  @spec parse(map()) :: map() | {:error, term()}
  def parse(data) do
    Enum.reduce_while(data, %{}, fn kv, acc ->
      case parse_data(kv) do
        {_key, {:error, error}} -> {:halt, {:error, error}}
        {key, value} -> {:cont, Map.put(acc, key, value)}
      end
    end)
  end

  defp parse_data({key, "=" <> value}) do
    {key, parse_formula(value, key)}
  end

  defp parse_data({key, value}) when is_binary(value) do
    case Decimal.parse(value) do
      {decimal, _} -> {key, decimal}
      :error -> {key, value}
    end
  end

  defp parse_data({key, value}) when is_float(value) do
    {key, Decimal.from_float(value)}
  end

  defp parse_data({key, value}), do: {key, value}

  defp parse_formula(string, key) do
    result =
      string
      |> Lexer.tokenize!()
      |> :formula_parser.parse()

    case result do
      {:ok, function} ->
        function

      {:error, _} ->
        {:error, InvalidFormulaError.exception(message: "Please check your formula", key: key)}
    end
  end
end