// ❌ Anti-Pattern: Unbranded monetary primitives — the compiler cannot distinguish currencies

function addBalances(a: number, b: number): number {
  return a + b;
}

const usdBalance = 1000;   // USD in cents
const eurBalance = 850;    // EUR in cents

// This compiles cleanly — both are just `number`
const total = addBalances(usdBalance, eurBalance); // 1850 — wrong! Mixed currencies

class CustomerAccount {
  id: string;
  balance: number;

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

class VendorAccount {
  id: string;
  balance: number;

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

function processCustomerAccount(account: CustomerAccount): void {
  console.log(`Processing customer: ${account.id}`);
}

const vendor = new VendorAccount('vnd_001', 5000);

// ✅ This compiles without error — VendorAccount is structurally identical to CustomerAccount
processCustomerAccount(vendor);
// Output: "Processing customer: vnd_001"
// The function ran a VendorAccount through customer-specific logic with no type error

// The Brand utility type — a type-level tag that creates nominal identity
declare const __brand: unique symbol;
type Brand<T, TBrand extends string> = T & { readonly [__brand]: TBrand };

// Domain-specific branded primitives
type CustomerId = Brand<string, 'CustomerId'>;
type VendorId   = Brand<string, 'VendorId'>;
type OrderId    = Brand<string, 'OrderId'>;
type UsdCents   = Brand<number, 'UsdCents'>;
type EurCents   = Brand<number, 'EurCents'>;

// Smart constructors — the only sanctioned way to produce a branded value
function asCustomerId(raw: string): CustomerId {
  if (!/^cus_[a-z0-9]{8,}$/.test(raw)) {
    throw new Error(`Invalid CustomerId: "${raw}"`);
  }
  return raw as CustomerId; // The only use of `as` — validated and contained
}

function asUsdCents(raw: number): UsdCents {
  if (!Number.isInteger(raw) || raw < 0) {
    throw new Error('UsdCents must be a non-negative integer');
  }
  return raw as UsdCents;
}

// Usage
const customerId = asCustomerId('cus_a1b2c3d4'); // CustomerId — branded
const usdBalance = asUsdCents(50000);             // UsdCents — branded

// ❌ Anti-Pattern — unbranded: the compiler cannot help
function transferUnbranded(from: number, to: number, amount: number): void {
  // Is amount USD? EUR? Satoshis? No way to tell from the type
}

// ✅ Branded — the compiler enforces correctness
function transferUsd(
  fromAccount: CustomerId,
  toAccount: CustomerId,
  amount: UsdCents,
): void {
  console.log(`Transferring ${amount} USD cents from ${fromAccount} to ${toAccount}`);
}

const customer = asCustomerId('cus_a1b2c3d4');
const recipient = asCustomerId('cus_e5f6g7h8');
const amount = asUsdCents(10000); // $100.00

// ✅ Correct call
transferUsd(customer, recipient, amount);

// ❌ These all fail at compile time — no runtime cost for the check
const vendorId = 'vnd_001' as VendorId;
transferUsd(vendorId, recipient, amount);
// Error: Argument of type 'VendorId' is not assignable to parameter of type 'CustomerId'

const eurAmount = 8500 as EurCents;
transferUsd(customer, recipient, eurAmount);
// Error: Argument of type 'EurCents' is not assignable to parameter of type 'UsdCents'

// Template literal brand — enforces the "ord_" prefix at compile time
type OrderIdLiteral = `ord_${string}`;

// Usage
function fetchOrder(id: OrderIdLiteral): Promise<void> {
  return fetch(`/api/orders/${id}`).then(() => {});
}

// ✅ Correctly prefixed — accepted
fetchOrder('ord_abc123def456');

// ❌ Wrong prefix — rejected at compile time
fetchOrder('cus_abc123def456');
// Error: Argument of type '"cus_abc123def456"' is not assignable to parameter of type '`ord_${string}`'

fetchOrder('12345'); // ❌ No prefix — rejected

type TransactionId = Brand<`txn_${string}`, 'TransactionId'>;

function asTransactionId(raw: string): TransactionId {
  if (!raw.startsWith('txn_') || raw.length < 12) {
    throw new Error(`Invalid TransactionId: "${raw}"`);
  }
  return raw as TransactionId;
}

// A plain `txn_` prefixed string is NOT assignable to TransactionId without going through the constructor
const txnId = asTransactionId('txn_a1b2c3d4e5f6'); // ✅
const fakeId: TransactionId = 'txn_a1b2c3d4e5f6' as any; // Explicit bypass — intentional

// ❌ Without polymorphic this — builder chain loses derived type
class BaseQuery {
  protected filters: string[] = [];

  addFilter(filter: string): BaseQuery { // ← Returns BaseQuery, not derived type
    this.filters.push(filter);
    return this;
  }

  build(): string {
    return this.filters.join(' AND ');
  }
}

class LedgerQuery extends BaseQuery {
  private accountId?: string;

  forAccount(id: string): LedgerQuery {
    this.accountId = id;
    return this;
  }
}

const query = new LedgerQuery()
  .addFilter('amount > 0')   // Returns BaseQuery — type information lost!
  .forAccount('acc_001');    // ❌ Error: Property 'forAccount' does not exist on type 'BaseQuery'

// ✅ Polymorphic this — derived type preserved through the chain
class BaseQuery {
  protected filters: string[] = [];

  addFilter(filter: string): this { // ← Returns `this`, not `BaseQuery`
    this.filters.push(filter);
    return this;
  }

  build(): string {
    return this.filters.join(' AND ');
  }
}

class LedgerQuery extends BaseQuery {
  private accountId?: string;

  forAccount(id: string): this {
    this.accountId = id;
    return this;
  }
}

const query = new LedgerQuery()
  .addFilter('amount > 0')   // Returns LedgerQuery — type preserved ✅
  .forAccount('acc_001')     // ✅ Works correctly
  .addFilter('status = paid') // ✅ Can chain back to base methods
  .build();

console.log(query); // "amount > 0 AND status = paid"

// ❌ Overkill class hierarchy for a pure data variant
abstract class PaymentEvent {
  abstract readonly kind: string;
  abstract readonly occurredAt: Date;
}

class PaymentAuthorized extends PaymentEvent {
  readonly kind = 'AUTHORIZED';
  constructor(
    readonly occurredAt: Date,
    readonly authCode: string,
    readonly amount: number,
  ) { super(); }
}

class PaymentDeclined extends PaymentEvent {
  readonly kind = 'DECLINED';
  constructor(
    readonly occurredAt: Date,
    readonly reason: string,
  ) { super(); }
}

class PaymentRefunded extends PaymentEvent {
  readonly kind = 'REFUNDED';
  constructor(
    readonly occurredAt: Date,
    readonly refundAmount: number,
    readonly originalTransactionId: string,
  ) { super(); }
}

// ✅ Discriminated union — zero prototype overhead, exhaustive pattern matching
type PaymentEvent =
  | { kind: 'AUTHORIZED'; occurredAt: Date; authCode: string; amount: number }
  | { kind: 'DECLINED';   occurredAt: Date; reason: string }
  | { kind: 'REFUNDED';   occurredAt: Date; refundAmount: number; originalTransactionId: string };

// Exhaustive handler — compiler guarantees all variants are covered
function describeEvent(event: PaymentEvent): string {
  switch (event.kind) {
    case 'AUTHORIZED':
      return `Authorized $${event.amount / 100} with code ${event.authCode}`;
    case 'DECLINED':
      return `Declined: ${event.reason}`;
    case 'REFUNDED':
      return `Refunded $${event.refundAmount / 100} for txn ${event.originalTransactionId}`;
    default:
      // TS ensures this branch is unreachable if all variants are handled
      assertNever(event);
  }
}

function assertNever(value: never): never {
  throw new Error(`Unhandled variant: ${JSON.stringify(value)}`);
}

type SupportedCurrency = 'USD' | 'EUR' | 'GBP';

type CurrencyConfig = {
  symbol: string;
  minorUnit: number;       // Number of decimal places
  roundingMode: 'HALF_UP' | 'HALF_EVEN';
};

// satisfies ensures all three currencies are covered,
// but inferred type retains the literal values — not just 'CurrencyConfig'
const currencyRegistry = {
  USD: { symbol: '$',  minorUnit: 2, roundingMode: 'HALF_UP'  },
  EUR: { symbol: '€',  minorUnit: 2, roundingMode: 'HALF_EVEN' },
  GBP: { symbol: '£',  minorUnit: 2, roundingMode: 'HALF_UP'  },
} satisfies Record<SupportedCurrency, CurrencyConfig>;

// ✅ Literal type is preserved — roundingMode is 'HALF_UP', not the wider string
const usdRounding = currencyRegistry.USD.roundingMode; // Type: 'HALF_UP' (not 'HALF_UP' | 'HALF_EVEN')

// Adding a new currency to SupportedCurrency without updating the registry triggers a compile error:
// Property 'JPY' is missing in type... satisfies Record<SupportedCurrency, CurrencyConfig>