import { DyNTS_Msg_Controller } from './msg.controller';
import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';
import { DyFM_msgModule_settings } from '@futdevpro/fsm-dynamo/messaging';
import { DyNTS_GlobalService } from '../../../_services/core/global.service';
import type { DyNTS_AuthService } from '../../../_services/core/auth.service';

describe('| DyNTS_Msg_Controller', () => {
  let controller: DyNTS_Msg_Controller;
  let mockAuthService: jasmine.SpyObj<{ getIssuerFromRequest: (req: unknown) => string }>;

  beforeEach(() => {
    mockAuthService = jasmine.createSpyObj('DyNTS_AuthService', ['getIssuerFromRequest']);
    mockAuthService.getIssuerFromRequest.and.returnValue('user-123');
    spyOn(DyNTS_GlobalService, 'getAuthService').and.returnValue(mockAuthService as unknown as DyNTS_AuthService);
    controller = DyNTS_Msg_Controller.getInstance();
  });

  it('| should be a singleton instance', () => {
    const instance1 = DyNTS_Msg_Controller.getInstance();
    const instance2 = DyNTS_Msg_Controller.getInstance();

    expect(instance1).toBe(instance2);
    expect(instance1).toBeInstanceOf(DyNTS_Msg_Controller);
  });

  describe('| setupEndpoints', () => {
    it('| should setup all messaging endpoints', () => {
      controller.setupEndpoints();

      expect(controller.endpoints).toBeDefined();
      expect(controller.endpoints.length).toBeGreaterThanOrEqual(12);
    });

    it('| should setup getConversations endpoint', () => {
      controller.setupEndpoints();

      const getConversationsEndpoint = controller.endpoints.find(ep => ep.name === 'getConversations');
      expect(getConversationsEndpoint).toBeDefined();
      expect(getConversationsEndpoint?.type).toBe(DyFM_HttpCallType.get);
      expect(getConversationsEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.getConversations);
      expect((getConversationsEndpoint as any)?.tasks).toBeDefined();
      expect((getConversationsEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup getConversation endpoint', () => {
      controller.setupEndpoints();

      const getConversationEndpoint = controller.endpoints.find(ep => ep.name === 'getConversation');
      expect(getConversationEndpoint).toBeDefined();
      expect(getConversationEndpoint?.type).toBe(DyFM_HttpCallType.get);
      expect(getConversationEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.getConversation);
      expect((getConversationEndpoint as any)?.tasks).toBeDefined();
      expect((getConversationEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup createConversation endpoint', () => {
      controller.setupEndpoints();

      const createConversationEndpoint = controller.endpoints.find(ep => ep.name === 'createConversation');
      expect(createConversationEndpoint).toBeDefined();
      expect(createConversationEndpoint?.type).toBe(DyFM_HttpCallType.post);
      expect(createConversationEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.createConversation);
      expect((createConversationEndpoint as any)?.tasks).toBeDefined();
      expect((createConversationEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup getMessages endpoint', () => {
      controller.setupEndpoints();

      const getMessagesEndpoint = controller.endpoints.find(ep => ep.name === 'getMessages');
      expect(getMessagesEndpoint).toBeDefined();
      expect(getMessagesEndpoint?.type).toBe(DyFM_HttpCallType.get);
      expect(getMessagesEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.getMessages);
      expect((getMessagesEndpoint as any)?.tasks).toBeDefined();
      expect((getMessagesEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup sendMessage endpoint', () => {
      controller.setupEndpoints();

      const sendMessageEndpoint = controller.endpoints.find(ep => ep.name === 'sendMessage');
      expect(sendMessageEndpoint).toBeDefined();
      expect(sendMessageEndpoint?.type).toBe(DyFM_HttpCallType.post);
      expect(sendMessageEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.sendMessage);
      expect((sendMessageEndpoint as any)?.tasks).toBeDefined();
      expect((sendMessageEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup editMessage endpoint', () => {
      controller.setupEndpoints();

      const editMessageEndpoint = controller.endpoints.find(ep => ep.name === 'editMessage');
      expect(editMessageEndpoint).toBeDefined();
      expect(editMessageEndpoint?.type).toBe(DyFM_HttpCallType.patch);
      expect(editMessageEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.editMessage);
      expect((editMessageEndpoint as any)?.tasks).toBeDefined();
      expect((editMessageEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup deleteMessage endpoint', () => {
      controller.setupEndpoints();

      const deleteMessageEndpoint = controller.endpoints.find(ep => ep.name === 'deleteMessage');
      expect(deleteMessageEndpoint).toBeDefined();
      expect(deleteMessageEndpoint?.type).toBe(DyFM_HttpCallType.delete);
      expect(deleteMessageEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.deleteMessage);
      expect((deleteMessageEndpoint as any)?.tasks).toBeDefined();
      expect((deleteMessageEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup markAsRead endpoint', () => {
      controller.setupEndpoints();

      const markAsReadEndpoint = controller.endpoints.find(ep => ep.name === 'markAsRead');
      expect(markAsReadEndpoint).toBeDefined();
      expect(markAsReadEndpoint?.type).toBe(DyFM_HttpCallType.post);
      expect(markAsReadEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.markAsRead);
      expect((markAsReadEndpoint as any)?.tasks).toBeDefined();
      expect((markAsReadEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup addReaction endpoint', () => {
      controller.setupEndpoints();

      const addReactionEndpoint = controller.endpoints.find(ep => ep.name === 'addReaction');
      expect(addReactionEndpoint).toBeDefined();
      expect(addReactionEndpoint?.type).toBe(DyFM_HttpCallType.post);
      expect(addReactionEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.addReaction);
      expect((addReactionEndpoint as any)?.tasks).toBeDefined();
      expect((addReactionEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup removeReaction endpoint', () => {
      controller.setupEndpoints();

      const removeReactionEndpoint = controller.endpoints.find(ep => ep.name === 'removeReaction');
      expect(removeReactionEndpoint).toBeDefined();
      expect(removeReactionEndpoint?.type).toBe(DyFM_HttpCallType.delete);
      expect(removeReactionEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.removeReaction);
      expect((removeReactionEndpoint as any)?.tasks).toBeDefined();
      expect((removeReactionEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup updateConversation endpoint', () => {
      controller.setupEndpoints();

      const updateConversationEndpoint = controller.endpoints.find(ep => ep.name === 'updateConversation');
      expect(updateConversationEndpoint).toBeDefined();
      expect(updateConversationEndpoint?.type).toBe(DyFM_HttpCallType.patch);
      expect(updateConversationEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.updateConversation);
      expect((updateConversationEndpoint as any)?.tasks).toBeDefined();
      expect((updateConversationEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup deleteConversation endpoint', () => {
      controller.setupEndpoints();

      const deleteConversationEndpoint = controller.endpoints.find(ep => ep.name === 'deleteConversation');
      expect(deleteConversationEndpoint).toBeDefined();
      expect(deleteConversationEndpoint?.type).toBe(DyFM_HttpCallType.delete);
      expect(deleteConversationEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.deleteConversation);
      expect((deleteConversationEndpoint as any)?.tasks).toBeDefined();
      expect((deleteConversationEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup addParticipant endpoint', () => {
      controller.setupEndpoints();

      const addParticipantEndpoint = controller.endpoints.find(ep => ep.name === 'addParticipant');
      expect(addParticipantEndpoint).toBeDefined();
      expect(addParticipantEndpoint?.type).toBe(DyFM_HttpCallType.post);
      expect(addParticipantEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.addParticipant);
      expect((addParticipantEndpoint as any)?.tasks).toBeDefined();
      expect((addParticipantEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup removeParticipant endpoint', () => {
      controller.setupEndpoints();

      const removeParticipantEndpoint = controller.endpoints.find(ep => ep.name === 'removeParticipant');
      expect(removeParticipantEndpoint).toBeDefined();
      expect(removeParticipantEndpoint?.type).toBe(DyFM_HttpCallType.delete);
      expect(removeParticipantEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.removeParticipant);
      expect((removeParticipantEndpoint as any)?.tasks).toBeDefined();
      expect((removeParticipantEndpoint as any)?.tasks?.length).toBe(1);
    });

    it('| should setup getAgentProcess endpoint', () => {
      controller.setupEndpoints();

      const getAgentProcessEndpoint = controller.endpoints.find(ep => ep.name === 'getAgentProcess');
      expect(getAgentProcessEndpoint).toBeDefined();
      expect(getAgentProcessEndpoint?.type).toBe(DyFM_HttpCallType.get);
      expect(getAgentProcessEndpoint?.endpoint).toBe(DyFM_msgModule_settings.endPoints.getAgentProcess);
      expect((getAgentProcessEndpoint as any)?.tasks).toBeDefined();
      expect((getAgentProcessEndpoint as any)?.tasks?.length).toBe(1);
    });
  });
});