import { expect } from '@push.rocks/tapbundle';
import {
  EventSystem,
  ProxyEvents,
  ComponentType
} from '../../../ts/core/utils/event-system.js';

// Test event system
expect.describe('Event System', async () => {
  let eventSystem: EventSystem;
  let receivedEvents: any[] = [];
  
  // Set up a new event system before each test
  expect.beforeEach(() => {
    eventSystem = new EventSystem(ComponentType.SMART_PROXY, 'test-id');
    receivedEvents = [];
  });
  
  expect.it('should emit certificate events with correct structure', async () => {
    // Set up listeners
    eventSystem.on(ProxyEvents.CERTIFICATE_ISSUED, (data) => {
      receivedEvents.push({
        type: 'issued',
        data
      });
    });
    
    eventSystem.on(ProxyEvents.CERTIFICATE_RENEWED, (data) => {
      receivedEvents.push({
        type: 'renewed',
        data
      });
    });
    
    // Emit events
    eventSystem.emitCertificateIssued({
      domain: 'example.com',
      certificate: 'cert-content',
      privateKey: 'key-content',
      expiryDate: new Date('2025-01-01')
    });
    
    eventSystem.emitCertificateRenewed({
      domain: 'example.com',
      certificate: 'new-cert-content',
      privateKey: 'new-key-content',
      expiryDate: new Date('2026-01-01'),
      isRenewal: true
    });
    
    // Verify events
    expect(receivedEvents.length).to.equal(2);
    
    // Check issuance event
    expect(receivedEvents[0].type).to.equal('issued');
    expect(receivedEvents[0].data.domain).to.equal('example.com');
    expect(receivedEvents[0].data.certificate).to.equal('cert-content');
    expect(receivedEvents[0].data.componentType).to.equal(ComponentType.SMART_PROXY);
    expect(receivedEvents[0].data.componentId).to.equal('test-id');
    expect(receivedEvents[0].data.timestamp).to.be.a('number');
    
    // Check renewal event
    expect(receivedEvents[1].type).to.equal('renewed');
    expect(receivedEvents[1].data.domain).to.equal('example.com');
    expect(receivedEvents[1].data.isRenewal).to.be.true;
    expect(receivedEvents[1].data.expiryDate).to.deep.equal(new Date('2026-01-01'));
  });
  
  expect.it('should emit component lifecycle events', async () => {
    // Set up listeners
    eventSystem.on(ProxyEvents.COMPONENT_STARTED, (data) => {
      receivedEvents.push({
        type: 'started',
        data
      });
    });
    
    eventSystem.on(ProxyEvents.COMPONENT_STOPPED, (data) => {
      receivedEvents.push({
        type: 'stopped',
        data
      });
    });
    
    // Emit events
    eventSystem.emitComponentStarted('TestComponent', '1.0.0');
    eventSystem.emitComponentStopped('TestComponent');
    
    // Verify events
    expect(receivedEvents.length).to.equal(2);
    
    // Check started event
    expect(receivedEvents[0].type).to.equal('started');
    expect(receivedEvents[0].data.name).to.equal('TestComponent');
    expect(receivedEvents[0].data.version).to.equal('1.0.0');
    
    // Check stopped event
    expect(receivedEvents[1].type).to.equal('stopped');
    expect(receivedEvents[1].data.name).to.equal('TestComponent');
  });
  
  expect.it('should emit connection events', async () => {
    // Set up listeners
    eventSystem.on(ProxyEvents.CONNECTION_ESTABLISHED, (data) => {
      receivedEvents.push({
        type: 'established',
        data
      });
    });
    
    eventSystem.on(ProxyEvents.CONNECTION_CLOSED, (data) => {
      receivedEvents.push({
        type: 'closed',
        data
      });
    });
    
    // Emit events
    eventSystem.emitConnectionEstablished({
      connectionId: 'conn-123',
      clientIp: '192.168.1.1',
      port: 443,
      isTls: true,
      domain: 'example.com'
    });
    
    eventSystem.emitConnectionClosed({
      connectionId: 'conn-123',
      clientIp: '192.168.1.1',
      port: 443
    });
    
    // Verify events
    expect(receivedEvents.length).to.equal(2);
    
    // Check established event
    expect(receivedEvents[0].type).to.equal('established');
    expect(receivedEvents[0].data.connectionId).to.equal('conn-123');
    expect(receivedEvents[0].data.clientIp).to.equal('192.168.1.1');
    expect(receivedEvents[0].data.port).to.equal(443);
    expect(receivedEvents[0].data.isTls).to.be.true;
    
    // Check closed event
    expect(receivedEvents[1].type).to.equal('closed');
    expect(receivedEvents[1].data.connectionId).to.equal('conn-123');
  });
  
  expect.it('should support once and off subscription methods', async () => {
    // Set up a listener that should fire only once
    eventSystem.once(ProxyEvents.CONNECTION_ESTABLISHED, (data) => {
      receivedEvents.push({
        type: 'once',
        data
      });
    });
    
    // Set up a persistent listener
    const persistentHandler = (data: any) => {
      receivedEvents.push({
        type: 'persistent',
        data
      });
    };
    
    eventSystem.on(ProxyEvents.CONNECTION_ESTABLISHED, persistentHandler);
    
    // First event should trigger both listeners
    eventSystem.emitConnectionEstablished({
      connectionId: 'conn-1',
      clientIp: '192.168.1.1',
      port: 443
    });
    
    // Second event should only trigger the persistent listener
    eventSystem.emitConnectionEstablished({
      connectionId: 'conn-2',
      clientIp: '192.168.1.1',
      port: 443
    });
    
    // Unsubscribe the persistent listener
    eventSystem.off(ProxyEvents.CONNECTION_ESTABLISHED, persistentHandler);
    
    // Third event should not trigger any listeners
    eventSystem.emitConnectionEstablished({
      connectionId: 'conn-3',
      clientIp: '192.168.1.1',
      port: 443
    });
    
    // Verify events
    expect(receivedEvents.length).to.equal(3);
    expect(receivedEvents[0].type).to.equal('once');
    expect(receivedEvents[0].data.connectionId).to.equal('conn-1');
    
    expect(receivedEvents[1].type).to.equal('persistent');
    expect(receivedEvents[1].data.connectionId).to.equal('conn-1');
    
    expect(receivedEvents[2].type).to.equal('persistent');
    expect(receivedEvents[2].data.connectionId).to.equal('conn-2');
  });
});