apibrasil

defmodule ApiBrasil.Platform.Payments do
  @moduledoc """
  Pagamentos e recargas (PIX, boleto e cartão): `/recharge`,
  `/{provider}/pix/*`, `/{provider}/boleto/*`, `/mercadopago/card/*`.

      alias ApiBrasil.Platform.Payments

      {:ok, _} = Payments.recharge(client, %{"amount" => 50, "type" => "pix"})
      {:ok, _} = Payments.pix_generate(client, Payments.provider_santander(), %{"amount" => 50})

      {:ok, pdf} = Payments.boleto_pdf(client, Payments.provider_inter(), "ID")
      File.write!("boleto.pdf", pdf)
  """

  use ApiBrasil.Core.Service

  @doc "Provedor de pagamento Santander (`santander`)."
  @spec provider_santander() :: String.t()
  def provider_santander, do: "santander"

  @doc "Provedor de pagamento Inter (`inter`)."
  @spec provider_inter() :: String.t()
  def provider_inter, do: "inter"

  @doc "Provedor de pagamento Mercado Pago (`mercadopago`)."
  @spec provider_mercado_pago() :: String.t()
  def provider_mercado_pago, do: "mercadopago"

  @doc "Provedor de pagamento Sicoob (`sicoob`)."
  @spec provider_sicoob() :: String.t()
  def provider_sicoob, do: "sicoob"

  @doc "Detalha uma recarga: `GET /recharge/{identifier}`."
  @spec recharge_show(Client.t(), String.t(), keyword()) :: result()
  def recharge_show(client, identifier, opts \\ []) do
    Service.get(client, "recharge/#{Service.encode_path(identifier)}", opts)
  end

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

  @doc "Gera uma cobrança PIX: `POST /{provider}/pix/generate`."
  @spec pix_generate(Client.t(), String.t(), term(), keyword()) :: result()
  def pix_generate(client, provider, body \\ nil, opts \\ []) do
    Service.post(client, "#{Service.encode_path(provider)}/pix/generate", body, opts)
  end

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

  @doc "Consulta uma cobrança PIX: `GET /{provider}/pix/{tx_id}`."
  @spec pix_status(Client.t(), String.t(), String.t(), keyword()) :: result()
  def pix_status(client, provider, tx_id, opts \\ []) do
    path = "#{Service.encode_path(provider)}/pix/#{Service.encode_path(tx_id)}"
    Service.get(client, path, opts)
  end

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

  @doc "Gera um boleto: `POST /{provider}/boleto/generate`."
  @spec boleto_generate(Client.t(), String.t(), term(), keyword()) :: result()
  def boleto_generate(client, provider, body \\ nil, opts \\ []) do
    Service.post(client, "#{Service.encode_path(provider)}/boleto/generate", body, opts)
  end

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

  @doc "Consulta um boleto: `GET /{provider}/boleto/{id}`."
  @spec boleto_status(Client.t(), String.t(), String.t(), keyword()) :: result()
  def boleto_status(client, provider, id, opts \\ []) do
    path = "#{Service.encode_path(provider)}/boleto/#{Service.encode_path(id)}"
    Service.get(client, path, opts)
  end

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

  @doc """
  Baixa o PDF de um boleto: `GET /{provider}/boleto/{id}/pdf`.

  Devolve os bytes crus do arquivo.
  """
  @spec boleto_pdf(Client.t(), String.t(), String.t(), keyword()) ::
          {:ok, binary()} | {:error, Error.t()}
  def boleto_pdf(client, provider, id, opts \\ []) do
    path = "#{Service.encode_path(provider)}/boleto/#{Service.encode_path(id)}/pdf"
    Service.download(client, path, opts)
  end

  @doc "Como `boleto_pdf/4`, mas levanta `ApiBrasil.Core.Error` em caso de falha."
  @spec boleto_pdf!(Client.t(), String.t(), String.t(), keyword()) :: binary()
  def boleto_pdf!(client, provider, id, opts \\ []) do
    Service.unwrap!(boleto_pdf(client, provider, id, opts))
  end

  @doc "Consulta um pagamento de cartão: `GET /mercadopago/card/{id}`."
  @spec card_status(Client.t(), String.t(), keyword()) :: result()
  def card_status(client, id, opts \\ []) do
    Service.get(client, "mercadopago/card/#{Service.encode_path(id)}", opts)
  end

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

  route_get(:recharges, "recharges", "Lista as recargas: `GET /recharges`.")

  route_get(
    :checkout_payment_methods,
    "checkout/payment-methods",
    "Métodos de pagamento do checkout: `GET /checkout/payment-methods`."
  )

  route_get(
    :checkout_periods,
    "checkout/periods",
    "Períodos do checkout: `GET /checkout/periods`."
  )

  route_post(:recharge, "recharge", "Cria uma recarga (`pix` | `boleto`): `POST /recharge`.")

  route_post(
    :card_process,
    "mercadopago/card/process",
    "Processa um pagamento com cartão (Mercado Pago): `POST /mercadopago/card/process`."
  )

  route_post(
    :card_installments,
    "mercadopago/card/installments",
    "Consulta as parcelas do cartão: `POST /mercadopago/card/installments`."
  )

  route_post(
    :validate_coupon,
    "checkout/validate-coupon",
    "Valida um cupom: `POST /checkout/validate-coupon`."
  )

  route_post(
    :checkout_finalize,
    "checkout/finalize",
    "Finaliza o checkout: `POST /checkout/finalize`."
  )
end