package nl.kallestruik.darena

import co.aikar.commands.BukkitCommandExecutionContext
import co.aikar.commands.InvalidCommandArgument
import co.aikar.commands.MessageType
import co.aikar.commands.PaperCommandManager
import nl.kallestruik.darena.arenas.Arena
import nl.kallestruik.darena.commands.CommandDArena
import nl.kallestruik.darena.exceptions.TeamNotFoundException
import nl.kallestruik.darena.listeners.*
import nl.kallestruik.darena.managers.*
import nl.kallestruik.darena.types.Reloadable
import nl.kallestruik.darena.types.Team
import org.bukkit.ChatColor
import org.bukkit.plugin.java.JavaPlugin
import java.io.File

//TODO: Add documentation on a wiki page or something for this whole thing.

class DArena: JavaPlugin() {
    private lateinit var commandManager: PaperCommandManager
    private lateinit var configManager: ConfigManager
    private lateinit var pointsManager: PointsManager
    private lateinit var teamManager: TeamManager
    private lateinit var arenaManager: ArenaManager
    private lateinit var editManager: EditManager
    private lateinit var gameManager: GameManager

    private lateinit var reloadable: Map<String, Reloadable>

    override fun onEnable() {
        commandManager = PaperCommandManager(this)
        commandManager.enableUnstableAPI("help")
        commandManager.enableUnstableAPI("brigadier")



        configManager = ConfigManager(File(dataFolder, "config.yml"))
        configManager.load()

        teamManager = TeamManager(File(dataFolder, "teams.yml"))
        teamManager.load()

        pointsManager = PointsManager(teamManager, File(dataFolder, "points.yml"))
        pointsManager.load()

        arenaManager = ArenaManager(teamManager, pointsManager, configManager, this, File(dataFolder, "arenas"), File(dataFolder, "arena.schema.json"))
        arenaManager.loadArenas()

        editManager = EditManager(arenaManager, this)
        arenaManager.editManager = editManager

        gameManager = GameManager(arenaManager, File(dataFolder, "games.yml"))
        gameManager.load()

        reloadable = mapOf(
            Pair("arenas", arenaManager),
            Pair("config", configManager),
            Pair("games", gameManager),
        )

        setupCommandContexts()
        setupCommandCompletions()
        setupACFFormatting()

        commandManager.registerCommand(CommandDArena(arenaManager, editManager, pointsManager, teamManager, gameManager))

        server.pluginManager.registerEvents(CheckpointListener(arenaManager), this)
        server.pluginManager.registerEvents(TeamListener(teamManager), this)
        server.pluginManager.registerEvents(KillListener(arenaManager), this)
        server.pluginManager.registerEvents(FireballListener(arenaManager, configManager), this)
        server.pluginManager.registerEvents(FallListener(arenaManager), this)
        server.pluginManager.registerEvents(BorderListener(arenaManager), this)
        server.pluginManager.registerEvents(BuildRestrictionListener(arenaManager), this)
        server.pluginManager.registerEvents(SectionListener(arenaManager), this)
        server.pluginManager.registerEvents(CheckpointSoundListener(arenaManager), this)
        server.pluginManager.registerEvents(CheckpointMessageListener(arenaManager), this)
        server.pluginManager.registerEvents(GrapplingHookListener(arenaManager), this)
        server.pluginManager.registerEvents(EditListener(editManager, this), this)
    }

    override fun onDisable() {
        teamManager.save()
        pointsManager.save()

    }

    //TODO: Move this to a more suitable location
    private fun setupACFFormatting() {
        commandManager.setFormat(
            MessageType.INFO,
            ChatColor.GRAY,
            ChatColor.YELLOW,
            ChatColor.RED
        )
        commandManager.setFormat(
            MessageType.SYNTAX,
            ChatColor.YELLOW,
            ChatColor.GREEN,
            ChatColor.WHITE
        )
        commandManager.setFormat(
            MessageType.ERROR,
            ChatColor.RED,
            ChatColor.DARK_GREEN,
            ChatColor.GREEN
        )
        commandManager.setFormat(
            MessageType.HELP,
            ChatColor.YELLOW,
            ChatColor.AQUA,
            ChatColor.GRAY
        )
    }

    //TODO: Move this to a more suitable location
    private fun setupCommandContexts() {
        commandManager.commandContexts.registerContext(
            Arena::class.java
        ) { context: BukkitCommandExecutionContext ->
            return@registerContext arenaManager.getArena(context.popFirstArg())
                ?: throw InvalidCommandArgument("Arena does not exist!")
        }

        commandManager.commandContexts.registerContext(
            Team::class.java
        ) { context: BukkitCommandExecutionContext ->
            try {
                return@registerContext teamManager.getTeamByName(context.popFirstArg())
            } catch (e: TeamNotFoundException) {
                throw InvalidCommandArgument("Arena does not exist!")
            }
        }

        commandManager.commandContexts.registerContext(
            Reloadable::class.java
        ) { context: BukkitCommandExecutionContext ->
            return@registerContext reloadable[context.popFirstArg()]
                ?: throw InvalidCommandArgument("That is not a reloadable component!")
        }
    }

    //TODO: Move this to a more suitable location
    private fun setupCommandCompletions() {
        // Arena
        commandManager.commandCompletions.registerAsyncCompletion("arena") {
            arenaManager.getAllArenaNames()
        }

        commandManager.commandCompletions.setDefaultCompletion("arena", Arena::class.java)

        // Team
        commandManager.commandCompletions.registerAsyncCompletion("team") {
            teamManager.getAllTeamNames()
        }

        commandManager.commandCompletions.setDefaultCompletion("team", Team::class.java)

        // teamOptions
        commandManager.commandCompletions.registerCompletion("teamOptions") {
            listOf(
                "color",
                "prefix"
            )
        }

        // Reloadable
        commandManager.commandCompletions.registerAsyncCompletion("reloadable") {
            reloadable.keys
        }

        commandManager.commandCompletions.setDefaultCompletion("reloadable", Reloadable::class.java)
    }
}