kiln

defmodule Kiln.Builders.Handler do
  alias Kiln.Builders.Handler
  alias Kiln.Responses.{ErrorResponse, Response}

  def get_request_user(conn, auth_kind) do
    conn.private[auth_kind]
  end

  def add_items(conn, controller, user, opts) do
    count = controller.get_count(conn.query_params, user)

    Keyword.put(opts, :items, count)
  end

  def send_error(conn, error, opts) do
    resp_type = opts[:response_type]

    case error do
      :forbidden ->
        Response.send(conn, 403, ErrorResponse.forbidden(), opts, resp_type)

      :not_found ->
        Response.send(conn, 404, ErrorResponse.not_found(), opts, resp_type)

      %Ecto.Changeset{} = changeset ->
        payload = ErrorResponse.unprocessable(changeset)
        Response.send(conn, 422, payload, opts, resp_type)

      _ ->
        Response.send(conn, 500, ErrorResponse.unknown(), opts, resp_type)
    end
  end

  def new_item(conn, controller, opts) do
    user = Handler.get_request_user(conn, opts[:auth_kind])

    case controller.new(conn.body_params, user) do
      {:ok, item} ->
        Response.send(conn, 201, item, opts, opts[:response_type])

      {:error, error} ->
        Handler.send_error(conn, error, opts)
    end
  end

  def get_items(conn, controller, raw_opts) do
    user = Handler.get_request_user(conn, raw_opts[:auth_kind])
    opts = Handler.add_items(conn, controller, user, raw_opts)
    payload = controller.get(conn.query_params, user)

    Response.send(conn, 200, payload, opts, raw_opts[:response_type])
  end

  def show_item(conn, controller, id, opts) do
    resp_type = opts[:response_type]
    user = Handler.get_request_user(conn, opts[:auth_kind])

    case controller.show(id, user) do
      [item] -> Response.send(conn, 200, item, opts, resp_type)
      [] -> Response.send(conn, 404, :not_found, opts, resp_type)
      {:error, error} -> Handler.send_error(conn, error, opts)
    end
  end

  def edit_item(conn, controller, id, opts) do
    user = Handler.get_request_user(conn, opts[:auth_kind])

    case controller.edit(conn.body_params, id, user) do
      {:ok, item} ->
        Response.send(conn, 200, item, opts, opts[:response_type])

      {:error, error} ->
        Handler.send_error(conn, error, opts)
    end
  end

  def delete_item(conn, controller, id, opts) do
    resp_type = opts[:response_type]
    user = Handler.get_request_user(conn, opts[:auth_kind])

    case controller.delete(id, user) do
      {0, nil} ->
        Response.send(conn, 404, :not_found, opts, resp_type)

      {_, nil} ->
        Response.send(conn, 204, [], opts, resp_type)

      {:error, error} ->
        Handler.send_error(conn, error, opts)
    end
  end
end