class DatabasePool {
  private static instance: DatabasePool | null = null;
  private pool: Connection[] = [];

  // constructor פרטי — לא ניתן לקרוא new DatabasePool() מבחוץ
  private constructor() {
    this.pool = createConnections(process.env.DATABASE_URL!, 10);
  }

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

  async query(sql: string, params: unknown[]): Promise<Row[]> {
    const conn = await this.getConnection();
    try {
      return await conn.execute(sql, params);
    } finally {
      this.releaseConnection(conn);
    }
  }
}

// שימוש — כל קריאה מחזירה אותו instance
const db = DatabasePool.getInstance();
await db.query("SELECT * FROM users WHERE id = ?", [userId]);

interface Notification {
  send(to: string, message: string): Promise<void>;
}

class EmailNotification implements Notification {
  async send(to: string, message: string): Promise<void> {
    await sendgrid.send({ to, subject: "New notification", html: message });
  }
}

class SMSNotification implements Notification {
  async send(to: string, message: string): Promise<void> {
    await twilio.messages.create({ to, from: SMS_FROM, body: message });
  }
}

class PushNotification implements Notification {
  async send(to: string, message: string): Promise<void> {
    await firebase.messaging().send({ token: to, notification: { body: message } });
  }
}

// ה-Factory
function createNotification(type: "email" | "sms" | "push"): Notification {
  switch (type) {
    case "email": return new EmailNotification();
    case "sms": return new SMSNotification();
    case "push": return new PushNotification();
    default: throw new Error(`Unknown notification type: ${type}`);
  }
}

// שימוש — ה-caller לא יודע ולא צריך לדעת
const notification = createNotification(user.preferredChannel);
await notification.send(user.contact, "Your order is ready!");

type EventHandler<T> = (data: T) => void | Promise<void>;

class EventBus {
  private listeners = new Map<string, EventHandler<unknown>[]>();

  on<T>(event: string, handler: EventHandler<T>): void {
    const handlers = this.listeners.get(event) ?? [];
    this.listeners.set(event, [...handlers, handler as EventHandler<unknown>]);
  }

  async emit<T>(event: string, data: T): Promise<void> {
    const handlers = this.listeners.get(event) ?? [];
    await Promise.all(handlers.map(h => h(data)));
  }
}

const eventBus = new EventBus();

// Observers — כל אחד אחראי לעצמו
eventBus.on("order.completed", async ({ orderId, userId, total }) => {
  await emailService.sendOrderConfirmation(userId, orderId);
});

eventBus.on("order.completed", async ({ orderId, items }) => {
  await inventoryService.decrementStock(items);
});

eventBus.on("order.completed", async ({ orderId, total, userId }) => {
  await analytics.track("purchase", { orderId, total, userId });
});

// Subject — לא יודע מי מאזין
class OrdersService {
  async completeOrder(orderId: string): Promise<void> {
    const order = await this.ordersRepo.complete(orderId);
    // emit ותן לכולם להגיב
    await eventBus.emit("order.completed", order);
  }
}

interface PaymentStrategy {
  charge(amount: number, currency: string, metadata: PaymentMetadata): Promise<PaymentResult>;
  refund(transactionId: string, amount: number): Promise<RefundResult>;
}

class StripeStrategy implements PaymentStrategy {
  async charge(amount: number, currency: string, meta: PaymentMetadata) {
    const intent = await stripe.paymentIntents.create({
      amount: Math.round(amount * 100), // Stripe works in cents
      currency,
      payment_method: meta.paymentMethodId,
      confirm: true,
    });
    return { transactionId: intent.id, status: intent.status };
  }

  async refund(transactionId: string, amount: number) {
    const refund = await stripe.refunds.create({
      payment_intent: transactionId,
      amount: Math.round(amount * 100),
    });
    return { refundId: refund.id };
  }
}

class PayPalStrategy implements PaymentStrategy {
  async charge(amount: number, currency: string, meta: PaymentMetadata) {
    const order = await paypal.orders.create({ amount, currency });
    const captured = await paypal.orders.capture(order.id);
    return { transactionId: captured.id, status: "success" };
  }

  async refund(transactionId: string, amount: number) {
    const refund = await paypal.captures.refund(transactionId, { amount });
    return { refundId: refund.id };
  }
}

// Context — לא יודע איזה Strategy נבחר
class PaymentProcessor {
  constructor(private strategy: PaymentStrategy) {}

  setStrategy(strategy: PaymentStrategy): void {
    this.strategy = strategy;
  }

  async processPayment(amount: number, currency: string, meta: PaymentMetadata) {
    return this.strategy.charge(amount, currency, meta);
  }
}

// שימוש
const processor = new PaymentProcessor(new StripeStrategy());
await processor.processPayment(99.99, "ILS", paymentMeta);

// לעבור ל-PayPal — שורה אחת
processor.setStrategy(new PayPalStrategy());

type AsyncFn<T> = (...args: unknown[]) => Promise<T>;

// Decorator: Caching
function withCache<T>(fn: AsyncFn<T>, ttlMs = 60_000): AsyncFn<T> {
  const cache = new Map<string, { value: T; expiresAt: number }>();

  return async (...args) => {
    const key = JSON.stringify(args);
    const cached = cache.get(key);

    if (cached && Date.now() < cached.expiresAt) {
      return cached.value;
    }

    const value = await fn(...args);
    cache.set(key, { value, expiresAt: Date.now() + ttlMs });
    return value;
  };
}

// Decorator: Retry
function withRetry<T>(fn: AsyncFn<T>, maxRetries = 3, delayMs = 1000): AsyncFn<T> {
  return async (...args) => {
    for (let attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        return await fn(...args);
      } catch (error) {
        if (attempt === maxRetries) throw error;
        await new Promise(r => setTimeout(r, delayMs * attempt)); // exponential backoff
      }
    }
    throw new Error("Should not reach here");
  };
}

// Decorator: Logging
function withLogging<T>(fn: AsyncFn<T>, name: string): AsyncFn<T> {
  return async (...args) => {
    const start = Date.now();
    try {
      const result = await fn(...args);
      logger.info(`${name} succeeded in ${Date.now() - start}ms`);
      return result;
    } catch (error) {
      logger.error(`${name} failed after ${Date.now() - start}ms`, { error });
      throw error;
    }
  };
}

// הפונקציה הבסיסית — נקייה, פשוטה
async function fetchUser(userId: string): Promise<User> {
  return db.query("SELECT * FROM users WHERE id = ?", [userId]);
}

// הרכבה — כל decorator מוסיף שכבה
const fetchUserWithLogging = withLogging(fetchUser, "fetchUser");
const fetchUserWithRetry = withRetry(fetchUserWithLogging, 3, 500);
const fetchUserCached = withCache(fetchUserWithRetry, 30_000);

// שימוש — caller לא יודע על הdecorators
const user = await fetchUserCached("user-123");