const { Server } = require('socket.io');
const Client = require('socket.io-client');
const http = require('http');
const { initializeMessageSocket, emitNewMessage, emitMessageRead } = require('../../../sockets/messageSocket');

describe('Message Socket', () => {
  let io, serverSocket, clientSocket;
  let httpServer;

  beforeAll((done) => {
    // Create HTTP server
    httpServer = http.createServer();

    // Create Socket.io server
    io = new Server(httpServer);

    httpServer.listen(() => {
      const port = httpServer.address().port;

      // Initialize message socket handlers
      initializeMessageSocket(io);

      // Create client socket
      clientSocket = new Client(`http://localhost:${port}`);

      // Mock authentication by setting userId
      io.use((socket, next) => {
        socket.userId = 'test-user-123';
        socket.user = {
          id: 'test-user-123',
          email: 'test@example.com',
          firstName: 'Test',
          lastName: 'User'
        };
        next();
      });

      // Wait for connection
      io.on('connection', (socket) => {
        serverSocket = socket;
      });

      clientSocket.on('connect', done);
    });
  });

  afterAll(() => {
    io.close();
    clientSocket.close();
    httpServer.close();
  });

  test('should connect successfully', () => {
    expect(clientSocket.connected).toBe(true);
  });

  test('should join conversation room', (done) => {
    const otherUserId = 'other-user-456';

    clientSocket.on('conversation_joined', (data) => {
      expect(data.otherUserId).toBe(otherUserId);
      expect(data.conversationRoom).toContain('conv_');
      done();
    });

    clientSocket.emit('join_conversation', { otherUserId });
  });

  test('should emit typing start event', (done) => {
    const receiverId = 'receiver-789';

    serverSocket.on('typing_start', (data) => {
      expect(data.receiverId).toBe(receiverId);
      done();
    });

    clientSocket.emit('typing_start', { receiverId });
  });

  test('should emit typing stop event', (done) => {
    const receiverId = 'receiver-789';

    serverSocket.on('typing_stop', (data) => {
      expect(data.receiverId).toBe(receiverId);
      done();
    });

    clientSocket.emit('typing_stop', { receiverId });
  });

  test('should emit new message to receiver', (done) => {
    const receiverId = 'receiver-123';
    const messageData = {
      id: 'message-456',
      senderId: 'sender-789',
      receiverId: receiverId,
      subject: 'Test Subject',
      content: 'Test message content',
      createdAt: new Date().toISOString()
    };

    // Create a second client to receive the message
    const port = httpServer.address().port;
    const receiverClient = new Client(`http://localhost:${port}`);

    receiverClient.on('connect', () => {
      receiverClient.on('new_message', (message) => {
        expect(message.id).toBe(messageData.id);
        expect(message.content).toBe(messageData.content);
        receiverClient.close();
        done();
      });

      // Emit the message
      emitNewMessage(io, receiverId, messageData);
    });
  });

  test('should emit message read status to sender', (done) => {
    const senderId = 'sender-123';
    const readData = {
      messageId: 'message-789',
      readAt: new Date().toISOString(),
      readBy: 'reader-456'
    };

    // Create a sender client to receive the read receipt
    const port = httpServer.address().port;
    const senderClient = new Client(`http://localhost:${port}`);

    senderClient.on('connect', () => {
      senderClient.on('message_read', (data) => {
        expect(data.messageId).toBe(readData.messageId);
        expect(data.readBy).toBe(readData.readBy);
        senderClient.close();
        done();
      });

      // Emit the read status
      emitMessageRead(io, senderId, readData);
    });
  });

  test('should handle disconnection gracefully', (done) => {
    const testClient = new Client(`http://localhost:${httpServer.address().port}`);

    testClient.on('connect', () => {
      testClient.on('disconnect', (reason) => {
        expect(reason).toBeTruthy();
        done();
      });

      testClient.disconnect();
    });
  });
});