meli

defmodule Meli.CustomerError do
  @moduledoc false
  use Meli.Exception, resource: "Customer"
end

defmodule Meli.Resources.Customer do
  @moduledoc """
  Resource for managing customers in Mercado Pago.

  Customers allow you to store payer information and save card tokens
  for recurring payments or faster checkout experiences.

  ## Examples

      # Create a customer
      {:ok, customer} = Meli.Resources.Customer.create(%{
        email: "customer@email.com",
        first_name: "John",
        last_name: "Doe",
        identification: %{type: "RFC", number: "ABC123456789"}
      })

      # Get a customer by ID
      {:ok, customer} = Meli.Resources.Customer.get("customer_id")

      # Search customers by email
      {:ok, results} = Meli.Resources.Customer.search(email: "customer@email.com")

      # Update a customer
      {:ok, customer} = Meli.Resources.Customer.update("customer_id", %{
        first_name: "Jane"
      })

      # Delete a customer
      {:ok, _} = Meli.Resources.Customer.delete("customer_id")
  """

  alias Meli.Client
  alias Meli.CustomerError
  alias Meli.Structs.Customer

  @path "/v1/customers"

  @type create_params :: %{
          required(:email) => String.t(),
          optional(:first_name) => String.t(),
          optional(:last_name) => String.t(),
          optional(:phone) => map(),
          optional(:identification) => map(),
          optional(:address) => map(),
          optional(:description) => String.t(),
          optional(:metadata) => map(),
          optional(:default_card) => String.t()
        }

  @type search_params :: [
          {:email, String.t()},
          {:id, String.t()}
        ]

  @doc """
  Creates a new customer.

  ## Required Parameters

    * `:email` - Customer email (unique)

  ## Optional Parameters

    * `:first_name` - First name
    * `:last_name` - Last name
    * `:phone` - Phone information
    * `:identification` - Identification document
    * `:address` - Customer address
    * `:description` - Customer description
    * `:metadata` - Custom metadata
    * `:default_card` - Default card ID

  ## Examples

      {:ok, customer} = Meli.Resources.Customer.create(%{
        email: "customer@email.com",
        first_name: "John",
        last_name: "Doe"
      })
  """
  @spec create(create_params(), keyword()) ::
          {:ok, Customer.t()} | {:error, Meli.Error.t()}
  def create(params, opts \\ []) do
    client = resolve_client(opts)

    with {:ok, body} <- Client.post(client, @path, params) do
      {:ok, Customer.from_map(body)}
    end
  end

  @doc """
  Creates a new customer. Raises on error.
  """
  @spec create!(create_params(), keyword()) :: Customer.t()
  def create!(params, opts \\ []) do
    case create(params, opts) do
      {:ok, customer} -> customer
      {:error, error} -> raise CustomerError.from_error(error)
    end
  end

  @doc """
  Gets a customer by ID.

  ## Examples

      {:ok, customer} = Meli.Resources.Customer.get("customer_id")
  """
  @spec get(String.t(), keyword()) ::
          {:ok, Customer.t()} | {:error, Meli.Error.t()}
  def get(id, opts \\ []) do
    client = resolve_client(opts)

    with {:ok, body} <- Client.get(client, "#{@path}/#{id}") do
      {:ok, Customer.from_map(body)}
    end
  end

  @doc """
  Gets a customer by ID. Raises on error.
  """
  @spec get!(String.t(), keyword()) :: Customer.t()
  def get!(id, opts \\ []) do
    case get(id, opts) do
      {:ok, customer} -> customer
      {:error, error} -> raise CustomerError.from_error(error)
    end
  end

  @doc """
  Searches for customers matching the given criteria.

  ## Search Parameters

    * `:email` - Customer email
    * `:id` - Customer ID

  ## Examples

      {:ok, results} = Meli.Resources.Customer.search(email: "customer@email.com")
  """
  @spec search(search_params(), keyword()) ::
          {:ok, %{results: [Customer.t()], paging: map()}} | {:error, Meli.Error.t()}
  def search(params, opts \\ []) do
    client = resolve_client(opts)

    with {:ok, body} <- Client.get(client, "#{@path}/search", params: Map.new(params)) do
      results = Enum.map(body["results"] || [], &Customer.from_map/1)

      {:ok,
       %{
         results: results,
         paging: body["paging"]
       }}
    end
  end

  @doc """
  Searches for customers. Raises on error.
  """
  @spec search!(search_params(), keyword()) :: %{results: [Customer.t()], paging: map()}
  def search!(params, opts \\ []) do
    case search(params, opts) do
      {:ok, result} -> result
      {:error, error} -> raise CustomerError.from_error(error)
    end
  end

  @doc """
  Updates a customer.

  ## Examples

      {:ok, customer} = Meli.Resources.Customer.update("customer_id", %{
        first_name: "Jane"
      })
  """
  @spec update(String.t(), map(), keyword()) ::
          {:ok, Customer.t()} | {:error, Meli.Error.t()}
  def update(id, params, opts \\ []) do
    client = resolve_client(opts)

    with {:ok, body} <- Client.put(client, "#{@path}/#{id}", params) do
      {:ok, Customer.from_map(body)}
    end
  end

  @doc """
  Updates a customer. Raises on error.
  """
  @spec update!(String.t(), map(), keyword()) :: Customer.t()
  def update!(id, params, opts \\ []) do
    case update(id, params, opts) do
      {:ok, customer} -> customer
      {:error, error} -> raise CustomerError.from_error(error)
    end
  end

  @doc """
  Deletes a customer.

  ## Examples

      {:ok, _} = Meli.Resources.Customer.delete("customer_id")
  """
  @spec delete(String.t(), keyword()) ::
          {:ok, map()} | {:error, Meli.Error.t()}
  def delete(id, opts \\ []) do
    client = resolve_client(opts)
    Client.delete(client, "#{@path}/#{id}")
  end

  @doc """
  Deletes a customer. Raises on error.
  """
  @spec delete!(String.t(), keyword()) :: map()
  def delete!(id, opts \\ []) do
    case delete(id, opts) do
      {:ok, result} -> result
      {:error, error} -> raise CustomerError.from_error(error)
    end
  end

  defp resolve_client(opts) do
    case Keyword.get(opts, :client) do
      nil -> Client.new(opts)
      client -> client
    end
  end
end