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

import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
import { DyNTS_Bot_Main_ControlService } from './bot-main.control-service';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
import { DyNTS_Bot_MessagingProvider_ServiceBase } from './bot-messaging-provider.service-base';
import { DyNTS_Bot_MessageWrapper } from '../_models/bot-message-wrapper.interface';
import { DyNTS_Bot_Global_Settings } from '../_models/bot-global-settings.interface';

export abstract class DyNTS_Bot_Commands_ControlService extends DyNTS_SingletonService {

  // the getInstance() should be implemented in the concrete child class
  /* static getInstance(): DyNTS_Bot_Commands_ControlService {
    return DyNTS_Bot_Commands_ControlService.getSingletonInstance();
  } */

  protected mainBot_CS: DyNTS_Bot_Main_ControlService;
  protected abstract getMainBotControlService(): DyNTS_Bot_Main_ControlService;

  
  get defaultProvider(): DyNTS_Bot_MessagingProvider_ServiceBase<any, any, any> {
    return this.mainBot_CS.defaultProvider;
  }

  /* get provider(): DyNTS_Bot_MessagingProvider<any, any, any> {
    return this.mainBot_CS?.provider;
  } */

  /* protected constructor() {
    super();

    if (!this.provider) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings(
          'constructor', 
          new Error(
            'Bot provider not yet initialized, ' +
            'should only be called after DyNTS_Bot_Main_ControlService.start'
          ), 
          'system-init'
        ),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-C00`,
      })
    }
  } */
 
  async setup(issuer: string): Promise<void> {
    try {
      this.mainBot_CS = this.getMainBotControlService();

      if (!this.mainBot_CS) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings('setup', new Error('Main Bot Control Service not found'), issuer),
          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-S01`,
        })
      }
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('setup', error, issuer),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-S000`,
      })
    }
  }

  async start(issuer: string): Promise<void> {
    try {
      if (!this.defaultProvider) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings('start', new Error('Bot provider not yet started'), issuer),
          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-ST00`,
        })
      }
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('start', error, issuer),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-ST00`,
      })
    }
  }

  async handleCommand<T_MessagingPlatformMessage extends any = any>(
    message: DyNTS_Bot_MessageWrapper<T_MessagingPlatformMessage>, 
    issuer: string
  ): Promise<void> {
    try {
      const botSettings: DyNTS_Bot_Global_Settings = DyNTS_global_settings.bot_settings;
      let haveCommandOperator: boolean = false;
      let msg: string = message.content.replace(
        message.provider.getUserMention(message.provider.botId), ''
        //`<@${this.mainBot_CS.botClientId}>`, ''
      ).trim();

      if (!botSettings?.commandSettings?.commandOperator) {
        haveCommandOperator = true;
      } else if (
        msg.startsWith(botSettings.commandSettings.commandOperator)
      ) {
        haveCommandOperator = true;
        msg = msg.replace(botSettings.commandSettings.commandOperator, '');
      }

      if (!haveCommandOperator) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings(
            'handleCommand', 
            new Error('No command operator found in the message'), 
            issuer
          ),
          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC1`,
        })
      }

      const commandExists = botSettings?.commandSettings?.commands?.find(
        (command) => msg.startsWith(command.command)
      );

      if (!commandExists) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings(
            'handleCommand', 
            new Error(`Command not found: "${msg.split(' ')[0]}"`), 
            issuer
          ),
          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC2`,
        })
      }

      if (commandExists.permissionNeeded) {
        const permissionNeeded = await commandExists.permissionNeeded(message);

        if (!permissionNeeded) {
          throw new DyFM_Error({
            ...this.getDefaultErrorSettings(
              'handleCommand', 
              new Error('Permission needed'), 
              issuer
            ),
            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC3`,
          })
        }
      }

      await commandExists.commandHandler(message);
    } catch (error) {
      message.provider.replyToMessage(
        message,
        `Error occurred while handling the command:\n` +
        DyFM_Error.getAnyMessage(error)
      );

      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('handleCommand', error, issuer),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-Bot-CCS-HC0`,
      })
    }
  }
}