defmodule Circlex.Struct.SourceDest do
  use Circlex.Struct.JasonHelper
  import Circlex.Struct.Util

  defmodule Identity do
    use Circlex.Struct.JasonHelper
    import Circlex.Struct.Util

    defstruct [:type, :name, :addresses]

    def deserialize(identity) do
      %__MODULE__{
        name: fetch(identity, :name),
        type: fetch(identity, :type),
        addresses:
          (fetch(identity, :addresses) || [])
          |> Enum.map(&Circlex.Struct.PhysicalAddress.deserialize/1)
      }
    end

    def serialize(identity) do
      %{
        name: identity.name,
        type: identity.type,
        addresses: Enum.map(identity.addresses || [], &Circlex.Struct.PhysicalAddress.serialize/1)
      }
    end
  end

  defstruct [:type, :id, :address, :address_tag, :chain, :address_id, identities: []]

  def deserialize(source_dest) do
    case fetch(source_dest, :type) do
      "wire" ->
        %__MODULE__{
          type: :wire,
          id: fetch(source_dest, :id)
        }

      "wallet" ->
        %__MODULE__{
          type: :wallet,
          id: fetch(source_dest, :id),
          address: fetch(source_dest, :address)
        }

      "blockchain" ->
        %__MODULE__{
          type: :blockchain,
          address: fetch(source_dest, :address),
          address_tag: fetch(source_dest, :addressTag),
          chain: fetch(source_dest, :chain)
        }

      "verified_blockchain" ->
        %__MODULE__{
          type: :verified_blockchain,
          address_id: fetch(source_dest, :addressId)
        }
    end
    |> Map.put(
      :identities,
      (fetch(source_dest, :identities) || [])
      |> Enum.map(&Identity.deserialize/1)
    )
  end

  def serialize(source_dest) do
    base_source_dest =
      case source_dest.type do
        :wire ->
          %{
            type: "wire",
            id: source_dest.id
          }

        :wallet ->
          Map.merge(
            %{
              type: "wallet",
              id: source_dest.id
            },
            if(is_nil(source_dest.address),
              do: %{},
              else: %{address: String.downcase(source_dest.address)}
            )
          )

        :blockchain ->
          case source_dest.chain do
            "ETH" ->
              %{
                type: "blockchain",
                address: String.downcase(source_dest.address),
                chain: source_dest.chain
              }

            _ ->
              %{
                type: "blockchain",
                address: source_dest.address,
                chain: source_dest.chain
              }
          end

        :verified_blockchain ->
          %{
            type: "verified_blockchain",
            addressId: source_dest.address_id
          }
      end

    # a bit of a mess here b/c destinations and core api transfers souerces aren't really supposed to have identities whatsoever,
    # so we drop the key from json if it is empty
    if Enum.empty?(source_dest.identities) do
      base_source_dest
    else
      Map.put(
        base_source_dest,
        :identities,
        Enum.map(source_dest.identities, &__MODULE__.Identity.serialize/1)
      )
    end
  end
end