import { DyNTS_DiAs_IO_ControlService } from './dias-io.control-service';
import { DyNTS_DiAs_Main_ControlService } from './dias-main.control-service';
import { DyNTS_DiBo_IO_ControlService } from '../../discord-bot/_services/dibo-io.control-service';
import { Message } from 'discord.js';
import { DyFM_Error } from '@futdevpro/fsm-dynamo';
import { DyNTS_DiAs_Util } from '../_collections/dias.util';
import { DyNTS_DiBo_global_settings } from '../../discord-bot/_collections/dibo-global-settings.conts';

class TestDiAsIOService extends DyNTS_DiAs_IO_ControlService {
  protected mainDiscordBot_CS: any;
  protected getMainDiscordBotControlService(): DyNTS_DiAs_Main_ControlService {
    return {
      gatherDiscordMessagesForMessage: jasmine.createSpy('gatherDiscordMessagesForMessage').and.returnValue(
        Promise.resolve([])
      ),
      botClientId: 'bot-123',
      botDisplayName: 'TestBot',
      defaultSystemPrompt: 'Test prompt',
      llmChat_CS: {
        requestSimpleMessageInConversation: jasmine.createSpy('requestSimpleMessageInConversation').and.returnValue(
          Promise.resolve('AI response')
        ),
      },
    } as any;
  }

  protected getCommandsControlService(): any {
    return {} as any;
  }

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

xdescribe('| DyNTS_DiAs_IO_ControlService', () => {
  let service: TestDiAsIOService;

  beforeEach(() => {
    service = TestDiAsIOService.getInstance();
    (service as any).mainDiscordBot_CS = (service as any).getMainDiscordBotControlService();
  });

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

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

  it('| should get LLM chat service from main bot service', () => {
    expect(service.llmChat_CS).toBeDefined();
  });

  describe('| handleMessage', () => {
    it('| should handle message with AI and reply', async () => {
      const mockMessage = {
        reply: jasmine.createSpy('reply').and.returnValue(Promise.resolve({} as Message)),
      } as any as Message;
      spyOn(DyNTS_DiAs_Util, 'convertDiscordMessagesToOAIConversation').and.returnValue([
        { role: 'user' as any, content: 'User message' },
      ]);

      const result = await service.handleMessage(mockMessage, 'issuer-123');

      expect((service as any).mainDiscordBot_CS.gatherDiscordMessagesForMessage).toHaveBeenCalledWith(mockMessage);
      expect((service as any).mainDiscordBot_CS.llmChat_CS.requestSimpleMessageInConversation).toHaveBeenCalled();
      expect(mockMessage.reply).toHaveBeenCalledWith('AI response');
    });

    it('| should send error reply when error occurs and debugLevel >= 1', async () => {
      const mockMessage = {
        reply: jasmine.createSpy('reply').and.returnValue(Promise.resolve({} as Message)),
      } as any as Message;
      (service as any).mainDiscordBot_CS.gatherDiscordMessagesForMessage = jasmine.createSpy('gatherDiscordMessagesForMessage').and.returnValue(
        Promise.reject(new Error('Test error'))
      );
      service.dontSendErrorReply = false;
      // debugLevel is a property, not a function - set it directly
      (DyNTS_DiBo_global_settings as any).debugLevel = 1;

      await expectAsync(
        service.handleMessage(mockMessage, 'issuer-123')
      ).toBeRejected();

      expect(mockMessage.reply).toHaveBeenCalled();
    });

    it('| should not send error reply when dontSendErrorReply is true', async () => {
      const mockMessage = {
        reply: jasmine.createSpy('reply'),
      } as any as Message;
      (service as any).mainDiscordBot_CS.gatherDiscordMessagesForMessage = jasmine.createSpy('gatherDiscordMessagesForMessage').and.returnValue(
        Promise.reject(new Error('Test error'))
      );
      service.dontSendErrorReply = true;

      await expectAsync(
        service.handleMessage(mockMessage, 'issuer-123')
      ).toBeRejected();

      expect(mockMessage.reply).not.toHaveBeenCalled();
    });
  });
});