// ❌ Hardcoded type — caller knows too much
interface Logger {
  log(message: string): void
}

class ConsoleLogger implements Logger {
  log(message: string) { console.log(`[CONSOLE] ${message}`) }
}

class FileLogger implements Logger {
  constructor(private path: string) {}
  log(message: string) { fs.appendFileSync(this.path, `${message}\n`) }
}

// Caller must know which logger to instantiate
const logger = process.env.LOG_TO_FILE
  ? new FileLogger('./app.log')  // ← Caller imports FileLogger
  : new ConsoleLogger()          // ← Caller imports ConsoleLogger
// Every call site carries this decision — change it in one place and you miss others

// ✅ Factory function — caller knows the interface, not the class
function createLogger(config: { destination: 'console' | 'file'; path?: string }): Logger {
  if (config.destination === 'file') {
    if (!config.path) throw new Error('File logger requires a path')
    return new FileLogger(config.path)
  }
  return new ConsoleLogger()
}

// Caller only needs the Logger interface
const logger = createLogger({ destination: process.env.LOG_DEST as 'console' | 'file' })
logger.log('Server started')
// The concrete class is an implementation detail — callers are never exposed to it

// ❌ Unnecessary class Singleton pattern — JavaScript already provides this
class Config {
  private static instance: Config | null = null
  private values: Record<string, string>

  private constructor() {
    this.values = { ...process.env }
  }

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

  get(key: string): string | undefined {
    return this.values[key]
  }
}

// ✅ Module-level singleton — the module cache IS the singleton guarantee
// config.ts
const config = {
  apiKey:   process.env.API_KEY ?? '',
  baseUrl:  process.env.BASE_URL ?? 'https://api.example.com',
  timeout:  parseInt(process.env.TIMEOUT ?? '5000'),
}
export default config
// This object is evaluated once and cached.
// Every import in every file gets the SAME object reference.

// consumer-a.ts
import config from './config'  // Gets cached module object

// consumer-b.ts
import config from './config'  // Gets the SAME cached module object
// config in consumer-a === config in consumer-b → true

// ❌ Direct coupling — AuthService must know about every dependent
class AuthService {
  private analyticsService: AnalyticsService
  private sessionService: SessionService

  constructor(analytics: AnalyticsService, session: SessionService) {
    this.analyticsService = analytics  // AuthService now depends on both
    this.sessionService   = session
  }

  async login(credentials: Credentials): Promise<void> {
    const user = await this.validateCredentials(credentials)
    this.analyticsService.trackLogin(user.id)  // Direct call — tight coupling
    this.sessionService.createSession(user.id)  // Direct call — tight coupling
  }
}

// ✅ Observer pattern — AuthService emits; dependents subscribe
type EventMap = {
  'user:login':   { userId: string; timestamp: number }
  'user:logout':  { userId: string }
  'error:auth':   { reason: string }
}

class TypedEventBus<T extends Record<string, unknown>> {
  private listeners: { [K in keyof T]?: Array<(payload: T[K]) => void> } = {}

  on<K extends keyof T>(event: K, handler: (payload: T[K]) => void): () => void {
    if (!this.listeners[event]) this.listeners[event] = []
    this.listeners[event]!.push(handler)
    return () => this.off(event, handler)  // Returns unsubscribe fn
  }

  off<K extends keyof T>(event: K, handler: (payload: T[K]) => void): void {
    this.listeners[event] = this.listeners[event]?.filter(h => h !== handler)
  }

  emit<K extends keyof T>(event: K, payload: T[K]): void {
    this.listeners[event]?.forEach(h => h(payload))
  }
}

const authBus = new TypedEventBus<EventMap>()

// AuthService emits — knows nothing about consumers
class AuthService {
  async login(credentials: Credentials): Promise<void> {
    const user = await this.validateCredentials(credentials)
    authBus.emit('user:login', { userId: user.id, timestamp: Date.now() })
    // That's it — AuthService is done. Consumers subscribe independently.
  }
}

// Consumers subscribe — know nothing about each other
authBus.on('user:login', ({ userId }) => analytics.trackLogin(userId))
authBus.on('user:login', ({ userId }) => session.create(userId))
authBus.on('user:login', ({ userId }) => welcomeEmailQueue.push(userId))

// ✅ Proxy for validation — intercept writes to enforce invariants
function createValidatedConfig<T extends object>(
  target: T,
  validators: { [K in keyof T]?: (value: T[K]) => string | null }
): T {
  return new Proxy(target, {
    set(obj, prop: string | symbol, value) {
      const key = prop as keyof T
      const validate = validators[key]

      if (validate) {
        const error = validate(value)
        if (error) throw new TypeError(`Config validation failed for '${String(prop)}': ${error}`)
      }

      obj[key] = value
      return true
    }
  })
}

const serverConfig = createValidatedConfig(
  { port: 3000, host: 'localhost', timeout: 5000 },
  {
    port:    v => (v < 1 || v > 65535) ? 'Port must be 1–65535' : null,
    timeout: v => v < 100 ? 'Timeout must be at least 100ms' : null,
  }
)

serverConfig.port = 8080   // ✅ Valid
serverConfig.port = -1     // ❌ TypeError: Config validation failed for 'port': Port must be 1–65535
serverConfig.timeout = 50  // ❌ TypeError: Config validation failed for 'timeout': ...

// ❌ Circular ESM — partially initialized binding
// a.mjs
import { b } from './b.mjs'
export const a = 'Module A'
console.log('a.mjs: b =', b)  // ← b may be undefined here!

// b.mjs
import { a } from './a.mjs'
export const b = 'Module B'
console.log('b.mjs: a =', a)  // ← a may be undefined here!

// Execution order:
// 1. Node starts evaluating a.mjs
// 2. Sees import from b.mjs → evaluates b.mjs first
// 3. b.mjs imports a.mjs → a.mjs is already being evaluated (cycle detected)
//    ESM gives b.mjs access to a.mjs's namespace, but 'a' is not yet initialized
// 4. console.log in b.mjs: a = undefined ← live binding, not yet assigned
// 5. b.mjs finishes: b = 'Module B'
// 6. a.mjs continues: b = 'Module B' ← correct, b is now initialized

// ✅ Break the cycle with dynamic import inside a function
// a.mjs
export const a = 'Module A'

export async function callB() {
  const { b } = await import('./b.mjs')  // ← Lazy: resolved at call time, not module load
  return b
}

// b.mjs
export const b = 'Module B'

export async function callA() {
  const { a } = await import('./a.mjs')  // ← Lazy: resolved at call time
  return a
}

// No circular evaluation problem:
// a.mjs exports 'a' immediately — b.mjs does not need it at load time
// b.mjs exports 'b' immediately — a.mjs does not need it at load time
// Cross-calls happen lazily, after both modules are fully initialized

// ✅ Dynamic import for feature-flagged code — never loaded if flag is off
async function initFeature(featureId: string): Promise<void> {
  const features: Record<string, () => Promise<{ init: () => void }>> = {
    'video-editor':  () => import('./features/VideoEditor'),
    'data-export':   () => import('./features/DataExport'),
    'ai-assistant':  () => import('./features/AIAssistant'),
  }

  const loader = features[featureId]
  if (!loader) throw new Error(`Unknown feature: ${featureId}`)

  const { init } = await loader()
  init()
}

// Only 'features/VideoEditor' is fetched if the user accesses the video editor feature
// The other modules are never downloaded for users who don't use them

// ✅ Preload hint — start loading before the user navigates
function prefetchRoute(path: string) {
  const routes: Record<string, () => Promise<unknown>> = {
    '/checkout': () => import('./pages/Checkout'),
    '/profile':  () => import('./pages/Profile'),
  }
  routes[path]?.()  // Fire but don't await — preloads the chunk in the background
}