import { Guild, Message } from 'discord.js';

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

import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
import { DyNTS_DiBo_Main_ControlService } from './dibo-main.control-service';
import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
import { DyNTS_DiBo_global_settings } from '../_collections/dibo-global-settings.conts';


export abstract class DyNTS_DiBo_Commands_ControlService extends DyNTS_SingletonService {

  /* static getInstance(): DyNTS_DiBo_Commands_ControlService {
    return DyNTS_DiBo_Commands_ControlService.getSingletonInstance();
  } */

  protected abstract getMainDiscordBotControlService(): DyNTS_DiBo_Main_ControlService;
  protected diAs_CS: DyNTS_DiBo_Main_ControlService;
  /* protected abstract readonly diAs_CS: DyNTS_DiBo_Main_ControlService; */

  get discordServer(): Guild {
    return this.diAs_CS?.discordServer;
  }

  /* protected constructor() {
    super();

    if (!this.discordServer) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings(
          'constructor', 
          new Error(
            'Discord server not yet initialized, ' +
            'should only be called after DyNTS_DiBo_Main_ControlService.start'
          ), 
          'system-init'
        ),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-C00`,
      })
    }
  } */

  async setup(issuer: string): Promise<void> {
    try {
      this.diAs_CS = this.getMainDiscordBotControlService();

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

  async start(issuer: string): Promise<void> {
    try {
      if (!this.discordServer) {
        throw new DyFM_Error({
          ...this.getDefaultErrorSettings('start', new Error('Discord server not found'), issuer),
          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-ST00`,
        })
      }
    } catch (error) {
      throw new DyFM_Error({
        ...this.getDefaultErrorSettings('start', error, issuer),
        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-DiBo-CCS-ST00`,
      })
    }
  }

  async handleCommand(message: Message, issuer: string): Promise<void> {
    try {
      let haveCommandOperator = false;
      let msg = message.content.replace(
        `<@${this.diAs_CS.client.user.id}>`, ''
      ).trim();

      if (!DyNTS_DiBo_global_settings.commandSettings.commandOperator) {
        haveCommandOperator = true;
      } else if (
        msg.startsWith(DyNTS_DiBo_global_settings.commandSettings.commandOperator)
      ) {
        haveCommandOperator = true;
        msg = msg.replace(DyNTS_DiBo_global_settings.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-DiBo-CCS-HC1`,
        })
      }

      const commandExists = DyNTS_DiBo_global_settings.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-DiBo-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-DiBo-CCS-HC3`,
          })
        }
      }

      await commandExists.commandHandler(message);
    } catch (error) {
      message.reply(
        `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-DiBo-CCS-HC0`,
      })
    }
  }
}