import 'dart:convert';

import 'package:test/test.dart';

import 'package:pshared/api/requests/payment/initiate.dart';
import 'package:pshared/api/requests/payment/initiate_payments.dart';
import 'package:pshared/api/requests/payment/quote.dart';
import 'package:pshared/data/dto/money.dart';
import 'package:pshared/data/dto/payment/endpoint.dart';
import 'package:pshared/data/dto/payment/intent/payment.dart';
import 'package:pshared/data/mapper/payment/payment.dart';
import 'package:pshared/models/payment/asset.dart';
import 'package:pshared/models/payment/chain_network.dart';
import 'package:pshared/models/payment/methods/card_token.dart';
import 'package:pshared/models/payment/methods/crypto_address.dart';
import 'package:pshared/models/payment/methods/managed_wallet.dart';

void main() {
  group('Payment request DTO contract', () {
    test('serializes endpoint types to backend canonical values', () {
      final managed = ManagedWalletPaymentMethod(
        managedWalletRef: 'mw-1',
      ).toDTO();
      final external = CryptoAddressPaymentMethod(
        asset: const PaymentAsset(
          chain: ChainNetwork.tronMainnet,
          tokenSymbol: 'USDT',
        ),
        address: 'TXYZ',
      ).toDTO();
      final cardToken = CardTokenPaymentMethod(
        token: 'tok_1',
        maskedPan: '4111',
      ).toDTO();

      expect(managed.type, equals('managedWallet'));
      expect(external.type, equals('cryptoAddress'));
      expect(cardToken.type, equals('cardToken'));
    });

    test('quote payment request uses expected backend field names', () {
      final request = QuotePaymentRequest(
        idempotencyKey: 'idem-1',
        previewOnly: true,
        intent: const PaymentIntentDTO(
          kind: 'payout',
          source: PaymentEndpointDTO(
            type: 'ledger',
            data: {'ledger_account_ref': 'ledger:src'},
          ),
          destination: PaymentEndpointDTO(
            type: 'cardToken',
            data: {'token': 'tok_1', 'masked_pan': '4111'},
          ),
          amount: MoneyDTO(amount: '10', currency: 'USD'),
          settlementMode: 'fix_received',
        ),
      );

      final json =
          jsonDecode(jsonEncode(request.toJson())) as Map<String, dynamic>;

      expect(json['idempotencyKey'], equals('idem-1'));
      expect(json['previewOnly'], isTrue);
      expect(json['intent'], isA<Map<String, dynamic>>());

      final intent = json['intent'] as Map<String, dynamic>;
      expect(intent['kind'], equals('payout'));
      expect(intent['settlement_mode'], equals('fix_received'));
      expect(intent.containsKey('settlement_currency'), isFalse);

      final source = intent['source'] as Map<String, dynamic>;
      final destination = intent['destination'] as Map<String, dynamic>;
      expect(source['type'], equals('ledger'));
      expect(destination['type'], equals('cardToken'));
    });

    test('initiate payment by quote keeps expected fields', () {
      final request = InitiatePaymentRequest(
        idempotencyKey: 'idem-2',
        quoteRef: 'q-1',
        metadata: const {'intent_ref': 'intent-1'},
      );

      final json = request.toJson();
      expect(json['idempotencyKey'], equals('idem-2'));
      expect(json['quoteRef'], equals('q-1'));
      expect(
        (json['metadata'] as Map<String, dynamic>)['intent_ref'],
        equals('intent-1'),
      );
      expect(json.containsKey('intent'), isTrue);
      expect(json['intent'], isNull);
    });

    test('initiate multi payments request keeps expected fields', () {
      final request = InitiatePaymentsRequest(
        idempotencyKey: 'idem-3',
        quoteRef: 'q-2',
        metadata: const {'client_payment_ref': 'cp-1'},
      );

      final json = request.toJson();
      expect(json['idempotencyKey'], equals('idem-3'));
      expect(json['quoteRef'], equals('q-2'));
      expect(
        (json['metadata'] as Map<String, dynamic>)['client_payment_ref'],
        equals('cp-1'),
      );
    });
  });
}