const resolveFolder = (folderName) => path.resolve(__dirname, '.', folderName)
const fs = require('fs')
const path = require('path')

class CommandManager {
  constructor(client) {
    this.client = client
    this.cache = new Map()
    this.aliases = new Map()
  }

  load(options = {}) {
    const commandFolderPath = options.path || '../Plugins'
    const commandFolder = resolveFolder(commandFolderPath)
    if (options.category === undefined) options.category = true
    if (options.plugins === undefined) options.plugins = true
    // PluginMode will iterate through all SubFolders
    fs.readdirSync(commandFolder).map(async (dir) => {
      if (dir.endsWith('.txt')) return
      if (!options.category && dir.endsWith('.js')) {
        const commandPath = path.join(commandFolder, dir)
        this.loadCommand(commandPath)
      } else {
        fs.readdirSync(path.join(commandFolder, dir)).map((cmd) => {
          if (cmd.endsWith('.js') && !options.plugins) {
            const commandPath = path.join(commandFolder, dir, cmd)
            this.loadCommand(commandPath)
          } else if (commandFolderPath === '../Plugins') {
            if (cmd !== 'commands') return
            fs.readdirSync(path.join(commandFolder, dir, cmd)).map((cmdfile) => {
              if (!cmdfile.endsWith('.js')) return
              const commandPath = path.join(commandFolder, dir, cmd, cmdfile)
              this.loadCommand(commandPath)
            })
          }
        })
      }
    })
  }

  loadCommand(commandPath) {
    const pull = require(path.join(commandPath))
    if (pull.name) {
      pull.path = commandPath
      this.cache.set(pull.name, pull)
    }
    if (pull.aliases) {
      pull.aliases.map((p) => this.aliases.set(p, pull))
    }
    return pull
  }

  reloadCommand(commandName) {
    const command = this.cache.get(commandName)
    if (!command) return
    const commandPath = path.join(command.path)
    delete require.cache[require.resolve(commandPath)]
    return this.loadCommand(commandPath)
  }

  isCommand(message) {
    if (message.isFromBot) return false
    const prefix = '!'
    const escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
    const prefixRegex = new RegExp(`^(<@!?${this.client.id}>|${escapeRegex(prefix)})\\s*`)
    if (!prefixRegex.test(message.content)) return false

    const [, matchedPrefix] = message.content.match(prefixRegex)
    const args = message.content.slice(matchedPrefix.length).trim().split(/ +/)

    this.onMessage(message, prefix, args)
    return true
  }

  isInteraction(interaction) {
    if (interaction.type !== 2) return
    this.onInteraction(interaction)
  }

  async onMessage(message, guild, args) {
    const commandName = args.shift().toLowerCase()
    const command = this.cache.get(commandName) // || this.cache.find(cmd => cmd.aliases && cmd.aliases.includes(commandName));
    if (!command && message.content.includes(this.client.id)) {
      // Handle, when Command has not been found
      const options = { content: 'I did not found the Command!' }
      this.client.helpers.sendMessage(message.channelId, options)
    }
    if (!command) return

    const messagecommand = new command({
      manager: this,
      message,
      client: this.client,
      args,
      settings: {},
      commandName: command.name,
    })
    messagecommand.execute()?.catch?.((error) => {
      console.log(error)
      // Call Function on CommandResponse.js, handle the error
      return messagecommand.onError(error ?? 'custom')
    })
  }

  async onInteraction(interaction) {
    const command = this.cache.get(interaction.data.name)
    if (!command) return

    const args = []
    // Map all Values and Args
    interaction.data.options?.map((o) => {
      if (o.name) args.push(o.name)
      if (o.options) {
        o.options.map((o2) => {
          if (o2.value) return args.push(o2.value)
          if (o2.name) args.push(o2.name)
          if (o2.options) o2.options.map((v) => args.push(v.value))
        })
      }
    })

    const messagecommand = new command({
      manager: this,
      interaction,
      client: this.client,
      args,
      settings: {},
      commandName: command.name,
    })
    messagecommand.execute()?.catch?.((error) => {
      console.log(error)
      // Call Function on CommandResponse.js, handle the error
      return messagecommand.onError(error ?? 'custom')
    })
  }
}
module.exports = CommandManager