meili

defmodule Meili.Index do
  @moduledoc """
  Manages Meilisearch indexes.
  """

  alias Meili.Client

  @doc """
  Lists all indexes.

  Supports optional query params:
  - `limit`: The maximum number of indexes to return.
  - `offset`: The number of indexes to skip.

  ## Examples
      Meili.Index.list()
      Meili.Index.list(limit: 10)
      Meili.Index.list(client, limit: 10)
  """
  def list(client_or_opts \\ nil, opts \\ []) do
    case client_or_opts do
      %Client{} = client ->
        do_list(client, opts)

      nil ->
        do_list(Meili.default_client(), [])

      opts when is_list(opts) ->
        do_list(Meili.default_client(), opts)
    end
  end

  @doc """
  Lists all indexes, raising on error.
  """
  def list!(client_or_opts \\ nil, opts \\ []) do
    case list(client_or_opts, opts) do
      {:ok, body} -> body
      {:error, exception} -> raise exception
    end
  end

  defp do_list(client, opts) do
    params = Keyword.take(opts, [:limit, :offset])
    Client.request(client, :get, "/indexes", params: params)
  end

  @doc """
  Retrieves a single index.

  ## Examples
      Meili.Index.get("movies")
      Meili.Index.get(client, "movies")
  """
  def get(client_or_uid, uid_or_nil \\ nil) do
    case client_or_uid do
      %Client{} = client ->
        Client.request(client, :get, "/indexes/#{uid_or_nil}")

      uid when is_binary(uid) ->
        Client.request(Meili.default_client(), :get, "/indexes/#{uid}")
    end
  end

  @doc """
  Retrieves a single index, raising on error.
  """
  def get!(client_or_uid, uid_or_nil \\ nil) do
    case get(client_or_uid, uid_or_nil) do
      {:ok, body} -> body
      {:error, exception} -> raise exception
    end
  end

  @doc """
  Creates a new index.

  Options can be a primary key string, a keyword list, or a map.

  ## Examples
      Meili.Index.create("movies")
      Meili.Index.create("movies", "id")
      Meili.Index.create("movies", primary_key: "id")
      Meili.Index.create(client, "movies", primary_key: "id")
  """
  def create(client_or_uid, uid_or_opts \\ [], opts \\ []) do
    case client_or_uid do
      %Client{} = client ->
        do_create(client, uid_or_opts, opts)

      uid when is_binary(uid) ->
        do_create(Meili.default_client(), uid, uid_or_opts)
    end
  end

  @doc """
  Creates a new index, raising on error.
  """
  def create!(client_or_uid, uid_or_opts \\ [], opts \\ []) do
    case create(client_or_uid, uid_or_opts, opts) do
      {:ok, body} -> body
      {:error, exception} -> raise exception
    end
  end

  defp do_create(client, uid, opts) do
    body =
      cond do
        is_binary(opts) ->
          %{uid: uid, primaryKey: opts}

        is_list(opts) ->
          body = %{uid: uid}
          pk = opts[:primary_key] || opts[:primaryKey]

          if pk,
            do: Map.put(body, :primaryKey, pk),
            else: body

        is_map(opts) ->
          Map.put(opts, :uid, uid)

        true ->
          %{uid: uid}
      end

    Client.request(client, :post, "/indexes", json: body)
  end

  @doc """
  Updates an index (currently, only the primaryKey can be updated).

  ## Examples
      Meili.Index.update("movies", "new_id")
      Meili.Index.update("movies", primary_key: "new_id")
      Meili.Index.update(client, "movies", primary_key: "new_id")
  """
  def update(client_or_uid, uid_or_opts \\ [], opts \\ []) do
    case client_or_uid do
      %Client{} = client ->
        do_update(client, uid_or_opts, opts)

      uid when is_binary(uid) ->
        do_update(Meili.default_client(), uid, uid_or_opts)
    end
  end

  @doc """
  Updates an index, raising on error.
  """
  def update!(client_or_uid, uid_or_opts \\ [], opts \\ []) do
    case update(client_or_uid, uid_or_opts, opts) do
      {:ok, body} -> body
      {:error, exception} -> raise exception
    end
  end

  defp do_update(client, uid, opts) do
    body =
      cond do
        is_binary(opts) ->
          %{primaryKey: opts}

        is_list(opts) ->
          body = %{}
          pk = opts[:primary_key] || opts[:primaryKey]

          if pk,
            do: Map.put(body, :primaryKey, pk),
            else: body

        is_map(opts) ->
          opts

        true ->
          %{}
      end

    Client.request(client, :patch, "/indexes/#{uid}", json: body)
  end

  @doc """
  Deletes an index.

  ## Examples
      Meili.Index.delete("movies")
      Meili.Index.delete(client, "movies")
  """
  def delete(client_or_uid, uid_or_nil \\ nil) do
    case client_or_uid do
      %Client{} = client ->
        Client.request(client, :delete, "/indexes/#{uid_or_nil}")

      uid when is_binary(uid) ->
        Client.request(Meili.default_client(), :delete, "/indexes/#{uid}")
    end
  end

  @doc """
  Deletes an index, raising on error.
  """
  def delete!(client_or_uid, uid_or_nil \\ nil) do
    case delete(client_or_uid, uid_or_nil) do
      {:ok, body} -> body
      {:error, exception} -> raise exception
    end
  end

  @doc """
  Swaps the contents of two or more indexes.

  ## Examples
      Meili.Index.swap([%{indexes: ["movies_a", "movies_b"]}])
      Meili.Index.swap(client, [%{indexes: ["movies_a", "movies_b"]}])
  """
  def swap(client_or_indexes, indexes_or_nil \\ nil) do
    case client_or_indexes do
      %Client{} = client ->
        Client.request(client, :post, "/swap-indexes", json: indexes_or_nil)

      indexes when is_list(indexes) ->
        Client.request(Meili.default_client(), :post, "/swap-indexes", json: indexes)
    end
  end

  @doc """
  Swaps the contents of indexes, raising on error.
  """
  def swap!(client_or_indexes, indexes_or_nil \\ nil) do
    case swap(client_or_indexes, indexes_or_nil) do
      {:ok, body} -> body
      {:error, exception} -> raise exception
    end
  end

  @doc """
  Gets stats of a specific index.

  ## Examples
      Meili.Index.stats("movies")
      Meili.Index.stats(client, "movies")
  """
  def stats(client_or_uid, uid_or_nil \\ nil) do
    case client_or_uid do
      %Client{} = client ->
        Client.request(client, :get, "/indexes/#{uid_or_nil}/stats")

      uid when is_binary(uid) ->
        Client.request(Meili.default_client(), :get, "/indexes/#{uid}/stats")
    end
  end

  @doc """
  Gets stats of a specific index, raising on error.
  """
  def stats!(client_or_uid, uid_or_nil \\ nil) do
    case stats(client_or_uid, uid_or_nil) do
      {:ok, body} -> body
      {:error, exception} -> raise exception
    end
  end

  @doc """
  Triggers compaction of a specific index.

  ## Examples
      Meili.Index.compact("movies")
      Meili.Index.compact(client, "movies")
  """
  def compact(client_or_uid, uid_or_nil \\ nil) do
    case client_or_uid do
      %Client{} = client ->
        Client.request(client, :post, "/indexes/#{uid_or_nil}/compact")

      uid when is_binary(uid) ->
        Client.request(Meili.default_client(), :post, "/indexes/#{uid}/compact")
    end
  end

  @doc """
  Triggers compaction of a specific index, raising on error.
  """
  def compact!(client_or_uid, uid_or_nil \\ nil) do
    case compact(client_or_uid, uid_or_nil) do
      {:ok, body} -> body
      {:error, exception} -> raise exception
    end
  end
end