import { DyFM_OAI_Model, DyFM_OAI_Settings } from '@futdevpro/fsm-dynamo/ai/open-ai';
import { DyNTS_OAI_LLMChat_ServiceBase } from './../../ai/_modules/open-ai/_services/oai-llm-chat.service-base';
import { DyNTS_DAI_DocChunk, DyNTS_DAI_docChunk_dataParams } from '../../ai/_modules/document-ai/_models/data-models/dai-doc-chunk.data-model';
import { DyNTS_OAI_DocChunkDataService } from '../../ai/_modules/open-ai/_services/data-services/oai-doc-chunk-data.service';
import { DyFM_DataModel_Params, DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
// TODO: Fix imports when FSM package exports are updated
// import { DyFM_OAI_Settings } from '@futdevpro/fsm-dynamo';
// import { DyFM_OAI_Model } from '@futdevpro/fsm-dynamo';
import { DyNTS_DiAs_Main_ControlService } from './dias-main.control-service';
import { DyNTS_AI_LLMChat_ServiceBase } from '../../ai/_services/ai-llm-chat.service-base';
import { DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
import { DyNTS_OAI_LLMDefaultPredefined_Requests } from '../../ai/_modules/open-ai/_collections/oai-llm-predefined-requests.conts';
import { DyNTS_DAI_Document_Util } from '../../ai/_modules/document-ai/_collections/dai-document.util';
import { DyNTS_DAI_DocPage } from '../../ai/_modules/document-ai/_models/data-models/dai-doc-page.data-model';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
import { DyNTS_DAI_Document } from '../../ai/_modules/document-ai/_models/data-models/dai-document.data-model';


export abstract class DyNTS_DiAs_Chunk_DataService<
  T_Chunk extends DyNTS_DAI_DocChunk = DyNTS_DAI_DocChunk,
  T_Page extends DyNTS_DAI_DocPage<T_Chunk> = DyNTS_DAI_DocPage<T_Chunk>, 
  T_ExternalDocumentId = string,
  T_Document extends DyNTS_DAI_Document<T_Chunk, T_Page, T_ExternalDocumentId> = DyNTS_DAI_Document<T_Chunk, T_Page, T_ExternalDocumentId>,
> extends DyNTS_OAI_DocChunkDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document> {

  protected abstract readonly mainDiscordBot_CS: DyNTS_DiAs_Main_ControlService;

  get llmChat_CS(): DyNTS_OAI_LLMChat_ServiceBase {
    return this.mainDiscordBot_CS.llmChat_CS;
  }

  constructor(
    issuer: string,
    dataParams?: DyFM_DataModel_Params<T_Chunk>,
    openAiSettings?: DyFM_OAI_Settings,
  ) {
    super(
      issuer,
      openAiSettings ?? 
        new DyFM_OAI_Settings({
          config: {
            apiKey: DyNTS_global_settings.env_settings.openAi.apiKey,
            organization: DyNTS_global_settings.env_settings.openAi.organization,
            project: DyNTS_global_settings.env_settings.openAi.project,
          },
          defaultSettings: {
            useModel: DyFM_OAI_Model.textEmbedding_3Large,
          },
        }),
      dataParams ?? DyNTS_DAI_docChunk_dataParams as DyFM_DataModel_Params<T_Chunk>, 
    );
  }

  /* abstract getPageLink(page: T_Page): string; */

  async resolveConversation(
    conversation: DyFM_AI_Message[],
    limit: number = 10,
    numberOfCandidates: number = 200,
  ): Promise<string> {
    try {
      DyFM_Log.info('🔍 Document message received:', conversation[conversation.length - 1].content);

      const vectorSearchNeeded: boolean = await this.llmChat_CS.requestYesNoInConversation({
        conversation: conversation,
        message: DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.doWeNeedVectorSearch,
        issuer: this.issuer,
        settings: {
          systemPrompt: DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt,
        },
      });

      let result: string;
      if (vectorSearchNeeded) {
        result = await this.vectorSearchAndResolveConversation(conversation, limit, numberOfCandidates);
      } else {
        result = await this.llmChat_CS.requestSimpleMessageInConversation({
          conversation: conversation,
          settings: {
            systemPrompt: DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt,
          },
          issuer: this.issuer,
        });
      }

      return result;
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('resolveMessage', error),
        errorCode: 'ODB-DCHDS-RM0',
      });
    }
  }

  // TODO 
  // add code overview by coding policies 
  //  (Milyen jellegű coding policies lehet releváns az adott kérdésben)
  async vectorSearchAndResolveConversation(
    conversation: DyFM_AI_Message[],
    limit: number = 3,
    numberOfCandidates: number = 100,
  ): Promise<string> {
    try {
      const searchResults: T_Chunk[] = await this.vectorSearchUsingConversation(
        conversation,
        limit,
        numberOfCandidates,
      );

      const parsedSearchResults: string = searchResults.map((result) => {
        return '' +
          '\npage: ' + result.pageName +
          '\npageLink: ' + result.pageLink +
          '\ncontent: ' +
          `\n${result.chunkContent.replace(/\n/g, '\n  ')}`
      }).join('\n\n');

      DyFM_Log.H_success(`✅ Document search results:`, parsedSearchResults);
      
      const result: string = await this.llmChat_CS.requestSimpleMessageInConversation({
        conversation: conversation,
        settings: {
          systemPrompt: 
            DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt +
            DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.resolveSearchResults +
            parsedSearchResults,
        },
        issuer: this.issuer,
      });

      return result;
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('searchInfoInDocumentsAndAnswer', error),
        errorCode: 'ODB-DCHDS-SIIA0',
      });
    }
  }

  // TODO: EZT KELL HÍVNI PARANCSRA 
  async vectorSearchUsingConversation(
    conversation: DyFM_AI_Message[],
    limit: number = 3,
    numberOfCandidates: number = 100,
  ): Promise<T_Chunk[]> {
    try {
      const lastMessage: DyFM_AI_Message = conversation[conversation.length - 1];

      const searchQuestion: string = await this.llmChat_CS.requestSimpleMessageInConversation({
        conversation: conversation,
        message: DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.getSearchQuestion,
        settings: {
          systemPrompt: 
            DyNTS_OAI_LLMDefaultPredefined_Requests.defaultSystemPrompt +
            DyNTS_OAI_LLMDefaultPredefined_Requests.vectorSearch.systemPrompt,
        },
        issuer: this.issuer,
      });

      DyFM_Log.testInfo('🔍 Document search question:', searchQuestion);

      const searchResults: T_Chunk[] = await this.vectorSearch({
        input: searchQuestion + ' ' + lastMessage.content,
        searchInKey: 'chunkParentedContentVectorized',
        limit: limit,
        numberOfCandidates: numberOfCandidates,
      });

      return searchResults;
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('vectorSearchUsingConversation', error),
        errorCode: 'ODB-DCHDS-VSUC0',
      });
    }
  }
}