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

class EventBus<Events extends Record<string, unknown>> {
  private listeners = new Map<keyof Events, Set<EventHandler<unknown>>>();

  subscribe<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): () => void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, new Set());
    }
    this.listeners.get(event)!.add(handler as EventHandler<unknown>);

    // מחזיר Unsubscribe function — כמו useEffect ב-React
    return () => this.unsubscribe(event, handler);
  }

  unsubscribe<K extends keyof Events>(event: K, handler: EventHandler<Events[K]>): void {
    this.listeners.get(event)?.delete(handler as EventHandler<unknown>);
  }

  async emit<K extends keyof Events>(event: K, data: Events[K]): Promise<void> {
    const handlers = this.listeners.get(event);
    if (!handlers) return;

    // Promise.allSettled — לא עוצרים אם Handler אחד נכשל
    const results = await Promise.allSettled(
      [...handlers].map((handler) => handler(data))
    );

    // Log שגיאות בלי לעצור את זרימת האירועים
    for (const result of results) {
      if (result.status === 'rejected') {
        console.error('Event handler failed:', result.reason);
      }
    }
  }
}

// הגדרת Events — Type Safety מלאה
interface AppEvents {
  'order:placed': { orderId: string; userId: string; items: OrderItem[]; total: number };
  'order:shipped': { orderId: string; trackingNumber: string };
  'user:registered': { userId: string; email: string; name: string };
  'payment:failed': { orderId: string; reason: string; retryCount: number };
}

const eventBus = new EventBus<AppEvents>();

// OrderService — עכשיו קורא רק ל-EventBus
class OrderService {
  constructor(
    private orderRepository: OrderRepository,
    private eventBus: EventBus<AppEvents>
  ) {}

  async placeOrder(order: CreateOrderRequest): Promise<string> {
    const savedOrder = await this.orderRepository.save(order);

    // emit אחד — כולם שיטפלו בעצמם
    await this.eventBus.emit('order:placed', {
      orderId: savedOrder.id,
      userId: order.userId,
      items: order.items,
      total: order.total,
    });

    return savedOrder.id;
  }
}

// Handlers — כל אחד אחראי על Feature שלו
class OrderEmailHandler {
  constructor(private emailService: EmailService) {}

  async handle(data: AppEvents['order:placed']): Promise<void> {
    await this.emailService.sendOrderConfirmation(data.userId, data.orderId);
    console.log(`Email sent for order ${data.orderId}`);
  }
}

class InventoryHandler {
  constructor(private inventoryService: InventoryService) {}

  async handle(data: AppEvents['order:placed']): Promise<void> {
    for (const item of data.items) {
      await this.inventoryService.reduce(item.productId, item.quantity);
    }
  }
}

class AnalyticsHandler {
  async handle(data: AppEvents['order:placed']): Promise<void> {
    console.log(`Analytics: order_placed — userId=${data.userId}, total=${data.total}`);
  }
}

// Bootstrap — רישום Handlers
const emailHandler = new OrderEmailHandler(emailService);
const inventoryHandler = new InventoryHandler(inventoryService);
const analyticsHandler = new AnalyticsHandler();

eventBus.subscribe('order:placed', (data) => emailHandler.handle(data));
eventBus.subscribe('order:placed', (data) => inventoryHandler.handle(data));
eventBus.subscribe('order:placed', (data) => analyticsHandler.handle(data));

// הוספת Handler חדש — לא נוגעים ב-OrderService
eventBus.subscribe('order:placed', async (data) => {
  // Loyalty points — Feature חדש, לא שינינו שום קוד קיים
  await loyaltyService.addPoints(data.userId, Math.floor(data.total));
});
Observer Pattern — מנגנון אירועים

Observer Pattern — מנגנון אירועים

Observer Pattern — מנגנון אירועים
