defmodule Blossom.Models.Casks do
  alias Blossom.Models.Casks
  alias Blossom.Utils
  alias KilnCore.Builders.Model, as: Builder
  alias KilnCore.Utils, as: KilnCoreUtils

  def expand_perms(action) do
    Utils.expand_perms("realms", "casks", action)
  end

  def make_new(params, user, ctx) do
    params
    |> Builder.handle_params(ctx[:protected_fields], user)
    |> ctx[:schema].new()
  end

  def set_fetch_params(assignments, params) do
    {realms, casks, _ids} = assignments

    params
    |> Map.put("allowed_ids", casks)
    |> Map.put("allowed_realms", realms)
  end

  def fetch(func, params, user, ctx) do
    new_params =
      "list"
      |> Casks.expand_perms()
      |> ctx[:roles_assignments].get_reduced([], [], user)
      |> Casks.set_fetch_params(params)

    apply(ctx[:schema], func, [new_params])
  end

  def new(params, user, ctx) do
    case user do
      :system ->
        ctx[:schema].new(params)

      %{"sub" => _} ->
        perms = Casks.expand_perms("create")

        case Utils.check_create_item(user, perms, [], [], ctx) do
          {:ok, _} -> Casks.make_new(params, user, ctx)
          e -> e
        end

      _ ->
        {:error, :forbidden}
    end
  end

  def get(params, user, ctx) do
    case user do
      :system ->
        ctx[:schema].get(params)

      %{"sub" => _} ->
        Casks.fetch(:get, params, user, ctx)

      _ ->
        []
    end
  end

  def get_count(params, user, ctx) do
    case user do
      :system ->
        ctx[:schema].get_count(params)

      %{"sub" => _} ->
        Casks.fetch(:get_count, params, user, ctx)

      _ ->
        0
    end
  end

  def show(id, user, ctx) do
    case user do
      :system ->
        ctx[:schema].show([id])

      %{"sub" => _} ->
        perms = Casks.expand_perms("show")

        if Utils.has_item_perms?(id, user, perms, ctx) do
          ctx[:schema].show([id])
        else
          {:error, :forbidden}
        end

      _ ->
        {:error, :forbidden}
    end
  end

  def edit(params, id, user, ctx) do
    case user do
      :system ->
        ctx[:schema].edit(params, [id])

      %{"sub" => _} ->
        perms = Casks.expand_perms("edit")

        if Utils.has_item_perms?(id, user, perms, ctx) do
          params
          |> Builder.handle_params(ctx[:protected_fields], user)
          |> Map.drop(["id", "realm"])
          |> ctx[:schema].edit(id)
        else
          {:error, :forbidden}
        end

      _ ->
        {:error, :forbidden}
    end
  end

  def delete(id, user, ctx) do
    case user do
      :system ->
        ctx[:schema].delete(id)

      %{"sub" => _} ->
        perms = Casks.expand_perms("delete")

        if Utils.has_item_perms?(id, user, perms, ctx) do
          ctx[:schema].delete(id)
        else
          {:error, :forbidden}
        end

      _ ->
        {:error, :forbidden}
    end
  end

  defmacro __using__(opts \\ []) do
    quote do
      use KilnCore.Model,
        protected_fields:
          Keyword.get(unquote(opts), :protected_fields, ["enabled"]),
        schema: unquote(Keyword.get(opts, :schema))

      @realms KilnCoreUtils.option_or_mod_replace(
                @caller,
                unquote(opts),
                :realms,
                Realms,
                2
              )

      @roles_assignments KilnCoreUtils.option_or_mod_replace(
                           @caller,
                           unquote(opts),
                           :roles_assignments,
                           RolesAssignments,
                           2
                         )

      @ctx [
        schema: @schema,
        protected_fields: @protected_fields,
        realms: @realms,
        roles_assignments: @roles_assignments
      ]

      def new(params, user) do
        Casks.new(params, user, @ctx)
      end

      def get(params, user) do
        Casks.get(params, user, @ctx)
      end

      def get_count(params, user) do
        Casks.get_count(params, user, @ctx)
      end

      def show(id, user) do
        Casks.show(id, user, @ctx)
      end

      def edit(params, id, user) do
        Casks.edit(params, id, user, @ctx)
      end

      def delete(id, user) do
        Casks.delete(id, user, @ctx)
      end
    end
  end
end