import TypeClass

defclass Witchcraft.Functor do
  @moduledoc ~S"""
  Functors are datatypes that allow the application of functions to their interior values.
  Always returns data in the same structure (same size, tree layout, and so on).

  Please note that bitstrings are not functors, as they fail the
  functor composition constraint. They change the structure of the underlying data,
  and thus composed lifting does not equal lifing a composed function. If you
  need to map over a bitstring, convert it to and from a charlist.

  ## Type Class

  An instance of `Witchcraft.Functor` must define `Witchcraft.Functor.map/2`.

      Functor  [map/2]
  """

  alias __MODULE__

  use Witchcraft.Internal

  use Quark

  @type t :: any()

  where do
    @doc ~S"""
    `map` a function into one layer of a data wrapper.
    There is an autocurrying variant: `lift/2`.

    ## Examples

        iex> map([1, 2, 3], fn x -> x + 1 end)
        [2, 3, 4]

        iex> %{a: 1, b: 2} ~> fn x -> x * 10 end
        %{a: 10, b: 20}

        iex> map(%{a: 2, b: [1, 2, 3]}, fn
        ...>   int when is_integer(int) -> int * 100
        ...>   value -> inspect(value)
        ...> end)
        %{a: 200, b: "[1, 2, 3]"}

    """
    @spec map(Functor.t(), (any() -> any())) :: Functor.t()
    def map(wrapped, fun)
  end

  properties do
    def identity(data) do
      wrapped = generate(data)

      wrapped
      |> Functor.map(&id/1)
      |> equal?(wrapped)
    end

    def composition(data) do
      wrapped = generate(data)

      f = fn x -> inspect(wrapped == x) end
      g = fn x -> inspect(wrapped != x) end

      left = Functor.map(wrapped, fn x -> x |> g.() |> f.() end)
      right = wrapped |> Functor.map(g) |> Functor.map(f)

      equal?(left, right)
    end
  end

  @doc ~S"""
  `map` with its arguments flipped.

  ## Examples

      iex> across(fn x -> x + 1 end, [1, 2, 3])
      [2, 3, 4]

      iex> fn
      ...>   int when is_integer(int) -> int * 100
      ...>   value -> inspect(value)
      ...> end
      ...> |> across(%{a: 2, b: [1, 2, 3]})
      %{a: 200, b: "[1, 2, 3]"}

  """
  @spec across((any() -> any()), Functor.t()) :: Functor.t()
  def across(fun, wrapped), do: map(wrapped, fun)

  @doc ~S"""
  `map/2` but with the function automatically curried

  ## Examples

      iex> lift([1, 2, 3], fn x -> x + 1 end)
      [2, 3, 4]

      iex> [1, 2, 3]
      ...> |> lift(fn x -> x + 55 end)
      ...> |> lift(fn y -> y * 10 end)
      [560, 570, 580]

      iex> [1, 2, 3]
      ...> |> lift(fn(x, y) -> x + y end)
      ...> |> List.first()
      ...> |> apply([9])
      10

  """
  @spec lift(Functor.t(), fun()) :: Functor.t()
  def lift(wrapped, fun), do: Functor.map(wrapped, curry(fun))

  @doc """
  `lift/2` but with arguments flipped.

  ## Examples

      iex> fn x -> x + 1 end |> over([1, 2, 3])
      [2, 3, 4]

  """
  @spec over(fun(), Functor.t()) :: Functor.t()
  def over(fun, wrapped), do: lift(wrapped, fun)

  @doc ~S"""
  Operator alias for `lift/2`

  ## Example

      iex> [1, 2, 3]
      ...> ~> fn x -> x + 55 end
      ...> ~> fn y -> y * 10 end
      [560, 570, 580]

      iex> [1, 2, 3]
      ...> ~> fn(x, y) -> x + y end
      ...> |> List.first()
      ...> |> apply([9])
      10

  """
  defalias data ~> fun, as: :lift

  @doc ~S"""
  `~>/2` with arguments flipped.

      iex> (fn x -> x + 5 end) <~ [1,2,3]
      [6, 7, 8]

  Note that the mnemonic is flipped from `|>`, and combinging directions can
  be confusing. It's generally recommended to use `~>`, or to keep `<~` on
  the same line both of it's arguments:

      iex> fn(x, y) -> x + y end <~ [1, 2, 3]
      ...> |> List.first()
      ...> |> apply([9])
      10

  ...or in an expression that's only pointing left:

      iex> fn y -> y * 10 end
      ...> <~ fn x -> x + 55 end
      ...> <~ [1, 2, 3]
      [560, 570, 580]

  """
  def fun <~ data, do: data ~> fun

  @doc ~S"""
  Replace all inner elements with a constant value

  ## Examples

      iex> replace([1, 2, 3], "hi")
      ["hi", "hi", "hi"]

  """
  @spec replace(Functor.t(), any()) :: Functor.t()
  def replace(wrapped, replace_with), do: wrapped ~> (&constant(replace_with, &1))

  @doc """
  `map` a function over a data structure, with each mapping occuring asynchronously.

  Especially helpful when each application take a long time.

  ## Examples

      iex> async_map([1, 2, 3], fn x -> x * 10 end)
      [10, 20, 30]

      0..10_000
      |> Enum.to_list()
      |> async_map(fn x ->
        Process.sleep(500)
        x * 10
      end)
      #=> [0, 10, ...] in around a second

  """
  @spec async_map(Functor.t(), (any() -> any())) :: Functor.t()
  def async_map(functor, fun) do
    functor
    |> Functor.map(fn item ->
      Task.async(fn ->
        fun.(item)
      end)
    end)
    |> Functor.map(&Task.await/1)
  end

  @doc """
  `async_map/2` with arguments flipped.

  ## Examples

      iex> fn x -> x * 10 end
      ...> |> async_across([1, 2, 3])
      [10, 20, 30]

      fn x ->
        Process.sleep(500)
        x * 10
      end
      |> async_across(Enumto_list(0..10_000))
      #=> [0, 10, ...] in around a second

  """
  @spec async_across((any() -> any()), Functor.t()) :: Functor.t()
  def async_across(fun, functor), do: async_map(functor, fun)

  @doc """
  The same as `async_map/2`, except with the mapping function curried

  ## Examples

      iex> async_lift([1, 2, 3], fn x -> x * 10 end)
      [10, 20, 30]

      0..10_000
      |> Enum.to_list()
      |> async_lift(fn x ->
        Process.sleep(500)
        x * 10
      end)
      #=> [0, 10, ...] in around a second

  """
  @spec async_lift(Functor.t(), fun()) :: Functor.t()
  def async_lift(functor, fun), do: async_map(functor, curry(fun))

  @doc """
  `async_lift/2` with arguments flipped.

  ## Examples

      iex> fn x -> x * 10 end
      ...> |> async_over([1, 2, 3])
      [10, 20, 30]

      fn x ->
        Process.sleep(500)
        x * 10
      end
      |> async_over(Enumto_list(0..10_000))
      #=> [0, 10, ...] in around a second

  """
  @spec async_over(fun(), Functor.t()) :: Functor.t()
  def async_over(fun, functor), do: async_map(functor, fun)
end

definst Witchcraft.Functor, for: Function do
  use Quark

  @doc """
  Compose functions

  ## Example

      iex> ex = Witchcraft.Functor.lift(fn x -> x * 10 end, fn x -> x + 2 end)
      ...> ex.(2)
      22

  """
  def map(f, g), do: Quark.compose(g, f)
end

definst Witchcraft.Functor, for: List do
  def map(list, fun), do: Enum.map(list, fun)
end

definst Witchcraft.Functor, for: Tuple do
  def map(tuple, fun) do
    case tuple do
      {} ->
        {}

      {first} ->
        {fun.(first)}

      {first, second} ->
        {first, fun.(second)}

      {first, second, third} ->
        {first, second, fun.(third)}

      {first, second, third, fourth} ->
        {first, second, third, fun.(fourth)}

      {first, second, third, fourth, fifth} ->
        {first, second, third, fourth, fun.(fifth)}

      big_tuple ->
        last_index = tuple_size(big_tuple) - 1

        mapped =
          big_tuple
          |> elem(last_index)
          |> fun.()

        put_elem(big_tuple, last_index, mapped)
    end
  end
end

definst Witchcraft.Functor, for: Map do
  def map(hashmap, fun) do
    hashmap
    |> Map.to_list()
    |> Witchcraft.Functor.map(fn {key, value} -> {key, fun.(value)} end)
    |> Enum.into(%{})
  end
end