import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
import { DyNTS_Bot_IO_ControlService } from './bot-io.control-service';
import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-service';
import { DyNTS_Bot_Commands_ControlService } from './bot-commands.control-service';
import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';
import { DyFM_Error, DyFM_Async } from '@futdevpro/fsm-dynamo';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
import { second } from '@futdevpro/fsm-dynamo';

class TestBotMainService extends DyNTS_Bot_Main_ControlService<DyFM_Msg_Provider_Type> {
  protected getBotIOControlService(): DyNTS_Bot_IO_ControlService {
    return {
      setup: jasmine.createSpy('setup').and.returnValue(Promise.resolve()),
      start: jasmine.createSpy('start').and.returnValue(Promise.resolve()),
    } as any;
  }

  protected getRoutinesControlService(): DyNTS_Bot_Routines_ControlService {
    return {
      setup: jasmine.createSpy('setup').and.returnValue(Promise.resolve()),
      start: jasmine.createSpy('start').and.returnValue(Promise.resolve()),
    } as any;
  }

  protected getCommandsControlService(): DyNTS_Bot_Commands_ControlService {
    return {
      setup: jasmine.createSpy('setup').and.returnValue(Promise.resolve()),
      start: jasmine.createSpy('start').and.returnValue(Promise.resolve()),
    } as any;
  }

  protected defaultProviderType: DyFM_Msg_Provider_Type = DyFM_Msg_Provider_Type.discord;
  protected availableProviders: DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any>[] = [
    {
      type: DyFM_Msg_Provider_Type.discord,
      setup: jasmine.createSpy('setup').and.returnValue(Promise.resolve()),
      start: jasmine.createSpy('start').and.returnValue(Promise.resolve()),
      create_onErrorEventListener: jasmine.createSpy('create_onErrorEventListener'),
      create_onMessageEventListener: jasmine.createSpy('create_onMessageEventListener'),
      sendReport: jasmine.createSpy('sendReport').and.returnValue(Promise.resolve()),
      name: 'TestProvider',
      config: { reportChannelName: 'test-channel' },
    } as any,
  ];

  static getInstance(): TestBotMainService {
    return TestBotMainService.getSingletonInstance();
  }
}

xdescribe('| DyNTS_Bot_Main_ControlService', () => {
  let service: TestBotMainService;

  beforeEach(() => {
    service = TestBotMainService.getInstance();
  });

  afterEach(async () => {
    try {
      // Megvárjuk, hogy a bot leálljon és a process listener-ek lefussanak
      await DyFM_Async.delay(200);
      
      // Biztosítjuk, hogy a provider-ek ne próbáljanak üzenetet küldeni
      if (service && (service as any)._providers) {
        const providers = (service as any)._providers as Map<any, any>;
        providers.forEach((provider) => {
          if (provider) {
            // Eltávolítjuk a sendMessageToChannelByName metódust, hogy ne próbáljon üzenetet küldeni
            if (typeof provider.sendMessageToChannelByName === 'function') {
              provider.sendMessageToChannelByName = undefined;
            }
            // Invalidáljuk a config-ot is, hogy ne legyen reportChannelName
            if (provider.config) {
              provider.config.reportChannelName = undefined;
              provider.config = undefined;
            }
            // Invalidáljuk a name-et is
            provider.name = undefined;
          }
        });
        // Töröljük a providers map-et is
        (service as any)._providers.clear();
      }
      
      // Invalidáljuk a defaultProvider-t is
      if (service && (service as any)._defaultProvider) {
        (service as any)._defaultProvider = undefined;
      }
      
      await DyFM_Async.delay(200);
    } catch (error) {
      // Csendes hiba-kezelés
    }
  });

  afterAll(async () => {
    try {
      // Végleges cleanup a tesztek végén - megvárjuk, hogy minden process listener lefusson
      await DyFM_Async.delay(500);
      
      // Invalidáljuk a service-t is
      if (service) {
        (service as any)._providers = undefined;
        (service as any)._defaultProvider = undefined;
      }
      
      await DyFM_Async.delay(500);
    } catch (error) {
      // Csendes hiba-kezelés
    }
  });

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

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

  describe('| defaultProvider', () => {
    it('| should return default provider after setup', async () => {
      await service.setup('issuer-123');

      expect(service.defaultProvider).toBeDefined();
    });
  });

  describe('| setup', () => {
    it('| should throw error when no providers configured', async () => {
      const serviceWithoutProviders = new (class extends TestBotMainService {
        protected override availableProviders: any[] = [];
      } as any)();

      // Expect rejection - may be DyFM_Error or Error
      await expectAsync(
        serviceWithoutProviders.setup('issuer-123')
      ).toBeRejected();
    });

    it('| should throw error when default provider type not set', async () => {
      const serviceWithoutDefaultType = new (class extends TestBotMainService {
        protected override defaultProviderType: any = undefined;
      } as any)();

      // Expect rejection - may be DyFM_Error or Error
      await expectAsync(
        serviceWithoutDefaultType.setup('issuer-123')
      ).toBeRejected();
    });

    it('| should setup all services', async () => {
      await service.setup('issuer-123');

      expect(service.botIO_CS).toBeDefined();
      expect(service.routines_CS).toBeDefined();
      expect(service.commands_CS).toBeDefined();
    });

    it('| should throw error when botIO_CS not found', async () => {
      const serviceWithoutBotIO = new (class extends TestBotMainService {
        protected override getBotIOControlService(): any {
          return null;
        }
      } as any)();

      await expectAsync(
        serviceWithoutBotIO.setup('issuer-123')
      ).toBeRejected();
    });
  });

  describe('| start', () => {
    it('| should start routines and botIO services', async () => {
      (service as any).botIO_CS = (service as any).getBotIOControlService();
      (service as any).routines_CS = (service as any).getRoutinesControlService();

      await service.start('issuer-123');

      expect(service.routines_CS.start).toHaveBeenCalledWith('issuer-123');
      expect(service.botIO_CS.start).toHaveBeenCalledWith('issuer-123');
    });
  });

  describe('| getProviderByType', () => {
    it('| should return provider by type', async () => {
      await service.setup('issuer-123');

      const provider = service.getProviderByType(DyFM_Msg_Provider_Type.discord);

      expect(provider).toBeDefined();
      expect(provider.type).toBe(DyFM_Msg_Provider_Type.discord);
    });
  });

  describe('| sendReport', () => {
    it('| should send report via default provider', async () => {
      await service.setup('issuer-123');

      await service.sendReport('Test report');

      expect(service.defaultProvider.sendReport).toHaveBeenCalledWith('Test report');
    });
  });
});