import { DyNTS_AI_LLMChat_ServiceBase } from './ai-llm-chat.service-base';
import { DyNTS_AI_LLM_ServiceBase } from './ai-llm.service-base';
import { DyFM_AI_CallSettings, DyFM_AI_MessageRole, DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
import { DyFM_AI_ConversationBase_Input, DyFM_AI_ConversationGenericSelect_Input, DyFM_AI_ConversationGenericMultiSelect_Input, DyFM_AI_ConversationJSONKeysDescription_Input, DyFM_AI_ConversationJSONExactKeys_Input } from '../_models/ai-input-interfaces';

class TestLLMChatService extends DyNTS_AI_LLMChat_ServiceBase<DyFM_AI_CallSettings> {
  readonly aiProvider: any = {} as any;
  readonly capabilities: any = {} as any;
  setup = (config: any): void => {};
  testConnection = async (issuer: string): Promise<boolean> => true;
  readonly defaultSettings: DyFM_AI_CallSettings = {
    systemPrompt: 'Test system prompt',
    useModel: 'test-model',
    debugLog: false,
  };

  readonly predefinedRequests = {
    yesNo: {
      upperCaseYes: 'YES',
    },
  };

  requestSimpleMessage = async (set: any): Promise<string> => { return ''; };
  requestYesNo = async (set: any): Promise<boolean> => { return false; };
  requestPercentage = async (set: any): Promise<number> => { return 0; };
  requestSelect = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
  requestMultiselect = async <T>(set: any): Promise<T[] | { unparsableResult: string }> => { return []; };
  requestJSON = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
  requestJSONQuestionWithKeysDescription = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
  requestJSONWithExactKeys = async <T>(set: any): Promise<T | { unparsableResult: string }> => { return null as any; };
  requestList = async <T>(set: any): Promise<T[] | { unparsableResult: string }> => { return []; };

  async requestSimpleMessageInConversation(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<string> {
    return 'Test response';
  }

  async requestYesNoInConversation(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<boolean> {
    return true;
  }

  async requestPercentageInConversation(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<number> {
    return 50;
  }

  async requestSelectInConversation<T>(set: DyFM_AI_ConversationGenericSelect_Input<T, DyFM_AI_CallSettings>): Promise<T | { unparsableResult: string }> {
    return null as any;
  }

  async requestMultiselectInConversation<T>(set: DyFM_AI_ConversationGenericMultiSelect_Input<T, DyFM_AI_CallSettings>): Promise<T[] | { unparsableResult: string }> {
    return [];
  }

  async requestJSONInConversation<T = any>(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<T | { unparsableResult: string }> {
    return null as any;
  }

  async requestJSONInConversationWithKeysDescription<T>(set: DyFM_AI_ConversationJSONKeysDescription_Input<DyFM_AI_CallSettings>): Promise<T | { unparsableResult: string }> {
    return null as any;
  }

  async requestJSONInConversationWithExactKeys<T>(set: DyFM_AI_ConversationJSONExactKeys_Input<DyFM_AI_CallSettings>): Promise<T | { unparsableResult: string }> {
    return null as any;
  }

  async requestListInConversation(set: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings>): Promise<string[] | { unparsableResult: string }> {
    return [];
  }

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

describe('| DyNTS_AI_LLMChat_ServiceBase', () => {
  let service: TestLLMChatService;

  beforeEach(() => {
    service = new (TestLLMChatService as any)();
  });

  describe('| constructor', () => {
    it('| should extend LLM service base', () => {
      expect(service).toBeInstanceOf(DyNTS_AI_LLM_ServiceBase);
    });
  });

  describe('| requestSimpleMessageInConversation', () => {
    it('| should request simple message in conversation', async () => {
      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
        conversation: [
          { role: DyFM_AI_MessageRole.user, content: 'Hello' },
        ],
        issuer: 'test-issuer',
      };

      const result = await service.requestSimpleMessageInConversation(input);

      expect(result).toBe('Test response');
    });
  });

  describe('| requestYesNoInConversation', () => {
    it('| should request yes/no in conversation', async () => {
      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
        conversation: [
          { role: DyFM_AI_MessageRole.user, content: 'Is this true?' },
        ],
        issuer: 'test-issuer',
      };

      const result = await service.requestYesNoInConversation(input);

      expect(result).toBe(true);
    });
  });

  describe('| requestPercentageInConversation', () => {
    it('| should request percentage in conversation', async () => {
      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
        conversation: [
          { role: DyFM_AI_MessageRole.user, content: 'What percentage?' },
        ],
        issuer: 'test-issuer',
      };

      const result = await service.requestPercentageInConversation(input);

      expect(result).toBe(50);
    });
  });

  describe('| requestSelectInConversation', () => {
    it('| should request select in conversation', async () => {
      const input: DyFM_AI_ConversationGenericSelect_Input<string, DyFM_AI_CallSettings> = {
        conversation: [
          { role: DyFM_AI_MessageRole.user, content: 'Choose one' },
        ],
        selectFrom: ['option1', 'option2'],
        issuer: 'test-issuer',
      };

      const result = await service.requestSelectInConversation(input);

      expect(result).toBeDefined();
    });
  });

  describe('| requestMultiselectInConversation', () => {
    it('| should request multiselect in conversation', async () => {
      const input: DyFM_AI_ConversationGenericMultiSelect_Input<string, DyFM_AI_CallSettings> = {
        conversation: [
          { role: DyFM_AI_MessageRole.user, content: 'Choose multiple' },
        ],
        options: ['option1', 'option2'],
        issuer: 'test-issuer',
      };

      const result = await service.requestMultiselectInConversation(input);

      expect(result).toBeDefined();
      expect(Array.isArray(result)).toBe(true);
    });
  });

  describe('| requestJSONInConversation', () => {
    it('| should request JSON in conversation', async () => {
      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
        conversation: [
          { role: DyFM_AI_MessageRole.user, content: 'Return JSON' },
        ],
        issuer: 'test-issuer',
      };

      const result = await service.requestJSONInConversation(input);

      expect(result).toBeDefined();
    });
  });

  describe('| requestJSONInConversationWithKeysDescription', () => {
    it('| should request JSON with keys description in conversation', async () => {
      const input: DyFM_AI_ConversationJSONKeysDescription_Input<DyFM_AI_CallSettings> = {
        conversation: [
          { role: DyFM_AI_MessageRole.user, content: 'Return JSON with keys' },
        ],
        keysDescription: 'key1: Description 1',
        issuer: 'test-issuer',
      };

      const result = await service.requestJSONInConversationWithKeysDescription(input);

      expect(result).toBeDefined();
    });
  });

  describe('| requestJSONInConversationWithExactKeys', () => {
    it('| should request JSON with exact keys in conversation', async () => {
      const input: DyFM_AI_ConversationJSONExactKeys_Input<DyFM_AI_CallSettings> = {
        conversation: [
          { role: DyFM_AI_MessageRole.user, content: 'Return JSON with exact keys' },
        ],
        keys: ['key1', 'key2'],
        issuer: 'test-issuer',
      };

      const result = await service.requestJSONInConversationWithExactKeys(input);

      expect(result).toBeDefined();
    });
  });

  describe('| requestListInConversation', () => {
    it('| should request list in conversation', async () => {
      const input: DyFM_AI_ConversationBase_Input<DyFM_AI_CallSettings> = {
        conversation: [
          { role: DyFM_AI_MessageRole.user, content: 'Return list' },
        ],
        issuer: 'test-issuer',
      };

      const result = await service.requestListInConversation(input);

      expect(result).toBeDefined();
      expect(Array.isArray(result)).toBe(true);
    });
  });
});