import { DyNTS_Bot_Routines_ControlService } from './bot-routines.control-service';
import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
import { DyFM_Error } from '@futdevpro/fsm-dynamo';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';

class TestBotRoutinesService extends DyNTS_Bot_Routines_ControlService {
  protected declare mainBot_CS: any;
  protected getMainBotControlService(): DyNTS_Bot_Main_ControlService {
    return {
      defaultProvider: {
        botId: 'bot-123',
      },
    } as any;
  }

  startRoutines = async (issuer: string): Promise<void> => {
    // Mock implementation
  };

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

xdescribe('| DyNTS_Bot_Routines_ControlService', () => {
  let service: TestBotRoutinesService;

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

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

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

  describe('| defaultProvider', () => {
    it('| should return default provider from main bot service', () => {
      (service as any).mainBot_CS = (service as any).getMainBotControlService();

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

  describe('| routinesStarted', () => {
    it('| should return undefined initially', () => {
      // Reset the private _routinesStarted field to undefined for clean test
      (service as any)._routinesStarted = undefined;
      expect(service.routinesStarted).toBeFalsy();
    });

    it('| should return true after start', async () => {
      (service as any).mainBot_CS = (service as any).getMainBotControlService();
      await service.start('issuer-123');

      expect(service.routinesStarted).toBe(true);
    });
  });

  describe('| setup', () => {
    it('| should setup main bot service', async () => {
      await service.setup('issuer-123');

      expect((service as any).mainBot_CS).toBeDefined();
    });

    it('| should throw error when main bot service not found', async () => {
      const serviceWithoutMainBot = new (class extends TestBotRoutinesService {
        protected override getMainBotControlService(): any {
          return null;
        }
      } as any)();

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

  describe('| start', () => {
    it('| should throw error when default provider not started', async () => {
      const serviceWithoutProvider = new (class extends TestBotRoutinesService {
        protected override getMainBotControlService(): any {
          return {
            defaultProvider: null,
          };
        }
      } as any)();

      await expectAsync(
        serviceWithoutProvider.start('issuer-123')
      ).toBeRejected();
    });

    it('| should start routines and set routinesStarted flag', async () => {
      (service as any).mainBot_CS = (service as any).getMainBotControlService();
      spyOn(service, 'startRoutines').and.returnValue(Promise.resolve());

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

      expect(service.startRoutines).toHaveBeenCalledWith('issuer-123');
      expect(service.routinesStarted).toBe(true);
    });
  });
});