defmodule UltraPlug.Repository do
  @moduledoc """
  Accesses the configured repo.

  TODO: Document configuration
  TODO: Document options
  """

  import Plug.Conn

  @repo Application.get_env(:ultra_plug, :repo)

  def init(opts) do
    {to, [{action, from}]} = Keyword.pop(opts, :to)

    to = cond do
      !to and action == :all -> detect_to(from, true)
      !to -> detect_to(from)
      true -> to
    end

    {action, from, to}
  end

  defp detect_to(from, plural? \\ false) do
    schema? = Kernel.function_exported?(from, :__schema__, 1)

    cond do
      schema? and plural? -> detect_plural(from)
      schema? -> detect_singular(from)
      true -> from
    end
  end

  defp detect_plural(from) do
    from.__schema__(:source)
    |> String.to_atom
  end

  defp detect_singular(from) do
    from.__schema__(:source)
    |> String.replace_suffix("s", "")
    |> String.to_atom
  end

  def call(conn, opts \\ [])

  def call(conn = %{assigns: %{error: _}}, _) do
    conn
  end

  def call(conn, {:all, from, to}) do
    result = apply(@repo, :all, [from])
    assign(conn, to, result)
  end

  def call(conn, {:delete!, from, to}) do
    result = apply(@repo, :delete!, [conn.assigns[from]])
    assign(conn, to, result)
  end

  def call(conn, {:get!, from, to}) do
    result = apply(@repo, :get!, [from, conn.params["id"]])
    assign(conn, to, result)
  end

  def call(conn, {:insert, from, to}) do
    case apply(@repo, :insert, [conn.assigns[from]]) do
      {:error, error} -> assign(conn, :error, error)
      {:ok, result} -> assign(conn, to, result)
    end
  end

  def call(conn, {:insert!, from, to}) do
    result = apply(@repo, :insert!, [conn.assigns[from]])
    assign(conn, to, result)
  end

  def call(conn, {:update, from, to}) do
    case apply(@repo, :update, [conn.assigns[from]]) do
      {:error, error} -> assign(conn, :error, error)
      {:ok, result} -> assign(conn, to, result)
    end
  end

  def call(conn, opts) when is_list(opts) do
    call(conn, init(opts))
  end
end