package de.viper.survivalplus;

import de.viper.survivalplus.commands.*;
import de.viper.survivalplus.listeners.*;
import de.viper.survivalplus.listeners.DebugArmorStandListener;
import de.viper.survivalplus.listeners.ArmorStandDestroyListener;
import de.viper.survivalplus.tasks.AutoClearTask;
import de.viper.survivalplus.recipe.BackpackRecipe;
import de.viper.survivalplus.Manager.StatsManager;
import de.viper.survivalplus.Manager.BlockManager;
import de.viper.survivalplus.util.LockSystem;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.ArmorStand;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.event.HandlerList;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.logging.Level;

public class SurvivalPlus extends JavaPlugin {

    private File langFile;
    private FileConfiguration langConfig;
    private File homesFile;
    private FileConfiguration homesConfig;
    private File gravesFile;
    private FileConfiguration gravesConfig;
    private File helpFile;
    private FileConfiguration helpConfig;
    private File backpackFile;
    private FileConfiguration backpackConfig;
    private File friendsFile;
    private FileConfiguration friendsConfig;
    private File leashesFile;
    private FileConfiguration leashesConfig;
    private File mobCapFile;
    private FileConfiguration mobCapConfig;

    private SpawnProtectionListener spawnProtectionListener;
    private int autoClearTaskId = -1;
    private StatsManager statsManager;

    // Listener als Felder speichern
    private MobLeashLimitListener mobLeashLimitListener;
    private MobCapListener mobCapListener;
    private SleepListener sleepListener;
    private OreAlarmListener oreAlarmListener;
    private AFKListener afkListener;
    private GraveListener graveListener;
    private SitListener sitListener;
    private PlayerJoinListener playerJoinListener;

@Override
public void onEnable() {
    updateConfigFiles(); // Config-Dateien aktualisieren
    createHomesFile();
    createGravesFile();
    createBackpackFile();
    createFriendsFile();
    createLeashesFile();
    createMobCapFile();

    // PluginManager holen
    PluginManager pluginManager = getServer().getPluginManager();

    // FriendCommand instanzieren
    FriendCommand friendCommand = new FriendCommand(this, friendsConfig, langConfig, getLogger());

    // StatsManager vor den Listenern initialisieren
    statsManager = new StatsManager(this);

    // Listener initialisieren (sitListener zuerst!)
    sitListener = new SitListener(this);
    afkListener = new AFKListener(this);
    graveListener = new GraveListener(this);
    playerJoinListener = new PlayerJoinListener(friendCommand);

    // Commands registrieren
    getCommand("gm").setExecutor(new GamemodeCommand(this));
    getCommand("sp").setExecutor(new PluginCommand(this));
    getCommand("sethome").setExecutor(new HomeCommand(this));
    getCommand("delhome").setExecutor(new HomeCommand(this));
    getCommand("homelist").setExecutor(new HomeCommand(this));
    getCommand("inv").setExecutor(new InventoryCommand(this));
    getCommand("ec").setExecutor(new EnderchestCommand(this));
    getCommand("setspawn").setExecutor(new SetSpawnCommand(this));
    getCommand("setworldspawn").setExecutor(new SetWorldSpawnCommand(this));
    getCommand("clearchat").setExecutor(new ClearChatCommand());
    getCommand("clearitems").setExecutor(new ClearItemsCommand(this));
    getCommand("closedoors").setExecutor(new CloseDoorsCommand(this));
    getCommand("sit").setExecutor(new SitCommand(this, sitListener));
    getCommand("back").setExecutor(new BackCommand(this));
    getCommand("friend").setExecutor(friendCommand);
    getCommand("ir").setExecutor(new ItemRenameCommand(this));
    getCommand("showarmorstands").setExecutor(new ShowArmorStandsCommand(this));
    getCommand("cleardebugarmorstands").setExecutor(new ClearDebugArmorStandsCommand(this));
    getCommand("trash").setExecutor(new TrashCommand());
    getCommand("workbench").setExecutor(new WorkbenchCommand());
    getCommand("anvil").setExecutor(new AnvilCommand());

    TeleportCommands teleportCommands = new TeleportCommands(this);
    getCommand("tp").setExecutor(teleportCommands);
    getCommand("tphere").setExecutor(teleportCommands);
    getCommand("tpa").setExecutor(teleportCommands);
    getCommand("tpaccept").setExecutor(teleportCommands);
    getCommand("tpdeny").setExecutor(teleportCommands);

    getCommand("kit").setExecutor(new KitCommand(this));

    // BlockManager erstellen
    BlockManager blockManager = new BlockManager();

    // Konfiguration laden
    FileConfiguration config = getConfig();

    // Listener registrieren
    BackpackRecipe.register(this, langConfig);

    pluginManager.registerEvents(new ChatBlockListener(blockManager), this);
    pluginManager.registerEvents(new InventoryClickListener(this), this);
    pluginManager.registerEvents(sitListener, this);
    pluginManager.registerEvents(afkListener, this);
    pluginManager.registerEvents(graveListener, this);
    pluginManager.registerEvents(new BackpackListener(backpackConfig, langConfig, getLogger(), backpackFile), this);
    pluginManager.registerEvents(new StatsListener(this, statsManager), this);
    pluginManager.registerEvents(new LoginListener(this), this);
    pluginManager.registerEvents(new DebugArmorStandListener(), this);
    pluginManager.registerEvents(new ArmorStandDestroyListener(), this);
    pluginManager.registerEvents(new FirstJoinListener(), this);
    pluginManager.registerEvents(playerJoinListener, this);

    // Befehle mit BlockManager und Konfiguration registrieren
    getCommand("block").setExecutor(new BlockCommand(blockManager, config));
    getCommand("blocklist").setExecutor(new BlockListCommand(blockManager, config));
    getCommand("unblock").setExecutor(new UnblockCommand(blockManager, config));

    // Stats-Befehl registrieren
    getCommand("stats").setExecutor(new StatsCommand(this, statsManager));

    sleepListener = new SleepListener(this);
    pluginManager.registerEvents(sleepListener, this);

    oreAlarmListener = new OreAlarmListener(this);
    pluginManager.registerEvents(oreAlarmListener, this);

    mobLeashLimitListener = new MobLeashLimitListener(this, getConfig());
    pluginManager.registerEvents(mobLeashLimitListener, this);

    mobCapListener = new MobCapListener(this, getConfig());
    pluginManager.registerEvents(mobCapListener, this);

    spawnProtectionListener = new SpawnProtectionListener(this);
    pluginManager.registerEvents(spawnProtectionListener, this);

    LockSystem lockSystem = new LockSystem(this);
    pluginManager.registerEvents(lockSystem, this);
    getCommand("lock").setExecutor(lockSystem);

    // AutoClear Task starten
    startAutoClearTask();

    // Beispiel ArmorStand spawnen
    spawnArmorStandExample();

    getLogger().info(getMessage("plugin.enabled"));
}

    private void spawnArmorStandExample() {
        World world = Bukkit.getWorld("world");
        if (world == null) {
            getLogger().warning("Welt 'world' nicht gefunden, ArmorStand wird nicht gespawnt.");
            return;
        }

        Location loc = new Location(world, 0.5, 100, 0.5);
        ArmorStand armorStand = world.spawn(loc, ArmorStand.class);
        armorStand.setVisible(false);
        armorStand.setCustomName(ChatColor.GREEN + "Mein ArmorStand");
        armorStand.setCustomNameVisible(true);
        armorStand.setGravity(false);
        armorStand.setMarker(true);
        armorStand.addScoreboardTag("debugArmorStand");
    }

    @Override
    public void onDisable() {
        if (autoClearTaskId != -1) {
            Bukkit.getScheduler().cancelTask(autoClearTaskId);
        }
        saveStats();
        saveLeashesConfig();
        saveMobCapConfig();

        getLogger().info(getMessage("plugin.disabled"));
    }

    public void saveStats() {
        if (statsManager != null) {
            statsManager.saveStats();
        }
    }

    public String getPluginInfo() {
        return ChatColor.translateAlternateColorCodes('&', getMessage("plugin.info"));
    }

    // === Config Updating Logic ===
    private void updateConfigFiles() {
        updateConfigFile("config.yml");
        updateConfigFile("lang.yml");
        updateConfigFile("help.yml");
    }

    private void updateConfigFile(String fileName) {
        File file = new File(getDataFolder(), fileName);
        FileConfiguration currentConfig = YamlConfiguration.loadConfiguration(file);
        InputStream defaultStream = getResource(fileName);

        if (defaultStream == null) {
            getLogger().warning(fileName + " nicht im JAR gefunden. Erstelle leere Datei.");
            if (!file.exists()) {
                try {
                    file.createNewFile();
                    if (fileName.equals("config.yml")) {
                        saveDefaultConfig();
                    } else if (fileName.equals("lang.yml")) {
                        createLangFile();
                    } else if (fileName.equals("help.yml")) {
                        createHelpFile();
                    }
                } catch (IOException e) {
                    getLogger().severe("Fehler beim Erstellen der " + fileName + ": " + e.getMessage());
                }
                return;
            }
        }

        FileConfiguration defaultConfig = defaultStream != null ?
                YamlConfiguration.loadConfiguration(new InputStreamReader(defaultStream)) : new YamlConfiguration();

        // Merge default config into current config
        mergeConfigs(defaultConfig, currentConfig);

        // Save updated config
        try {
            currentConfig.save(file);
            getLogger().info(fileName + " erfolgreich aktualisiert.");
        } catch (IOException e) {
            getLogger().severe("Fehler beim Speichern der " + fileName + ": " + e.getMessage());
        }

        // Update instance variables
        if (fileName.equals("config.yml")) {
            reloadConfig();
        } else if (fileName.equals("lang.yml")) {
            langFile = file;
            langConfig = currentConfig;
        } else if (fileName.equals("help.yml")) {
            helpFile = file;
            helpConfig = currentConfig;
        }
    }

    private void mergeConfigs(FileConfiguration defaultConfig, FileConfiguration currentConfig) {
        for (String key : defaultConfig.getKeys(true)) {
            if (!currentConfig.contains(key)) {
                currentConfig.set(key, defaultConfig.get(key));
            } else if (defaultConfig.isConfigurationSection(key) && currentConfig.isConfigurationSection(key)) {
                // Rekursiv für Untersektionen
                mergeConfigs(defaultConfig.getConfigurationSection(key), currentConfig.getConfigurationSection(key));
            }
        }
    }

    private void mergeConfigs(ConfigurationSection defaultSection, ConfigurationSection currentSection) {
        for (String key : defaultSection.getKeys(false)) {
            if (!currentSection.contains(key)) {
                currentSection.set(key, defaultSection.get(key));
            } else if (defaultSection.isConfigurationSection(key) && currentSection.isConfigurationSection(key)) {
                mergeConfigs(defaultSection.getConfigurationSection(key), currentSection.getConfigurationSection(key));
            }
        }
    }

    // === Lang.yml ===
    private void createLangFile() {
        langFile = new File(getDataFolder(), "lang.yml");
        if (!langFile.exists()) {
            saveResource("lang.yml", false);
        }
        langConfig = YamlConfiguration.loadConfiguration(langFile);
    }

    public String getMessage(String key) {
        String message = langConfig.getString(key);
        if (message == null) {
            getLogger().warning("Fehlender Sprachschlüssel: " + key);
            return ChatColor.RED + "[Missing lang key: " + key + "]";
        }
        return ChatColor.translateAlternateColorCodes('&', message);
    }

    public void reloadLangConfig() {
        updateConfigFile("lang.yml");
    }

    public FileConfiguration getLangConfig() {
        return langConfig;
    }

    // === Homes.yml ===
    private void createHomesFile() {
        homesFile = new File(getDataFolder(), "homes.yml");
        if (!homesFile.exists()) {
            try {
                homesFile.createNewFile();
                getLogger().info("homes.yml wurde erstellt.");
            } catch (IOException e) {
                getLogger().severe("Fehler beim Erstellen der homes.yml: " + e.getMessage());
            }
        }
        homesConfig = YamlConfiguration.loadConfiguration(homesFile);
    }

    public FileConfiguration getHomesConfig() {
        return homesConfig;
    }

    public void saveHomesConfig() {
        try {
            homesConfig.save(homesFile);
            getLogger().info("homes.yml erfolgreich gespeichert.");
        } catch (IOException e) {
            getLogger().log(Level.SEVERE, "Fehler beim Speichern der homes.yml: " + e.getMessage());
        }
    }

    public void reloadHomesConfig() {
        homesConfig = YamlConfiguration.loadConfiguration(homesFile);
        getLogger().info("homes.yml erfolgreich neu geladen.");
    }

    // === Graves.yml ===
    private void createGravesFile() {
        gravesFile = new File(getDataFolder(), "graves.yml");
        if (!gravesFile.exists()) {
            try {
                gravesFile.createNewFile();
                getLogger().info("graves.yml wurde erstellt.");
            } catch (IOException e) {
                getLogger().severe("Fehler beim Erstellen der graves.yml: " + e.getMessage());
            }
        }
        gravesConfig = YamlConfiguration.loadConfiguration(gravesFile);
    }

    public FileConfiguration getGravesConfig() {
        return gravesConfig;
    }

    public void saveGravesConfig() {
        try {
            gravesConfig.save(gravesFile);
            getLogger().info("graves.yml erfolgreich gespeichert.");
        } catch (IOException e) {
            getLogger().log(Level.SEVERE, "Fehler beim Speichern der graves.yml: " + e.getMessage());
        }
    }

    public void reloadGravesConfig() {
        gravesConfig = YamlConfiguration.loadConfiguration(gravesFile);
        getLogger().info("graves.yml erfolgreich neu geladen.");
    }

    // === Help.yml ===
    private void createHelpFile() {
        helpFile = new File(getDataFolder(), "help.yml");
        if (!helpFile.exists()) {
            try {
                InputStream resource = getResource("help.yml");
                if (resource != null) {
                    saveResource("help.yml", false);
                } else {
                    getLogger().warning("help.yml nicht im JAR gefunden. Erstelle leere Datei.");
                    helpConfig = new YamlConfiguration();
                    helpConfig.set("header", "§6=== SurvivalPlus Hilfe ===");
                    helpConfig.set("footer", "§6=====================");
                    helpConfig.save(helpFile);
                }
            } catch (IOException e) {
                getLogger().severe("Fehler beim Erstellen der help.yml: " + e.getMessage());
            }
        }
        helpConfig = YamlConfiguration.loadConfiguration(helpFile);
    }

    public FileConfiguration getHelpConfig() {
        return helpConfig;
    }

    public void reloadHelpConfig() {
        updateConfigFile("help.yml");
    }

    // === Backpack.yml ===
    private void createBackpackFile() {
        backpackFile = new File(getDataFolder(), "backpacks.yml");
        if (!backpackFile.exists()) {
            try {
                backpackFile.createNewFile();
                getLogger().info("backpacks.yml wurde erstellt.");
            } catch (IOException e) {
                getLogger().severe("Fehler beim Erstellen der backpacks.yml: " + e.getMessage());
            }
        }
        backpackConfig = YamlConfiguration.loadConfiguration(backpackFile);
    }

    public FileConfiguration getBackpackConfig() {
        return backpackConfig;
    }

    public void saveBackpackConfig() {
        try {
            backpackConfig.save(backpackFile);
            getLogger().info("backpacks.yml erfolgreich gespeichert.");
        } catch (IOException e) {
            getLogger().log(Level.SEVERE, "Fehler beim Speichern der backpacks.yml: " + e.getMessage());
        }
    }

    public void reloadBackpackConfig() {
        backpackConfig = YamlConfiguration.loadConfiguration(backpackFile);
        getLogger().info("backpacks.yml erfolgreich neu geladen.");
    }

    // === Friends.yml ===
    private void createFriendsFile() {
        friendsFile = new File(getDataFolder(), "friends.yml");
        if (!friendsFile.exists()) {
            try {
                friendsFile.createNewFile();
                getLogger().info("friends.yml wurde erstellt.");
            } catch (IOException e) {
                getLogger().severe("Fehler beim Erstellen der friends.yml: " + e.getMessage());
            }
        }
        friendsConfig = YamlConfiguration.loadConfiguration(friendsFile);
    }

    public FileConfiguration getFriendsConfig() {
        return friendsConfig;
    }

    public void saveFriendsConfig() {
        try {
            friendsConfig.save(friendsFile);
            getLogger().info("friends.yml erfolgreich gespeichert.");
        } catch (IOException e) {
            getLogger().log(Level.SEVERE, "Fehler beim Speichern der friends.yml: " + e.getMessage());
        }
    }

    public void reloadFriendsConfig() {
        friendsConfig = YamlConfiguration.loadConfiguration(friendsFile);
        getLogger().info("friends.yml erfolgreich neu geladen.");
    }

    // === Leashes.yml ===
    private void createLeashesFile() {
        leashesFile = new File(getDataFolder(), "leashes.yml");
        if (!leashesFile.exists()) {
            try {
                leashesFile.createNewFile();
                getLogger().info("leashes.yml wurde erstellt.");
            } catch (IOException e) {
                getLogger().severe("Fehler beim Erstellen der leashes.yml: " + e.getMessage());
            }
        }
        leashesConfig = YamlConfiguration.loadConfiguration(leashesFile);
    }

    public FileConfiguration getLeashesConfig() {
        return leashesConfig;
    }

    public void saveLeashesConfig() {
        try {
            leashesConfig.save(leashesFile);
            getLogger().info("leashes.yml erfolgreich gespeichert.");
        } catch (IOException e) {
            getLogger().log(Level.SEVERE, "Fehler beim Speichern der leashes.yml: " + e.getMessage());
        }
    }

    public void reloadLeashesConfig() {
        leashesConfig = YamlConfiguration.loadConfiguration(leashesFile);
        getLogger().info("leashes.yml erfolgreich neu geladen.");
    }

    // === MobCap.yml ===
    private void createMobCapFile() {
        mobCapFile = new File(getDataFolder(), "mobcap.yml");
        if (!mobCapFile.exists()) {
            try {
                mobCapFile.createNewFile();
                getLogger().info("mobcap.yml wurde erstellt.");
            } catch (IOException e) {
                getLogger().severe("Fehler beim Erstellen der mobcap.yml: " + e.getMessage());
            }
        }
        mobCapConfig = YamlConfiguration.loadConfiguration(mobCapFile);
    }

    public FileConfiguration getMobCapConfig() {
        return mobCapConfig;
    }

    public void saveMobCapConfig() {
        try {
            mobCapConfig.save(mobCapFile);
            getLogger().info("mobcap.yml erfolgreich gespeichert.");
        } catch (IOException e) {
            getLogger().log(Level.SEVERE, "Fehler beim Speichern der mobcap.yml: " + e.getMessage());
        }
    }

    public void reloadMobCapConfig() {
        mobCapConfig = YamlConfiguration.loadConfiguration(mobCapFile);
        getLogger().info("mobcap.yml erfolgreich neu geladen.");
    }

    // === AutoClearTask ===
    private void startAutoClearTask() {
        if (autoClearTaskId != -1) {
            Bukkit.getScheduler().cancelTask(autoClearTaskId);
            autoClearTaskId = -1;
        }

        if (getConfig().getBoolean("auto-clear-enabled", true)) {
            int intervalMinutes = getConfig().getInt("auto-clear-interval-minutes", 15);
            int intervalTicks = intervalMinutes * 60 * 20; // Minuten in Ticks umrechnen
            if (intervalTicks > 0) {
                autoClearTaskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(this, new AutoClearTask(this), intervalTicks, intervalTicks);
                getLogger().info("AutoClearTask gestartet mit Intervall von " + intervalMinutes + " Minuten.");
            }
        } else {
            getLogger().info("AutoClearTask deaktiviert, da auto-clear-enabled auf false gesetzt ist.");
        }
    }

    // === Reload Plugin ===
    public void reloadPlugin() {
        try {
            // Config-Dateien aktualisieren
            updateConfigFiles();
            reloadBackpackConfig();
            reloadFriendsConfig();
            reloadHomesConfig();
            reloadGravesConfig();
            reloadLeashesConfig();
            reloadMobCapConfig();

            // AutoClearTask neu starten
            startAutoClearTask();

            // Bestehende Listener abmelden
            PluginManager pm = getServer().getPluginManager();
            HandlerList.unregisterAll(this);

            // FriendCommand instanzieren für PlayerJoinListener
            FriendCommand friendCommand = new FriendCommand(this, friendsConfig, langConfig, getLogger());

            // Listener neu erstellen und registrieren
            mobLeashLimitListener = new MobLeashLimitListener(this, getConfig());
            mobLeashLimitListener.reloadConfig(getConfig());
            pm.registerEvents(mobLeashLimitListener, this);

            mobCapListener = new MobCapListener(this, getConfig());
            mobCapListener.reloadConfig(getConfig());
            pm.registerEvents(mobCapListener, this);

            sleepListener = new SleepListener(this);
            sleepListener.reloadConfig(getConfig());
            pm.registerEvents(sleepListener, this);

            oreAlarmListener = new OreAlarmListener(this);
            oreAlarmListener.reloadConfig(getConfig());
            pm.registerEvents(oreAlarmListener, this);

            afkListener = new AFKListener(this);
            afkListener.reloadConfig(getConfig());
            pm.registerEvents(afkListener, this);

            graveListener = new GraveListener(this);
            graveListener.reloadConfig(getConfig());
            pm.registerEvents(graveListener, this);

            sitListener = new SitListener(this);
            pm.registerEvents(sitListener, this);

            playerJoinListener = new PlayerJoinListener(friendCommand);
            pm.registerEvents(playerJoinListener, this);

            pm.registerEvents(new InventoryClickListener(this), this);
            pm.registerEvents(new BackpackListener(backpackConfig, langConfig, getLogger(), backpackFile), this);
            pm.registerEvents(new StatsListener(this, statsManager), this);
            pm.registerEvents(new LoginListener(this), this);
            pm.registerEvents(new DebugArmorStandListener(), this);
            pm.registerEvents(new ArmorStandDestroyListener(), this);
            pm.registerEvents(new FirstJoinListener(), this);

            spawnProtectionListener = new SpawnProtectionListener(this);
            pm.registerEvents(spawnProtectionListener, this);

            LockSystem lockSystem = new LockSystem(this);
            pm.registerEvents(lockSystem, this);
            getCommand("lock").setExecutor(lockSystem);

            // Commands neu registrieren
            getCommand("friend").setExecutor(friendCommand);

            getLogger().info(getMessage("plugin.reloaded"));
        } catch (Exception e) {
            getLogger().severe("Fehler beim Neuladen des Plugins: " + e.getMessage());
            e.printStackTrace();
        }
    }
}