sendico/frontend/pshared/lib/provider/payment/quotation/intent_builder.dart

import 'package:pshared/models/payment/asset.dart';
import 'package:pshared/models/payment/chain_network.dart';
import 'package:pshared/models/payment/currency_pair.dart';
import 'package:pshared/models/payment/customer.dart';
import 'package:pshared/models/payment/fx/intent.dart';
import 'package:pshared/models/payment/fx/side.dart';
import 'package:pshared/models/payment/kind.dart';
import 'package:pshared/models/payment/methods/card.dart';
import 'package:pshared/models/payment/methods/data.dart';
import 'package:pshared/models/payment/methods/iban.dart';
import 'package:pshared/models/payment/methods/ledger.dart';
import 'package:pshared/models/payment/methods/managed_wallet.dart';
import 'package:pshared/models/payment/methods/russian_bank.dart';
import 'package:pshared/models/payment/source.dart';
import 'package:pshared/models/payment/methods/type.dart';
import 'package:pshared/models/money.dart';
import 'package:pshared/models/payment/settlement_mode.dart';
import 'package:pshared/models/payment/intent.dart';
import 'package:pshared/models/recipient/recipient.dart';
import 'package:pshared/controllers/payment/source.dart';
import 'package:pshared/provider/payment/amount.dart';
import 'package:pshared/provider/payment/flow.dart';
import 'package:pshared/provider/recipient/provider.dart';
import 'package:pshared/utils/currency.dart';

class QuotationIntentBuilder {
  PaymentIntent? build({
    required PaymentAmountProvider payment,
    required PaymentSourceController sources,
    required PaymentFlowProvider flow,
    required RecipientsProvider recipients,
  }) {
    final selectedSource = sources.selectedSource;
    final paymentData = flow.selectedPaymentData;
    final selectedMethod = flow.selectedMethod;
    if (selectedSource == null || paymentData == null) return null;

    final customer = _buildCustomer(
      recipient: recipients.currentObject,
      method: selectedMethod,
      data: paymentData,
    );
    final sourceCurrency = _resolveSourceCurrency(selectedSource);
    if (sourceCurrency == null) return null;
    final targetCurrency = _resolveTargetCurrency(paymentData);
    final fxIntent = _buildFxIntent(
      baseCurrency: sourceCurrency,
      quoteCurrency: targetCurrency,
    );
    final amount = Money(
      amount: payment.amount.toString(),
      currency: sourceCurrency,
    );
    return PaymentIntent(
      kind: PaymentKind.payout,
      amount: amount,
      destination: paymentData,
      source: _buildSourceEndpoint(selectedSource),
      fx: fxIntent,
      settlementMode: payment.payerCoversFee
          ? SettlementMode.fixReceived
          : SettlementMode.fixSource,
      settlementCurrency: _resolveSettlementCurrency(
        amount: amount,
        fx: fxIntent,
      ),
      customer: customer,
    );
  }

  String _resolveTargetCurrency(PaymentMethodData destination) {
    // Current payout flow is RUB-settlement oriented.
    // Avoid requesting unsupported self-pairs (e.g. RUB/RUB).
    return 'RUB';
  }

  FxIntent? _buildFxIntent({
    required String baseCurrency,
    required String quoteCurrency,
  }) {
    final base = baseCurrency.trim().toUpperCase();
    final quote = quoteCurrency.trim().toUpperCase();
    if (base.isEmpty || quote.isEmpty || base == quote) {
      return null;
    }
    return FxIntent(
      pair: CurrencyPair(base: base, quote: quote),
      side: FxSide.sellBaseBuyQuote,
    );
  }

  String? _resolveSourceCurrency(PaymentSource source) {
    return switch (source.type) {
      PaymentSourceType.wallet => currencyCodeToString(source.wallet!.currency),
      PaymentSourceType.ledger => source.ledgerAccount?.currency,
    };
  }

  PaymentMethodData _buildSourceEndpoint(PaymentSource source) {
    return switch (source.type) {
      PaymentSourceType.wallet => ManagedWalletPaymentMethod(
        managedWalletRef: source.wallet!.id,
        asset: PaymentAsset(
          tokenSymbol: source.wallet?.tokenSymbol ?? '',
          chain: source.wallet?.network ?? ChainNetwork.unspecified,
        ),
      ),
      PaymentSourceType.ledger => LedgerPaymentMethod(
        ledgerAccountRef: source.ledgerAccount!.ledgerAccountRef,
      ),
    };
  }

  String _resolveSettlementCurrency({
    required Money amount,
    required FxIntent? fx,
  }) {
    final pair = fx?.pair;
    if (pair != null) {
      switch (fx?.side ?? FxSide.unspecified) {
        case FxSide.buyBaseSellQuote:
          if (pair.base.isNotEmpty) return pair.base;
          break;
        case FxSide.sellBaseBuyQuote:
          if (pair.quote.isNotEmpty) return pair.quote;
          break;
        case FxSide.unspecified:
          break;
      }
      if (amount.currency == pair.base && pair.quote.isNotEmpty) {
        return pair.quote;
      }
      if (amount.currency == pair.quote && pair.base.isNotEmpty) {
        return pair.base;
      }
      if (pair.quote.isNotEmpty) return pair.quote;
      if (pair.base.isNotEmpty) return pair.base;
    }
    return amount.currency;
  }

  Customer? _buildCustomer({
    required Recipient? recipient,
    required PaymentMethod? method,
    required PaymentMethodData? data,
  }) {
    final id = recipient?.id ?? method?.recipientRef;
    if (id == null || id.isEmpty) return null;

    final name = _resolveCustomerName(
      method: method,
      data: data,
      recipient: recipient,
    );
    final parts = name == null || name.trim().isEmpty
        ? const <String>[]
        : name.trim().split(RegExp(r'\s+'));
    final firstName = parts.isNotEmpty ? parts.first : null;
    final lastName = parts.length >= 2 ? parts.last : null;
    final middleName = parts.length > 2
        ? parts.sublist(1, parts.length - 1).join(' ')
        : null;

    return Customer(
      id: id,
      firstName: firstName,
      middleName: middleName,
      lastName: lastName,
      country: _resolveCustomerCountry(method: method, data: data),
    );
  }

  String? _resolveCustomerName({
    required PaymentMethod? method,
    required PaymentMethodData? data,
    required Recipient? recipient,
  }) {
    final card = method?.cardData ?? (data is CardPaymentMethod ? data : null);
    if (card != null) {
      final fullName = '${card.firstName} ${card.lastName}'.trim();
      if (fullName.isNotEmpty) return fullName;
    }

    final iban = method?.ibanData ?? (data is IbanPaymentMethod ? data : null);
    if (iban != null && iban.accountHolder.trim().isNotEmpty) {
      return iban.accountHolder.trim();
    }

    final bank =
        method?.bankAccountData ??
        (data is RussianBankAccountPaymentMethod ? data : null);
    if (bank != null && bank.recipientName.trim().isNotEmpty) {
      return bank.recipientName.trim();
    }

    final recipientName = recipient?.name.trim();
    return recipientName?.isNotEmpty == true ? recipientName : null;
  }

  String? _resolveCustomerCountry({
    required PaymentMethod? method,
    required PaymentMethodData? data,
  }) {
    final card = method?.cardData ?? (data is CardPaymentMethod ? data : null);
    return card?.country;
  }
}