import { expect, tap } from '@git.zone/tstest/tapbundle';
import * as smartsocket from '../ts/index.js';
import { SmartServe } from '@push.rocks/smartserve';

let smartserveInstance: SmartServe;
let testSmartsocket: smartsocket.Smartsocket;
let testSmartsocketClient: smartsocket.SmartsocketClient;
let testSocketFunction: smartsocket.SocketFunction<any>;

const testConfig = {
  port: 3000,
};

// Setup smartsocket with smartserve integration
tap.test('should create smartsocket and smartserve with websocket hooks', async () => {
  // Create smartsocket (no port - hooks mode for smartserve integration)
  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver-smartserve' });
  expect(testSmartsocket).toBeInstanceOf(smartsocket.Smartsocket);

  // Get websocket hooks from smartsocket and pass to smartserve
  const wsHooks = testSmartsocket.getSmartserveWebSocketHooks();
  smartserveInstance = new SmartServe({
    port: testConfig.port,
    websocket: wsHooks,
  });
  // That's it! No setExternalServer needed - hooks connect everything
});

tap.test('should register a socket function', async () => {
  testSocketFunction = new smartsocket.SocketFunction({
    funcDef: async (dataArg, socketConnectionArg) => {
      return dataArg;
    },
    funcName: 'testFunction1',
  });
  testSmartsocket.addSocketFunction(testSocketFunction);
});

tap.test('should start smartserve', async () => {
  await smartserveInstance.start();
  // No need to call testSmartsocket.start() - hooks mode doesn't need it
});

tap.test('should connect client through smartserve', async () => {
  testSmartsocketClient = new smartsocket.SmartsocketClient({
    port: testConfig.port,
    url: 'http://localhost',
    alias: 'testClient1',
  });
  testSmartsocketClient.addSocketFunction(testSocketFunction);
  await testSmartsocketClient.connect();
});

tap.test('should be able to make a functionCall from client to server', async () => {
  const response: any = await testSmartsocketClient.serverCall('testFunction1', {
    value1: 'hello from smartserve test',
  });
  expect(response.value1).toEqual('hello from smartserve test');
});

tap.test('should be able to make multiple function calls', async () => {
  for (let i = 0; i < 10; i++) {
    const randomString = `message-${i}-${Math.random()}`;
    const response: any = await testSmartsocketClient.serverCall('testFunction1', {
      value1: randomString,
    });
    expect(response.value1).toEqual(randomString);
  }
});

tap.test('client should disconnect and reconnect through smartserve', async (tools) => {
  await testSmartsocketClient.disconnect();
  await tools.delayFor(100);
  await testSmartsocketClient.connect();

  // Verify connection still works after reconnect
  const response: any = await testSmartsocketClient.serverCall('testFunction1', {
    value1: 'after reconnect',
  });
  expect(response.value1).toEqual('after reconnect');
});

// Cleanup
tap.test('should close the server', async (tools) => {
  await testSmartsocketClient.stop();
  await testSmartsocket.stop();
  await smartserveInstance.stop();
  tools.delayFor(1000).then(() => process.exit(0));
});

export default tap.start();