// ❌ Anti-Pattern: Hollow data-bag — public mutation with no invariant protection
class BankAccount {
  public id: string;
  public balance: number;
  public currency: string;
  public ownerId: string;

  constructor(id: string, balance: number, currency: string, ownerId: string) {
    this.id = id;
    this.balance = balance;
    this.currency = currency;
    this.ownerId = ownerId;
  }
}

// Caller code — no barriers whatsoever
const account = new BankAccount('acc_001', 1000, 'USD', 'usr_042');
account.balance = -99999;        // Silent corruption — bypasses all business rules
account.currency = 'MONOPOLY';   // Nonsense value accepted without complaint
console.log(Object.keys(account)); // ['id', 'balance', 'currency', 'ownerId'] — fully exposed

class LedgerEntry {
  readonly entryId: string;
  private readonly amount: number;

  constructor(entryId: string, amount: number) {
    this.entryId = entryId;
    this.amount = amount;
  }

  getAmount(): number {
    return this.amount;
  }
}

// ✅ What V8 actually executes — no types, no private, no readonly
"use strict";
class LedgerEntry {
  constructor(entryId, amount) {
    this.entryId = entryId;
    this.amount = amount;   // ← "private" is completely gone
  }
  getAmount() {
    return this.amount;
  }
}

class AccountBalance {
  private balance: number = 0;

  deposit(amount: number): void {
    this.balance += amount;
  }
}

const acct = new AccountBalance();
acct.deposit(500);

// TypeScript compiler rejects this line:
// acct.balance  ← TS Error: Property 'balance' is private

// But at runtime, every JavaScript technique works:
console.log((acct as any).balance);           // 500 — type assertion bypasses TS
console.log(Object.keys(acct));                // ['balance'] — fully enumerable
console.log(JSON.stringify(acct));             // {"balance":500} — serialized in plain JSON
console.log(Reflect.ownKeys(acct));            // ['balance'] — visible to reflection

class AccountBalance {
  #balance: number = 0;   // ECMAScript native private field

  deposit(amount: number): void {
    this.#balance += amount;
  }

  getBalance(): number {
    return this.#balance;
  }
}

const acct = new AccountBalance();
acct.deposit(500);

// TypeScript rejects access attempts:
// acct.#balance  ← SyntaxError at parse time

// At runtime, all bypass techniques fail hard:
console.log((acct as any)['#balance']);        // undefined — PrivateName is not a string key
console.log(Object.keys(acct));                // [] — not enumerable
console.log(JSON.stringify(acct));             // {} — not serialized
console.log(Reflect.ownKeys(acct));            // [] — not reflected

// ❌ Verbose — three lines of repetition per field
class OrderLine {
  private readonly productId: string;
  private quantity: number;
  private unitPrice: number;

  constructor(productId: string, quantity: number, unitPrice: number) {
    this.productId = productId;
    this.quantity = quantity;
    this.unitPrice = unitPrice;
  }
}

// ✅ Parameter properties — declares and assigns in one expression
class OrderLine {
  constructor(
    private readonly productId: string,
    private quantity: number,
    private unitPrice: number,
  ) {}

  lineTotal(): number {
    return this.quantity * this.unitPrice;
  }
}

class Account {
  protected readonly accountId: string;
  protected balance: number;

  constructor(accountId: string, initialBalance: number) {
    this.accountId = accountId;
    this.balance = initialBalance;
    console.log(`[Account] constructor — balance: ${this.balance}`);
  }
}

class SavingsAccount extends Account {
  // 1. Field initializer — runs AFTER super() returns, BEFORE constructor body
  private readonly interestRate: number = 0.045;

  constructor(accountId: string, initialBalance: number) {
    super(accountId, initialBalance); // ← 2. Base class constructor runs here
    // 3. Derived constructor body — interestRate is already set to 0.045
    console.log(`[Savings] constructor — rate: ${this.interestRate}`);
  }

  applyInterest(): void {
    this.balance += this.balance * this.interestRate;
  }
}

const savings = new SavingsAccount('acc_007', 10_000);
// Output:
// [Account] constructor — balance: 10000
// [Savings] constructor — rate: 0.045

class Base {
  constructor() {
    this.validate(); // ← Called during super(), before derived field initializers run
  }
  validate(): void {}
}

class Derived extends Base {
  // Field initializer runs AFTER super() completes
  private readonly limit: number = 1000;

  override validate(): void {
    // ❌ this.limit is undefined here — super() hasn't finished yet
    if (this.limit < 0) throw new Error('Invalid limit');
  }
}

new Derived(); // No error thrown — limit is undefined, not < 0

class TransactionProcessor {
  private readonly processorId: string;

  constructor(processorId: string) {
    this.processorId = processorId;
  }

  // ✅ Prototype method — allocated once on the prototype, shared by all instances
  process(amount: number): string {
    return `[${this.processorId}] processed ${amount}`;
  }
}

const p1 = new TransactionProcessor('proc_001');
const p2 = new TransactionProcessor('proc_002');

// Both instances share the exact same function object
console.log(p1.process === p2.process); // true — same V8 heap reference

class TransactionProcessor {
  private readonly processorId: string;

  constructor(processorId: string) {
    this.processorId = processorId;
  }

  // ❌ Arrow function field — new closure allocated per instance
  process = (amount: number): string => {
    return `[${this.processorId}] processed ${amount}`;
  };
}

const p1 = new TransactionProcessor('proc_001');
const p2 = new TransactionProcessor('proc_002');

// Each instance has its own separate function closure
console.log(p1.process === p2.process); // false — different heap objects

// Prototype method version: memory per instance
// = fixed object overhead (~56 bytes on V8 x64)
// + string for processorId
// + prototype pointer (shared — not duplicated)

// Arrow function field version: memory per instance
// = fixed object overhead (~56 bytes)
// + string for processorId
// + NEW function closure object (~128 bytes) ← duplicated 100,000 times

// Approximate extra heap cost for 100,000 instances:
// 100,000 × 128 bytes ≈ 12.8 MB of additional closure allocations

class MonetaryBalance {
  #cents: number;

  constructor(initialCents: number) {
    // Invariant enforced at construction time
    if (initialCents < 0) throw new RangeError('Balance cannot be negative');
    this.#cents = initialCents;
  }

  get cents(): number {
    return this.#cents;
  }

  set cents(value: number) {
    // ✅ Invariant enforced at every write — no caller can bypass this
    if (value < 0) throw new RangeError(`Cannot set balance to ${value} cents`);
    if (!Number.isInteger(value)) throw new TypeError('Balance must be whole cents');
    this.#cents = value;
  }

  get dollars(): number {
    // Derived property — computed from source of truth, never stored separately
    return this.#cents / 100;
  }
}

const balance = new MonetaryBalance(50000); // $500.00
balance.cents = -1;   // ❌ Throws RangeError: Cannot set balance to -1 cents
balance.cents = 50.5; // ❌ Throws TypeError: Balance must be whole cents
balance.cents = 75000; // ✅ Sets to $750.00

// ❌ NEVER do this — async getter is a footgun
class AccountView {
  private accountId: string;

  constructor(accountId: string) {
    this.accountId = accountId;
  }

  // This getter returns a Promise, not a number — callers must know to await it
  // but the syntax `account.balance` looks synchronous, so they often don't
  get balance(): Promise<number> {
    return fetch(`/api/accounts/${this.accountId}`)
      .then(r => r.json())
      .then(data => data.balance);
  }
}

// Caller is fooled by the synchronous-looking syntax
const account = new AccountView('acc_001');
console.log(account.balance); // Logs: Promise { <pending> } — not a number

class LedgerConfig {
  // Static field — class-level constant, not per-instance
  static readonly MAX_TRANSACTION_AMOUNT_CENTS = 10_000_000; // $100,000.00

  // Static block (TS 4.9+ / ES2022) — executes once on first module load
  static {
    const envMax = parseInt(process.env.MAX_TX_CENTS ?? '');
    if (!isNaN(envMax) && envMax > 0) {
      // Mutating a readonly static inside a static block is the only allowed escape hatch
      (LedgerConfig as any).MAX_TRANSACTION_AMOUNT_CENTS = envMax;
    }
    console.log(`[LedgerConfig] initialized — cap: ${LedgerConfig.MAX_TRANSACTION_AMOUNT_CENTS} cents`);
  }
}

class AccountId {
  readonly #value: string;

  // Private constructor — only this class can call new AccountId(...)
  private constructor(value: string) {
    this.#value = value;
  }

  // ✅ Static factory — enforces format invariant before constructing
  static fromString(raw: string): AccountId {
    if (!/^acc_[a-z0-9]{8,}$/.test(raw)) {
      throw new Error(`Invalid AccountId format: "${raw}"`);
    }
    return new AccountId(raw);
  }

  toString(): string {
    return this.#value;
  }
}

const id = AccountId.fromString('acc_a1b2c3d4'); // ✅
const bad = AccountId.fromString('12345');         // ❌ Throws at factory

// ✅ Pattern: Private constructor + static factory = "final" class
class TransactionId {
  readonly #id: string;

  private constructor(id: string) {
    this.#id = id;
  }

  static generate(): TransactionId {
    // Could use crypto.randomUUID(), nanoid, or any ID strategy
    const id = `txn_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
    return new TransactionId(id);
  }

  static fromString(raw: string): TransactionId {
    if (!raw.startsWith('txn_')) throw new Error('Invalid TransactionId');
    return new TransactionId(raw);
  }

  toString(): string {
    return this.#id;
  }
}

// This line will fail at compile time — constructor is private
// class ExtendedId extends TransactionId {} // ← TS Error: Cannot extend a class with a private constructor

const txnId = TransactionId.generate();
console.log(txnId.toString()); // txn_lf0abc_x4mn2

// Interview Sandbox Fallback — when ECMAScript #private is unavailable
// Works in any ES6-capable runtime including Node 10+

const _balance = new WeakMap<AccountBalance, number>();

class AccountBalance {
  constructor(initialCents: number) {
    _balance.set(this, initialCents);
  }

  get cents(): number {
    return _balance.get(this)!;
  }

  deposit(amountCents: number): void {
    if (amountCents <= 0) throw new RangeError('Deposit must be positive');
    _balance.set(this, _balance.get(this)! + amountCents);
  }
}

const acct = new AccountBalance(10000);
acct.deposit(5000);
console.log(acct.cents); // 15000
// Object.keys(acct) → [] — balance not enumerable
// JSON.stringify(acct) → {} — balance not serialized