# Chaos Inventory Mode Configuration by Eternal Polar
# Color codes supported: Use & symbol (e.g., &6 for gold, &c for red)
# 1.16+ versions support hex colors: &x&R&G&B&R&G&B (e.g., &x&FF&55&00&FF&55&00)
# All messages support multi-line configuration

# Chance of inventory shuffle (0.0-1.0, e.g., 0.2 = 20%)
chaos-chance: 0.2

# 2. Enabled Worlds List (Empty list = Apply to all worlds; Fill with world names to apply only to specific worlds)
# Example: enabled-worlds: [ "ESpeedBuild1", "ESpeedBuild2" ]
enabled-worlds: []

# Message configuration
messages:
  start:
    - "&7=== Chaos Inventory Mode Started ==="
    - "&eEvery block placement has a &c20%&e chance to shuffle your inventory"
    - "&eGood luck and happy building!"
    - "&7===================================="

  end:
    - "&6=== Chaos Inventory Mode Ended ==="
    - "&eThanks for participating in the game!"
    - "&6=================================="
  chaos:
    - "&c| &7Your inventory has been shuffled! &c|"
    - "&7Quickly find the items you need to continue building!"
 

package eternalpolar.spigot.espeedbuilderchaosinventorymode.Function;

import eternalpolar.spigot.espeedbuilder.api.ServerMode;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Mode implements ServerMode, Listener {
    private static final Pattern HEX_COLOR_PATTERN = Pattern.compile("§x§[0-9A-Fa-f]§[0-9A-Fa-f]§[0-9A-Fa-f]§[0-9A-Fa-f]§[0-9A-Fa-f]§[0-9A-Fa-f]");
    private static final Pattern VERSION_PATTERN = Pattern.compile("1\\.(\\d+)\\.");
    private static final int MIN_VERSION_FOR_ISLOADED = 13;

    private final JavaPlugin plugin;
    private final Random random = new Random();
    private final int serverVersion;
    private List<String> enabledWorlds;

    private double chaosChance;
    private List<String> startMessages;
    private List<String> endMessages;
    private List<String> chaosMessages;
    public Mode(JavaPlugin plugin) {
        this.plugin = plugin;
        this.serverVersion = getServerVersion();

        loadConfig();
        plugin.getLogger().info("Chaos Inventory Mode loaded! Applied to: " +
                (enabledWorlds.isEmpty() ? "All Worlds" : enabledWorlds.size() + " Worlds"));
    }

    private void loadConfig() {
        File configFile = new File(plugin.getDataFolder(), "config.yml");
        if (!configFile.exists()) {
            plugin.getDataFolder().mkdirs();
            plugin.saveResource("config.yml", false);
        }

        FileConfiguration config = YamlConfiguration.loadConfiguration(configFile);
        // Inventory shuffle probability (0.0~1.0)
        chaosChance = Math.max(0.0, Math.min(1.0, config.getDouble("chaos-chance", 0.2)));
        // Enabled worlds list (empty means all worlds)
        enabledWorlds = config.getStringList("enabled-worlds");
        startMessages = config.getStringList("messages.start");
        endMessages = config.getStringList("messages.end");
        chaosMessages = config.getStringList("messages.chaos");

        setDefaultMessages();
    }

    private void setDefaultMessages() {
        if (startMessages.isEmpty()) {
            startMessages.add("§6=== Chaos Inventory Mode Started ===");
            startMessages.add("§eApplied to: " + (enabledWorlds.isEmpty() ? "All Worlds" : enabledWorlds.size() + " Worlds"));
            startMessages.add("§eChaos Chance: " + (int)(chaosChance * 100) + "%");
            startMessages.add("§6====================================");
        }

        if (endMessages.isEmpty()) {
            endMessages.add("§6=== Chaos Inventory Mode Ended ===");
            endMessages.add("§eThanks for participating!");
            endMessages.add("§6==================================");
        }

        if (chaosMessages.isEmpty()) {
            chaosMessages.add("§c⚠️ Your inventory has been shuffled!");
            chaosMessages.add("§eFind your items fast!");
        }
    }

    @Override
    public void run() {
        sendBroadcastMessages(startMessages);
    }

    @Override
    public void initGame() {}

    @Override
    public void whileGRound() {}

    @Override
    public void EndGame() {
        BlockPlaceEvent.getHandlerList().unregister(this);
        sendBroadcastMessages(endMessages);
        plugin.getLogger().info("Chaos Inventory Mode ended.");
    }
   
    @EventHandler
    public void onBlockPlace(BlockPlaceEvent event) {
        Player player = event.getPlayer();
        World playerWorld = player.getWorld();
        if (playerWorld == null) {
            return;
        }

        if (!enabledWorlds.isEmpty() && !enabledWorlds.contains(playerWorld.getName())) {
            return;
        }

        if (random.nextDouble() <= chaosChance) {
            shuffleInventory(player);
            sendPlayerMessages(player, chaosMessages);
        }
    }

    // -------------------------- Utility methods --------------------------
    // Shuffle inventory (only 36 main inventory slots, excess items drop)
    private void shuffleInventory(Player player) {
        if (player == null) {
            return;
        }

        ItemStack[] inventory = player.getInventory().getContents();
        List<ItemStack> nonNullItems = new ArrayList<>();
        for (ItemStack item : inventory) {
            if (item != null && item.getAmount() > 0) {
                nonNullItems.add(item);
            }
        }

        Collections.shuffle(nonNullItems);
        player.getInventory().clear();
        int slot = 0;
        for (ItemStack item : nonNullItems) {
            if (slot < 36) {
                player.getInventory().setItem(slot++, item);
            } else {
                player.getWorld().dropItem(player.getLocation(), item);
            }
        }
    }

    private void sendBroadcastMessages(List<String> messages) {
        List<String> colored = colorizeMessages(messages);
        for (String msg : colored) {
            Bukkit.broadcastMessage(msg);
        }
    }

    private void sendPlayerMessages(Player player, List<String> messages) {
        if (player == null || !player.isOnline()) {
            return;
        }
        List<String> colored = colorizeMessages(messages);
        for (String msg : colored) {
            player.sendMessage(msg);
        }
    }

    private List<String> colorizeMessages(List<String> messages) {
        List<String> colored = new ArrayList<>();
        for (String msg : messages) {
            colored.add(translateColorCodes(msg));
        }
        return colored;
    }

    private String translateColorCodes(String message) {
        if (message == null) {
            return "";
        }
        String translated = message.replace('&', '§');
        if (serverVersion < 16) {
            Matcher matcher = HEX_COLOR_PATTERN.matcher(translated);
            translated = matcher.replaceAll("");
        }
        return translated;
    }

    private int getServerVersion() {
        String version = Bukkit.getVersion();
        Matcher matcher = VERSION_PATTERN.matcher(version);
        if (matcher.find()) {
            try {
                return Integer.parseInt(matcher.group(1));
            } catch (NumberFormatException e) {
                plugin.getLogger().warning("Failed to parse server version: " + version);
            }
        }
        return 12; // Default to 1.12.2
    }
}