apibrasil

defmodule ApiBrasil.Platform.Devices do
  @moduledoc """
  Gestão de devices (`/devices/*`).

  Devices são a credencial de consumo dos serviços device-based: crie um
  device com a SecretKey da API desejada e use o `device_token` retornado
  como header `DeviceToken`.

      alias ApiBrasil.Platform.Devices

      {:ok, device} =
        client
        |> ApiBrasil.with_options(secret_key: "SUA_SECRET_KEY")
        |> Devices.store(%{"device_name" => "meu-bot", "type" => "server"})

      client = ApiBrasil.put_device_token(client, device["device_token"])
  """

  use ApiBrasil.Core.Service

  @doc """
  Lista os devices do usuário: `GET /devices`.

  `query` é opcional e vira query string (ex.: `%{"search" => "meu-bot"}`).
  """
  @spec list(Client.t(), map() | keyword() | nil, keyword()) :: result()
  def list(client, query \\ nil, opts \\ []) do
    Service.get_query(client, "devices", query, opts)
  end

  @doc "Como `list/3`, mas levanta `ApiBrasil.Core.Error` em caso de falha."
  @spec list!(Client.t(), map() | keyword() | nil, keyword()) :: map()
  def list!(client, query \\ nil, opts \\ []) do
    Service.unwrap!(list(client, query, opts))
  end

  @doc """
  Cria um device: `POST /devices/store`.

  O body aceita `device_name`, `type` (`cellphone` | `tablet` | `computer` |
  `server`), `device_key`, `server_search` e os webhooks. A SecretKey da API
  (painel APIBrasil) vai no header: informe em `:secret_key` nas opções da
  chamada ou configure `secret_key` no cliente — nesse caso ela é injetada
  automaticamente.
  """
  @spec store(Client.t(), term(), keyword()) :: result()
  def store(client, body \\ nil, opts \\ []) do
    Service.post(client, "devices/store", body, Service.with_secret_key(client, opts))
  end

  @doc "Como `store/3`, mas levanta `ApiBrasil.Core.Error` em caso de falha."
  @spec store!(Client.t(), term(), keyword()) :: map()
  def store!(client, body \\ nil, opts \\ []) do
    Service.unwrap!(store(client, body, opts))
  end

  @doc """
  Detalha um device: `GET /devices/show?search={device_token}`.

  `nil` (ou string vazia) usa o device configurado no cliente.
  """
  @spec show(Client.t(), String.t() | nil, keyword()) :: result()
  def show(client, device_token \\ nil, opts \\ []) do
    query = %{"search" => resolve_token(client, device_token)}
    Service.get_query(client, "devices/show", query, opts)
  end

  @doc "Como `show/3`, mas levanta `ApiBrasil.Core.Error` em caso de falha."
  @spec show!(Client.t(), String.t() | nil, keyword()) :: map()
  def show!(client, device_token \\ nil, opts \\ []) do
    Service.unwrap!(show(client, device_token, opts))
  end

  @doc """
  Remove um device: `DELETE /devices/destroy`.

  `nil` (ou string vazia) usa o device configurado no cliente.
  """
  @spec destroy(Client.t(), String.t() | nil, keyword()) :: result()
  def destroy(client, device_token \\ nil, opts \\ []) do
    body = %{"search" => resolve_token(client, device_token)}
    Service.delete(client, "devices/destroy", body, opts)
  end

  @doc "Como `destroy/3`, mas levanta `ApiBrasil.Core.Error` em caso de falha."
  @spec destroy!(Client.t(), String.t() | nil, keyword()) :: map()
  def destroy!(client, device_token \\ nil, opts \\ []) do
    Service.unwrap!(destroy(client, device_token, opts))
  end

  route_post(
    :update,
    "devices/update",
    "Atualiza um device: `POST /devices/update` (body com `device_token` + campos)."
  )

  route_post(
    :requests,
    "devices/requests",
    "Histórico de requisições do device: `POST /devices/requests`."
  )

  defp resolve_token(%Client{device_token: device_token}, token) when token in [nil, ""],
    do: device_token || ""

  defp resolve_token(_client, token), do: to_string(token)
end