import { Message } from '../structures/message.ts'
import { awaitSync } from '../utils/mixedPromise.ts'
import { Client, ClientOptions } from './client.ts'
import {
  CategoriesManager,
  CommandContext,
  CommandsManager,
  parseCommand
} from './command.ts'
import { ExtensionsManager } from './extensions.ts'

type PrefixReturnType = string | string[] | Promise<string | string[]>

export interface CommandClientOptions extends ClientOptions {
  prefix: string | string[]
  mentionPrefix?: boolean
  getGuildPrefix?: (guildID: string) => PrefixReturnType
  getUserPrefix?: (userID: string) => PrefixReturnType
  isGuildBlacklisted?: (guildID: string) => boolean | Promise<boolean>
  isUserBlacklisted?: (guildID: string) => boolean | Promise<boolean>
  isChannelBlacklisted?: (guildID: string) => boolean | Promise<boolean>
  spacesAfterPrefix?: boolean
  betterArgs?: boolean
  owners?: string[]
  allowBots?: boolean
  allowDMs?: boolean
  caseSensitive?: boolean
}

export class CommandClient extends Client implements CommandClientOptions {
  prefix: string | string[]
  mentionPrefix: boolean
  getGuildPrefix: (guildID: string) => PrefixReturnType
  getUserPrefix: (userID: string) => PrefixReturnType
  isGuildBlacklisted: (guildID: string) => boolean | Promise<boolean>
  isUserBlacklisted: (guildID: string) => boolean | Promise<boolean>
  isChannelBlacklisted: (guildID: string) => boolean | Promise<boolean>
  spacesAfterPrefix: boolean
  betterArgs: boolean
  owners: string[]
  allowBots: boolean
  allowDMs: boolean
  caseSensitive: boolean
  extensions: ExtensionsManager = new ExtensionsManager(this)
  commands: CommandsManager = new CommandsManager(this)
  categories: CategoriesManager = new CategoriesManager(this)

  constructor(options: CommandClientOptions) {
    super(options)
    this.prefix = options.prefix
    this.mentionPrefix =
      options.mentionPrefix === undefined ? false : options.mentionPrefix
    this.getGuildPrefix =
      options.getGuildPrefix === undefined
        ? (id: string) => this.prefix
        : options.getGuildPrefix
    this.getUserPrefix =
      options.getUserPrefix === undefined
        ? (id: string) => this.prefix
        : options.getUserPrefix
    this.isUserBlacklisted =
      options.isUserBlacklisted === undefined
        ? (id: string) => false
        : options.isUserBlacklisted
    this.isGuildBlacklisted =
      options.isGuildBlacklisted === undefined
        ? (id: string) => false
        : options.isGuildBlacklisted
    this.isChannelBlacklisted =
      options.isChannelBlacklisted === undefined
        ? (id: string) => false
        : options.isChannelBlacklisted
    this.spacesAfterPrefix =
      options.spacesAfterPrefix === undefined
        ? false
        : options.spacesAfterPrefix
    this.betterArgs =
      options.betterArgs === undefined ? false : options.betterArgs
    this.owners = options.owners === undefined ? [] : options.owners
    this.allowBots = options.allowBots === undefined ? false : options.allowBots
    this.allowDMs = options.allowDMs === undefined ? true : options.allowDMs
    this.caseSensitive =
      options.caseSensitive === undefined ? false : options.caseSensitive

    this.on(
      'messageCreate',
      async (msg: Message) => await this.processMessage(msg)
    )
  }

  async processMessage(msg: Message): Promise<any> {
    if (!this.allowBots && msg.author.bot === true) return

    const isUserBlacklisted = await awaitSync(
      this.isUserBlacklisted(msg.author.id)
    )
    if (isUserBlacklisted === true) return

    const isChannelBlacklisted = await awaitSync(
      this.isChannelBlacklisted(msg.channel.id)
    )
    if (isChannelBlacklisted === true) return

    if (msg.guild !== undefined) {
      const isGuildBlacklisted = await awaitSync(
        this.isGuildBlacklisted(msg.guild.id)
      )
      if (isGuildBlacklisted === true) return
    }

    let prefix: string | string[] = await awaitSync(
      this.getUserPrefix(msg.author.id)
    )

    if (msg.guild !== undefined) {
      prefix = await awaitSync(this.getGuildPrefix(msg.guild.id))
    }

    let mentionPrefix = false

    if (typeof prefix === 'string') {
      if (msg.content.startsWith(prefix) === false) {
        if (this.mentionPrefix) mentionPrefix = true
        else return
      }
    } else {
      const usedPrefix = prefix.find((v) => msg.content.startsWith(v))
      if (usedPrefix === undefined) {
        if (this.mentionPrefix) mentionPrefix = true
        else return
      } else prefix = usedPrefix
    }

    if (mentionPrefix) {
      if (msg.content.startsWith(this.user?.mention as string) === true)
        prefix = this.user?.mention as string
      else if (
        msg.content.startsWith(this.user?.nickMention as string) === true
      )
        prefix = this.user?.nickMention as string
      else return
    }

    if (typeof prefix !== 'string') return

    const parsed = parseCommand(this, msg, prefix)
    const command = this.commands.find(parsed.name)

    if (command === undefined) return
    const category =
      command.category !== undefined
        ? this.categories.get(command.category)
        : undefined

    // Guild whitelist exists, and if does and Command used in a Guild, is this Guild allowed?
    // This is a bit confusing here, if these settings on a Command exist, and also do on Category, Command overrides them
    if (
      command.whitelistedGuilds === undefined &&
      category?.whitelistedGuilds !== undefined &&
      msg.guild !== undefined &&
      category.whitelistedGuilds.includes(msg.guild.id) === false
    )
      return
    if (
      command.whitelistedGuilds !== undefined &&
      msg.guild !== undefined &&
      command.whitelistedGuilds.includes(msg.guild.id) === false
    )
      return

    // Checks for Channel Whitelist
    if (
      command.whitelistedChannels === undefined &&
      category?.whitelistedChannels !== undefined &&
      category.whitelistedChannels.includes(msg.channel.id) === false
    )
      return
    if (
      command.whitelistedChannels !== undefined &&
      command.whitelistedChannels.includes(msg.channel.id) === false
    )
      return

    // Checks for Users Whitelist
    if (
      command.whitelistedUsers === undefined &&
      category?.whitelistedUsers !== undefined &&
      category.whitelistedUsers.includes(msg.author.id) === false
    )
      return
    if (
      command.whitelistedUsers !== undefined &&
      command.whitelistedUsers.includes(msg.author.id) === false
    )
      return

    const ctx: CommandContext = {
      client: this,
      name: parsed.name,
      prefix,
      args: parsed.args,
      argString: parsed.argString,
      message: msg,
      author: msg.author,
      command,
      channel: msg.channel,
      guild: msg.guild
    }

    // In these checks too, Command overrides Category if present
    // Check if Command is only for Owners
    if (
      (command.ownerOnly !== undefined || category === undefined
        ? command.ownerOnly
        : category.ownerOnly) === true &&
      !this.owners.includes(msg.author.id)
    )
      return this.emit('commandOwnerOnly', ctx, command)

    // Check if Command is only for Guild
    if (
      (command.guildOnly !== undefined || category === undefined
        ? command.guildOnly
        : category.guildOnly) === true &&
      msg.guild === undefined
    )
      return this.emit('commandGuildOnly', ctx, command)

    // Check if Command is only for DMs
    if (
      (command.dmOnly !== undefined || category === undefined
        ? command.dmOnly
        : category.dmOnly) === true &&
      msg.guild !== undefined
    )
      return this.emit('commandDmOnly', ctx, command)

    const allPermissions =
      command.permissions !== undefined
        ? command.permissions
        : category?.permissions

    if (
      (command.botPermissions !== undefined ||
        category?.permissions !== undefined) &&
      msg.guild !== undefined
    ) {
      // TODO: Check Overwrites too
      const me = await msg.guild.me()
      const missing: string[] = []

      let permissions =
        command.botPermissions === undefined
          ? category?.permissions
          : command.botPermissions

      if (permissions !== undefined) {
        if (typeof permissions === 'string') permissions = [permissions]

        if (allPermissions !== undefined)
          permissions = [...new Set(...permissions, ...allPermissions)]

        for (const perm of permissions) {
          if (me.permissions.has(perm) === false) missing.push(perm)
        }

        if (missing.length !== 0)
          return this.emit(
            'commandBotMissingPermissions',
            ctx,
            command,
            missing
          )
      }
    }

    if (
      (command.userPermissions !== undefined ||
        category?.userPermissions !== undefined) &&
      msg.guild !== undefined
    ) {
      let permissions =
        command.userPermissions !== undefined
          ? command.userPermissions
          : category?.userPermissions

      if (permissions !== undefined) {
        if (typeof permissions === 'string') permissions = [permissions]

        if (allPermissions !== undefined)
          permissions = [...new Set(...permissions, ...allPermissions)]

        const missing: string[] = []

        for (const perm of permissions) {
          const has = msg.member?.permissions.has(perm)
          if (has !== true) missing.push(perm)
        }

        if (missing.length !== 0)
          return this.emit(
            'commandUserMissingPermissions',
            command,
            missing,
            ctx
          )
      }
    }

    if (command.args !== undefined) {
      if (typeof command.args === 'boolean' && parsed.args.length === 0)
        return this.emit('commandMissingArgs', ctx, command)
      else if (
        typeof command.args === 'number' &&
        parsed.args.length < command.args
      )
        this.emit('commandMissingArgs', ctx, command)
    }

    try {
      this.emit('commandUsed', ctx, command)

      const beforeExecute = await awaitSync(command.beforeExecute(ctx))
      if (beforeExecute === false) return

      const result = await awaitSync(command.execute(ctx))
      command.afterExecute(ctx, result)
    } catch (e) {
      this.emit('commandError', command, ctx, e)
    }
  }
}