import { DyFM_Error, DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';

import { DyNTS_global_settings } from '../../_collections/global-settings.const';
import { DyNTS_RouteSecurity } from '../../_enums/route-security.enum';
import { DyNTS_Endpoint_Params } from '../../_models/control-models/endpoint-params.control-model';
import {
  DyNTS_RoutingModule_Settings
} from '../../_models/interfaces/routing-module-settings.interface';
import { DyNTS_Controller } from './controller.service';
import { DyNTS_RoutingModule } from './routing-module.service';

describe('| DyNTS_RoutingModule', () => {
  let routingModule: DyNTS_RoutingModule;
  let mockController: DyNTS_Controller;
  let mockEndpoint: DyNTS_Endpoint_Params;

  beforeEach(() => {
    mockController = {
      setupEndpoints: jasmine.createSpy('setupEndpoints'),
      endpoints: [],
    } as unknown as DyNTS_Controller;

    mockEndpoint = {
      endpoint: '/test',
      type: DyFM_HttpCallType.get,
      getFullExecution: jasmine.createSpy('getFullExecution'),
      security: DyNTS_RouteSecurity.open,
    } as any as DyNTS_Endpoint_Params;

    const settings: DyNTS_RoutingModule_Settings = {
      route: '/test',
      controllers: [ mockController ],
    };

    routingModule = new DyNTS_RoutingModule(settings);
  });

  it('| should initialize with given settings', () => {
    expect(routingModule.route).toContain('/test');
    expect(routingModule.endpoints.length).toBe(0);
  });

  it('| should setup routes by calling setupEndpoints on each controller', () => {
    routingModule['setupRoutes']();
    expect(mockController.setupEndpoints).toHaveBeenCalled();
  });

  it('| should add endpoints from controllers to the routing module', () => {
    mockController.endpoints = [ mockEndpoint ];
    routingModule['setupRoutes']();
    expect(routingModule.endpoints).toContain(mockEndpoint);
  });

  it('should mount open routes correctly', () => {
    mockEndpoint.getFullExecution = jasmine.createSpy('getFullExecution').and.returnValue(async () => {});
    routingModule.endpoints = [ mockEndpoint ];
    routingModule['mountOpenRoute'](mockEndpoint);
    expect(routingModule.openRouter.stack.length).toBeGreaterThan(0);
  });

  it('should mount secure routes correctly', () => {
    mockEndpoint.security = DyNTS_RouteSecurity.secure;
    mockEndpoint.getFullExecution = jasmine.createSpy('getFullExecution').and.returnValue(async () => {});
    routingModule.endpoints = [ mockEndpoint ];
    routingModule['mountSecureRoute'](mockEndpoint);
    expect(routingModule.secureRouter.stack.length).toBeGreaterThan(0);
  });

  it('should throw error for invalid route type in open route', () => {
    mockEndpoint.type = 'invalid' as DyFM_HttpCallType;
    expect(() => routingModule['mountOpenRoute'](mockEndpoint)).toThrow();
  });

  it('should throw error for invalid route type in secure route', () => {
    mockEndpoint.type = 'invalid' as DyFM_HttpCallType;
    expect(() => routingModule['mountSecureRoute'](mockEndpoint)).toThrow();
  });

  it('| should handle endpoint duplication error', () => {
    routingModule.endpoints = [ mockEndpoint, mockEndpoint ];
    expect(() => routingModule['mountRoutes']()).toThrowError(/ENDPOINT DUPLICATION/);
  });

  it('| should use DyNTS_global_settings.baseUrl as route prefix', () => {
    const originalBaseUrl: string = DyNTS_global_settings.baseUrl;
    try {
      DyNTS_global_settings.baseUrl = '/custom-api';
      const moduleWithCustomBase: DyNTS_RoutingModule = new DyNTS_RoutingModule({
        route: '/foo',
        controllers: [ mockController ],
      });
      expect(moduleWithCustomBase.route).toBe('/custom-api/foo');
    } finally {
      DyNTS_global_settings.baseUrl = originalBaseUrl;
    }
  });
});