import { describe, expect, test, vi } from 'vitest';
import Plugin from '../src/index.js';
import { DevToolsTunnel } from '../src/lib/RemoteDevTools.js';

describe('Integration tests', () => {
  const webSocketDebuggerUrl = 'ws://127.0.0.1:9222/devtools/browser/abc123';

  describe('DevToolsTunnel integration', () => {
    test('_createServer creates http server', async () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);
      instance.proxyServer = {
        web: vi.fn(),
        ws: vi.fn(),
        close: vi.fn(),
      };

      const server = await instance._createServer(0); // port 0 = random port
      expect(server).toBeDefined();
      expect(typeof server.listen).toBe('function');
      expect(typeof server.close).toBe('function');
      server.close();
    });

    test('_createServer with auth', async () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);
      instance.proxyServer = {
        web: vi.fn(),
        ws: vi.fn(),
        close: vi.fn(),
      };

      const auth = instance._createBasicAuth('user', 'pass');
      const server = await instance._createServer(0, auth);
      expect(server).toBeDefined();
      server.close();
    });

    test('close method closes all resources', () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);

      const mockTunnel = {
        url: 'https://test.localtunnel.me',
        close: vi.fn(),
        on: vi.fn(),
      };

      const mockServer = {
        close: vi.fn(),
        listen: vi.fn(),
        on: vi.fn(),
      };

      const mockProxy = {
        close: vi.fn(),
        web: vi.fn(),
        ws: vi.fn(),
        on: vi.fn(),
      };

      instance.tunnel = mockTunnel;
      instance.server = mockServer;
      instance.proxyServer = mockProxy;

      const result = instance.close();

      expect(mockTunnel.close).toHaveBeenCalled();
      expect(mockServer.close).toHaveBeenCalled();
      expect(mockProxy.close).toHaveBeenCalled();
      expect(result).toBe(instance);
    });

    test('proxy server handles proxyReq event', () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);
      const proxy = instance._createProxyServer('localhost', '9222');

      // Verify proxy has event handlers
      expect(proxy).toBeDefined();
      expect(typeof proxy.web).toBe('function');
      expect(typeof proxy.ws).toBe('function');

      proxy.close();
    });
  });

  describe('Plugin integration', () => {
    test('createTunnel validates browser has wsEndpoint', async () => {
      const instance = Plugin();
      const invalidBrowser = { someOtherMethod: () => 'test' };

      await expect(
        instance.createTunnel(invalidBrowser as any)
      ).rejects.toThrow();
    });

    test('exports Tunnel class methods', () => {
      // Verify the Tunnel class has the expected methods by checking the module structure
      const pluginModule = Plugin();
      expect(typeof pluginModule.createTunnel).toBe('function');
      expect(typeof pluginModule.getLocalDevToolsUrl).toBe('function');
      expect(typeof pluginModule.setAuthCredentials).toBe('function');
    });

    test('plugin debug method is available', () => {
      const instance = Plugin();
      expect(typeof instance.debug).toBe('function');
    });
  });

  describe('Tunnel class via module', () => {
    test('Tunnel constructor and methods exist', async () => {
      // Import the module to access the Tunnel class
      const module = await import('../src/index.js');

      // The module exports a default factory function
      const plugin = module.default();

      // Verify plugin has the expected structure
      expect(plugin.name).toBe('devtools');
      expect(typeof plugin.createTunnel).toBe('function');
    });
  });

  describe('DevToolsTunnel._createTunnel', () => {
    test('_createTunnel returns promise', async () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);

      // Mock localtunnel to avoid actual network calls
      const mockTunnel = {
        url: 'https://test.localtunnel.me',
        close: vi.fn(),
        on: vi.fn((_event: string, _callback: any) => {
          // Simulate the tunnel being created
          return mockTunnel;
        }),
      };

      // We can't easily mock the imported module, but we can test that the method exists
      expect(typeof instance._createTunnel).toBe('function');
    });
  });

  describe('Additional RemoteDevTools coverage', () => {
    test('fetchVersion and fetchList methods exist', async () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);
      expect(typeof instance.fetchVersion).toBe('function');
      expect(typeof instance.fetchList).toBe('function');
    });

    test('url getter before tunnel creation', () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);
      instance.tunnel = { url: 'https://example.com' };
      expect(instance.url).toBe('https://example.com');
    });

    test('getUrlForPageId with tunnelHost set', () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);
      instance.tunnelHost = 'test.example.com';
      const url = instance.getUrlForPageId('page-456');
      expect(url).toContain('test.example.com');
      expect(url).toContain('page-456');
      expect(url).toContain('wss=');
    });

    test('server upgrade event handler', async () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);
      instance.proxyServer = {
        web: vi.fn(),
        ws: vi.fn(),
        close: vi.fn(),
      };

      const server = await instance._createServer(0);

      // Simulate an upgrade request (WebSocket)
      const mockReq = { url: '/devtools/page/123' };
      const mockSocket = {};
      const mockHead = Buffer.from('');

      // Trigger the upgrade event
      server.emit('upgrade', mockReq, mockSocket, mockHead);

      // Verify the proxy ws method was called
      expect(instance.proxyServer.ws).toHaveBeenCalledWith(
        mockReq,
        mockSocket,
        mockHead
      );

      server.close();
    });

    test('_createTunnel sets up event handlers', async () => {
      const instance = new DevToolsTunnel(webSocketDebuggerUrl);

      const handlers: Record<string, any> = {};
      const mockTunnel: any = {
        url: 'https://test.localtunnel.me',
        close: vi.fn(),
        on: vi.fn((event: string, handler: any) => {
          handlers[event] = handler;
          return mockTunnel;
        }),
      };

      // Mock localtunnel temporarily
      vi.mock('localtunnel', () => ({
        default: vi.fn(() => Promise.resolve(mockTunnel)),
      }));

      // Verify that _createTunnel would set up event handlers
      expect(typeof instance._createTunnel).toBe('function');
    });
  });
});