defmodule Algae do
  @moduledoc """
  Builder DSL to handle common ADT definition use cases
  """

  import Algae.Internal

  @type ast() :: {atom(), any(), any()}

  @doc ~S"""
  Build a product type

  Includes:

  * Struct
  * Type definition
  * Constructor function (for piping and defaults)
  * Implicit defaults for simple values

  ## Definition

  For convenveniece, several variants of the DSL are available.

  ### Standard

      defmodule Player do
        # =============== #
        # Data Definition #
        # =============== #

        defdata do
          name       :: String.t()
          hit_points :: non_neg_integer()
          experience :: non_neg_integer()
        end

        # =================== #
        #    Rest of Module   #
        # (business as usual) #
        # =================== #

        @spec attack(t(), t()) :: {t(), t()}
        def attack(%{experience: xp} = player, %{hit_points: hp} = target) do
          {
            %{player | experience: xp + 50},
            %{target | hit_points: hp - 10}
          }
        end
      end

      #=> %Player{name: "Sir Bob", hit_points: 10, experience: 500}

  ### Single Field Shorthand

  Without any fields specified, Algae will default to a single field with
  the same name as the module (essentially a "wrapper type"). You must still
  provide the type for this field, however.

  Embedded in another module:

      defmodule Id do
        defdata any()
      end

      %Id{}
      #=> %Id{id: nil}

  Standalone:

      defdata Wrapper :: any()

      %Wrapper{}
      #=> %Wrapper{wrapper: nil}

  ## Constructor

  A helper function, especially useful for piping. The order of arguments is
  the same as the order that they are defined in.

      defmodule Person do
        defdata do
          name :: String.t()
          age  :: non_neg_integer()
        end
      end

      Person.new("Rachel Weintraub")
      #=> %Person{
      #     name: "Rachel Weintraub",
      #     age:  0
      #   }

  ### Constructor Defaults

  Fields will automatically default to a sensible value (a typical "zero" for
  that datatype). For example, `non_neg_integer()` will default to `0`,
  and `String.t()` will default to `""`.

  You may also overwrite these defaults with the `\\\\` syntax.

      defmodule Pet do
        defdata do
          name      :: String.t()
          leg_count :: non_neg_integer() \\\\ 4
        end
      end

      Pet.new("Crookshanks")
      #=> %Pet{
      #     name: "Crookshanks",
      #     leg_count: 4
      #   }

      Pet.new("Paul the Psychic Octopus", 8)
      #=> %Pet{
      #     name: "Paul the Psychic Octopus",
      #     leg_count: 8
      #   }

  This overwriting syntax is _required_ for complex types:

      defdata Grocery do
        item :: {String.t(), integer(), boolean()} \\\\ {"Apple", 4, false}
      end

      Grocery.new()
      #=> %Grocery{
      #     item: {"Apple", 4, false}
      #   }

  ### Overwrite Constructor

  The `new` constructor function may be overwritten.

      iex> defmodule Constant do
      ...>   defdata fun()
      ...>
      ...>   def new(value), do: %Constant{constant: fn _ -> value end}
      ...> end
      ...>
      ...> fourty_two = Constant.new(42)
      ...> fourty_two.constant.(33)
      42

  ## Empty Tag

  An empty type (with no fields) is definable using the `none`() type

      defmodule Nothing do
        defdata none()
      end

      Nothing.new()
      #=> %Nothing{}

  """
  defmacro defdata(ast) do
    caller_module = __CALLER__.module

    case ast do
      {:none, _, _} = _type ->
        embedded_data_ast()

      {:\\, _, [{:::, _, [module_ctx, type]}, default]} ->
        caller_module
        |> modules(module_ctx)
        |> data_ast(default, type)

      {:\\, _, [type, default]} ->
        caller_module
        |> List.wrap()
        |> embedded_data_ast(default, type)

      {:::, _, [module_ctx, {:none, _, _} = type]} ->
        caller_module
        |> modules(module_ctx)
        |> data_ast(type)

      {:::, _, [module_ctx, type]} ->
        caller_module
        |> modules(module_ctx)
        |> data_ast(default_value(type), type)

      {_, _, _} = type ->
        data_ast(caller_module, type)

      [do: {:__block__, _, lines}] ->
        data_ast(lines, __CALLER__)

      [do: line] ->
        data_ast([line], __CALLER__)
    end
  end

  defmacro defdata(module_ctx, do: body) do
    module_name =
      __CALLER__.module
      |> modules(module_ctx)
      |> Module.concat()

    inner =
      body
      |> case do
           {:__block__, _, lines} -> lines
           line -> List.wrap(line)
      end
      |> data_ast(__CALLER__)

    quote do
      defmodule unquote(module_name) do
        unquote(inner)
      end
    end
  end

  @doc """
  Build a sum (coproduct) type from product types

      defmodule Light do
        # ============== #
        # Sum Definition #
        # ============== #

        defsum do
          defdata Red    :: none()
          defdata Yellow :: none()
          defdata Green  :: none()
        end

        # =================== #
        #    Rest of Module   #
        # (business as usual) #
        # =================== #

        def from_number(1), do: %Light.Red{}
        def from_number(2), do: %Light.Yellow{}
        def from_number(3), do: %Light.Green{}
      end

      Light.new()
      #=> %Light.Red{}

  ## Embedded Products

  Data with multiple fileds can be defined directly as part of a sum

      defmodule Pet do
        defsum do
          defdata Cat do
            name :: String.t()
            claw_sharpness :: String.t()
          end

          defdata Dog do
            name :: String.t()
            bark_loudness :: non_neg_integer()
          end
        end
      end

  ## Default Constructor

  The first `defdata`'s constructor will be the default constructor for the sum

      defmodule Maybe do
        defsum do
          defdata Nothing :: none()
          defdata Just    :: any()
        end
      end

      Maybe.new()
      #=> %Maybe.Nothing{}

  ## Tagged Unions

  Sums join existing types with tags: new types to help distibguish the context
  that they are in (the sum type)

      defdata Book  :: String.t() \\\\ "War and Peace"
      defdata Video :: String.t() \\\\ "2001: A Space Odyssey"

      defmodule Media do
        defsum do
          defdata Paper :: Book.t()
          defdata Film  :: Video.t() \\\\ Video.new("A Clockwork Orange")
        end
      end

      media = Media.new()
      #=> %Paper{
      #      paper: %Book{
      #        book: "War and Peace"
      #      }
      #   }

  """
  @spec defsum([do: {:__block__, [any()], ast()}]) :: ast()
  defmacro defsum(do: {:__block__, _, [first | _] = parts} = block) do
    module_ctx = __CALLER__.module
    types = or_types(parts, module_ctx)

    default_module =
      module_ctx
      |> List.wrap()
      |> Kernel.++(submodule_name(first))
      |> Module.concat()

    quote do
      @type t :: unquote(types)
      unquote(block)

      @spec new() :: t()
      def new, do: unquote(default_module).new()

      defoverridable [new: 0]
    end
  end
end