import { EventEmitter } from 'events';

// ==========================================
// 1. ARCHITECTURE DEFINITIONS & TYPES
// ==========================================
interface Transaction {
  idempotencyKey: string;
  txId: string;
  amountInCents: number;
  direction: 'INBOUND_CHARGE' | 'OUTBOUND_PAYOUT';
  account: string;
}

enum Rail {
  FEDNOW = 'FEDNOW_REALTIME_API',
  ACH = 'SAME_DAY_ACH_BATCH',
  WIRE = 'FEDWIRE_HIGH_VALUE'
}

// ==========================================
// 2. THE ENTERPRISE CORE ENGINE
// ==========================================
class HyperScalePaymentSystem {
  // Real-time state memory pools
  private processedKeys = new Set<string>();
  private ledger: Array<{ txId: string; type: 'DEBIT' | 'CREDIT'; amount: number; account: string; time: number }> = [];
  private eventBus = new EventEmitter();

  constructor() {
    this.initializeCoreListeners();
  }

  /**
   * Gateway entry point for incoming requests
   */
  public async handleTransactionRequest(req: Transaction): Promise<string> {
    // IDEMPOTENCY GUARD: Prevent duplicate execution crashes or double charges
    if (this.processedKeys.has(req.idempotencyKey)) {
      return `[REJECTED] Duplicate transaction request blocked for key: ${req.idempotencyKey}`;
    }
    this.processedKeys.add(req.idempotencyKey);

    // ASYNC INGESTION: Drop transaction into message bus and return acceptance immediately
    this.eventBus.emit('ingest_transaction', req);
    return `[ACCEPTED] Transaction ${req.txId} queued successfully for processing.`;
  }

  /**
   * Core Distributed Event Pipelines
   */
  private initializeCoreListeners() {
    this.eventBus.on('ingest_transaction', async (tx: Transaction) => {
      console.log(`\n⚡ [SYSTEM EVENT] Processing Tx: ${tx.txId} ($${(tx.amountInCents / 100).toFixed(2)})`);
      
      // 1. EXECUTE DOUBLE-ENTRY ACCOUNTING LOCK
      const now = Date.now();
      if (tx.direction === 'INBOUND_CHARGE') {
        this.ledger.push({ txId: tx.txId, type: 'DEBIT', amount: tx.amountInCents, account: `CUSTOMER:${tx.account}`, time: now });
        this.ledger.push({ txId: tx.txId, type: 'CREDIT', amount: tx.amountInCents, account: 'INTERNAL_TREASURY_REVENUE', time: now });
      } else {
        this.ledger.push({ txId: tx.txId, type: 'DEBIT', amount: tx.amountInCents, account: 'INTERNAL_TREASURY_REVENUE', time: now });
        this.ledger.push({ txId: tx.txId, type: 'CREDIT', amount: tx.amountInCents, account: `YOUR_EXTERNAL_BANK:${tx.account}`, time: now });
      }
      console.log(` └─► [LEDGER COMMITTED] Write-Only record locked in database.`);

      // 2. EXECUTE SMART ROUTING RULES
      const optimalRail = this.calculateSmartRoute(tx.amountInCents, tx.direction);
      console.log(` └─► [ROUTING OUTCOME] Dispatched via network rail: [${optimalRail}]`);
      console.log(` ✓ [SETTLED] State finalized across clearing networks.`);
    });
  }

  /**
   * Smart Router logic based on monetary cost constraints
   */
  private calculateSmartRoute(amount: number, direction: 'INBOUND_CHARGE' | 'OUTBOUND_PAYOUT'): Rail {
    if (amount >= 10000000) return Rail.WIRE; // Transactions over $100k route through high-security FedWire
    if (direction === 'OUTBOUND_PAYOUT' || amount < 500000) return Rail.FEDNOW; // Instant settlement for rapid funds clear
    return Rail.ACH; // High volume non-urgent charges batch over ACH to reduce interchange fees
  }

  /**
   * Total account system validation audit helper
   */
  public dumpAuditLogs() {
    console.log(`\n================== SYSTEM RECONCILIATION AUDIT ==================`);
    console.table(this.ledger);
    console.log(`=================================================================`);
  }
}

// ==========================================
// 3. RUN INTERACTIVE SIMULATION RUNNER
// ==========================================
async function runSystemDemo() {
  const paymentEngine = new HyperScalePaymentSystem();

  // Scenario A: Customer pays you $1,500.00
  const response1 = await paymentEngine.handleTransactionRequest({
    idempotencyKey: "id_key_001_prod",
    txId: "tx_99210_charge",
    amountInCents: 150000,
    direction: "INBOUND_CHARGE",
    account: "user_wallet_abc"
  });
  console.log(response1);

  // Scenario B: Networks experience latency and resend the identical payload
  const response1Duplicate = await paymentEngine.handleTransactionRequest({
    idempotencyKey: "id_key_001_prod",
    txId: "tx_99210_charge",
    amountInCents: 150000,
    direction: "INBOUND_CHARGE",
    account: "user_wallet_abc"
  });
  console.log(response1Duplicate);

  // Scenario C: Automated sweep pays out $120,000.00 directly to your corporate holding bank
  const response2 = await paymentEngine.handleTransactionRequest({
    idempotencyKey: "id_key_002_prod",
    txId: "tx_99211_payout",
    amountInCents: 12000000,
    direction: "OUTBOUND_PAYOUT",
    account: "holding_acc_9922"
  });
  console.log(response2);

  // Yield runtime execution processing cycles to completely flush the event pipeline
  setTimeout(() => {
    paymentEngine.dumpAuditLogs();
  }, 100);
}

runSystemDemo();