defmodule Stellar.TxBuild.Default do
  @moduledoc """
  Default TxBuild implementation.
  """
  alias StellarBase.XDR.{TransactionExt, SorobanTransactionData}
  alias Stellar.{TxBuild, Network}

  alias Stellar.TxBuild.{
    Account,
    Memo,
    BaseFee,
    Operation,
    Operations,
    SequenceNumber,
    Signature,
    Preconditions,
    TimeBounds,
    Transaction,
    TransactionEnvelope,
    TransactionSignature
  }

  @behaviour Stellar.TxBuild.Spec

  @preconditions_keys [
    :time_bounds,
    :ledger_bounds,
    :min_seq_num,
    :min_seq_age,
    :min_seq_ledger_gap,
    :extra_signers
  ]

  @impl true
  def new(%Account{} = source_account, opts) do
    network_passphrase = Keyword.get(opts, :network_passphrase, Network.testnet_passphrase())
    sequence_number = Keyword.get(opts, :sequence_number, SequenceNumber.new())
    base_fee = Keyword.get(opts, :base_fee, BaseFee.new())
    memo = Keyword.get(opts, :memo, Memo.new())
    operations = Keyword.get(opts, :operations, Operations.new())

    preconditions =
      opts
      |> Keyword.take(@preconditions_keys)
      |> Preconditions.new()

    case Transaction.new(
           source_account: source_account,
           sequence_number: sequence_number,
           base_fee: base_fee,
           preconditions: preconditions,
           memo: memo,
           operations: operations
         ) do
      %Transaction{} = transaction ->
        {:ok,
         %TxBuild{
           tx: transaction,
           signatures: [],
           tx_envelope: nil,
           network_passphrase: network_passphrase
         }}

      error ->
        error
    end
  end

  def new(_source_account, _opts), do: {:error, :invalid_source_account}

  @impl true
  def set_network_passphrase({:ok, %TxBuild{} = tx_build}, network_passphrase),
    do: {:ok, %{tx_build | network_passphrase: network_passphrase}}

  @impl true
  def add_memo({:ok, %TxBuild{tx: tx} = tx_build}, %Memo{} = memo) do
    transaction = %{tx | memo: memo}
    {:ok, %{tx_build | tx: transaction}}
  end

  def add_memo({:ok, %TxBuild{}}, _memo), do: {:error, :invalid_memo}
  def add_memo(error, _memo), do: error

  @impl true
  def set_time_bounds(
        {:ok, %TxBuild{tx: %{preconditions: %{type: :none} = preconditions} = tx} = tx_build},
        %TimeBounds{} = time_bounds
      ) do
    preconditions = %{preconditions | type: :precond_time, preconditions: time_bounds}
    transaction = %{tx | preconditions: preconditions}
    {:ok, %{tx_build | tx: transaction}}
  end

  def set_time_bounds(
        {:ok,
         %TxBuild{tx: %{preconditions: %{type: :precond_time} = preconditions} = tx} = tx_build},
        %TimeBounds{} = time_bounds
      ) do
    preconditions = %{preconditions | preconditions: time_bounds}
    transaction = %{tx | preconditions: preconditions}
    {:ok, %{tx_build | tx: transaction}}
  end

  def set_time_bounds(
        {:ok,
         %TxBuild{
           tx:
             %{
               preconditions:
                 %{type: :precond_v2, preconditions: inner_preconditions} = preconditions
             } = tx
         } = tx_build},
        %TimeBounds{} = time_bounds
      ) do
    inner_preconditions = Keyword.put(inner_preconditions, :time_bounds, time_bounds)
    preconditions = %{preconditions | preconditions: inner_preconditions}
    transaction = %{tx | preconditions: preconditions}
    {:ok, %{tx_build | tx: transaction}}
  end

  def set_time_bounds({:ok, %TxBuild{}}, _time_bounds), do: {:error, :invalid_time_bounds}
  def set_time_bounds(error, _time_bounds), do: error

  @impl true
  def set_preconditions({:ok, %TxBuild{tx: tx} = tx_build}, %Preconditions{} = preconditions) do
    transaction = %{tx | preconditions: preconditions}
    {:ok, %{tx_build | tx: transaction}}
  end

  def set_preconditions({:ok, %TxBuild{}}, _preconditions), do: {:error, :invalid_preconditions}
  def set_preconditions(error, _preconditions), do: error

  @impl true
  def set_base_fee({:ok, %TxBuild{tx: tx} = tx_build}, %BaseFee{} = base_fee) do
    %Transaction{operations: %Operations{count: ops_count}} = tx
    transaction = %{tx | base_fee: BaseFee.increment(base_fee, ops_count)}

    {:ok, %{tx_build | tx: transaction}}
  end

  def set_base_fee({:ok, %TxBuild{}}, _base_fee), do: {:error, :invalid_base_fee}
  def set_base_fee(error, _base_fee), do: error

  @impl true
  def set_sequence_number({:ok, %TxBuild{tx: tx} = tx_build}, %SequenceNumber{} = seq_num) do
    transaction = %{tx | sequence_number: seq_num}
    {:ok, %{tx_build | tx: transaction}}
  end

  def set_sequence_number({:ok, %TxBuild{}}, _seq_num), do: {:error, :invalid_sequence_number}
  def set_sequence_number(error, _seq_num), do: error

  @impl true
  def add_operations({:ok, %TxBuild{}} = tx_build, []), do: tx_build

  def add_operations({:ok, %TxBuild{}} = tx_build, [operation | operations]) do
    tx_build
    |> add_operation(operation)
    |> add_operations(operations)
  end

  def add_operations({:ok, %TxBuild{}}, _operations), do: {:error, :invalid_operation}
  def add_operations(error, _operations), do: error

  @impl true
  def add_operation({:ok, %TxBuild{tx: tx} = tx_build}, operation_body) do
    with %Operation{} = operation <- Operation.new(operation_body),
         %Operations{} = operations <- Operations.add(tx.operations, operation) do
      transaction = %{tx | operations: operations, base_fee: BaseFee.increment(tx.base_fee)}
      {:ok, %{tx_build | tx: transaction}}
    end
  end

  def add_operation(error, _operation), do: error

  @impl true
  def set_soroban_data({:ok, %TxBuild{}} = tx_build, soroban_data)
      when is_binary(soroban_data) do
    case check_soroban_data(soroban_data) do
      {:ok, soroban_tx_data} ->
        set_soroban_data(tx_build, soroban_tx_data)

      error ->
        error
    end
  end

  def set_soroban_data(
        {:ok, %TxBuild{tx: tx} = tx_build},
        %SorobanTransactionData{} = soroban_tx_data
      ) do
    ext = TransactionExt.new(soroban_tx_data, 1)
    transaction = %{tx | ext: ext}
    {:ok, %{tx_build | tx: transaction}}
  end

  def set_soroban_data({:ok, %TxBuild{}}, _soroban_tx_data),
    do: {:error, :invalid_soroban_data}

  def set_soroban_data(error, _soroban_data), do: error

  @impl true
  def sign({:ok, %TxBuild{}} = tx_build, []), do: tx_build

  def sign({:ok, %TxBuild{}} = tx_build, [%Signature{} = signature | signatures]) do
    tx_build
    |> sign(signature)
    |> sign(signatures)
  end

  def sign({:ok, %TxBuild{signatures: signatures} = tx_build}, %Signature{} = signature) do
    {:ok, %{tx_build | signatures: signatures ++ [signature]}}
  end

  def sign({:ok, %TxBuild{}}, _signature), do: {:error, :invalid_signature}
  def sign(error, _signature), do: error

  @impl true
  def build(
        {:ok,
         %TxBuild{tx: tx, signatures: signatures, network_passphrase: network_passphrase} =
           tx_build}
      ) do
    tx_envelope =
      TransactionEnvelope.new(
        tx: tx,
        signatures: signatures,
        network_passphrase: network_passphrase
      )

    {:ok, %{tx_build | tx_envelope: tx_envelope}}
  end

  def build(error), do: error

  @impl true
  def envelope(
        {:ok, %TxBuild{tx: tx, signatures: signatures, network_passphrase: network_passphrase}}
      ) do
    [tx: tx, signatures: signatures, network_passphrase: network_passphrase]
    |> TransactionEnvelope.new()
    |> TransactionEnvelope.to_xdr()
    |> TransactionEnvelope.to_base64()
    |> (&{:ok, &1}).()
  end

  def envelope(error), do: error

  @impl true
  def sign_envelope(tx_base64, [], _network_passphrase), do: tx_base64

  def sign_envelope({:ok, tx_base64}, signatures, network_passphrase),
    do: sign_envelope(tx_base64, signatures, network_passphrase)

  def sign_envelope(tx_base64, [%Signature{} = signature | signatures], network_passphrase) do
    tx_base64
    |> sign_envelope(signature, network_passphrase)
    |> sign_envelope(signatures, network_passphrase)
  end

  def sign_envelope(tx_base64, %Signature{} = signature, network_passphrase) do
    tx_base64
    |> TransactionEnvelope.add_signature(signature, network_passphrase)
    |> TransactionEnvelope.to_base64()
    |> (&{:ok, &1}).()
  end

  def sign_envelope(_tx_base64, _signature, _network_passphrase), do: {:error, :invalid_signature}

  @impl true
  def hash({:ok, %TxBuild{tx: tx, network_passphrase: network_passphrase}}) do
    tx
    |> Transaction.to_xdr()
    |> TransactionSignature.base_signature(network_passphrase)
    |> Base.encode16(case: :lower)
    |> (&{:ok, &1}).()
  end

  def hash(error), do: error

  @spec check_soroban_data(soroban_data :: binary()) ::
          {:ok, SorobanTransactionData.t()} | {:error, atom()}
  defp check_soroban_data(soroban_data) do
    with {:ok, raw_soroban_data} <- Base.decode64(soroban_data),
         {:ok, {%SorobanTransactionData{} = soroban_tx_data, ""}} <-
           SorobanTransactionData.decode_xdr(raw_soroban_data) do
      {:ok, soroban_tx_data}
    else
      _ ->
        {:error, :invalid_soroban_data}
    end
  end
end