// ❌ Anti-Pattern: Concurrent transfer requests with no lock — double-spend vulnerability

class LedgerService {
  private accounts = new Map<string, number>()

  async transfer(fromId: string, toId: string, amount: number): Promise<void> {
    const balance = this.accounts.get(fromId) ?? 0

    if (balance < amount) {
      throw new Error('Insufficient funds')
    }

    // ⚠️ Race window: two simultaneous calls both pass the balance check
    // before either writes the debit. Both see balance = 1000.
    // Both transfer 800. Final balance: -600.
    await this.persist('debit', fromId, amount)  // await = yield event loop
    await this.persist('credit', toId, amount)
  }
}

// Simulated concurrent requests — both pass the balance check simultaneously
const ledger = new LedgerService()
await Promise.all([
  ledger.transfer('acc-1', 'acc-2', 800),
  ledger.transfer('acc-1', 'acc-3', 800),
])
// Result: acc-1 balance = -600. acc-2 and acc-3 each credited 800.

// Nominal types prevent silent ID swaps — UserId ≠ AccountId at the type level
declare const __brand: unique symbol
type Brand<T, B> = T & { [__brand]: B }

type UserId    = Brand<string, 'UserId'>
type AccountId = Brand<string, 'AccountId'>
type Money     = Brand<number, 'Money'>       // Always in cents — no float arithmetic

const toMoney = (cents: number): Money => {
  if (!Number.isInteger(cents) || cents < 0) throw new Error('Money must be non-negative integer cents')
  return cents as Money
}

// Functional error handling: failures are values, not control flow
type Ok<T>  = { ok: true;  value: T }
type Err<E> = { ok: false; error: E }
type Result<T, E = string> = Ok<T> | Err<E>

const ok  = <T>(value: T): Ok<T>   => ({ ok: true,  value })
const err = <E>(error: E): Err<E>  => ({ ok: false, error })

interface Transaction {
  id: string
  type: 'credit' | 'debit'
  amount: Money
  timestamp: Date
  description: string
}

class LedgerAccount {
  private _balance: Money
  private _transactions: Transaction[] = []

  constructor(
    private readonly id: AccountId,
    private readonly ownerId: UserId,
    initialBalance: Money,
  ) {
    this._balance = initialBalance
  }

  get balance(): Money { return this._balance }
  get id(): AccountId  { return this.id }

  credit(amount: Money, description: string): Result<Transaction> {
    if (amount <= 0) return err('Credit amount must be positive')

    const tx: Transaction = {
      id: `tx_${Date.now()}_${Math.random().toString(36).slice(2)}`,
      type: 'credit',
      amount,
      timestamp: new Date(),
      description,
    }
    this._balance = toMoney(this._balance + amount)
    this._transactions.push(tx)
    return ok(tx)
  }

  debit(amount: Money, description: string): Result<Transaction> {
    if (amount <= 0)            return err('Debit amount must be positive')
    if (amount > this._balance) return err(`Insufficient funds: balance ${this._balance}, requested ${amount}`)

    const tx: Transaction = {
      id: `tx_${Date.now()}_${Math.random().toString(36).slice(2)}`,
      type: 'debit',
      amount,
      timestamp: new Date(),
      description,
    }
    this._balance = toMoney(this._balance - amount)
    this._transactions.push(tx)
    return ok(tx)
  }

  getHistory(): readonly Transaction[] {
    return this._transactions
  }
}

// AsyncMutex: per-account lock that serializes concurrent async operations
// Uses a promise chain — zero dependencies, pure Node.js
class AsyncMutex {
  private queue: Promise<void> = Promise.resolve()

  async acquire<T>(fn: () => Promise<T>): Promise<T> {
    // Append this work to the end of the current queue.
    // Each waiter chains off the previous lock release.
    const result = this.queue.then(fn)
    // Advance the queue past this work item (swallowing errors so the chain continues)
    this.queue = result.then(
      () => undefined,
      () => undefined,
    )
    return result
  }
}

// ✅ Fixed LedgerService with per-account mutex
class SafeLedgerService {
  private accounts = new Map<AccountId, LedgerAccount>()
  private mutexes  = new Map<AccountId, AsyncMutex>()

  private getMutex(id: AccountId): AsyncMutex {
    if (!this.mutexes.has(id)) this.mutexes.set(id, new AsyncMutex())
    return this.mutexes.get(id)!
  }

  async transfer(
    fromId: AccountId,
    toId: AccountId,
    amount: Money,
  ): Promise<Result<{ debitTx: Transaction; creditTx: Transaction }>> {
    // Lock both accounts in a canonical order to prevent deadlock
    const [first, second] = [fromId, toId].sort() as [AccountId, AccountId]

    return this.getMutex(first).acquire(() =>
      this.getMutex(second).acquire(async () => {
        const from = this.accounts.get(fromId)
        const to   = this.accounts.get(toId)
        if (!from) return err(`Account ${fromId} not found`)
        if (!to)   return err(`Account ${toId} not found`)

        const debitResult = from.debit(amount, `Transfer to ${toId}`)
        if (!debitResult.ok) return err(debitResult.error)

        const creditResult = to.credit(amount, `Transfer from ${fromId}`)
        if (!creditResult.ok) {
          // Compensate: re-credit the source (saga compensation)
          from.credit(amount, `Reversal — credit failed for ${toId}`)
          return err(creditResult.error)
        }

        return ok({ debitTx: debitResult.value, creditTx: creditResult.value })
      }),
    )
  }
}

// Port interface — high-level policy depends on this abstraction, not concrete SDKs
interface PaymentGateway {
  charge(amount: Money, currency: string, token: string): Promise<Result<string>>
  refund(chargeId: string, amount: Money): Promise<Result<void>>
}

// Strategy registry — replaces if/else chains with a keyed registry
class PaymentStrategyRegistry {
  private readonly gateways = new Map<string, PaymentGateway>()

  register(name: string, gateway: PaymentGateway): this {
    this.gateways.set(name, gateway)
    return this
  }

  resolve(name: string): Result<PaymentGateway> {
    const gw = this.gateways.get(name)
    return gw ? ok(gw) : err(`Unknown payment gateway: "${name}"`)
  }
}

// Adapter — wraps the Stripe SDK behind the PaymentGateway port
class StripeAdapter implements PaymentGateway {
  constructor(private readonly apiKey: string) {}

  async charge(amount: Money, currency: string, token: string): Promise<Result<string>> {
    try {
      // In production: const charge = await stripe.charges.create(...)
      const chargeId = `ch_${Date.now()}`
      return ok(chargeId)
    } catch (e) {
      return err(`Stripe charge failed: ${(e as Error).message}`)
    }
  }

  async refund(chargeId: string, amount: Money): Promise<Result<void>> {
    try {
      // In production: await stripe.refunds.create({ charge: chargeId, amount })
      return ok(undefined)
    } catch (e) {
      return err(`Stripe refund failed: ${(e as Error).message}`)
    }
  }
}

type EventHandler<T> = (payload: T) => Promise<void> | void

class DomainEventBus {
  private handlers = new Map<string, EventHandler<unknown>[]>()

  on<T>(event: string, handler: EventHandler<T>): void {
    const existing = this.handlers.get(event) ?? []
    this.handlers.set(event, [...existing, handler as EventHandler<unknown>])
  }

  async emit<T>(event: string, payload: T): Promise<void> {
    const handlers = this.handlers.get(event) ?? []
    await Promise.allSettled(handlers.map(h => h(payload)))
  }
}

// Usage: observers subscribe without coupling to the payment service
const bus = new DomainEventBus()

bus.on<{ accountId: AccountId; amount: Money }>('transfer.completed', async ({ accountId, amount }) => {
  console.log(`[Audit] Account ${accountId} transferred ${amount} cents`)
})

bus.on<{ accountId: AccountId; amount: Money }>('transfer.completed', async ({ accountId, amount }) => {
  // Fraud detection — fires concurrently with audit via Promise.allSettled
  if (amount > toMoney(1_000_000)) {
    console.warn(`[Fraud] Large transfer flagged: ${amount} cents on ${accountId}`)
  }
})

interface LedgerRepository {
  findById(id: AccountId): Promise<LedgerAccount | null>
  save(account: LedgerAccount): Promise<void>
  findByOwner(ownerId: UserId): Promise<LedgerAccount[]>
}

// Interview-ready: Map-backed, async-delayed to simulate real I/O
class InMemoryLedgerRepository implements LedgerRepository {
  private store = new Map<AccountId, LedgerAccount>()

  private delay(ms = 10): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms))
  }

  async findById(id: AccountId): Promise<LedgerAccount | null> {
    await this.delay()
    return this.store.get(id) ?? null
  }

  async save(account: LedgerAccount): Promise<void> {
    await this.delay()
    this.store.set(account.id, account)
  }

  async findByOwner(ownerId: UserId): Promise<LedgerAccount[]> {
    await this.delay()
    return [...this.store.values()].filter(a => a.ownerId === ownerId)
  }
}

Minutes 0–10   → Requirements & API Contracts
Minutes 10–20  → Domain Model & UML Sketch (Mermaid.js)
Minutes 20–45  → Core Implementation (aggregates, ports, adapters)
Minutes 45–55  → Concurrency & Edge Cases (mutex, compensation)
Minutes 55–60  → Tests: verify invariants and race conditions

// Assemble the full production system
async function buildProductionEngine() {
  const repo    = new InMemoryLedgerRepository()
  const ledger  = new SafeLedgerService()
  const bus     = new DomainEventBus()
  const registry = new PaymentStrategyRegistry()
    .register('stripe', new StripeAdapter(process.env.STRIPE_KEY ?? 'sk_test_***'))

  // Wire domain events
  bus.on<{ from: AccountId; to: AccountId; amount: Money }>('transfer.completed', async (e) => {
    console.log(`[Audit] Transfer ${e.amount}¢: ${e.from} → ${e.to}`)
  })

  // Seed accounts
  const acc1 = 'acc_001' as AccountId
  const acc2 = 'acc_002' as AccountId
  ledger.accounts.set(acc1, new LedgerAccount(acc1, 'usr_1' as UserId, toMoney(100_000)))
  ledger.accounts.set(acc2, new LedgerAccount(acc2, 'usr_2' as UserId, toMoney(50_000)))

  // Concurrent transfer stress test — proves mutex works
  const transfers = Array.from({ length: 10 }, (_, i) =>
    ledger.transfer(acc1, acc2, toMoney(5_000))
  )
  const results = await Promise.all(transfers)

  const succeeded = results.filter(r => r.ok).length
  const failed    = results.filter(r => !r.ok).length

  console.log(`Transfers: ${succeeded} succeeded, ${failed} failed`)
  // Expected: 10 succeed (acc1 had 100k, 10 × 5k = 50k)
  // acc1 final balance: 50_000 (= 100_000 - 10 × 5_000)
}