import { DyNTS_Bot_Commands_ControlService } from './bot-commands.control-service';
import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
import { DyFM_Error, DyFM_EnvironmentFlag } from '@futdevpro/fsm-dynamo';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
import { DyNTS_GlobalService } from '../../../_services/core/global.service';

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

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

xdescribe('| DyNTS_Bot_Commands_ControlService', () => {
  let service: TestBotCommandsService;
  let mockDBService: jasmine.SpyObj<{
    find: (f: unknown) => Promise<unknown[]>;
    getAll: () => Promise<unknown[]>;
    getDataById: (id: string) => Promise<unknown>;
  }>;

  beforeAll(() => {
    if (!DyNTS_global_settings.systemShortCodeName) {
      (DyNTS_global_settings as { systemShortCodeName?: string }).systemShortCodeName = 'TEST';
    }
  });

  beforeEach(() => {
    DyNTS_global_settings.env_settings = {
      environment: DyFM_EnvironmentFlag.local,
      mongoUri: 'mongodb://localhost:27017/test',
    } as typeof DyNTS_global_settings.env_settings;

    mockDBService = jasmine.createSpyObj('DyNTS_DBService', [
      'find', 'findOne', 'getDataById', 'getAll', 'getDataListByIds', 'getDataByDependencyId',
      'getDataListByDependencyId', 'getDataListByDependencyIds', 'createData', 'modifyData',
      'markDeletedById', 'trueDeleteDataById', 'trueDeleteAllData', 'restoreDeletedById',
    ]);
    spyOn(DyNTS_GlobalService, 'getDBService').and.returnValue(mockDBService as never);
    spyOn(DyNTS_GlobalService, 'getDBServiceByKey').and.returnValue(mockDBService as never);

    service = TestBotCommandsService.getInstance();
  });

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

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

  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('| 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 TestBotCommandsService {
        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 TestBotCommandsService {
        protected override getMainBotControlService(): any {
          return {
            defaultProvider: null,
          };
        }
      } as any)();

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

    it('| should succeed when default provider is started', async () => {
      (service as any).mainBot_CS = (service as any).getMainBotControlService();

      await expectAsync(
        service.start('issuer-123')
      ).toBeResolved();
    });
  });
});