defmodule Plaid.PaymentInitiation do
  @moduledoc """
  [Plaid Payment Initiation API](https://plaid.com/docs/api/products/#payment-initiation-uk-and-europe) calls and schema.
  """

  alias Plaid.Castable

  alias Plaid.PaymentInitiation.{
    Address,
    Amount,
    BACS,
    Payment,
    Recipient,
    Schedule
  }

  defmodule CreateRecipientResponse do
    @moduledoc """
    [Plaid API /payment_initiation/recipient/create response schema.](https://plaid.com/docs/api/products/#payment_initiationrecipientcreate)
    """

    @behaviour Castable

    @type t :: %__MODULE__{
            recipient_id: String.t(),
            request_id: String.t()
          }

    defstruct [
      :recipient_id,
      :request_id
    ]

    @impl true
    def cast(generic_map) do
      %__MODULE__{
        recipient_id: generic_map["recipient_id"],
        request_id: generic_map["request_id"]
      }
    end
  end

  @doc """
  Create a recipient for payment initiation.

  Does a `POST /payment_initiation/recipient/create` call which creates a payment
  recipient for payment initiation. 

  The endpoint is idempotent: if a request has already been made with the
  same payment details, Plaid will return the same `recipient_id`.

  ## Params

  * `name` - The name of the recipient.

  ## Options

  * `:iban` - The International Bank Account Number (IBAN) for the recipient.
  * `:bacs` - The sort code of the account.
  * `:address` - The address of the payment recipient.

  If `:bacs` data is not provided, `:iban` becomes required.

  ## Examples

      PaymentInitiation.create_recipient("Wonder Wallet", client_id: "123", secret: "abc")
      {:ok, %PaymentInitiation.CreateRecipientResponse{}}

  """
  @spec create_recipient(name :: String.t(), options, Plaid.config()) ::
          {:ok, CreateRecipientResponse.t()} | {:error, Plaid.Error.t()}
        when options: %{
               optional(:iban) => String.t(),
               optional(:bacs) => BACS.t(),
               optional(:address) => Address.t()
             }
  def create_recipient(name, options \\ %{}, config) do
    options_payload = Map.take(options, [:iban, :bacs, :address])

    payload =
      %{}
      |> Map.put(:name, name)
      |> Map.merge(options_payload)

    Plaid.Client.call(
      "/payment_initiation/recipient/create",
      payload,
      CreateRecipientResponse,
      config
    )
  end

  defmodule GetRecipientResponse do
    @moduledoc """
    [Plaid API /payment_initiation/recipient/get response schema.](https://plaid.com/docs/api/products/#payment_initiationrecipientget)
    """

    @behaviour Castable

    @type t :: %__MODULE__{
            recipient_id: String.t(),
            name: String.t(),
            address: Address.t() | nil,
            iban: String.t() | nil,
            bacs: BACS.t() | nil,
            request_id: String.t()
          }

    defstruct [
      :recipient_id,
      :name,
      :address,
      :iban,
      :bacs,
      :request_id
    ]

    @impl true
    def cast(generic_map) do
      %__MODULE__{
        recipient_id: generic_map["recipient_id"],
        name: generic_map["name"],
        address: Castable.cast(Address, generic_map["address"]),
        iban: generic_map["iban"],
        bacs: Castable.cast(BACS, generic_map["bacs"]),
        request_id: generic_map["request_id"]
      }
    end
  end

  @doc """
  Get a recipient for payment initiation.

  Does a `POST /payment_initiation/recipient/get` call to
  get details about a payment recipient.

  ## Params

  * `recipient_id` - The ID of the recipient.

  ## Examples

      PaymentInitiation.get_recipient("recipient-id-sandbox-123xxx", client_id: "123", secret: "abc")
      {:ok, %PaymentInitiation.GetRecipientResponse{}}

  """
  @spec get_recipient(recipient_id :: String.t(), Plaid.config()) ::
          {:ok, CreateRecipientResponse.t()} | {:error, Plaid.Error.t()}
  def get_recipient(recipient_id, config) do
    Plaid.Client.call(
      "/payment_initiation/recipient/get",
      %{recipient_id: recipient_id},
      GetRecipientResponse,
      config
    )
  end

  defmodule ListRecipientsResponse do
    @moduledoc """
    [Plaid API /payment_initiation/recipient/list response schema.](https://plaid.com/docs/api/products/#payment_initiationrecipientlist)
    """

    @behaviour Castable

    @type t :: %__MODULE__{
            recipients: [Recipient.t()],
            request_id: String.t()
          }

    defstruct [
      :recipients,
      :request_id
    ]

    @impl true
    def cast(generic_map) do
      %__MODULE__{
        recipients: Castable.cast_list(Recipient, generic_map["recipients"]),
        request_id: generic_map["request_id"]
      }
    end
  end

  @doc """
  List the payment recipients that you have previously created.

  Does a `POST /payment_initiation/recipient/list` call to
  list all recipients you have previously created.


  ## Examples

      PaymentInitiation.list_recipients(client_id: "123", secret: "abc")
      {:ok, %PaymentInitiation.ListRecipientsResponse{}}

  """
  @spec list_recipients(Plaid.config()) ::
          {:ok, ListRecipientsResponse.t()} | {:error, Plaid.Error.t()}
  def list_recipients(config) do
    Plaid.Client.call(
      "/payment_initiation/recipient/list",
      ListRecipientsResponse,
      config
    )
  end

  defmodule CreatePaymentResponse do
    @moduledoc """
    [Plaid API /payment_initiation/payment/create response schema.](https://plaid.com/docs/api/products/#payment_initiationpaymentcreate)
    """

    @behaviour Castable

    @type t :: %__MODULE__{
            payment_id: String.t(),
            status: String.t(),
            request_id: String.t()
          }

    defstruct [
      :payment_id,
      :status,
      :request_id
    ]

    @impl true
    def cast(generic_map) do
      %__MODULE__{
        payment_id: generic_map["payment_id"],
        status: generic_map["status"],
        request_id: generic_map["request_id"]
      }
    end
  end

  @doc """
  Create a payment for a recipient.

  Does a `POST /payment_initiation/payment/create` call which creates
  a one-time or standing (recurring) payment for a recipient.

  ## Params

  * `recipient_id` - The ID of the recipient the payment is for.
  * `reference` - A reference for the payment.
  * `amount` - A payment amount.

  ## Options

  * `:schedule` - The schedule that the payment will be executed on.

  ## Examples

      PaymentInitiation.create_payment(
        "recipient-id-prod-123xxx",
        "Purchase Order  123",
        %PaymentInitiation.Amount{currency: "GBP", value: 200},
        %{
          schedule: %PaymentInitiation.Schedule{
            interval: "WEEKLY",
            interval_execution_day: 2,
            start_date: "2021-01-01",
            end_date: "2021-01-31"
          }
        },
        client_id: "123",
        secret: "abc"
      )
      {:ok, %PaymentInitiation.CreateRecipientResponse{}}

  """
  @spec create_payment(
          recipient_id :: String.t(),
          reference :: String.t(),
          amount :: Amount.t(),
          options,
          Plaid.config()
        ) :: {:ok, CreatePaymentResponse.t()} | {:error, Plaid.Error.t()}
        when options: %{optional(:schedule) => Schedule.t()}
  def create_payment(recipient_id, reference, amount, options \\ %{}, config) do
    payload =
      %{}
      |> Map.put(:recipient_id, recipient_id)
      |> Map.put(:reference, reference)
      |> Map.put(:amount, amount)
      |> Plaid.Util.maybe_put(:schedule, options)

    Plaid.Client.call(
      "/payment_initiation/payment/create",
      payload,
      CreatePaymentResponse,
      config
    )
  end

  defmodule GetPaymentResponse do
    @moduledoc """
    [Plaid API /payment_initiation/payment/get response schema.](https://plaid.com/docs/api/products/#payment_initiationpaymentget)
    """

    @behaviour Castable

    @type t :: %__MODULE__{
            payment_id: String.t(),
            payment_token: String.t(),
            amount: Amount.t(),
            status: String.t(),
            recipient_id: String.t(),
            reference: String.t(),
            last_status_update: String.t(),
            schedule: Schedule.t() | nil,
            adjusted_reference: String.t() | nil,
            payment_expiration_time: String.t() | nil,
            request_id: String.t()
          }

    defstruct [
      :payment_id,
      :payment_token,
      :amount,
      :status,
      :recipient_id,
      :reference,
      :last_status_update,
      :schedule,
      :adjusted_reference,
      :payment_expiration_time,
      :request_id
    ]

    @impl true
    def cast(generic_map) do
      %__MODULE__{
        payment_id: generic_map["payment_id"],
        payment_token: generic_map["payment_token"],
        amount: Castable.cast(Amount, generic_map["amount"]),
        status: generic_map["status"],
        recipient_id: generic_map["recipient_id"],
        reference: generic_map["reference"],
        last_status_update: generic_map["last_status_update"],
        schedule: Castable.cast(Schedule, generic_map["schedule"]),
        adjusted_reference: generic_map["adjust_reference"],
        payment_expiration_time: generic_map["payment_expiration_time"],
        request_id: generic_map["request_id"]
      }
    end
  end

  @doc """
  Get payment details.

  Does a `POST /payment_initiation/payment/create` call to get
  details about a payment.

  ## Params

  * `payment_id` - The payment_id returned from /payment_initiation/payment/create.

  ## Examples

      PaymentInitiation.get_payment(
        "payment-id-prod-123xxx",
        client_id: "123",
        secret: "abc"
      )
      {:ok, %PaymentInitiation.GetPaymentResponse{}}

  """
  @spec get_payment(payment_id :: String.t(), Plaid.config()) ::
          {:ok, GetPaymentResponse.t()} | {:error, Plaid.Error.t()}
  def get_payment(payment_id, config) do
    Plaid.Client.call(
      "/payment_initiation/payment/get",
      %{payment_id: payment_id},
      GetPaymentResponse,
      config
    )
  end

  defmodule ListPaymentsResponse do
    @moduledoc """
    [Plaid API /payment_initiation/payment/list response schema.](https://plaid.com/docs/api/products/#payment_initiationpaymentlist)
    """

    @behaviour Castable

    @type t :: %__MODULE__{
            payments: [Payment.t()],
            next_cursor: String.t(),
            request_id: String.t()
          }

    defstruct [
      :payments,
      :next_cursor,
      :request_id
    ]

    @impl true
    def cast(generic_map) do
      %__MODULE__{
        payments: Castable.cast_list(Payment, generic_map["payments"]),
        next_cursor: generic_map["next_cursor"],
        request_id: generic_map["request_id"]
      }
    end
  end

  @doc """
  List payments.

  Does a `POST /payment_initiation/payment/list` call to get
  all created payments.

  ## Options

  * `:count` - The maximum number of payments to return.
  * `:cursor` - A date string in RFC 3339 format. Only payments created before the cursor will be returned.

  ## Examples

      PaymentInitiation.list_payments(
        client_id: "123",
        secret: "abc"
      )
      {:ok, %PaymentInitiation.ListPaymentsResponse{}}

  """
  @spec list_payments(options, Plaid.config()) ::
          {:ok, ListPaymentsResponse.t()} | {:error, Plaid.Error.t()}
        when options: %{
               optional(:count) => integer(),
               optional(:cursor) => String.t()
             }
  def list_payments(options \\ %{}, config) do
    payload = Map.take(options, [:count, :cursor])

    Plaid.Client.call(
      "/payment_initiation/payment/list",
      payload,
      ListPaymentsResponse,
      config
    )
  end
end