package club.mcscrims.speedhg

import club.mcscrims.core.config.ConfigData
import club.mcscrims.core.config.ConfigFormat
import club.mcscrims.core.config.ConfigLoader
import club.mcscrims.core.database.DatabaseConfig
import club.mcscrims.core.database.mongodb.MongoManager
import club.mcscrims.speedhg.ability.AbilityContext
import club.mcscrims.speedhg.ability.AbilityHitListener
import club.mcscrims.speedhg.ability.CooldownManager
import club.mcscrims.speedhg.ability.HitCounterManager
import club.mcscrims.speedhg.config.KitConfig
import club.mcscrims.speedhg.config.MessageConfig
import club.mcscrims.speedhg.config.PluginConfig
import club.mcscrims.speedhg.database.StatsRepository
import club.mcscrims.speedhg.game.GameManager
import club.mcscrims.speedhg.command.KitsCommand
import club.mcscrims.speedhg.database.PlayerRepository
import club.mcscrims.speedhg.kit.KitInventoryListener
import club.mcscrims.speedhg.kit.KitInventoryManager
import club.mcscrims.speedhg.kit.KitListener
import club.mcscrims.speedhg.kit.KitManager
import club.mcscrims.speedhg.listener.GameStateListener
import club.mcscrims.speedhg.listener.LunarClientListener
import club.mcscrims.speedhg.recraft.RecraftInspector
import club.mcscrims.speedhg.recraft.RecraftUtils
import club.mcscrims.speedhg.world.WorldManager
import club.mcscrims.spigot.chat.ChatFormatter
import club.mcscrims.spigot.chat.ChatManager
import club.mcscrims.spigot.network.SpigotNetworkManager
import club.mcscrims.spigot.scheduler.SchedulerManager
import club.mcscrims.spigot.util.WorldEditUtils
import com.mongodb.client.model.Indexes
import kotlinx.coroutines.runBlocking
import net.kyori.adventure.text.Component
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer
import net.luckperms.api.LuckPerms
import org.bukkit.Bukkit
import org.bukkit.plugin.java.JavaPlugin

class SpeedHG : JavaPlugin() {

	companion object {

		internal lateinit var instance: SpeedHG

		fun Component.content(): String
		{
			return LegacyComponentSerializer.legacySection().serialize( this )
		}

	}

	private lateinit var configLoader: ConfigLoader
	internal lateinit var pluginConfig: ConfigData<PluginConfig>
	internal lateinit var messageConfig: ConfigData<MessageConfig>
	internal lateinit var kitConfig: ConfigData<KitConfig>
	internal lateinit var databaseConfig: ConfigData<DatabaseConfig>

	internal lateinit var chatManager: ChatManager<MessageConfig>
	internal lateinit var chatFormatter: ChatFormatter<MessageConfig>

	private lateinit var mongoManager: MongoManager
	internal lateinit var statsRepository: StatsRepository
	internal lateinit var playerRepository: PlayerRepository

	internal lateinit var networkManager: SpigotNetworkManager
	internal lateinit var schedulerManager: SchedulerManager

	internal lateinit var gameManager: GameManager
	internal lateinit var worldManager: WorldManager

	internal lateinit var abilityContext: AbilityContext
	internal lateinit var kitManager: KitManager
	internal lateinit var kitInventoryManager: KitInventoryManager

	internal lateinit var worldEditUtils: WorldEditUtils

	internal lateinit var luckPerms: LuckPerms
	internal var isReady: Boolean = false

	override fun onLoad()
	{
		instance = this

		loadConfigurations()
		setupDatabase()
		networkManager = SpigotNetworkManager.getInstance()!!

		worldManager = WorldManager( this )
		worldManager.deleteWorld()
	}

	override fun onEnable()
	{
		worldManager.setupWorld()

		chatFormatter = ChatFormatter.create(
			plugin = this,
			configClass = MessageConfig::class,
			messageExtractor = { config -> config.getAllMessages() },
			listExtractor = { config -> config.getListMessages() }
		)

		chatManager = ChatManager.withCustomConfig( this, chatFormatter )
		chatManager.initialize()

		schedulerManager = SchedulerManager( this )

		worldEditUtils = WorldEditUtils( this )

		gameManager = GameManager( this )
		gameManager.initialize()

		val cooldownManager = CooldownManager()
		val hitCounterManager = HitCounterManager()
		abilityContext = AbilityContext( cooldownManager, hitCounterManager )

		kitManager = KitManager( this )
		kitManager.initialize()

		kitInventoryManager = KitInventoryManager( this, kitManager )

		setupLuckPerms()
		registerListener()
		registerCommands()

		RecraftUtils.registerRecipes()
		RecraftInspector( this ).startRunnable()
	}

	override fun onDisable()
	{
		kitManager.clearAll()
		closeDatabase()
		networkManager.shutdown()
	}

	private fun registerListener()
	{
		server.pluginManager.registerEvents(GameStateListener( this, gameManager ), this )
		server.pluginManager.registerEvents(KitListener( this, kitManager ), this )
		server.pluginManager.registerEvents(KitInventoryListener( this, kitManager, kitInventoryManager ), this )
		server.pluginManager.registerEvents(AbilityHitListener( this, abilityContext ), this )
		LunarClientListener( this )
	}

	private fun registerCommands()
	{
		getCommand("kits")?.setExecutor(KitsCommand( this, kitInventoryManager ))
	}

	/*
	 * LUCKPERMS >>
	 */

	private fun setupLuckPerms()
	{
		val provider = server.servicesManager.getRegistration( LuckPerms::class.java )

		if ( provider != null )
			luckPerms = provider.provider

		if ( !::luckPerms.isInitialized )
			logger.warning( "LuckPerms could not be loaded." )
		else
			logger.info( "LuckPerms has successfully been loaded." )
	}

	/*
	 * DATABASE >>
	 */

	private fun setupDatabase()
	{
		// MongoManager initialisieren
		mongoManager = MongoManager.getInstance( name, logger )
		val connection = mongoManager.createConnection( "speedhg", databaseConfig.data )

		// Repositories initialisieren
		statsRepository = StatsRepository( connection )
		playerRepository = PlayerRepository( connection )

		// Indizes erstellen
		runBlocking {
			try
			{
				connection.createIndex( "player_stats", Indexes.ascending( "kills" ))
				connection.createIndex( "player_stats", Indexes.descending( "deaths" ))
				connection.createIndex( "player_stats", Indexes.ascending( "wins" ))
				connection.createIndex( "player_stats", Indexes.ascending( "unathleticIndex" ))
				connection.createIndex( "player_stats", Indexes.ascending( "ironFarmed" ))
				connection.createIndex( "kit_players", Indexes.text( "server" ))
			}
			catch ( ex: Exception ) {
				logger.warning( "Failed to create MongoDB indexes: ${ex.message}" )
				return@runBlocking
			}
		}

		logger.info( "Successfully enabled MongoDB" )
	}

	private fun closeDatabase()
	{
		// Alle Server von Kit-Spielern auf NULL setzen
		runBlocking {
			try
			{
				val players = Bukkit.getOnlinePlayers()
				players.forEach { player ->
					playerRepository.updateServer( player.uniqueId, "NULL" )
				}
				logger.info( "Updated ${players.size} players server to NULL." )
			}
			catch ( ex: Exception ) {
				logger.warning( "Failed to update player server: ${ex.message}" )
			}
		}.also {
			// MongoManager beenden
			mongoManager.shutdown()

			logger.info( "Successfully disabled MongoDB" )
		}
	}

	/*
	 * CONFIG >>
	 */

	private fun loadConfigurations()
	{
		configLoader = ConfigLoader.getInstance( name, logger, dataFolder )
		createConfigurations()
	}

	private fun createConfigurations()
	{
		pluginConfig = configLoader.loadConfig<PluginConfig>(
			fileName = "config.yml",
			format = ConfigFormat.YAML,
			autoReload = true
		)

		messageConfig = configLoader.loadConfig<MessageConfig>(
			fileName = "messages.yml",
			format = ConfigFormat.YAML,
			autoReload = false
		)

		kitConfig = configLoader.loadConfig<KitConfig>(
			fileName = "kits.yml",
			format = ConfigFormat.YAML,
			autoReload = false
		)

		databaseConfig = configLoader.loadConfig<DatabaseConfig>(
			fileName = "database.json",
			format = ConfigFormat.JSON,
			autoReload = false
		)
	}

	fun reloadConfigurations()
	{
		try
		{
			pluginConfig.reload()
			messageConfig.reload()
			kitConfig.reload()
			databaseConfig.reload()
		}
		catch ( ex: Exception ) {
			logger.severe( "Failed to reload configurations: ${ex.message}" )
		}
	}

}