import { describe, it, expect, vi } from 'vitest';
import { createEventEmitter, type EventType } from '@/lib/events.js';

describe('events.ts', () => {
  describe('createEventEmitter', () => {
    it('should emit events to single subscriber', () => {
      const emitter = createEventEmitter();
      const callback = vi.fn();

      emitter.subscribe(callback);
      emitter.emit('agent:stream', { message: 'test' });

      expect(callback).toHaveBeenCalledOnce();
      expect(callback).toHaveBeenCalledWith('agent:stream', { message: 'test' });
    });

    it('should emit events to multiple subscribers', () => {
      const emitter = createEventEmitter();
      const callback1 = vi.fn();
      const callback2 = vi.fn();
      const callback3 = vi.fn();

      emitter.subscribe(callback1);
      emitter.subscribe(callback2);
      emitter.subscribe(callback3);
      emitter.emit('feature:started', { id: '123' });

      expect(callback1).toHaveBeenCalledOnce();
      expect(callback2).toHaveBeenCalledOnce();
      expect(callback3).toHaveBeenCalledOnce();
      expect(callback1).toHaveBeenCalledWith('feature:started', { id: '123' });
    });

    it('should support unsubscribe functionality', () => {
      const emitter = createEventEmitter();
      const callback = vi.fn();

      const unsubscribe = emitter.subscribe(callback);
      emitter.emit('agent:stream', { test: 1 });

      expect(callback).toHaveBeenCalledOnce();

      unsubscribe();
      emitter.emit('agent:stream', { test: 2 });

      expect(callback).toHaveBeenCalledOnce(); // Still called only once
    });

    it('should handle errors in subscribers without crashing', () => {
      const emitter = createEventEmitter();
      const errorCallback = vi.fn(() => {
        throw new Error('Subscriber error');
      });
      const normalCallback = vi.fn();
      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});

      emitter.subscribe(errorCallback);
      emitter.subscribe(normalCallback);

      expect(() => {
        emitter.emit('feature:error', { error: 'test' });
      }).not.toThrow();

      expect(errorCallback).toHaveBeenCalledOnce();
      expect(normalCallback).toHaveBeenCalledOnce();
      expect(consoleSpy).toHaveBeenCalled();

      consoleSpy.mockRestore();
    });

    it('should emit different event types', () => {
      const emitter = createEventEmitter();
      const callback = vi.fn();

      emitter.subscribe(callback);

      const eventTypes: EventType[] = [
        'agent:stream',
        'auto-mode:started',
        'feature:completed',
        'project:analysis-progress',
      ];

      eventTypes.forEach((type) => {
        emitter.emit(type, { type });
      });

      expect(callback).toHaveBeenCalledTimes(4);
    });

    it('should handle emitting without subscribers', () => {
      const emitter = createEventEmitter();

      expect(() => {
        emitter.emit('agent:stream', { test: true });
      }).not.toThrow();
    });

    it('should allow multiple subscriptions and unsubscriptions', () => {
      const emitter = createEventEmitter();
      const callback1 = vi.fn();
      const callback2 = vi.fn();
      const callback3 = vi.fn();

      const unsub1 = emitter.subscribe(callback1);
      const unsub2 = emitter.subscribe(callback2);
      const unsub3 = emitter.subscribe(callback3);

      emitter.emit('feature:started', { test: 1 });
      expect(callback1).toHaveBeenCalledOnce();
      expect(callback2).toHaveBeenCalledOnce();
      expect(callback3).toHaveBeenCalledOnce();

      unsub2();

      emitter.emit('feature:started', { test: 2 });
      expect(callback1).toHaveBeenCalledTimes(2);
      expect(callback2).toHaveBeenCalledOnce(); // Still just once
      expect(callback3).toHaveBeenCalledTimes(2);

      unsub1();
      unsub3();

      emitter.emit('feature:started', { test: 3 });
      expect(callback1).toHaveBeenCalledTimes(2);
      expect(callback2).toHaveBeenCalledOnce();
      expect(callback3).toHaveBeenCalledTimes(2);
    });
  });
});