// ❌ Anti-Pattern: Telescoping constructor — parameter order is invisible at call sites

class Order {
  constructor(
    orderId: string,
    customerId: string,
    shippingAddressId: string,
    billingAddressId: string,
    currency: string,
    isPriority: boolean,
    discountCode: string | null,
    taxRate: number,
  ) { /* ... */ }
}

// Call site — what does each positional argument mean?
const order = new Order(
  'ord_001',
  'cus_abc',
  'addr_shipping',
  'addr_billing',  // ← Did you mean shippingAddressId or billingAddressId?
  'USD',
  true,
  null,
  0.08,            // ← 8% tax rate — or 8%? Easy to confuse with 0.8
);

// ✅ Factory Method — runtime selection of concrete gateway

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

type PaymentResult = { status: 'OK'; transactionId: string } | { status: 'FAILED'; reason: string };
type GatewayProvider = 'stripe' | 'paypal' | 'adyen' | 'mock';

// Factory function — no class required for a factory
function createPaymentGateway(provider: GatewayProvider): IPaymentGateway {
  switch (provider) {
    case 'stripe': return new StripeGateway(process.env.STRIPE_KEY!);
    case 'paypal': return new PayPalGateway(process.env.PAYPAL_CLIENT_ID!);
    case 'adyen':  return new AdyenGateway(process.env.ADYEN_API_KEY!);
    case 'mock':   return new MockPaymentGateway();
    default:       throw new Error(`Unknown provider: ${provider}`);
  }
}

// Caller only knows about IPaymentGateway — never sees StripeGateway
const gateway = createPaymentGateway(process.env.PAYMENT_PROVIDER as GatewayProvider);

interface ILedgerFactory {
  createGateway(): IPaymentGateway;
  createRepository(): IOrderRepository;
  createAuditLogger(): IAuditLogger;
}

class SandboxLedgerFactory implements ILedgerFactory {
  createGateway(): IPaymentGateway { return new MockPaymentGateway(); }
  createRepository(): IOrderRepository { return new InMemoryOrderRepository(); }
  createAuditLogger(): IAuditLogger { return new ConsoleAuditLogger(); }
}

class ProductionLedgerFactory implements ILedgerFactory {
  createGateway(): IPaymentGateway { return new StripeGateway(process.env.STRIPE_KEY!); }
  createRepository(): IOrderRepository { return new PostgresOrderRepository(process.env.DB_URL!); }
  createAuditLogger(): IAuditLogger { return new CloudwatchAuditLogger(); }
}

// Entire environment is switched by passing a different factory
function bootstrapApplication(factory: ILedgerFactory) {
  const gateway = factory.createGateway();
  const repo = factory.createRepository();
  const logger = factory.createAuditLogger();
  return new PaymentOrchestrator(gateway, repo, logger);
}

const orchestrator = bootstrapApplication(
  process.env.NODE_ENV === 'test'
    ? new SandboxLedgerFactory()
    : new ProductionLedgerFactory(),
);

// ❌ Class singleton — global mutable state infects tests

class ConfigService {
  private static instance: ConfigService | null = null;
  private config: Record<string, string> = {};

  private constructor() {
    this.config = { apiKey: process.env.API_KEY ?? '' };
  }

  static getInstance(): ConfigService {
    if (!ConfigService.instance) {
      ConfigService.instance = new ConfigService();
    }
    return ConfigService.instance;
  }

  get(key: string): string { return this.config[key]; }
}

// In test A: ConfigService.getInstance() returns instance with test env
// In test B: ConfigService.getInstance() returns the SAME instance from test A
// Tests are order-dependent — a CI nightmare

// ✅ ESM module singleton — lazy, isolated per module resolution

// src/infrastructure/config.ts
class ConfigService {
  private readonly config: Record<string, string>;

  constructor() {
    this.config = { apiKey: process.env.API_KEY ?? '' };
  }

  get(key: string): string { return this.config[key]; }
}

// The module-level export IS the singleton — one instance per module graph
export const configService = new ConfigService();

// Phantom type markers — exist only in the type system, never at runtime
declare const __set: unique symbol;
type Set   = { readonly [__set]: true };
type Unset = { readonly [__set]: false };

// OrderBuilder with phantom parameters tracking which fields are set
class OrderBuilder<
  TCustomer extends Set | Unset = Unset,
  TItems    extends Set | Unset = Unset,
  TCurrency extends Set | Unset = Unset,
> {
  private readonly #data: {
    customerId?: string;
    items?: Array<{ productId: string; quantity: number }>;
    currency?: string;
    isPriority: boolean;
    discountCode: string | null;
  } = { isPriority: false, discountCode: null };

  // Each setter returns a new builder with an updated phantom type
  withCustomer(customerId: string): OrderBuilder<Set, TItems, TCurrency> {
    this.#data.customerId = customerId;
    return this as unknown as OrderBuilder<Set, TItems, TCurrency>;
  }

  withItems(items: Array<{ productId: string; quantity: number }>): OrderBuilder<TCustomer, Set, TCurrency> {
    this.#data.items = items;
    return this as unknown as OrderBuilder<TCustomer, Set, TCurrency>;
  }

  withCurrency(currency: string): OrderBuilder<TCustomer, TItems, Set> {
    this.#data.currency = currency;
    return this as unknown as OrderBuilder<TCustomer, TItems, Set>;
  }

  withPriority(priority: boolean): this {
    this.#data.isPriority = priority;
    return this;
  }

  withDiscount(code: string): this {
    this.#data.discountCode = code;
    return this;
  }

  // .build() is ONLY available when all three phantom types are Set
  build(
    this: OrderBuilder<Set, Set, Set>, // ← Constraint on `this`
  ): Order {
    return {
      customerId: this.#data.customerId!,
      items: this.#data.items!,
      currency: this.#data.currency!,
      isPriority: this.#data.isPriority,
      discountCode: this.#data.discountCode,
    };
  }
}

type Order = {
  customerId: string;
  items: Array<{ productId: string; quantity: number }>;
  currency: string;
  isPriority: boolean;
  discountCode: string | null;
};

// ✅ Complete construction — all required fields set
const order = new OrderBuilder()
  .withCustomer('cus_abc123')
  .withItems([{ productId: 'prd_001', quantity: 2 }])
  .withCurrency('USD')
  .withPriority(true)
  .build(); // ← Allowed: all phantom types are Set

// ❌ Incomplete construction — compile error
const incomplete = new OrderBuilder()
  .withCustomer('cus_abc123')
  .withCurrency('USD')
  .build();
// Error: Argument of type 'OrderBuilder<Set, Unset, Set>' is not assignable to
// parameter of type 'OrderBuilder<Set, Set, Set>'
// → Missing: .withItems(...)

// Without <const T>: caller must add 'as const' to preserve literal types
function createConfig<T extends Record<string, string>>(config: T): T {
  return config;
}

const cfg1 = createConfig({ provider: 'stripe', env: 'production' });
// cfg1.provider: string — widened, not 'stripe'

const cfg2 = createConfig({ provider: 'stripe', env: 'production' } as const);
// cfg2.provider: 'stripe' — preserved

// ✅ With <const T> (TS 5.0+): no 'as const' required
function createConfig<const T extends Record<string, string>>(config: T): T {
  return config;
}

const cfg3 = createConfig({ provider: 'stripe', env: 'production' });
// cfg3.provider: 'stripe' — automatically preserved as literal type

// ✅ 2-minute factory function for "support Stripe and Adyen" interview prompt
function createGateway(provider: 'stripe' | 'adyen'): IPaymentGateway {
  return provider === 'stripe' ? new StripeGateway() : new AdyenGateway();
}

// Save the Builder + Phantom Types for when the interviewer specifically asks
// "how do you prevent incomplete object construction at compile time?"