defmodule Requests.Payments.Payment do
  @moduledoc """
  TODO: either implement all of the sources or none and return the api errors.
  """
  alias Customers.BillingAddress
  alias Customers.Phone
  alias Requests.Payments.Payment.{
    AirlineData,
    AmountAllocation,
    BillingDescriptor,
    Risk,
    Sender
  }

  alias Requests.Payments.Sources
  alias Requests.Payments.ThreeDS

  @derive Jason.Encoder

  @type customer :: %{
          id: String.t(),
          email: String.t(),
          name: String.t(),
          tax_number: String.t(),
          phone: Phone.t()
        }

  @type item :: %{
          name: String.t(),
          quantity: String.t(),
          unit_price: String.t(),
          reference: String.t(),
          commodity_code: String.t(),
          unit_of_measure: String.t(),
          total_amount: String.t(),
          tax_amount: String.t(),
          discount_amount: String.t(),
          wxpay_goods_id: String.t(),
          url: String.t(),
          image_url: String.t()
        }

  @type processing :: %{
          order_id: String.t(),
          tax_amount: integer(),
          discount_amount: integer(),
          duty_amount: integer(),
          shipping_amount: integer(),
          shipping_tax_amount: integer(),
          aft: true | false,
          preferred_scheme: String.t(),
          merchant_initiated_reason: String.t(),
          campaign_id: integer(),
          product_type: String.t(),
          open_id: String.t(),
          original_order_amount: integer(),
          receipt_id: String.t(),
          terminal_type: String.t(),
          os_type: String.t(),
          invoice_id: String.t(),
          brand_name: String.t(),
          locale: String.t(),
          shipping_preference: String.t(),
          user_action: String.t(),
          set_transaction_context: map(),
          airline_data: AirlineData.t(),
          purchase_country: String.t(),
          custom_payment_method_ids: list(String.t()),
          merchant_callback_url: String.t()
        }

  @type recipient :: %{
          dob: String.t(),
          account_number: String.t(),
          address: BillingAddress.t(),
          first_name: String.t(),
          last_name: String.t()
        }

  @type shipping :: %{
          address: BillingAddress.t(),
          phone: Phone.t(),
          from_address_zip: String.t()
        }

  @type t() :: %__MODULE__{
          source: map(),
          amount: integer(),
          currency: <<_::3>>,
          payment_type: String.t(),
          merchant_initiated: true | false,
          reference: String.t(),
          description: String.t(),
          authorization_type: String.t(),
          capture: true | false,
          capture_on: String.t(),
          customer: customer(),
          billing_descriptor: BillingDescriptor.t(),
          shipping: shipping(),
          three_d_s: Integrated.t() | StandAlone.t() | ThirdParty.t(),
          processing_channel_id: String.t(),
          previous_payment_id: String.t(),
          risk: Risk.t(),
          success_url: String.t(),
          failure_url: String.t(),
          payment_ip: String.t(),
          sender: Sender.t(),
          recipient: recipient(),
          amount_allocations: list(AmountAllocation.t()),
          processing: processing(),
          items: list(item()),
          metadata: map(),
          type: String.t()
        }

  @enforce_keys [:currency, :processing_channel_id, :source, :type]
  defstruct [
    :source,
    :amount,
    :currency,
    :payment_type,
    :merchant_initiated,
    :reference,
    :description,
    :authorization_type,
    :capture,
    :capture_on,
    :customer,
    :billing_descriptor,
    :shipping,
    :three_d_s,
    :"3ds",
    :processing_channel_id,
    :previous_payment_id,
    :risk,
    :success_url,
    :failure_url,
    :payment_ip,
    :sender,
    :recipient,
    :amount_allocations,
    :processing,
    :items,
    :metadata,
    :type
  ]

  def build(
        %{
          currency: currency,
          source: source
        } = params
      )
      when is_binary(currency) and is_map(source) do
    %__MODULE__{
      source: Sources.build(source),
      amount: params[:amount],
      currency: currency,
      payment_type: params[:payment_type],
      merchant_initiated: params[:merchant_initiated],
      reference: params[:reference],
      description: params[:description],
      authorization_type: params[:authorization_type],
      capture: params[:capture],
      capture_on: params[:capture_on],
      customer: build_customer(params[:customer]),
      billing_descriptor: BillingDescriptor.build(params[:billing_descriptor]),
      shipping: build_shipping(params[:shipping]),
      "3ds": ThreeDS.build(params[:three_d_s]),
      processing_channel_id: params[:processing_channel_id],
      previous_payment_id: params[:previous_payment_id],
      risk: Risk.build(params[:risk]),
      success_url: params[:success_url],
      failure_url: params[:failure_url],
      payment_ip: params[:payment_ip],
      sender: Sender.build(params[:sender]),
      recipient: build_recipient(params[:recipient]),
      amount_allocations: AmountAllocation.build(params[:amount_allocations]),
      processing: build_processing(params[:processing]),
      items: build_items(params[:items]),
      metadata: params[:metadata],
      type: params[:type]
    }
  end

  def build(params) when is_map(params),
    do: {:error, "Payment must have currency, processing_channel_id, and source"}

  def build(_), do: {:error, "params must be a map"}

  defp build_customer(params) when is_map(params) do
    %{
      id: params[:id],
      email: params[:email],
      name: params[:name],
      tax_number: params[:tax_number],
      phone: Phone.build(params[:phone])
    }
  end

  defp build_customer(_), do: nil

  defp build_items(items) when is_list(items) do
    Enum.into(items, [], &build_item(&1))
  end

  defp build_items(_), do: nil

  defp build_item(params) when is_map(params) do
    %{
      name: params[:name],
      quantity: params[:quantity],
      unit_price: params[:unit_price],
      reference: params[:reference],
      commodity_code: params[:commodity_code],
      unit_of_measure: params[:unit_of_measure],
      total_amount: params[:total_amount],
      tax_amount: params[:tax_amount],
      discount_amount: params[:discount_amount],
      wxpay_goods_id: params[:wxpay_goods_id],
      url: params[:url],
      image_url: params[:image_url]
    }
  end

  defp build_item(_), do: nil

  defp build_processing(params) when is_map(params) do
    %{
      order_id: params[:order_id],
      tax_amount: params[:tax_amount],
      discount_amount: params[:discount_amount],
      duty_amount: params[:duty_amount],
      shipping_amount: params[:shipping_amount],
      shipping_tax_amount: params[:shipping_tax_amount],
      aft: params[:aft],
      preferred_scheme: params[:preferred_scheme],
      merchant_initiated_reason: params[:merchant_initiated_reason],
      campaign_id: params[:campaign_id],
      product_type: params[:product_type],
      open_id: params[:open_id],
      original_order_amount: params[:original_order_amount],
      receipt_id: params[:receipt_id],
      terminal_type: params[:terminal_type],
      os_type: params[:os_type],
      invoice_id: params[:invoice_id],
      brand_name: params[:brand_name],
      locale: params[:locale],
      shipping_preference: params[:shipping_preference],
      user_action: params[:user_action],
      set_transaction_context: params[:set_transaction_context],
      airline_data: AirlineData.build(params[:airline_data]),
      purchase_country: params[:purchase_country],
      custom_payment_method_ids: params[:custom_payment_method_ids],
      merchant_callback_url: params[:merchant_callback_url]
    }
  end

  defp build_processing(_), do: nil

  defp build_recipient(params) when is_map(params) do
    %{
      dob: params[:dob],
      account_number: params[:account_number],
      address: BillingAddress.build(params[:address]),
      first_name: params[:first_name],
      last_name: params[:last_name]
    }
  end

  defp build_recipient(_), do: nil

  defp build_shipping(params) when is_map(params) do
    %{
      address: BillingAddress.build(params[:address]),
      phone: Phone.build(params[:phone]),
      from_address_zip: params[:from_address_zip]
    }
  end

  defp build_shipping(_), do: nil
end