SubCommandBase.kt

package io.simplyservers.simplecore.api.command

import io.simplyservers.simplecore.api.command.delegates.BlankTabCompleter
import org.bukkit.command.Command
import org.bukkit.command.CommandSender

class SubCommandBase(
        private val argsCount: Int = 0,
        private val nameable: Nameable,
        private val tabCompleter: TabCompleter = BlankTabCompleter,
        private val subCommandProcessor: SubCommandProcessor
) :
        SimpleCommand,
        Nameable by nameable {

    private fun argsToProcess(args: Array<out String>) = args.sliceArray(0 until argsCount)
    private fun subCommandArg(args: Array<out String>) = args.getOrNull(argsCount)
    private fun argsToPass(args: Array<out String>) = args.sliceArray(argsCount + 1 until args.size)
    private fun Collection<io.simplyservers.simplecore.api.command.SimpleCommand>.getCommand(name: String) = this.firstOrNull { it.matches(name) }

    override fun on(sender: CommandSender, command: Command, alias: String, args: Array<out String>): Boolean {
        if (args.size < argsCount) return false

        val forArgs = argsToProcess(args)
        val possibleSubCommands = processArgs(sender, command, alias, forArgs)
        when (possibleSubCommands) {
            is SubCommandResult.Failure -> return false
            is SubCommandResult.Success -> {
                val subCommandArg = subCommandArg(args)?.toLowerCase()

                if (subCommandArg == null) {
                    sender.sendWrongSubCommand()
                    return false
                }

                val simpleCommand = possibleSubCommands.commands.getCommand(subCommandArg)

                if (simpleCommand == null) {
                    sender.sendWrongSubCommand()
                    return false
                }

                return simpleCommand.on(sender, command, alias, argsToPass(args))
            }
        }
    }

    private fun processArgs(sender: CommandSender, command: Command, alias: String, args: Array<out String>): SubCommandResult {
        return subCommandProcessor.on(sender, command, alias, args)
    }

    private fun CommandSender.sendWrongSubCommand(): String = TODO()

    override fun onTabComplete(sender: CommandSender, command: Command, alias: String, args: Array<out String>): Set<String> {

        if (args.size <= argsCount) return onTabArgs(sender, command, alias, args)
        val subCommands = processArgs(sender, command, alias, args)

        when (subCommands) {
            is SubCommandResult.Failure -> return emptySet()
            is SubCommandResult.Success -> {
                val allSubCommands = subCommands.commands
                if (allSubCommands.isEmpty()) return emptySet()

                val allSubCommandNames = allSubCommands.map { it.name }
                val enteredSimpleCommand = subCommandArg(args) ?: return allSubCommandNames.toSet()

                if (args.size == argsCount + 1) return allSubCommandNames.filter { it.startsWith(enteredSimpleCommand, ignoreCase = true) }.toSet()

                val subCommand = allSubCommands.getCommand(enteredSimpleCommand)

                if (subCommand != null) {
                    return subCommand.onTabComplete(sender, command, alias, argsToPass(args))
                }

                return emptySet()
            }
        }
    }

    fun onTabArgs(sender: CommandSender, command: Command, alias: String, args: Array<out String>): Set<String> {
        return tabCompleter.onTabComplete(sender, command, alias, args)
    }

    fun io.simplyservers.simplecore.api.command.SimpleCommand.matches(name: String): Boolean {
        return this.name == name || this.aliases.contains(name)
    }
}