// ❌ Anti-Pattern: 4-tier deep class hierarchy — every level adds coupling
class BaseEntity {
  abstract id: string;
  abstract createdAt: Date;
}

class AuditableEntity extends BaseEntity {
  abstract updatedAt: Date;
  abstract updatedBy: string;
}

class AccountEntity extends AuditableEntity {
  abstract accountType: 'CHECKING' | 'SAVINGS' | 'LEDGER';
  abstract balance: number;
}

class PremiumAccount extends AccountEntity {
  private interestMultiplier = 1.25;

  // To test PremiumAccount.calculateInterest(), you must instantiate
  // with FOUR layers of inherited abstract properties satisfied.
  // Mocking becomes a full constructor exercise, not a unit test.
  calculateInterest(rate: number): number {
    return this.balance * rate * this.interestMultiplier;
  }
}

// TypeScript source:
interface IPaymentGateway {
  charge(amount: number, currency: string): Promise<string>;
}

type PaymentResult = { status: 'OK'; transactionId: string } | { status: 'FAILED'; reason: string };

abstract class BaseProcessor {
  abstract process(amount: number): Promise<PaymentResult>;

  protected log(message: string): void {
    console.log(`[BaseProcessor] ${message}`);
  }
}

// ✅ Compiled JavaScript output:
// interface IPaymentGateway → NOTHING emitted (zero bytes)
// type PaymentResult        → NOTHING emitted (zero bytes)

// abstract class BaseProcessor → this IS emitted:
class BaseProcessor {
  log(message) {
    console.log(`[BaseProcessor] ${message}`);
  }
}

// interfaces can be augmented across module boundaries — type aliases cannot
interface IOrderRepository {
  findById(id: string): Promise<Order | null>;
}

// In another file / module — merges with the declaration above
interface IOrderRepository {
  findByCustomer(customerId: string): Promise<Order[]>;
}

// Implementors must now satisfy both method shapes
class PostgresOrderRepository implements IOrderRepository {
  findById(id: string): Promise<Order | null> { /* ... */ return Promise.resolve(null); }
  findByCustomer(customerId: string): Promise<Order[]> { /* ... */ return Promise.resolve([]); }
}

interface IOrderReader {
  findById(id: string): Promise<Order | null>;
}

interface ICachedReader {
  findById(id: string): Promise<Order | null>; // Same name, same signature — compatible
  invalidateCache(id: string): void;
}

// ✅ Single implementation satisfies both contracts
class CachedOrderRepository implements IOrderReader, ICachedReader {
  private cache = new Map<string, Order>();

  async findById(id: string): Promise<Order | null> {
    if (this.cache.has(id)) return this.cache.get(id)!;
    const order = await this.fetchFromDb(id);
    if (order) this.cache.set(id, order);
    return order;
  }

  invalidateCache(id: string): void {
    this.cache.delete(id);
  }

  private async fetchFromDb(id: string): Promise<Order | null> {
    return null; // Database query would go here
  }
}

// tsconfig.json: "noImplicitOverride": false (dangerous default)

class BaseAuditLogger {
  logTransaction(txnId: string): void {
    console.log(`[AUDIT] txn: ${txnId}`);
  }
}

class ComplianceLogger extends BaseAuditLogger {
  // Intended to override logTransaction — but no 'override' keyword
  logTransaction(txnId: string): void {
    // Regulatory compliance logic
    console.log(`[COMPLIANCE] txn: ${txnId} — flagged for review`);
  }
}

// Base class renames the method to logEvent():
class BaseAuditLogger {
  logEvent(txnId: string): void { // ← renamed
    console.log(`[AUDIT] txn: ${txnId}`);
  }
}

// ComplianceLogger still has logTransaction() — now it overrides NOTHING
// The compliance logging silently disappears from the call path.
// No compiler error. This ships to production.

// tsconfig.json: "noImplicitOverride": true  ← recommended for all new projects

class ComplianceLogger extends BaseAuditLogger {
  override logTransaction(txnId: string): void { // ← explicit override
    console.log(`[COMPLIANCE] txn: ${txnId} — flagged for review`);
  }
}

// If base class renames logTransaction → logEvent:
// Immediately: TS Error: "This member cannot have an 'override' modifier because
// it is not declared in the base class 'BaseAuditLogger'"
// The bug is caught at the earliest possible moment.

// ✅ Abstract class is justified — shared algorithm, variant steps
abstract class PaymentProcessor {
  // Template Method — defines the immutable algorithm sequence
  async process(amount: number, currency: string): Promise<PaymentResult> {
    await this.validate(amount, currency);           // Step 1 — invariant
    const normalized = await this.normalize(amount); // Step 2 — variant
    const result = await this.charge(normalized);    // Step 3 — variant
    await this.audit(result);                        // Step 4 — invariant
    return result;
  }

  // Invariant steps — shared implementation, not overridable
  private async validate(amount: number, currency: string): Promise<void> {
    if (amount <= 0) throw new RangeError('Amount must be positive');
    if (!['USD', 'EUR', 'GBP'].includes(currency)) throw new Error('Unsupported currency');
  }

  private async audit(result: PaymentResult): Promise<void> {
    console.log(`[AUDIT] Payment result: ${JSON.stringify(result)}`);
  }

  // Variant steps — must be provided by concrete subclasses
  protected abstract normalize(amount: number): Promise<number>;
  protected abstract charge(normalizedAmount: number): Promise<PaymentResult>;
}

type PaymentResult = { status: 'OK'; transactionId: string } | { status: 'FAILED'; reason: string };

class StripeProcessor extends PaymentProcessor {
  protected async normalize(amount: number): Promise<number> {
    return Math.round(amount * 100); // Convert to cents for Stripe
  }

  protected async charge(normalizedAmount: number): Promise<PaymentResult> {
    // Stripe API call
    return { status: 'OK', transactionId: `pi_${Date.now()}` };
  }
}

class AdyenProcessor extends PaymentProcessor {
  protected async normalize(amount: number): Promise<number> {
    return amount; // Adyen accepts decimal amounts
  }

  protected async charge(normalizedAmount: number): Promise<PaymentResult> {
    // Adyen API call
    return { status: 'OK', transactionId: `adyen_${Date.now()}` };
  }
}

// Constructor type for generic mixin base
type Constructor<T = {}> = new (...args: any[]) => T;

// Timestampable mixin — adds createdAt / updatedAt tracking
function Timestampable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    readonly createdAt: Date = new Date();
    updatedAt: Date = new Date();

    touch(): void {
      this.updatedAt = new Date();
    }
  };
}

// Auditable mixin — adds actor tracking for compliance
function Auditable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    private auditLog: Array<{ actor: string; action: string; at: Date }> = [];

    recordAction(actor: string, action: string): void {
      this.auditLog.push({ actor, action, at: new Date() });
    }

    getAuditTrail(): ReadonlyArray<{ actor: string; action: string; at: Date }> {
      return this.auditLog;
    }
  };
}

// SoftDeletable mixin — logical deletion without database record removal
function SoftDeletable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    deletedAt: Date | null = null;

    get isDeleted(): boolean {
      return this.deletedAt !== null;
    }

    softDelete(): void {
      if (this.deletedAt) throw new Error('Already deleted');
      this.deletedAt = new Date();
    }
  };
}

// Base domain entity
class BaseEntity {
  constructor(readonly id: string) {}
}

// Compose capabilities via mixin chain
class Order extends SoftDeletable(Auditable(Timestampable(BaseEntity))) {
  private readonly #lineItems: string[] = [];

  addItem(item: string, actor: string): void {
    this.#lineItems.push(item);
    this.recordAction(actor, `ADD_ITEM:${item}`);
    this.touch();
  }
}

const order = new Order('ord_abc123');
order.addItem('Product A', 'usr_admin_001');
console.log(order.createdAt);         // Date — from Timestampable
console.log(order.getAuditTrail());   // [{actor: 'usr_admin_001', action: 'ADD_ITEM:Product A', ...}]
order.softDelete();
console.log(order.isDeleted);         // true — from SoftDeletable

// T extends Entity<T> — T must be a subclass of Entity<T>
// This enables the base class to reference the concrete type of `this`
abstract class Entity<T extends Entity<T>> {
  protected abstract id(): string;

  // Base class method that returns the concrete derived type
  clone(): T {
    return Object.assign(Object.create(Object.getPrototypeOf(this)), this) as T;
  }

  equals(other: T): boolean {
    return this.id() === other.id();
  }
}

class LedgerEntry extends Entity<LedgerEntry> {
  constructor(
    private readonly entryId: string,
    readonly amount: number,
  ) {
    super();
  }

  protected id(): string {
    return this.entryId;
  }
}

const entry1 = new LedgerEntry('txn_001', 500);
const entry2 = entry1.clone(); // Type is LedgerEntry — not Entity<LedgerEntry>
const isSame = entry1.equals(entry2); // true