package de.leonhard.sapphire.lib

import co.aikar.commands.BaseCommand
import co.aikar.commands.ConditionFailedException
import de.leonhard.sapphire.Constants
import de.leonhard.sapphire.Sapphire
import net.md_5.bungee.api.ChatColor
//import net.md_5.bungee.api.ProxyServer
//import net.md_5.bungee.api.connection.ProxiedPlayer
import org.apache.commons.lang.StringUtils
//import org.bukkit.Bukkit
import org.bukkit.command.CommandSender

//import org.bukkit.entity.Player
//import java.util.*

abstract class UniversalCommand : BaseCommand() {
    private var libSender: LibSender? = null
    private val messages = Sapphire.getMessages()
    //TODO
    /*
    ->@MinArgsLength Annotation
    ->Validate true besser benennen
    _>ReturnTell mit ArrayList

     MultiLinguality besser.
     -
     */

    protected fun isFalse(toCheck: Boolean, falseMessage: String? = null) {
        if (!toCheck)
            returnTell(falseMessage)
    }

    protected fun isTrue(toCheck: Boolean, trueMessage: String? = null) {
        if (toCheck)
            returnTell(trueMessage)
    }

    /*
    Blank vs empty: -> Both checks for null
    Empty > Komplett leer   isEmpty(" ") = false isBlank(" ") = true
    Blank > Enthalt nur Leerzeichen
  https://stackoverflow.com/questions/23419087/stringutils-isblank-vs-string-isempty
     */

    protected fun getIntFromArgs(index: Int, noIntMessage: String? = messages.provideAnInteger(), args: Array<String> = origArgs): Int {
        return parseInt(args[index], noIntMessage)
    }

    protected fun getDoubleFromArgs(index: Int, noIntMessage: String? = messages.provideAnDouble(), args: Array<String> = origArgs): Double {
        return parseDouble(args[index], noIntMessage)
    }

    protected fun parseInt(string: String, noIntMessage: String? = messages.provideAnInteger()): Int {
        var result = 0
        if (string.isBlank())
            returnTell(noIntMessage)
        if (!StringUtils.isNumeric(string))
            returnTell(noIntMessage)
        try {
            result = string.toInt()
        } catch (e: IllegalArgumentException) {
            returnTell(noIntMessage)
        }
        return result
    }

    protected fun parseDouble(string: String, noDoubleMessage: String? = messages.provideAnInteger()): Double {
        var result = 0.0
        if (string.isBlank())
            returnTell(noDoubleMessage)
        if (!StringUtils.isNumeric(string))
            returnTell(noDoubleMessage)
        try {
            result = string.toDouble()
        } catch (e: IllegalArgumentException) {
            returnTell(noDoubleMessage)
        }
        return result
    }

    protected fun send(message: String, prefix: String = Sapphire.PREFIX) {
        libSender = LibSender(currentCommandIssuer.getIssuer())
        libSender?.send(message, prefix)
    }

    protected fun send(message: Array<String>, prefix: String = Sapphire.PREFIX) {
        libSender = LibSender(currentCommandIssuer.getIssuer())
        libSender?.send(message, prefix)

    }

    protected fun send(sender: Any, message: String, prefix: String = Sapphire.PREFIX) {
        val target: LibSender = LibSender(sender)
        target.send(message, prefix)
    }

    protected fun send(message: String) {
        libSender = LibSender(currentCommandIssuer.getIssuer())
        libSender?.send("§7$message", Sapphire.PREFIX)
    }

    protected fun checkPermission(permission: String, noPermMessage: String? = messages.noPerm()) {
        libSender = LibSender(currentCommandIssuer.getIssuer())
        val hasPerm = libSender?.hasPermission(permission) ?: false
        if (!hasPerm) {
            returnTell(noPermMessage)
        }
    }

//    protected fun isPlayer(falseMessage: String? = messages.provideAnPlayer()) {
//        libSender = LibSender(currentCommandIssuer.getIssuer())
//        if (Environment.isBungee() && libSender?.sender !is ProxiedPlayer) returnTell(falseMessage)
//        if (!Environment.isBungee() && libSender?.sender !is Player) returnTell(falseMessage)
//    }

    protected fun checkPermission(permission: Array<String>, noPermMessage: String? = messages.noPerm()) {
        libSender = LibSender(currentCommandIssuer.getIssuer())
        val hasPerm = libSender?.hasPermission(permission) ?: false
        if (!hasPerm) {
            returnTell(noPermMessage)
        }
    }

    protected fun checkByPassOrCMDPerm(cmdPerm: String, noPermMessage: String? = messages.noPerm()) {
        checkPermission(arrayOf(Constants.OP, Constants.COMMAND_BYPASS, cmdPerm), noPermMessage)
    }

    protected fun checkOpOrSetup(noPermMessage: String? = messages.noPerm()) {
        checkPermission(arrayOf(Constants.OP, Constants.SETUP))
    }

    protected fun <T> createLibSender(sender: T) {
        try {
            if (sender is CommandSender)
                this.libSender = LibSender(sender)
        } catch (ignored: Throwable) {

        }

        try {
            if (sender is net.md_5.bungee.api.CommandSender) {
                this.libSender = LibSender(sender)
            }
        } catch (ignored: Throwable) {

        }

    }

    protected fun checkArgsStrict(requiredLength: Int, falseMessage: String? = messages.useHelp(defaultRegisteredCommand.getCommand())) {
        libSender = LibSender(currentCommandIssuer.getIssuer())
        if (origArgs.size != requiredLength) {
            returnTell(falseMessage)
        }
    }

    protected fun checkArgsMaxLength(maxLength: Int, toLongMessage: String? = messages.useHelp(defaultRegisteredCommand.getCommand())) {
        isTrue(origArgs.size > maxLength, toLongMessage)
    }

    protected fun <T> getOrReturn(toGet: T?, nullMessage: String): T {
        if (toGet == null)
            returnTell(nullMessage)
        return toGet!!
    }

    protected fun returnTell(message: String?) {
        libSender = LibSender(currentCommandIssuer.getIssuer())
        if (message != null && !message.isBlank()) {
            send(message)
        }
        throw ConditionFailedException()
    }


    protected fun checkArgsMinLength(minLength: Int, falseMessage: String? = messages.useHelp(defaultRegisteredCommand.getCommand())) {
        libSender = LibSender(currentCommandIssuer)
        if (origArgs.size < minLength) {
            returnTell(falseMessage)
        }
    }

    protected fun checkNotNull(toCheck: Any?, nullMessage: String? = null) {
        libSender = LibSender(currentCommandIssuer)
        if (toCheck == null)
            returnTell(nullMessage)
    }

    protected fun <T> setSender(sender: T) {
        createLibSender(sender)
    }

//    protected fun getPlayerIfOnlineBungee(name: String, notOnlineMessage: String? = messages.playerNotOnline(name)): ProxiedPlayer {
//        if (!Environment.isBungee())
//            throw IllegalStateException("Accessing bungee while not on bungee")
//
//        if (ProxyServer.getInstance().getPlayer(name) != null)
//            return ProxyServer.getInstance().getPlayer(name)
//
//        returnTell(notOnlineMessage)
//        return libSender as ProxiedPlayer //Will never be executed
//    }
//
//    protected fun getPlayerIfOnlineSpigot(name: String, notOnlineMessage: String? = messages.playerNotOnline(name)): Player {
//        if (Environment.isBungee())
//            throw IllegalStateException("Accessing spigot while not on spigot")
//
//        val player = Bukkit.getPlayer(name)
//        if (player != null)
//            return player
//
//        returnTell(notOnlineMessage)
//        return libSender as Player //Will never be executed
//    }
//
//
//    protected fun isOnline(uuid: UUID, noPlayerMessage: String? = messages.playerNotOnline()) {
//        if (Environment.isBungee() && libSender?.sender is ProxiedPlayer && ProxyServer.getInstance().getPlayer(uuid) != null) return
//        if (!Environment.isBungee() && libSender?.sender is Player && Bukkit.getPlayer(uuid) != null) return
//        returnTell(noPlayerMessage)
//    }
//
//    protected fun isOnline(name: String, noPlayerMessage: String? = null) {
//        if (Environment.isBungee() && ProxyServer.getInstance().getPlayer(name) != null) return
//        if (!Environment.isBungee() && Bukkit.getPlayer(name) != null) return
//        returnTell(noPlayerMessage)
//    }

    abstract fun doHelp()
}