package mishtoof.badgesystem;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
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.player.PlayerQuitEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

public class Badges extends JavaPlugin implements CommandExecutor {
    public static final Map<String, ItemStack> badgeItems = new HashMap<>();
    private final Map<UUID, Inventory> playerInventories = new HashMap<>();
    private final Map<UUID, BadgeData> playerBadgeData = new HashMap<>();

    @Override
    public void onEnable() {
        initializeBadgeItems();
        loadPlayerBadgeData(); // Load player badge data when the server starts
        getCommand("badges").setExecutor(this);
        getServer().getPluginManager().registerEvents((Listener) this, this);
        getServer().getPluginManager().registerEvents(new PlayerQuitListener(), this);

    }

    @Override
    public void onDisable() {
        savePlayerBadgeData();
    }

    class PlayerQuitListener implements Listener {
        @EventHandler
        public void onPlayerQuit(PlayerQuitEvent event) {
            Player player = event.getPlayer();
            playerInventories.remove(player.getUniqueId());
            savePlayerBadgeData(); // Save player badge data when they quit
        }
    }

    @Override
    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
        if (!(sender instanceof Player)) {
            sender.sendMessage("Only players can use this command.");
            return true;
        }

        Player player = (Player) sender;

        if (args.length == 0) {
            Inventory inventory = createPersonalInventory(player);
            player.openInventory(inventory);
        } else if (args.length == 3 && args[0].equalsIgnoreCase("give")) {
            String targetPlayerName = args[1];
            Player targetPlayer = Bukkit.getPlayer(targetPlayerName);

            if (targetPlayer != null) {
                String badgeType = args[2];

                if (badgeItems.containsKey(badgeType.toLowerCase())) {
                    ItemStack badge = badgeItems.get(badgeType.toLowerCase());
                    Inventory inventory = createPersonalInventory(targetPlayer);
                    inventory.addItem(badge);
                    player.sendMessage("You gave the " + badgeType + " badge to " + targetPlayer.getName() + "!");
                    targetPlayer.sendMessage("You have received the " + badgeType + " badge!");
                } else {
                    player.sendMessage("Badgetype: " + ChatColor.RED + badgeType + ChatColor.WHITE + " does not exist.");
                }
            } else {
                player.sendMessage("Player " + targetPlayerName + " not found.");
            }
        } else {
            player.sendMessage(ChatColor.RED + "Invalid command usage. Usage: /badges [give <playername> <badgetype>]");
        }

        return true;
    }

    private Inventory createPersonalInventory(Player player) {
        UUID playerUUID = player.getUniqueId();
        Inventory inventory = playerInventories.get(playerUUID);

        if (inventory == null) {
            inventory = Bukkit.createInventory(player, 27, player.getName() + "'s Badges");
            playerInventories.put(playerUUID, inventory);
        }

        return inventory;
    }

    static void initializeBadgeItems() {
        // Add badge items to the map
        String[] badgeTypes = {"normal", "fire", "water", "grass", "electric", "ice", "fighting", "poison", "ground", "flying"};
        for (String badgeType : badgeTypes) {
            ItemStack badgeItem = createBadgeItem(badgeType);
            badgeItems.put(badgeType.toLowerCase(), badgeItem);
        }
    }

    private static ItemStack createBadgeItem(String badgeType) {
        ItemStack badge = new ItemStack(Material.DIAMOND);
        ItemMeta badgeMeta = badge.getItemMeta();
        badgeMeta.setDisplayName(ChatColor.GREEN + badgeType);
        badge.setItemMeta(badgeMeta);

        return badge;
    }

    private void loadPlayerBadgeData() {
        File dataFolder = getDataFolder();
        if (!dataFolder.exists()) {
            dataFolder.mkdirs();
        }

        File configFile = new File(dataFolder, "badge_data.yml");
        if (!configFile.exists()) {
            saveResource("badge_data.yml", false);
        }

        FileConfiguration config = YamlConfiguration.loadConfiguration(configFile);

        ConfigurationSection playersSection = config.getConfigurationSection("players");
        if (playersSection != null) {
            for (String playerUUID : playersSection.getKeys(false)) {
                UUID uuid = UUID.fromString(playerUUID);
                ConfigurationSection playerSection = playersSection.getConfigurationSection(playerUUID);
                if (playerSection != null) {
                    BadgeData badgeData = new BadgeData();
                    List<String> badgeTypes = playerSection.getStringList("badges");
                    if (badgeTypes != null) {
                        badgeData.getBadgeTypes().addAll(badgeTypes);
                    }
                    playerBadgeData.put(uuid, badgeData);
                }
            }
        }
    }

    private void savePlayerBadgeData() {
        File dataFolder = getDataFolder();
        if (!dataFolder.exists()) {
            dataFolder.mkdirs();
        }

        File configFile = new File(dataFolder, "badge_data.yml");
        FileConfiguration config = new YamlConfiguration();

        ConfigurationSection playersSection = config.createSection("players");
        for (Map.Entry<UUID, BadgeData> entry : playerBadgeData.entrySet()) {
            UUID uuid = entry.getKey();
            BadgeData badgeData = entry.getValue();
            ConfigurationSection playerSection = playersSection.createSection(uuid.toString());
            playerSection.set("badges", badgeData.getBadgeTypes());
        }

        try {
            config.save(configFile);
            getLogger().info("Player badge data saved to file.");
        } catch (IOException e) {
            getLogger().severe("Failed to save player badge data: " + e.getMessage());
        }
    }

}