kizuna_mem

defmodule KizunaMem do
  @moduledoc "Kizuna-Mem SDK client."

  defdelegate start_link(opts), to: KizunaMem.Client

  def connect(_endpoint, "", _tenant_id), do: {:error, "api_key must not be empty"}

  def connect(endpoint, api_key, tenant_id) do
    KizunaMem.Client.start_link(endpoint: endpoint, api_key: api_key, tenant_id: tenant_id)
  end

  def with_tenant(pid, tenant_id), do: KizunaMem.Client.with_tenant(pid, tenant_id)

  def observe(pid, speaker, text, opts \\ []) do
    params = %{speaker: speaker, text: text}

    params =
      case Keyword.get(opts, :timestamp) do
        nil -> params
        v -> Map.put(params, :timestamp, v)
      end

    params =
      case Keyword.get(opts, :session_id) do
        nil -> params
        v -> Map.put(params, :session_id, v)
      end

    KizunaMem.Client.observe(pid, params)
  end

  def retrieve(pid, query, opts \\ []) do
    params = %{query: query, top_k: Keyword.get(opts, :top_k, 10), debug: Keyword.get(opts, :debug, false)}

    params =
      case Keyword.get(opts, :token_budget) do
        nil -> params
        v -> Map.put(params, :token_budget, v)
      end

    params =
      case Keyword.get(opts, :retrieval_mode) do
        nil -> params
        v -> Map.put(params, :retrieval_mode, v)
      end

    params =
      case Keyword.get(opts, :decompose) do
        nil -> params
        v -> Map.put(params, :decompose, v)
      end

    KizunaMem.Client.retrieve(pid, params)
  end

  def observe_document(pid, opts), do: KizunaMem.Client.observe_document(pid, opts)

  def admin_metrics(pid), do: KizunaMem.Client.admin_metrics(pid)

  def admin_logs(pid, opts \\ %{}), do: KizunaMem.Client.admin_logs(pid, opts)

  def health(pid), do: KizunaMem.Client.health(pid)

  def forget_entity(pid, entity_id), do: KizunaMem.Client.forget_entity(pid, entity_id)

  def forget_tenant(pid), do: KizunaMem.Client.forget_tenant(pid)

  def export_data(pid), do: KizunaMem.Client.export_data(pid)
end