import { DyFM_AI_Message } from '@futdevpro/fsm-dynamo/ai';
import { DyFM_Msg_Provider_Type } from '@futdevpro/fsm-dynamo/messaging';

import { DyNTS_Bot_Main_ControlService } from '../../bot/_services/bot-main.control-service';
import { DyNTS_Bot_MessageWrapper } from '../../bot/_models/bot-message-wrapper.interface';
import { DyNTS_AI_LLMChat_ServiceBase } from '../../ai/_services/ai-llm-chat.service-base';
import { DyNTS_Ass_global_settings } from '../_collections/ass-global-settings.const';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
import { DyNTS_Ass_Util } from '../_collections/ass.util';
import { DyNTS_Ass_IO_ControlService } from './ass-io.control-service';
import { DyNTS_Bot_ChannelWrapper } from '../../bot/_models/bot-channel-wrapper.interface';

/**
 * Assistant Service Base
 * Integrates commsProvider (bot) and aiProvider (LLMChat) to create AI-powered assistant
 * USES EXISTING AI ABSTRACTIONS - no duplication
 */
export abstract class DyNTS_Ass_Main_ControlService<
  T_MessagingPlatformProvider_Type extends DyFM_Msg_Provider_Type | string = DyFM_Msg_Provider_Type,
> extends DyNTS_Bot_Main_ControlService<T_MessagingPlatformProvider_Type> {

  // AI Provider - uses EXISTING abstraction
  aiProvider: DyNTS_AI_LLMChat_ServiceBase;  
  protected abstract getAIProvider(): DyNTS_AI_LLMChat_ServiceBase;
    
  // Override botIO to use assistant IO
  /* protected abstract override getBotIOControlService(): DyNTS_Ass_IO_ControlService; */
  
  declare botIO_CS: DyNTS_Ass_IO_ControlService;
  protected abstract override getBotIOControlService(): DyNTS_Ass_IO_ControlService;
  
  // Assistant-specific settings
  defaultSystemPrompt: string = DyNTS_Ass_global_settings.defaultSystemPrompt;
  
  protected constructor() {
    super();
    
    // Initialize AI provider
    this.aiProvider = this.getAIProvider();
    
    // Apply system prompt
    if (this.aiProvider.defaultSettings) {
      this.aiProvider.defaultSettings.systemPrompt = this.defaultSystemPrompt;
    }
    
    // Set global settings
    DyNTS_global_settings.assistant_settings ??= DyNTS_Ass_global_settings;
  }
  
  /**
   * Gather messages from comms platform (any platform)
   * Same as dias.service-base but platform-agnostic
   * Now uses wrapper's provider to ensure messages from correct platform
   */
  async gatherMessagesForMessage<T>(
    message: DyNTS_Bot_MessageWrapper<T>,
    limit: number = 100
  ): Promise<DyNTS_Bot_MessageWrapper<T>[]> {
    // Use wrapper's provider to fetch messages from the correct platform
    const messages: DyNTS_Bot_MessageWrapper<T>[] = await message.provider.fetchMessagesForMessage(message, limit);
    
    // Filter out messages with skip flags
    return messages.filter(
      msg => !DyNTS_Ass_global_settings.skipConversationMessagesFlags.some(
        flag => msg.content.includes(flag)
      )
    ).sort((a, b) => a.timestamp - b.timestamp);
  }

  async gatherMessagesInChannel(
    channel: DyNTS_Bot_ChannelWrapper,
    issuer: string,
  ): Promise<DyNTS_Bot_MessageWrapper<any>[]> {
    return channel.provider.fetchMessages(channel, 100);
  }

  /**
   * Convert gathered messages to AI conversation using EXISTING DyFM_AI_Message
   */
  async gatherMessagesAsAIConversation<T>(
    message: DyNTS_Bot_MessageWrapper<T>,
    issuer: string,
  ): Promise<DyFM_AI_Message[]> {
    const messages: DyNTS_Bot_MessageWrapper<T>[] = await this.gatherMessagesForMessage<T>(message);
    
    return DyNTS_Ass_Util.convertBotMessagesToAIConversation({
      messages: messages,
      botClientId: message.provider.botId,
      botDisplayName: message.provider.botDisplayName,
      issuer: issuer,
    });
  }

  async gatherMessagesAsAIConversationInChannel<T>(
    channel: DyNTS_Bot_ChannelWrapper,
    issuer: string,
  ): Promise<DyFM_AI_Message[]> {
    const messages: DyNTS_Bot_MessageWrapper<T>[] = await this.gatherMessagesInChannel(channel, issuer);
    
    return DyNTS_Ass_Util.convertBotMessagesToAIConversation({
      messages: messages,
      botClientId: channel.provider.botId,
      botDisplayName: channel.provider.botDisplayName,
      issuer: issuer,
    });
  }
}