package me.mrkirby153.plugins.theplague.arena.classes;

import me.mrkirby153.plugins.theplague.ThePlague;
import me.mrkirby153.plugins.theplague.arena.Arena;
import me.mrkirby153.plugins.theplague.utils.ChatHelper;
import org.apache.commons.lang.WordUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Classes {
    private static ThePlague plugin = ThePlague.instance();
    private static YamlConfiguration config = ThePlague.config.getClassesConfig();
    private static YamlConfiguration arena = ThePlague.config.getArenaConfig();
    private static HashMap<String, String> chosenClass = new HashMap<String, String>();

    public static void addClass(String className, Player player) {
        savePlayerInventoryToFile(className.toLowerCase(), player);
    }

    public static void removeClass(String className) {
        config.set("classes." + className, null);
    }

    public static void serverStart() {
        // Not implemented yet!
    }

    private static void save() {
        ThePlague.config.saveClassesConfig();
    }

    @SuppressWarnings("deprecation")
    private static void loadClass(String className, Player player) {
        if (!classExists(className)) {
            ChatHelper.sendToPlayer(player, ChatColor.RED + "Class " + className + " does not appear to exist!");
            return;
        }
        // Check for permission
        if (!checkClassPermission(player, className)) {
            ChatHelper.sendToPlayer(player, ChatColor.RED + "You do not have permission to use " + className + " class!");
            return;
        }
        Inventory classInventory = loadClassFromFile(className);
        player.getInventory().setContents(classInventory.getContents());
        player.getInventory().setArmorContents(loadArmourFromFile(className));
        player.updateInventory();
        className = WordUtils.capitalizeFully(className.replace("_", " "));
        ChatHelper.sendToPlayer(player, ChatColor.GREEN + "Here are your items for " + ChatColor.GOLD + className
                + ChatColor.GREEN + "!");
    }

    public static boolean classExists(String className) {
        return (config.getConfigurationSection("classes." + className) != null);
    }

    private static void savePlayerInventoryToFile(String className, Player player, boolean donator) {
        PlayerInventory inventory = player.getInventory();
        String path = "classes." + className;
        // Reset the class loadout
        config.set(path, null);
        int itemNumber = 1;
        config.set(path + ".donator", donator);
        for (ItemStack item : inventory.getContents()) {
            if (item == null) {
                itemNumber++;
                continue;
            }
            String subPath = path + "." + Integer.toString(itemNumber);
            // Set material
            config.set(subPath + ".material", item.getType().toString());
            config.set(subPath + ".damage", item.getDurability());
            config.set(subPath + ".quantity", item.getAmount());
            // Set encnahtments
            saveEnch(subPath + ".enchantments", item);
            itemNumber++;
        }
        // Save armour
        String[] slot = {"boots", "leggings", "chestplate", "helmet"};
        for (int i = 0; i < slot.length; i++) {
            ItemStack item = player.getInventory().getArmorContents()[i];
            String subPath = path + ".armour." + slot[i];
            config.set(subPath + ".material", item.getType().toString());
            config.set(subPath + ".damage", item.getDurability());
            saveEnch(subPath + ".enchantments", item);
        }
        save();
    }

    public static void saveCustomIcon(ItemStack icon, String className) {
        if (!classExists(className)) return;
        config.set("classes." + className + ".displayIcon", icon.getType().toString());
        save();
    }

    public static void clearCustomIcon(String className) {
        config.set("classes." + className + ".displayIcon", null);
        save();
    }

    public static ItemStack getCustomIcon(String className) {
        if (!classExists(className)) return null;
        String material = config.getString("classes." + className + ".displayIcon");
        if (Material.getMaterial(material) == null)
            return new ItemStack(Material.IRON_SWORD);
        else
            return new ItemStack(Material.getMaterial(material));
    }

    private static void saveEnch(String path, ItemStack item) {
        Map<Enchantment, Integer> isEnch = item.getEnchantments();
        ArrayList<String> enchs = new ArrayList<String>();
        if (isEnch.size() > 0) {
            for (Map.Entry<Enchantment, Integer> ench : isEnch.entrySet()) {
                enchs.add(ench.getKey().getName() + "," + ench.getValue());
            }
        }
        config.set(path, enchs);
    }

    public static void savePlayerInventoryToFile(String className, Player player) {
        savePlayerInventoryToFile(className, player, false);
    }

    private static Inventory loadClassFromFile(String className) {
        Inventory classInventory;
        if (!classExists(className))
            return null;
        classInventory = Bukkit.createInventory(null, 36);
        for (String itemIndex : config.getConfigurationSection("classes." + className).getKeys(false)) {
            /* Load the item's attributes from the configuration file */
            if (itemIndex.contains("donator") || itemIndex.contains("armour") || itemIndex.contains("displayIcon"))
                continue;
            // The configuration path
            String path = "classes." + className + "." + itemIndex;
            // The item's material
            String material = config.getString(path + ".material");
            // The item's metadata/damage
            int damage = config.getInt(path + ".damage");
            // The item's quanitiy
            int quantity = config.getInt(path + ".quantity");
            // The item's unparsed list of enchantments
            List<String> unparsedEnchantments = config.getStringList(path + ".enchantments");

            /* Begin constructing the item */
            if (Material.getMaterial(material) == null)
                continue; // Skip if the item's material is not a valid material
            ItemStack item = new ItemStack(Material.getMaterial(material), quantity, (short) damage);

            // Adds enchantments (If any)
            if (unparsedEnchantments.size() > 0) {
                for (String unparsed : unparsedEnchantments) {
                    String parsed[] = unparsed.split(",");
                    int enchantmentLevel;
                    try {
                        enchantmentLevel = Integer.parseInt(parsed[1]);
                    } catch (NumberFormatException e) {
                        continue;
                    }
                    if (enchantmentLevel > 0) {
                        Enchantment enchantment = Enchantment.getByName(parsed[0]);
                        item.addUnsafeEnchantment(enchantment, enchantmentLevel);
                    }
                }
            }
            classInventory.setItem(Integer.valueOf(itemIndex) - 1, item);
        }
        return classInventory;
    }

    private static ItemStack[] loadArmourFromFile(String className) {
        ItemStack[] armourContents = new ItemStack[4];
        int index = 0;
        for (String configKey : config.getConfigurationSection("classes." + className + ".armour").getKeys(false)) {
            // The configuration path
            String path = "classes." + className + ".armour." + configKey;
            // The item's material
            String material = config.getString(path + ".material");
            // The item's metadata/damage
            int damage = config.getInt(path + ".damage");
            // The item's quanitiy
            int quantity = config.getInt(path + ".quantity");
            // The item's unparsed list of enchantments
            List<String> unparsedEnchantments = config.getStringList(path + ".enchantments");
            /* Begin constructing the item */
            if (Material.getMaterial(material) == null) {
                continue; // Skip if the item's material is not a valid material
            }
            ItemStack item = new ItemStack(Material.getMaterial(material), quantity, (short) damage);

            // Adds enchantments (If any)
            if (unparsedEnchantments.size() > 0) {
                for (String unparsed : unparsedEnchantments) {
                    String parsed[] = unparsed.split(",");
                    int enchantmentLevel;
                    try {
                        enchantmentLevel = Integer.parseInt(parsed[1]);
                    } catch (NumberFormatException e) {
                        enchantmentLevel = 0;
                    }
                    if (enchantmentLevel > 0) {
                        Enchantment enchantment = Enchantment.getByName(parsed[0]);
                        item.addUnsafeEnchantment(enchantment, enchantmentLevel);
                    }
                }
            }
            armourContents[index] = item;
            index++;
        }
        return armourContents;
    }

    private static boolean checkPermission(Player player, String permission) {
        return player.isOp() || player.hasPermission(permission);
    }

    public static boolean checkClassPermission(Player player, String className) {
        if (player.isOp())
            return true;
        return player.hasPermission("theplague.class.*") || player.hasPermission("theplague.class." + className);
    }

    public static ArrayList<String> getAllClasses() {
        ArrayList<String> classes = new ArrayList<String>();

        for (String className : config.getConfigurationSection("classes").getKeys(false)) {
            classes.add(className);
        }
        return classes;
    }

    public static void linkClassToArena(String className, String arenaName) {
        if (!Arena.arenaExists(arenaName)) return;
        List<String> currentClasses = arena.getStringList("arenas." + arenaName + ".classes");
        if (currentClasses == null)
            currentClasses = new ArrayList<String>();
        currentClasses.add(className);
        arena.set("arenas." + arenaName + ".classes", currentClasses);
        ThePlague.config.saveArenaConfig();
    }

    public static void unlinkClassToArena(String className, String arenaName) {
        if (!Arena.arenaExists(arenaName)) return;
        List<String> currentClasses = config.getStringList("arenas." + arenaName + ".classes");
        if (currentClasses == null)
            currentClasses = new ArrayList<String>();
        currentClasses.remove(className);
        arena.set("arenas." + arenaName + ".classes", currentClasses);
        ThePlague.config.saveArenaConfig();
    }

    public static void linkAllClasses(String arenaName) {
        if (!Arena.arenaExists(arenaName)) return;
        arena.set("arenas." + arenaName + ".classes", Classes.getAllClasses());
        ThePlague.config.saveArenaConfig();
    }

    public static void unlinkAllClasses(String arenaName) {
        if (!Arena.arenaExists(arenaName)) return;
        arena.set("arenas." + arenaName + ".classes", new ArrayList<String>());
        ThePlague.config.saveArenaConfig();
    }

    public static void chooseClass(Player player, String className) {
        if (!Arena.inArena(player)) {
            ChatHelper.sendToPlayer(player, ChatColor.RED + "You are not in an arena, Please join an arena first!");
            return;
        }
        className = className.replace(" ", "_");
        chosenClass.put(player.getName(), className);
        className = className.replace("_", " ");
        className = WordUtils.capitalizeFully(className);
        ChatHelper.sendToPlayer(player, ChatColor.GREEN + "You have chosen " + ChatColor.GOLD + className
                + ChatColor.GREEN + "! Your items will be given to you after the game starts.");
    }

    public static void removeClass(Player player) {
        chosenClass.remove(player.getName());
    }

    public static void setDefaultClass(String defaultClass, String arenaName) {
        if (!Arena.arenaExists(arenaName)) return;
        arena.set("arenas." + arenaName + ".defaultClass", defaultClass);
        ThePlague.config.saveArenaConfig();
        Arena.refreshArenaState(arenaName);
    }

    public static String getDefaultClass(String arenaName) {
        if (!Arena.arenaExists(arenaName)) return null;
        String className = arena.getString("arenas." + arenaName + ".defaultClass");
        if (!classExists(className)) {
            return null;
        }
        return className;
    }

    public static void loadGame(String arenaName) {
        if (!Arena.arenaExists(arenaName)) return;
        for (String playerName : Arena.getArenaPlayers(arenaName)) {
            Player player = Bukkit.getPlayerExact(playerName);
            if (!chosenClass.containsKey(player.getName())) {
                loadClass(getDefaultClass(arenaName), player);
                continue;
            }
            String className =  chosenClass.remove(playerName);
            loadClass(className, player);
        }
    }

    public static String getClass(String playerName) {
        if (chosenClass.get(playerName) == null) {
            return getDefaultClass(Arena.getCurrentArena(Bukkit.getPlayerExact(playerName)));
        }
        return chosenClass.get(playerName);
    }

    public static void setDonator(String className, boolean donator) {
        config.set("classes." + className + ".donator", donator);
        save();
    }

    public static boolean isDonator(String className) {
        return config.getBoolean("classes." + className + ".donator");
    }

    public static ArrayList<String> getLinkedClasses(String arenaName) {
        ArrayList<String> lc = new ArrayList<String>();
        for (String className : arena.getStringList("arenas." + arenaName + ".classes")) {
            lc.add(className);
        }
        return lc;
    }
}