import { DyNTS_Usage_Controller } from './usage.controller';
import { DyNTS_GlobalService } from '../../_services/core/global.service';
import { DyNTS_AuthService } from '../../_services/core/auth.service';
import { DyFM_HttpCallType } from '@futdevpro/fsm-dynamo';

describe('| DyNTS_Usage_Controller', () => {
  let controller: DyNTS_Usage_Controller;
  let mockAuthService: jasmine.SpyObj<DyNTS_AuthService>;

  beforeEach(() => {
    controller = DyNTS_Usage_Controller.getInstance();
    mockAuthService = jasmine.createSpyObj<DyNTS_AuthService>('AuthService', [
      'getUsernameFromRequest',
    ]);

    spyOn(DyNTS_GlobalService, 'getAuthService').and.returnValue(mockAuthService);
  });

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

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

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

    expect(controller.endpoints).toBeDefined();
    expect(controller.endpoints.length).toBeGreaterThan(0);
  });

  it('| should have newSession endpoint', () => {
    controller.setupEndpoints();

    const newSessionEndpoint = controller.endpoints.find(ep => ep.name === 'newSession');

    expect(newSessionEndpoint).toBeDefined();
    expect(newSessionEndpoint?.type).toBe(DyFM_HttpCallType.get);
    expect((newSessionEndpoint as any)?.tasks).toBeDefined();
    expect((newSessionEndpoint as any)?.tasks.length).toBeGreaterThan(0);
  });

  it('| should have updateUsage endpoint', () => {
    controller.setupEndpoints();

    const updateUsageEndpoint = controller.endpoints.find(ep => ep.name === 'updateUsage');

    expect(updateUsageEndpoint).toBeDefined();
    expect(updateUsageEndpoint?.type).toBe(DyFM_HttpCallType.post);
    expect((updateUsageEndpoint as any)?.tasks).toBeDefined();
    expect((updateUsageEndpoint as any)?.tasks.length).toBeGreaterThan(0);
  });

  it('| should have closeSession endpoint', () => {
    controller.setupEndpoints();

    const closeSessionEndpoint = controller.endpoints.find(ep => ep.name === 'closeSession');

    expect(closeSessionEndpoint).toBeDefined();
    expect(closeSessionEndpoint?.type).toBe(DyFM_HttpCallType.get);
    expect((closeSessionEndpoint as any)?.tasks).toBeDefined();
    expect((closeSessionEndpoint as any)?.tasks.length).toBeGreaterThan(0);
  });

  it('| should have getUsageData endpoint with authentication', () => {
    controller.setupEndpoints();

    const getUsageDataEndpoint = controller.endpoints.find(ep => ep.name === 'getUsageData');

    expect(getUsageDataEndpoint).toBeDefined();
    expect(getUsageDataEndpoint?.type).toBe(DyFM_HttpCallType.get);
    expect((getUsageDataEndpoint as any)?.preProcesses).toBeDefined();
    expect((getUsageDataEndpoint as any)?.preProcesses.length).toBeGreaterThan(0);
    expect((getUsageDataEndpoint as any)?.tasks).toBeDefined();
    expect((getUsageDataEndpoint as any)?.tasks.length).toBeGreaterThan(0);
  });
});