import { AuditLogger, AuditEventType } from '@/audit/logger/logger';
import { PaymentRepository } from '@/repositories/payment-repository';
import { TestHelpers } from '../utils/test-helpers';
import { PaymentType, Currency } from '@/models/payment';
import { PaymentRequest } from '@/gateway/validation/payment-validation';

describe('Audit Logging Compliance', () => {
  let paymentRepository: PaymentRepository;
  let testOperator: any;

  beforeAll(async () => {
    paymentRepository = new PaymentRepository();
  });

  beforeEach(async () => {
    await TestHelpers.cleanDatabase();
    testOperator = await TestHelpers.createTestOperator('TEST_AUDIT', 'MAKER' as any);
  });

  afterAll(async () => {
    await TestHelpers.cleanDatabase();
  });

  describe('Payment Event Logging', () => {
    it('should log payment initiation event', async () => {
      const paymentRequest: PaymentRequest = {
        type: PaymentType.CUSTOMER_CREDIT_TRANSFER,
        amount: 1000,
        currency: Currency.USD,
        senderAccount: 'ACC001',
        senderBIC: 'TESTBIC1',
        receiverAccount: 'ACC002',
        receiverBIC: 'TESTBIC2',
        beneficiaryName: 'Test Beneficiary',
      };

      const testPaymentId = await paymentRepository.create(
        paymentRequest,
        testOperator.id,
        `TEST-AUDIT-${Date.now()}`
      );

      const eventType = AuditEventType.PAYMENT_INITIATED;
      
      await AuditLogger.logPaymentEvent(
        eventType,
        testPaymentId,
        testOperator.id,
        {
          amount: 1000,
          currency: 'USD',
        }
      );

      expect(true).toBe(true);
    });

    it('should log payment approval event', async () => {
      const paymentRequest: PaymentRequest = {
        type: PaymentType.CUSTOMER_CREDIT_TRANSFER,
        amount: 1000,
        currency: Currency.USD,
        senderAccount: 'ACC001',
        senderBIC: 'TESTBIC1',
        receiverAccount: 'ACC002',
        receiverBIC: 'TESTBIC2',
        beneficiaryName: 'Test Beneficiary',
      };

      const paymentId = await paymentRepository.create(
        paymentRequest,
        testOperator.id,
        `TEST-AUDIT-${Date.now()}`
      );

      const checkerOperator = await TestHelpers.createTestOperator('TEST_CHECKER_AUDIT', 'CHECKER' as any);
      
      await AuditLogger.logPaymentEvent(
        AuditEventType.PAYMENT_APPROVED,
        paymentId,
        checkerOperator.id
      );

      expect(true).toBe(true);
    });

    it('should log payment rejection event', async () => {
      const paymentRequest: PaymentRequest = {
        type: PaymentType.CUSTOMER_CREDIT_TRANSFER,
        amount: 1000,
        currency: Currency.USD,
        senderAccount: 'ACC001',
        senderBIC: 'TESTBIC1',
        receiverAccount: 'ACC002',
        receiverBIC: 'TESTBIC2',
        beneficiaryName: 'Test Beneficiary',
      };

      const paymentId = await paymentRepository.create(
        paymentRequest,
        testOperator.id,
        `TEST-AUDIT-${Date.now()}`
      );

      await AuditLogger.logPaymentEvent(
        AuditEventType.PAYMENT_REJECTED,
        paymentId,
        testOperator.id,
        {
          reason: 'Test rejection',
        }
      );

      expect(true).toBe(true);
    });
  });

  describe('Compliance Screening Logging', () => {
    it('should log compliance screening events', async () => {
      const paymentRequest: PaymentRequest = {
        type: PaymentType.CUSTOMER_CREDIT_TRANSFER,
        amount: 1000,
        currency: Currency.USD,
        senderAccount: 'ACC001',
        senderBIC: 'TESTBIC1',
        receiverAccount: 'ACC002',
        receiverBIC: 'TESTBIC2',
        beneficiaryName: 'Test Beneficiary',
      };

      const paymentId = await paymentRepository.create(
        paymentRequest,
        testOperator.id,
        `TEST-AUDIT-${Date.now()}`
      );

      const screeningId = 'test-screening-123';
      
      await AuditLogger.logComplianceScreening(
        paymentId,
        screeningId,
        'PASS',
        {
          beneficiaryName: 'Test Beneficiary',
          screenedAt: new Date().toISOString(),
        }
      );

      expect(true).toBe(true);
    });

    it('should log screening failures with reasons', async () => {
      const paymentRequest: PaymentRequest = {
        type: PaymentType.CUSTOMER_CREDIT_TRANSFER,
        amount: 1000,
        currency: Currency.USD,
        senderAccount: 'ACC001',
        senderBIC: 'TESTBIC1',
        receiverAccount: 'ACC002',
        receiverBIC: 'TESTBIC2',
        beneficiaryName: 'Test Beneficiary',
      };

      const paymentId = await paymentRepository.create(
        paymentRequest,
        testOperator.id,
        `TEST-AUDIT-${Date.now()}`
      );

      const screeningId = 'test-screening-fail-123';
      
      await AuditLogger.logComplianceScreening(
        paymentId,
        screeningId,
        'FAIL',
        {
          reasons: ['Sanctions match', 'BIC on blocked list'],
        }
      );

      expect(true).toBe(true);
    });
  });

  describe('Ledger Posting Logging', () => {
    it('should log ledger posting events', async () => {
      const paymentRequest: PaymentRequest = {
        type: PaymentType.CUSTOMER_CREDIT_TRANSFER,
        amount: 1000,
        currency: Currency.USD,
        senderAccount: 'ACC001',
        senderBIC: 'TESTBIC1',
        receiverAccount: 'ACC002',
        receiverBIC: 'TESTBIC2',
        beneficiaryName: 'Test Beneficiary',
      };

      const paymentId = await paymentRepository.create(
        paymentRequest,
        testOperator.id,
        `TEST-AUDIT-${Date.now()}`
      );

      const transactionId = 'test-txn-123';
      
      await AuditLogger.logLedgerPosting(
        paymentId,
        transactionId,
        'ACC001',
        1000,
        'USD',
        {
          transactionType: 'DEBIT',
        }
      );

      expect(true).toBe(true);
    });
  });

  describe('Message Event Logging', () => {
    it('should log message generation events', async () => {
      const paymentRequest: PaymentRequest = {
        type: PaymentType.CUSTOMER_CREDIT_TRANSFER,
        amount: 1000,
        currency: Currency.USD,
        senderAccount: 'ACC001',
        senderBIC: 'TESTBIC1',
        receiverAccount: 'ACC002',
        receiverBIC: 'TESTBIC2',
        beneficiaryName: 'Test Beneficiary',
      };

      const paymentId = await paymentRepository.create(
        paymentRequest,
        testOperator.id,
        `TEST-AUDIT-${Date.now()}`
      );

      const messageId = 'test-msg-123';
      const uetr = '550e8400-e29b-41d4-a716-446655440000';
      
      await AuditLogger.logMessageEvent(
        AuditEventType.MESSAGE_GENERATED,
        paymentId,
        messageId,
        uetr,
        {
          messageType: 'pacs.008',
          msgId: 'MSG-12345',
        }
      );

      expect(true).toBe(true);
    });
  });

  describe('Audit Trail Integrity', () => {
    it('should maintain chronological order of events', async () => {
      const paymentRequest: PaymentRequest = {
        type: PaymentType.CUSTOMER_CREDIT_TRANSFER,
        amount: 1000,
        currency: Currency.USD,
        senderAccount: 'ACC001',
        senderBIC: 'TESTBIC1',
        receiverAccount: 'ACC002',
        receiverBIC: 'TESTBIC2',
        beneficiaryName: 'Test Beneficiary',
      };

      const paymentId = await paymentRepository.create(
        paymentRequest,
        testOperator.id,
        `TEST-AUDIT-${Date.now()}`
      );

      const events = [
        { type: AuditEventType.PAYMENT_INITIATED, timestamp: new Date() },
        { type: AuditEventType.PAYMENT_APPROVED, timestamp: new Date(Date.now() + 1000) },
        { type: AuditEventType.MESSAGE_GENERATED, timestamp: new Date(Date.now() + 2000) },
      ];

      for (const event of events) {
        await AuditLogger.logPaymentEvent(
          event.type,
          paymentId,
          testOperator.id
        );
        await new Promise(resolve => setTimeout(resolve, 100));
      }

      expect(true).toBe(true);
    });

    it('should include all required audit fields', async () => {
      const paymentRequest: PaymentRequest = {
        type: PaymentType.CUSTOMER_CREDIT_TRANSFER,
        amount: 1000,
        currency: Currency.USD,
        senderAccount: 'ACC001',
        senderBIC: 'TESTBIC1',
        receiverAccount: 'ACC002',
        receiverBIC: 'TESTBIC2',
        beneficiaryName: 'Test Beneficiary',
      };

      const paymentId = await paymentRepository.create(
        paymentRequest,
        testOperator.id,
        `TEST-AUDIT-${Date.now()}`
      );

      await AuditLogger.logPaymentEvent(
        AuditEventType.PAYMENT_INITIATED,
        paymentId,
        testOperator.id,
        {
          testField: 'testValue',
        }
      );

      expect(true).toBe(true);
    });
  });
});