import { DyNTS_Star_Controller, DyNTS_getStarRoute } from './star.controller';
import { DyFM_HttpCallType, DyFM_Error } from '@futdevpro/fsm-dynamo';
import { DyNTS_RoutingModule } from '../_services/route/routing-module.service';

describe('| DyNTS_Star_Controller', () => {
  let controller: DyNTS_Star_Controller;

  beforeEach(() => {
    controller = DyNTS_Star_Controller.getInstance();
  });

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

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

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

      expect(controller.endpoints).toBeDefined();
      expect(controller.endpoints.length).toBe(5);
    });

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

      const defaultGetEndpoint = controller.endpoints.find(ep => ep.name === 'defaultGet');
      expect(defaultGetEndpoint).toBeDefined();
      expect(defaultGetEndpoint?.type).toBe(DyFM_HttpCallType.get);
      expect(defaultGetEndpoint?.endpoint).toBe('/*');
      expect((defaultGetEndpoint as any)?.tasks).toBeDefined();
      expect((defaultGetEndpoint as any)?.tasks?.length).toBe(1);
    });

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

      const defaultPostEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPost');
      expect(defaultPostEndpoint).toBeDefined();
      expect(defaultPostEndpoint?.type).toBe(DyFM_HttpCallType.post);
      expect(defaultPostEndpoint?.endpoint).toBe('/*');
      expect((defaultPostEndpoint as any)?.tasks).toBeDefined();
      expect((defaultPostEndpoint as any)?.tasks?.length).toBe(1);
    });

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

      const defaultPutEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPut');
      expect(defaultPutEndpoint).toBeDefined();
      expect(defaultPutEndpoint?.type).toBe(DyFM_HttpCallType.put);
      expect(defaultPutEndpoint?.endpoint).toBe('/*');
      expect((defaultPutEndpoint as any)?.tasks).toBeDefined();
      expect((defaultPutEndpoint as any)?.tasks?.length).toBe(1);
    });

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

      const defaultPatchEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPatch');
      expect(defaultPatchEndpoint).toBeDefined();
      expect(defaultPatchEndpoint?.type).toBe(DyFM_HttpCallType.patch);
      expect(defaultPatchEndpoint?.endpoint).toBe('/*');
      expect((defaultPatchEndpoint as any)?.tasks).toBeDefined();
      expect((defaultPatchEndpoint as any)?.tasks?.length).toBe(1);
    });

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

      const defaultDeleteEndpoint = controller.endpoints.find(ep => ep.name === 'defaultDelete');
      expect(defaultDeleteEndpoint).toBeDefined();
      expect(defaultDeleteEndpoint?.type).toBe(DyFM_HttpCallType.delete);
      expect(defaultDeleteEndpoint?.endpoint).toBe('/*');
      expect((defaultDeleteEndpoint as any)?.tasks).toBeDefined();
      expect((defaultDeleteEndpoint as any)?.tasks?.length).toBe(1);
    });
  });

  describe('| DyNTS_getStarRoute', () => {
    it('| should return routing module', () => {
      const routingModule = DyNTS_getStarRoute();

      expect(routingModule).toBeInstanceOf(DyNTS_RoutingModule);
      // The route might be modified by RoutingModule, check if it contains /**
      expect(routingModule.route).toContain('**');
      expect((routingModule as any).controllers).toBeDefined();
      expect((routingModule as any).controllers.length).toBe(1);
      expect((routingModule as any).controllers[0]).toBeInstanceOf(DyNTS_Star_Controller);
    });

    it('| should return routing module with correct route', () => {
      const routingModule = DyNTS_getStarRoute();
      expect(routingModule.route).toBe('/api/**');
    });
  });

  describe('| endpoint tasks', () => {
    it('| should throw 404 error for defaultGet endpoint', async () => {
      controller.setupEndpoints();
      const defaultGetEndpoint = controller.endpoints.find(ep => ep.name === 'defaultGet');
      expect(defaultGetEndpoint).toBeDefined();

      const mockReq = {
        originalUrl: '/test-route',
      } as any;
      const mockRes = {} as any;

      try {
        await (defaultGetEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
        fail('Should have thrown an error');
      } catch (error) {
        expect(error).toBeInstanceOf(DyFM_Error);
        expect((error as DyFM_Error).___status).toBe(404);
        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-G404');
      }
    });

    it('| should throw 404 error for defaultPost endpoint', async () => {
      controller.setupEndpoints();
      const defaultPostEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPost');
      expect(defaultPostEndpoint).toBeDefined();

      const mockReq = {
        originalUrl: '/test-route',
      } as any;
      const mockRes = {} as any;

      try {
        await (defaultPostEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
        fail('Should have thrown an error');
      } catch (error) {
        expect(error).toBeInstanceOf(DyFM_Error);
        expect((error as DyFM_Error).___status).toBe(404);
        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-PO404');
      }
    });

    it('| should throw 404 error for defaultPut endpoint', async () => {
      controller.setupEndpoints();
      const defaultPutEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPut');
      expect(defaultPutEndpoint).toBeDefined();

      const mockReq = {
        originalUrl: '/test-route',
      } as any;
      const mockRes = {} as any;

      try {
        await (defaultPutEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
        fail('Should have thrown an error');
      } catch (error) {
        expect(error).toBeInstanceOf(DyFM_Error);
        expect((error as DyFM_Error).___status).toBe(404);
        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-PU404');
      }
    });

    it('| should throw 404 error for defaultPatch endpoint', async () => {
      controller.setupEndpoints();
      const defaultPatchEndpoint = controller.endpoints.find(ep => ep.name === 'defaultPatch');
      expect(defaultPatchEndpoint).toBeDefined();

      const mockReq = {
        originalUrl: '/test-route',
      } as any;
      const mockRes = {} as any;

      try {
        await (defaultPatchEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
        fail('Should have thrown an error');
      } catch (error) {
        expect(error).toBeInstanceOf(DyFM_Error);
        expect((error as DyFM_Error).___status).toBe(404);
        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-PA404');
      }
    });

    it('| should throw 404 error for defaultDelete endpoint', async () => {
      controller.setupEndpoints();
      const defaultDeleteEndpoint = controller.endpoints.find(ep => ep.name === 'defaultDelete');
      expect(defaultDeleteEndpoint).toBeDefined();

      const mockReq = {
        originalUrl: '/test-route',
      } as any;
      const mockRes = {} as any;

      try {
        await (defaultDeleteEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
        fail('Should have thrown an error');
      } catch (error) {
        expect(error).toBeInstanceOf(DyFM_Error);
        expect((error as DyFM_Error).___status).toBe(404);
        expect((error as DyFM_Error)._errorCode).toContain('DyNTS-RMS-D404');
      }
    });

    it('| should include originalUrl in error message', async () => {
      controller.setupEndpoints();
      const defaultGetEndpoint = controller.endpoints.find(ep => ep.name === 'defaultGet');
      expect(defaultGetEndpoint).toBeDefined();

      const mockReq = {
        originalUrl: '/custom-route',
      } as any;
      const mockRes = {} as any;

      try {
        await (defaultGetEndpoint as any).tasks[0](mockReq, mockRes, 'test-issuer');
        fail('Should have thrown an error');
      } catch (error) {
        expect(error).toBeInstanceOf(DyFM_Error);
        expect((error as DyFM_Error)._message).toContain('/custom-route');
      }
    });
  });
});