package club.mcscrims.speedhg

import club.mcscrims.speedhg.command.KitCommand
import club.mcscrims.speedhg.command.LeaderboardCommand
import club.mcscrims.speedhg.command.PerksCommand
import club.mcscrims.speedhg.command.RankingCommand
import club.mcscrims.speedhg.command.TimerCommand
import club.mcscrims.speedhg.config.CustomGameManager
import club.mcscrims.speedhg.config.CustomGameSettings
import club.mcscrims.speedhg.config.LanguageManager
import club.mcscrims.speedhg.database.DatabaseManager
import club.mcscrims.speedhg.database.StatsManager
import club.mcscrims.speedhg.disaster.DisasterManager
import club.mcscrims.speedhg.game.GameManager
import club.mcscrims.speedhg.game.PodiumManager
import club.mcscrims.speedhg.game.modules.AntiRunningManager
import club.mcscrims.speedhg.gui.listener.MenuListener
import club.mcscrims.speedhg.kit.KitManager
import club.mcscrims.speedhg.kit.impl.*
import club.mcscrims.speedhg.kit.listener.KitEventDispatcher
import club.mcscrims.speedhg.listener.ConnectListener
import club.mcscrims.speedhg.listener.GameStateListener
import club.mcscrims.speedhg.listener.SoupListener
import club.mcscrims.speedhg.listener.StatsListener
import club.mcscrims.speedhg.perk.PerkManager
import club.mcscrims.speedhg.perk.impl.BloodlustPerk
import club.mcscrims.speedhg.perk.impl.FeatherweightPerk
import club.mcscrims.speedhg.perk.impl.OraclePerk
import club.mcscrims.speedhg.perk.impl.VampirePerk
import club.mcscrims.speedhg.perk.listener.PerkEventDispatcher
import club.mcscrims.speedhg.ranking.RankingManager
import club.mcscrims.speedhg.scoreboard.ScoreboardManager
import club.mcscrims.speedhg.webhook.DiscordWebhookManager
import club.mcscrims.speedhg.world.WorldManager
import org.bukkit.Bukkit
import org.bukkit.Material
import org.bukkit.NamespacedKey
import org.bukkit.inventory.ItemStack
import org.bukkit.inventory.ShapelessRecipe
import org.bukkit.plugin.java.JavaPlugin

class SpeedHG : JavaPlugin() {

	companion object {

		lateinit var instance: SpeedHG
			private set

	}

	lateinit var languageManager: LanguageManager
		private set

	lateinit var gameManager: GameManager
		private set

	lateinit var antiRunningManager: AntiRunningManager
		private set

	lateinit var scoreboardManager: ScoreboardManager
		private set

	lateinit var kitManager: KitManager
		private set

	lateinit var perkManager: PerkManager
		private set

	lateinit var databaseManager: DatabaseManager
		private set

	lateinit var statsManager: StatsManager
		private set

	lateinit var discordWebhookManager: DiscordWebhookManager
		private set

	lateinit var customGameManager: CustomGameManager
		private set

	lateinit var rankingManager: RankingManager
		private set

	lateinit var podiumManager: PodiumManager
		private set

	lateinit var disasterManager: DisasterManager
		private set

	override fun onLoad()
	{
		instance = this

		customGameManager = CustomGameManager( this )
		customGameManager.load()

		saveDefaultConfig()
		reloadConfig()

		val worldManager = WorldManager( this )
		worldManager.prepareRandomWorld()
	}

	override fun onEnable()
	{
		databaseManager = DatabaseManager( this )
		try {
			databaseManager.connect()
		} catch ( e: Exception ) {
			logger.severe( "[Database] Verbindung fehlgeschlagen: ${e.message}" )
			logger.severe( "[Database] Plugin wird deaktiviert." )
			server.pluginManager.disablePlugin( this )
			return
		}

		statsManager = StatsManager( this )
		statsManager.initialize()

		languageManager       = LanguageManager( this )
		gameManager           = GameManager( this )
		rankingManager        = RankingManager( this )
		podiumManager         = PodiumManager( this )
		antiRunningManager    = AntiRunningManager( this )
		scoreboardManager     = ScoreboardManager( this )
		kitManager            = KitManager( this )
		discordWebhookManager = DiscordWebhookManager( this )

		perkManager = PerkManager( this )
		perkManager.initialize()

		disasterManager = DisasterManager( this )
		disasterManager.start()

		registerKits()
		registerPerks()
		registerCommands()
		registerListener()
		registerRecipes()

		logger.info("SpeedHG wurde geladen!")
	}

	override fun onDisable()
	{
		podiumManager.cleanup()
		if ( ::perkManager.isInitialized )     perkManager.shutdown()
		if ( ::statsManager.isInitialized )    statsManager.shutdown()
		if ( ::databaseManager.isInitialized ) databaseManager.disconnect()
		kitManager.clearAll()
		super.onDisable()
	}

	private fun registerKits()
	{
		kitManager.registerKit( ArmorerKit() )
		kitManager.registerKit( BackupKit() )
		kitManager.registerKit( BlackPantherKit() )
		kitManager.registerKit( GladiatorKit() )
		kitManager.registerKit( GoblinKit() )
		kitManager.registerKit( IceMageKit() )
		kitManager.registerKit( RattlesnakeKit() )
		kitManager.registerKit( TheWorldKit() )
		kitManager.registerKit( VenomKit() )
		kitManager.registerKit( VoodooKit() )
	}

	private fun registerPerks()
	{
		perkManager.registerPerk( OraclePerk() )
		perkManager.registerPerk( VampirePerk() )
		perkManager.registerPerk( FeatherweightPerk() )
		perkManager.registerPerk( BloodlustPerk() )
	}

	private fun registerCommands()
	{
		val kitCommand = KitCommand()
		getCommand( "kit" )?.apply {
			setExecutor( kitCommand )
			tabCompleter = kitCommand
		}

		val timerCommand = TimerCommand( this )
		getCommand( "timer" )?.apply {
			setExecutor( timerCommand )
			tabCompleter = timerCommand
		}

		val rankingCommand = RankingCommand( this )
		getCommand( "ranking" )?.apply {
			setExecutor( rankingCommand )
			tabCompleter = rankingCommand
		}

		getCommand( "leaderboard" )?.setExecutor( LeaderboardCommand() )
		getCommand( "perks" )?.setExecutor( PerksCommand() )
	}

	private fun registerListener()
	{
		val pm = Bukkit.getPluginManager()

		pm.registerEvents( ConnectListener(), this )
		pm.registerEvents( GameStateListener(), this )
		pm.registerEvents( SoupListener(), this )
		pm.registerEvents(KitEventDispatcher( this, kitManager ), this )
		pm.registerEvents( StatsListener(), this )
		pm.registerEvents( MenuListener(), this )
		pm.registerEvents(PerkEventDispatcher( this, perkManager ), this )
	}

	private fun registerRecipes()
	{
		val soup = ItemStack( Material.MUSHROOM_STEW )

		val cocoRecipe = ShapelessRecipe(NamespacedKey.minecraft( "cocoa_soup" ), soup )
		cocoRecipe.addIngredient( Material.COCOA_BEANS )
		cocoRecipe.addIngredient( Material.BOWL )

		val cactiRecipe = ShapelessRecipe(NamespacedKey.minecraft( "cacti_soup" ), soup )
		cactiRecipe.addIngredient( Material.CACTUS )
		cactiRecipe.addIngredient( Material.BOWL )

		Bukkit.addRecipe( cocoRecipe )
		Bukkit.addRecipe( cactiRecipe )
	}

}