package noppes.npcs;

import io.netty.buffer.ByteBuf;
import kamkeel.npcs.controllers.SyncController;
import kamkeel.npcs.network.PacketHandler;
import kamkeel.npcs.network.packets.data.ParticlePacket;
import kamkeel.npcs.network.packets.data.PlayerDataInfoPacket;
import kamkeel.npcs.network.packets.data.gui.GuiClosePacket;
import kamkeel.npcs.network.packets.data.gui.GuiErrorPacket;
import kamkeel.npcs.network.packets.data.gui.GuiOpenPacket;
import kamkeel.npcs.network.packets.data.gui.GuiTeleporterPacket;
import kamkeel.npcs.network.packets.data.large.GuiDataPacket;
import kamkeel.npcs.network.packets.data.large.ScrollDataPacket;
import kamkeel.npcs.network.packets.data.large.ScrollListPacket;
import kamkeel.npcs.network.packets.data.npc.DeleteNpcPacket;
import kamkeel.npcs.network.packets.data.npc.DialogPacket;
import kamkeel.npcs.network.packets.data.npc.EditNpcPacket;
import kamkeel.npcs.network.packets.data.npc.RolePacket;
import kamkeel.npcs.network.packets.data.script.ScriptedParticlePacket;
import kamkeel.npcs.util.ByteBufUtils;
import net.minecraft.command.server.CommandBlockLogic;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityList;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.entity.projectile.EntityArrow;
import net.minecraft.entity.projectile.EntityThrowable;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.server.MinecraftServer;
import net.minecraft.tileentity.MobSpawnerBaseLogic;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityCommandBlock;
import net.minecraft.tileentity.TileEntityMobSpawner;
import net.minecraft.util.ChatComponentTranslation;
import net.minecraft.util.DamageSource;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
import noppes.npcs.api.entity.IPlayer;
import noppes.npcs.config.ConfigMain;
import noppes.npcs.constants.EnumGuiType;
import noppes.npcs.constants.EnumPlayerData;
import noppes.npcs.constants.EnumRoleType;
import noppes.npcs.constants.EnumScrollData;
import noppes.npcs.containers.ContainerManageBanks;
import noppes.npcs.containers.ContainerManageRecipes;
import noppes.npcs.controllers.AnimationController;
import noppes.npcs.controllers.BankController;
import noppes.npcs.controllers.CustomEffectController;
import noppes.npcs.controllers.DialogController;
import noppes.npcs.controllers.FactionController;
import noppes.npcs.controllers.LinkedItemController;
import noppes.npcs.controllers.MagicController;
import noppes.npcs.controllers.PlayerDataController;
import noppes.npcs.controllers.PlayerQuestController;
import noppes.npcs.controllers.QuestController;
import noppes.npcs.controllers.RecipeController;
import noppes.npcs.controllers.ServerCloneController;
import noppes.npcs.controllers.TagController;
import noppes.npcs.controllers.TransportController;
import noppes.npcs.controllers.data.Animation;
import noppes.npcs.controllers.data.Bank;
import noppes.npcs.controllers.data.CustomEffect;
import noppes.npcs.controllers.data.Dialog;
import noppes.npcs.controllers.data.DialogCategory;
import noppes.npcs.controllers.data.DialogOption;
import noppes.npcs.controllers.data.Faction;
import noppes.npcs.controllers.data.LinkedItem;
import noppes.npcs.controllers.data.Magic;
import noppes.npcs.controllers.data.MagicCycle;
import noppes.npcs.controllers.data.MagicData;
import noppes.npcs.controllers.data.PlayerBankData;
import noppes.npcs.controllers.data.PlayerData;
import noppes.npcs.controllers.data.PlayerDialogData;
import noppes.npcs.controllers.data.PlayerFactionData;
import noppes.npcs.controllers.data.PlayerQuestData;
import noppes.npcs.controllers.data.PlayerTransportData;
import noppes.npcs.controllers.data.Quest;
import noppes.npcs.controllers.data.QuestCategory;
import noppes.npcs.controllers.data.QuestData;
import noppes.npcs.controllers.data.RecipeAnvil;
import noppes.npcs.controllers.data.RecipeCarpentry;
import noppes.npcs.controllers.data.Tag;
import noppes.npcs.controllers.data.TransportCategory;
import noppes.npcs.controllers.data.TransportLocation;
import noppes.npcs.entity.EntityDialogNpc;
import noppes.npcs.entity.EntityNPCInterface;
import noppes.npcs.roles.RoleTransporter;
import noppes.npcs.scripted.NpcAPI;
import noppes.npcs.scripted.ScriptSound;
import noppes.npcs.scripted.event.player.DialogEvent;

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

import static kamkeel.npcs.network.packets.data.large.ScrollDataPacket.sendScrollData;

public class NoppesUtilServer {
    private static HashMap<String, Quest> editingQuests = new HashMap<String, Quest>();

    public static IPlayer getIPlayer(EntityPlayer p) {
        return (IPlayer) NpcAPI.Instance().getIEntity(p);
    }

    public static UUID getUUID(Entity entity) {
        return entity instanceof EntityPlayer ? ((EntityPlayer) entity).getGameProfile().getId() : entity.getUniqueID();
    }

    public static boolean isScriptableItem(Item item) {
        return item == CustomItems.scripted_item || item == CustomItems.linked_item;
    }

    public static void setEditingNpc(EntityPlayer player, EntityNPCInterface npc) {
        PlayerData data = PlayerData.get(player);
        data.editingNpc = npc;
        if (npc != null)
            PacketHandler.Instance.sendToPlayer(new EditNpcPacket(npc.getEntityId()), (EntityPlayerMP) player);
    }

    public static EntityNPCInterface getEditingNpc(EntityPlayer player) {
        PlayerData data = PlayerData.get(player);
        return data.editingNpc;
    }

    public static void setEditingQuest(EntityPlayer player, Quest quest) {
        editingQuests.put(player.getCommandSenderName(), quest);
    }

    public static Quest getEditingQuest(EntityPlayer player) {
        return editingQuests.get(player.getCommandSenderName());
    }

    public static void sendRoleData(EntityPlayer player, EntityNPCInterface npc) {
        if (npc.advanced.role == EnumRoleType.None)
            return;
        NBTTagCompound comp = new NBTTagCompound();
        npc.roleInterface.writeToNBT(comp);
        comp.setInteger("EntityId", npc.getEntityId());
        comp.setInteger("Role", npc.advanced.role.ordinal());
        PacketHandler.Instance.sendToPlayer(new RolePacket(comp), (EntityPlayerMP) player);
    }

    public static void sendFactionDataAll(EntityPlayerMP player) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (Faction faction : FactionController.getInstance().factions.values()) {
            map.put(faction.name, faction.id);
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendAnimationDataAll(EntityPlayerMP player) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (Animation animation : AnimationController.getInstance().animations.values()) {
            map.put(animation.name, animation.id);
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendTagDataAll(EntityPlayerMP player) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (Tag tag : TagController.getInstance().tags.values()) {
            map.put(tag.name, tag.id);
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendBankDataAll(EntityPlayerMP player) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (Bank bank : BankController.getInstance().banks.values()) {
            map.put(bank.name, bank.id);
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static NBTTagCompound writeItem(ItemStack item, NBTTagCompound nbt) {
        String resourcelocation = Item.itemRegistry.getNameForObject(item.getItem());
        nbt.setString("id", resourcelocation == null ? "minecraft:air" : resourcelocation.toString());
        nbt.setByte("Count", (byte) item.stackSize);
        nbt.setShort("Damage", (short) item.getItemDamage());

        if (item.stackTagCompound != null) {
            nbt.setTag("tag", item.stackTagCompound);
        }

        return nbt;
    }

    public static ItemStack readItem(NBTTagCompound nbt) {
        Item item;
        if (nbt.hasKey("id", 8)) {
            item = getByNameOrId(nbt.getString("id"));
        } else {
            item = Item.getItemById(nbt.getShort("id"));
        }
        if (item == null)
            return null;
        ItemStack itemstack = new ItemStack(item);

        itemstack.stackSize = nbt.getByte("Count");
        itemstack.setItemDamage(nbt.getShort("Damage"));

        if (itemstack.getItemDamage() < 0) {
            itemstack.setItemDamage(0);
        }

        if (nbt.hasKey("tag", 10)) {
            itemstack.stackTagCompound = nbt.getCompoundTag("tag");
        }
        return itemstack;
    }

    public static Item getByNameOrId(String id) {
        Item item = (Item) Item.itemRegistry.getObject(id);

        if (item == null) {
            try {
                return Item.getItemById(Integer.parseInt(id));
            } catch (NumberFormatException numberformatexception) {
                ;
            }
        }

        return item;
    }

    public static void openDialog(EntityPlayer player, EntityNPCInterface npc, Dialog dia, int optionId) {
        Dialog dialog = dia.copy(player);
        PlayerData playerdata = PlayerData.get(player);

        if (!npc.isRemote()) {
            if (EventHooks.onNPCDialog(npc, player, dialog.id, optionId, dialog)) {
                return;
            }
            if (EventHooks.onDialogOpen(player, new DialogEvent.DialogOpen((IPlayer) NpcAPI.Instance().getIEntity(player), dialog))) {
                return;
            }
        }

        if (npc instanceof EntityDialogNpc || dia.id < 0) {
            dialog.hideNPC = true;
            PacketHandler.Instance.sendToPlayer(new DialogPacket(npc.getCommandSenderName(), -1, dialog.writeToNBT(new NBTTagCompound())), (EntityPlayerMP) player);
        } else
            PacketHandler.Instance.sendToPlayer(new DialogPacket("Real", npc.getEntityId(), dialog.writeToNBT(new NBTTagCompound())), (EntityPlayerMP) player);

        dia.factionOptions.addPoints(player);
        if (dialog.hasQuest())
            PlayerQuestController.addActiveQuest(new QuestData(dialog.getQuest()), player);
        if (!dialog.command.isEmpty()) {
            runCommand(player, npc.getCommandSenderName(), dialog.command);
        }
        if (dialog.mail.isValid())
            PlayerDataController.Instance.addPlayerMessage(player.getCommandSenderName(), dialog.mail);
        PlayerDialogData data = PlayerData.get(player).dialogData;
        if (!data.dialogsRead.contains(dialog.id) && dialog.id >= 0) {
            data.dialogsRead.add(dialog.id);
            playerdata.updateClient = true;
        }
        setEditingNpc(player, npc);
    }

    public static void runCommand(EntityPlayer player, String name, String command) {
        runCommand(player, name, command, player);
    }

    public static void runCommand(EntityLivingBase executer, String name, String command, EntityPlayer player) {
        if (player != null)
            command = command.replace("@dp", player.getCommandSenderName());
        command = command.replace("@npc", name);

        // Trim the command to remove leading/trailing spaces
        command = command.trim();

        String[] commands = command.split("@x"); // Split the command by @x

        // Create TileEntityCommandBlock instance outside the loop
        TileEntityCommandBlock tile = new TileEntityCommandBlock();
        tile.setWorldObj(executer.worldObj);
        tile.xCoord = MathHelper.floor_double(executer.posX);
        tile.yCoord = MathHelper.floor_double(executer.posY);
        tile.zCoord = MathHelper.floor_double(executer.posZ);

        // Create CommandBlockLogic instance outside the loop
        CommandBlockLogic logic = tile.func_145993_a();
        for (String cmd : commands) {
            logic.func_145752_a(cmd.trim()); // Trim the command to remove any leading/trailing spaces
            logic.func_145754_b("@" + name);
            logic.func_145755_a(executer.worldObj);
        }
    }


    public static void runCommand(World world, String name, String command) {
        TileEntityCommandBlock tile = new TileEntityCommandBlock();
        tile.setWorldObj(world.provider.worldObj);
        tile.xCoord = 0;
        tile.yCoord = 0;
        tile.zCoord = 0;

        // Trim the command to remove leading/trailing spaces
        command = command.trim();
        String[] commands = command.split("@x"); // Split the command by @x
        CommandBlockLogic logic = tile.func_145993_a();
        for (String cmd : commands) {
            logic.func_145752_a(cmd.trim()); // Trim the command to remove any leading/trailing spaces
            logic.func_145754_b("@" + name);
            logic.func_145755_a(world);
        }
    }

    public static void consumeItemStack(int i, EntityPlayer player) {
        ItemStack item = player.inventory.getCurrentItem();
        if (player.capabilities.isCreativeMode || item == null)
            return;

        --item.stackSize;
        if (item.stackSize <= 0)
            player.destroyCurrentEquippedItem();
    }

    public static void sendOpenGui(EntityPlayer player,
                                   EnumGuiType gui, EntityNPCInterface npc) {
        sendOpenGui(player, gui, npc, 0, 0, 0);
    }

    public static void sendOpenGuiNoDelay(EntityPlayer player,
                                          EnumGuiType gui, EntityNPCInterface npc) {
        sendOpenGuiNoDelay(player, gui, npc, 0, 0, 0);
    }

    public static void sendOpenGui(final EntityPlayer player,
                                   final EnumGuiType gui, final EntityNPCInterface npc, final int i, final int j, final int k) {
        if (!(player instanceof EntityPlayerMP))
            return;

        setEditingNpc(player, npc);
        sendExtraData(player, npc, gui, i, j, k);

        if (CustomNpcs.proxy.getServerGuiElement(gui.ordinal(), player, player.worldObj, i, j, k) != null) {
            player.openGui(CustomNpcs.instance, gui.ordinal(), player.worldObj, i, j, k);
            return;
        } else {
            GuiOpenPacket.openGUI((EntityPlayerMP) player, gui, i, j, k);
        }
        ArrayList<String> list = getScrollData(player, gui, npc);
        if (list == null || list.isEmpty())
            return;

        ScrollListPacket.sendList((EntityPlayerMP) player, list, EnumScrollData.OPTIONAL);
    }

    public static void sendOpenGuiNoDelay(final EntityPlayer player,
                                          final EnumGuiType gui, final EntityNPCInterface npc, final int i, final int j, final int k) {
        if (!(player instanceof EntityPlayerMP))
            return;

        setEditingNpc(player, npc);
        sendExtraData(player, npc, gui, i, j, k);

        if (CustomNpcs.proxy.getServerGuiElement(gui.ordinal(), player, player.worldObj, i, j, k) != null) {
            player.openGui(CustomNpcs.instance, gui.ordinal(), player.worldObj, i, j, k);
            return;
        } else {
            GuiOpenPacket.openGUI((EntityPlayerMP) player, gui, i, j, k);
        }
        ArrayList<String> list = getScrollData(player, gui, npc);
        if (list == null || list.isEmpty())
            return;

        ScrollListPacket.sendList((EntityPlayerMP) player, list, EnumScrollData.OPTIONAL);
    }


    private static void sendExtraData(EntityPlayer player, EntityNPCInterface npc, EnumGuiType gui, int i, int j, int k) {
        if (gui == EnumGuiType.PlayerFollower || gui == EnumGuiType.PlayerFollowerHire || gui == EnumGuiType.PlayerTrader || gui == EnumGuiType.PlayerTransporter) {
            sendRoleData(player, npc);
        }
    }

    private static ArrayList<String> getScrollData(EntityPlayer player, EnumGuiType gui, EntityNPCInterface npc) {
        if (gui == EnumGuiType.PlayerTransporter) {
            RoleTransporter role = (RoleTransporter) npc.roleInterface;
            ArrayList<String> list = new ArrayList<String>();
            TransportLocation location = role.getLocation();
            String name = role.getLocation().name;
            for (TransportLocation loc : location.category.getDefaultLocations()) {
                if (!list.contains(loc.name)) {
                    list.add(loc.name);
                }
            }
            PlayerTransportData playerdata = PlayerData.get(player).transportData;
            for (int i : playerdata.transports) {
                TransportLocation loc = TransportController.getInstance().getTransport(i);
                if (loc != null && location.category.locations.containsKey(loc.id)) {
                    if (!list.contains(loc.name)) {
                        list.add(loc.name);
                    }
                }
            }
            list.remove(name);
            return list;
        }
        return null;
    }

    public static void spawnParticle(Entity entity, String particle, int dimension) {
        PacketHandler.Instance.sendTracking(new ParticlePacket(entity.posX, entity.posY, entity.posZ, entity.height, entity.width, entity.yOffset, particle), entity);
    }

    public static void spawnScriptedParticle(NBTTagCompound compound, int dimensionId) {
        PacketHandler.Instance.sendToDimension(new ScriptedParticlePacket(compound), dimensionId);
    }

    public static void playSound(int id, ScriptSound sound) {
        List<EntityPlayer> list = MinecraftServer.getServer().getConfigurationManager().playerEntityList;
        for (EntityPlayer player : list) {
            NoppesUtilPlayer.playSoundTo((EntityPlayerMP) player, id, sound);
        }
    }

    public static void playSound(ScriptSound sound) {
        List<EntityPlayer> list = MinecraftServer.getServer().getConfigurationManager().playerEntityList;
        for (EntityPlayer player : list) {
            NoppesUtilPlayer.playSoundTo((EntityPlayerMP) player, sound);
        }
    }

    public static void stopSound(int id) {
        List<EntityPlayer> list = MinecraftServer.getServer().getConfigurationManager().playerEntityList;
        for (EntityPlayer player : list) {
            NoppesUtilPlayer.stopSoundFor((EntityPlayerMP) player, id);
        }
    }

    public static void pauseSounds() {
        List<EntityPlayer> list = MinecraftServer.getServer().getConfigurationManager().playerEntityList;
        for (EntityPlayer player : list) {
            NoppesUtilPlayer.pauseSoundsFor((EntityPlayerMP) player);
        }
    }

    public static void continueSounds() {
        List<EntityPlayer> list = MinecraftServer.getServer().getConfigurationManager().playerEntityList;
        for (EntityPlayer player : list) {
            NoppesUtilPlayer.continueSoundsFor((EntityPlayerMP) player);
        }
    }

    public static void stopSounds() {
        List<EntityPlayer> list = MinecraftServer.getServer().getConfigurationManager().playerEntityList;
        for (EntityPlayer player : list) {
            NoppesUtilPlayer.stopSoundsFor((EntityPlayerMP) player);
        }
    }

    public static void deleteNpc(EntityNPCInterface npc, EntityPlayer player) {
        PacketHandler.Instance.sendTracking(new DeleteNpcPacket(npc.getEntityId()), npc);
    }

    public static void createMobSpawner(int x, int y, int z, NBTTagCompound comp, EntityPlayer player) {
        comp.removeTag("Pos");
        ServerCloneController.Instance.cleanTags(comp);

        if (comp.getString("id").equalsIgnoreCase("entityhorse")) {
            player.addChatMessage(new ChatComponentTranslation("Currently you cant create horse spawner, its a minecraft bug"));
            return;
        }

        player.worldObj.setBlock(x, y, z, Blocks.mob_spawner); //setBlock
        TileEntityMobSpawner tile = (TileEntityMobSpawner) player.worldObj.getTileEntity(x, y, z);
        MobSpawnerBaseLogic logic = tile.func_145881_a();

        logic.setRandomEntity(logic.new WeightedRandomMinecart(comp, comp.getString("id")));
    }

    public static void sendQuestCategoryData(EntityPlayerMP player) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (QuestCategory category : QuestController.Instance.categories.values()) {
            map.put(category.title, category.id);
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendPlayerData(EnumPlayerData type, EntityPlayerMP player, String name) throws IOException {
        Map<String, Integer> map = new HashMap<String, Integer>();

        if (type == EnumPlayerData.Players) {
            for (String username : PlayerDataController.Instance.nameUUIDs.keySet()) {
                map.put(username, 0);
            }
            for (String username : MinecraftServer.getServer().getConfigurationManager().getAllUsernames()) {
                map.put(username, 0);
            }
        } else {
            PlayerData playerdata = PlayerDataController.Instance.getDataFromUsername(name);
            if (type == EnumPlayerData.Dialog) {
                PlayerDialogData data = playerdata.dialogData;

                for (int questId : data.dialogsRead) {
                    Dialog dialog = DialogController.Instance.dialogs.get(questId);
                    if (dialog == null)
                        continue;
                    map.put(dialog.category.title + ": " + dialog.title, questId);
                }
            } else if (type == EnumPlayerData.Quest) {
                PlayerQuestData data = playerdata.questData;

                for (int questId : data.activeQuests.keySet()) {
                    Quest quest = QuestController.Instance.quests.get(questId);
                    if (quest == null)
                        continue;
                    map.put(quest.category.title + ": " + quest.title + " (Active)", questId);
                }
                for (int questId : data.finishedQuests.keySet()) {
                    Quest quest = QuestController.Instance.quests.get(questId);
                    if (quest == null)
                        continue;
                    map.put(quest.category.title + ": " + quest.title + " (Finished)", questId);
                }
            } else if (type == EnumPlayerData.Transport) {
                PlayerTransportData data = playerdata.transportData;

                for (int questId : data.transports) {
                    TransportLocation location = TransportController.getInstance().getTransport(questId);
                    if (location == null)
                        continue;
                    map.put(location.category.title + ": " + location.name, questId);
                }
            } else if (type == EnumPlayerData.Bank) {
                PlayerBankData data = playerdata.bankData;

                for (int bankId : data.banks.keySet()) {
                    Bank bank = BankController.getInstance().banks.get(bankId);
                    if (bank == null)
                        continue;
                    map.put(bank.name, bankId);
                }
            } else if (type == EnumPlayerData.Factions) {
                PlayerFactionData data = playerdata.factionData;
                for (int factionId : data.factionData.keySet()) {
                    Faction faction = FactionController.getInstance().factions.get(factionId);
                    if (faction == null)
                        continue;
                    map.put(faction.name + "(" + data.getFactionPoints(factionId) + ")", factionId);
                }
            }
        }

        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void removePlayerData(ByteBuf buffer, EntityPlayerMP player) throws IOException {
        int id = buffer.readInt();
        if (EnumPlayerData.values().length <= id)
            return;
        String name = ByteBufUtils.readString(buffer);
        EnumPlayerData type = EnumPlayerData.values()[id];
        EntityPlayer pl = MinecraftServer.getServer().getConfigurationManager().func_152612_a(name);
        PlayerData playerdata = null;
        if (pl == null)
            playerdata = PlayerDataController.Instance.getDataFromUsername(name);
        else
            playerdata = PlayerData.get(pl);

        if (type == EnumPlayerData.Players) {
            String fileType = ".json";
            if (ConfigMain.DatFormat) {
                fileType = ".dat";
            }
            File file = new File(PlayerDataController.Instance.getSaveDir(), playerdata.uuid + fileType);
            if (file.exists())
                file.delete();
            if (pl != null) {
                PlayerDataController.Instance.removePlayerDataCache(pl.getUniqueID().toString());

                PlayerDataController.Instance.nameUUIDs.remove(name);
                PlayerDataController.Instance.savePlayerDataMap();

                int currentSlot = playerdata.profileSlot;

                playerdata.setNBT(new NBTTagCompound());
                playerdata.profileSlot = currentSlot;

                sendPlayerData(type, player, name);
                playerdata.save();
                return;
            }
        }
        if (type == EnumPlayerData.Quest) {
            PlayerQuestData data = playerdata.questData;
            int questId = buffer.readInt();
            data.activeQuests.remove(questId);
            data.finishedQuests.remove(questId);
            playerdata.save();
        }
        if (type == EnumPlayerData.Dialog) {
            PlayerDialogData data = playerdata.dialogData;
            data.dialogsRead.remove(buffer.readInt());
            playerdata.save();
        }
        if (type == EnumPlayerData.Transport) {
            PlayerTransportData data = playerdata.transportData;
            data.transports.remove(buffer.readInt());
            playerdata.save();
        }
        if (type == EnumPlayerData.Bank) {
            PlayerBankData data = playerdata.bankData;
            data.banks.remove(buffer.readInt());
            playerdata.save();
        }
        if (type == EnumPlayerData.Factions) {
            PlayerFactionData data = playerdata.factionData;
            data.factionData.remove(buffer.readInt());
            playerdata.save();
        }
        if (type == EnumPlayerData.Magic) {
            MagicData data = playerdata.magicData;
            data.removeMagic(buffer.readInt());
            playerdata.save();
        }
        if (pl != null) {
            SyncController.syncPlayer((EntityPlayerMP) pl);
        }
        sendPlayerData(type, player, name);
    }

    public static void regenPlayerData(EntityPlayerMP player) throws IOException {
        PlayerDataController.Instance.generatePlayerMap(player);
    }

    public static void sendRecipeData(EntityPlayerMP player, int size) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        if (size == 3) {
            for (RecipeCarpentry recipe : RecipeController.Instance.globalRecipes.values()) {
                map.put(recipe.name, recipe.id);
            }
        } else if (size == 4) {
            for (RecipeCarpentry recipe : RecipeController.Instance.carpentryRecipes.values()) {
                map.put(recipe.name, recipe.id);
            }
        } else {
            for (RecipeAnvil recipe : RecipeController.Instance.anvilRecipes.values()) {
                map.put(recipe.name, recipe.id);
            }
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendDialogData(EntityPlayerMP player, DialogCategory category) {
        if (category == null)
            return;
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for (Dialog dialog : category.dialogs.values()) {
            map.put(dialog.title, dialog.id);
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendDialogGroup(EntityPlayerMP player, DialogCategory category) {
        if (category == null)
            return;
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for (Dialog dialog : category.dialogs.values()) {
            map.put(dialog.title, dialog.id);
        }

        sendScrollData(player, map, EnumScrollData.DIALOG_GROUP);
    }

    public static void sendQuestData(EntityPlayerMP player, QuestCategory category) {
        if (category == null)
            return;
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for (Quest quest : category.quests.values()) {
            map.put(quest.title, quest.id);
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendQuestGroup(EntityPlayerMP player, QuestCategory category) {
        if (category == null)
            return;
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for (Quest quest : category.quests.values()) {
            map.put(quest.title, quest.id);
        }

        sendScrollData(player, map, EnumScrollData.QUEST_GROUP);
    }

    public static void sendCustomEffectDataAll(EntityPlayerMP player) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (CustomEffect effect : CustomEffectController.getInstance().getCustomEffects().values()) {
            map.put(effect.name, effect.id);
        }
        ScrollDataPacket.sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendLinkedItemDataAll(EntityPlayerMP player) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (LinkedItem linkedItem : LinkedItemController.getInstance().linkedItems.values()) {
            map.put(linkedItem.name, linkedItem.id);
        }
        ScrollDataPacket.sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendTransportCategoryData(EntityPlayerMP player) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for (TransportCategory category : TransportController.getInstance().categories.values()) {
            map.put(category.title, category.id);
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendTransportData(EntityPlayerMP player, int categoryid) {
        TransportCategory category = TransportController.getInstance().categories.get(categoryid);
        if (category == null)
            return;
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for (TransportLocation transport : category.locations.values()) {
            map.put(transport.name, transport.id);
        }
        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }


    public static void sendNpcDialogs(EntityPlayer player) {
        EntityNPCInterface npc = getEditingNpc(player);
        if (npc == null)
            return;
        for (int pos : npc.dialogs.keySet()) {
            DialogOption option = npc.dialogs.get(pos);
            if (option == null || !option.hasDialog())
                continue;

            NBTTagCompound compound = option.writeNBT();
            compound.setInteger("Position", pos);
            GuiDataPacket.sendGuiData((EntityPlayerMP) player, compound);
        }
    }

    public static void sendMagicInfo(EntityPlayerMP player, boolean cycles) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        if (cycles) {
            for (MagicCycle magicCycle : MagicController.getInstance().cycles.values()) {
                map.put(magicCycle.name, magicCycle.id);
            }
            sendScrollData(player, map, EnumScrollData.MAGIC_CYCLES);
        } else {
            for (Magic magic : MagicController.getInstance().magics.values()) {
                map.put(magic.name, magic.id);
            }
            sendScrollData(player, map, EnumScrollData.MAGIC);
        }
    }

    public static void sendAbilityTypesInfo(EntityPlayerMP player) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        kamkeel.npcs.controllers.data.ability.AbilityController controller = kamkeel.npcs.controllers.data.ability.AbilityController.Instance;
        if (controller != null) {
            int index = 0;
            for (String typeId : controller.getTypes()) {
                map.put(typeId, index++);
            }
        }
        sendScrollData(player, map, EnumScrollData.ABILITY_TYPES);
    }

    public static DialogOption setNpcDialog(int slot, int dialogId, EntityPlayer player) throws IOException {
        return setNpcDialog(slot, dialogId, getEditingNpc(player));
    }

    public static DialogOption setNpcDialog(int slot, int dialogId, EntityNPCInterface npc) {
        if (npc == null)
            return null;
        if (!npc.dialogs.containsKey(slot))
            npc.dialogs.put(slot, new DialogOption());

        DialogOption option = npc.dialogs.get(slot);
        option.dialogId = dialogId;
        if (option.hasDialog())
            option.title = option.getDialog().title;

        return option;
    }

    public static void saveTileEntity(EntityPlayerMP player, NBTTagCompound compound) {
        int x = compound.getInteger("x");
        int y = compound.getInteger("y");
        int z = compound.getInteger("z");

        TileEntity tile = player.worldObj.getTileEntity(x, y, z);
        if (tile != null)
            tile.readFromNBT(compound);

    }

    public static void setClonerGui(EntityPlayerMP player, int x, int y, int z) {
        if (player == null)
            return;
        GuiOpenPacket.openGUI(player, EnumGuiType.Cloner, x, y, z);
    }

    public static void setTeleporterGUI(EntityPlayerMP player) {
        if (player == null)
            return;
        PacketHandler.Instance.sendToPlayer(new GuiTeleporterPacket(), player);
    }

    public static void setRecipeGui(EntityPlayerMP player, RecipeCarpentry recipe) {
        if (recipe == null)
            return;
        if (!(player.openContainer instanceof ContainerManageRecipes))
            return;

        ContainerManageRecipes container = (ContainerManageRecipes) player.openContainer;
        container.setRecipe(recipe);
        GuiDataPacket.sendGuiData((EntityPlayerMP) player, recipe.writeNBT());
    }

    public static void setRecipeAnvilGui(EntityPlayerMP player, RecipeAnvil recipe) {
        if (recipe == null)
            return;
        if (!(player.openContainer instanceof ContainerManageRecipes))
            return;

        ContainerManageRecipes container = (ContainerManageRecipes) player.openContainer;
        container.setRecipe(recipe);
        GuiDataPacket.sendGuiData((EntityPlayerMP) player, recipe.writeNBT());
    }

    public static void sendBank(EntityPlayerMP player, Bank bank) {
        NBTTagCompound compound = new NBTTagCompound();
        bank.writeEntityToNBT(compound);
        GuiDataPacket.sendGuiData((EntityPlayerMP) player, compound);

        if (player.openContainer instanceof ContainerManageBanks) {
            ((ContainerManageBanks) player.openContainer).setBank(bank);
        }
        player.sendContainerAndContentsToPlayer(player.openContainer, player.openContainer.getInventory());
    }

    public static void sendNearbyNpcs(EntityPlayerMP player) {
        List<EntityNPCInterface> npcs = player.worldObj.getEntitiesWithinAABB(EntityNPCInterface.class, player.boundingBox.expand(120, 120, 120));
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for (EntityNPCInterface npc : npcs) {
            if (npc.isDead)
                continue;
            float distance = player.getDistanceToEntity(npc);
            DecimalFormat df = new DecimalFormat("#.#");
            String s = df.format(distance);
            if (distance < 10)
                s = "0" + s;
            map.put(s + " : " + npc.display.name, npc.getEntityId());
        }

        sendScrollData(player, map, EnumScrollData.OPTIONAL);
    }

    public static void sendGuiError(EntityPlayer player, int i) {
        GuiErrorPacket.errorGUI((EntityPlayerMP) player, i, new NBTTagCompound());
    }

    public static void sendGuiClose(EntityPlayerMP player, int i, NBTTagCompound comp) {
        if (player.openContainer != player.inventoryContainer) {
            player.openContainer = player.inventoryContainer;
        }
        GuiClosePacket.closeGUI(player, i, comp);
    }

    public static Entity spawnCloneWithProtection(NBTTagCompound compound, int x, int y,
                                                  int z, World worldObj) {
        ServerCloneController.Instance.cleanTags(compound);
        compound.setTag("Pos", NBTTags.nbtDoubleList(x + 0.5, y, z + 0.5));
        Entity entity = EntityList.createEntityFromNBT(compound, worldObj);
        if (entity == null) {
            return null;
        }
        entity.setPosition((double) x + 0.5, (double) y, (double) z + 0.5);
        if (entity instanceof EntityNPCInterface) {
            EntityNPCInterface npc = (EntityNPCInterface) entity;
            npc.ais.startPos = new int[]{MathHelper.floor_double(npc.posX), MathHelper.floor_double(npc.posY), MathHelper.floor_double(npc.posZ)};
            npc.ticksExisted = 0;
            npc.totalTicksAlive = 0;
        }
        worldObj.spawnEntityInWorld(entity);
        entity.prevPosY = entity.lastTickPosY = entity.posY = y + 1;
        return entity;
    }

    public static Entity getEntityFromNBT(NBTTagCompound compound, int x, int y,
                                          int z, World worldObj) {
        ServerCloneController.Instance.cleanTags(compound);
        compound.setTag("Pos", NBTTags.nbtDoubleList(x + 0.5, y + 1, z + 0.5));
        Entity entity = EntityList.createEntityFromNBT(compound, worldObj);
        if (entity == null) {
            return null;
        }
        if (entity instanceof EntityNPCInterface) {
            EntityNPCInterface npc = (EntityNPCInterface) entity;
            npc.ais.startPos = new int[]{MathHelper.floor_double(npc.posX), MathHelper.floor_double(npc.posY), MathHelper.floor_double(npc.posZ)};
            npc.ticksExisted = 0;
            npc.totalTicksAlive = 0;
        }
        return entity;
    }

    public static Entity spawnClone(NBTTagCompound compound, int x, int y,
                                    int z, World worldObj) {
        Entity entity = getEntityFromNBT(compound, x, y, z, worldObj);
        if (entity == null) {
            return null;
        }

        entity.dimension = worldObj.provider.dimensionId;
        int i = MathHelper.floor_double(entity.posX / 16.0D);
        int j = MathHelper.floor_double(entity.posZ / 16.0D);
        if (!entity.forceSpawn && !worldObj.checkChunksExist(
            (int) entity.posX, (int) entity.posY, (int) entity.posZ, (int) entity.posX, (int) entity.posY, (int) entity.posZ)) {
            return null;
        } else {
            worldObj.getChunkFromChunkCoords(i, j).addEntity(entity);
            worldObj.loadedEntityList.add(entity);
            worldObj.onEntityAdded(entity);
            return entity;
        }
    }

    public static boolean isOp(EntityPlayer player) {
        return MinecraftServer.getServer().getConfigurationManager().func_152596_g(player.getGameProfile());
    }


    public static void GivePlayerItem(Entity entity, EntityPlayer player, ItemStack item) {
        if (entity.worldObj.isRemote || item == null) {
            return;
        }
        item = item.copy();
        float f = 0.7F;
        double d = (double) (entity.worldObj.rand.nextFloat() * f) + (double) (1.0F - f);
        double d1 = (double) (entity.worldObj.rand.nextFloat() * f) + (double) (1.0F - f);
        double d2 = (double) (entity.worldObj.rand.nextFloat() * f) + (double) (1.0F - f);
        EntityItem entityitem = new EntityItem(entity.worldObj, entity.posX + d, entity.posY + d1, entity.posZ + d2,
            item);
        entityitem.delayBeforeCanPickup = 2;
        entity.worldObj.spawnEntityInWorld(entityitem);

        int i = item.stackSize;

        if (player.inventory.addItemStackToInventory(item)) {
            entity.worldObj.playSoundAtEntity(entityitem, "random.pop", 0.2F,
                ((entity.worldObj.rand.nextFloat() - entity.worldObj.rand.nextFloat()) * 0.7F + 1.0F) * 2.0F);
            player.onItemPickup(entityitem, i);

            if (item.stackSize <= 0) {
                entityitem.setDead();
            }
        }
    }

    public static EntityPlayer getPlayer(UUID id) {
        List<EntityPlayer> list = MinecraftServer.getServer().getConfigurationManager().playerEntityList;
        for (EntityPlayer player : list) {
            if (id.equals(player.getUniqueID()))
                return player;
        }
        return null;
    }

    public static Entity getEntityFromUUID(World world, UUID uuid) {
        for (Object obj : world.loadedEntityList) {
            if (obj instanceof Entity) {
                Entity entity = (Entity) obj;
                if (entity.getUniqueID().equals(uuid)) {
                    return entity;
                }
            }
        }
        return null;
    }

    static public EntityPlayer getPlayerByName(String playername) {
        return MinecraftServer.getServer().getConfigurationManager().func_152612_a(playername);
    }

    public static Entity GetDamageSource(DamageSource damagesource) {
        Entity entity = damagesource.getEntity();
        if (entity == null) {
            entity = damagesource.getSourceOfDamage();
        }

        if (entity instanceof EntityArrow && ((EntityArrow) entity).shootingEntity instanceof EntityLivingBase) {
            entity = ((EntityArrow) entity).shootingEntity;
        } else if (entity instanceof EntityThrowable) {
            entity = ((EntityThrowable) entity).getThrower();
        }

        return entity;
    }

    public static void isGUIOpen(ByteBuf buffer, EntityPlayer player) throws IOException {
        PlayerData playerdata = PlayerData.get(player);
        boolean isGUIOpen = buffer.readBoolean();
        playerdata.setGUIOpen(isGUIOpen);
    }

    public static boolean IsItemStackNull(ItemStack is) {
        return is == null || is.stackSize == 0 || is.getItem() == null;
    }

    public static String millisToTime(long millis) {
        long seconds = millis / 1000;
        long minutes = seconds / 60;
        long hours = minutes / 60;
        long days = hours / 24;
        seconds %= 60;
        minutes %= 60;
        hours %= 24;

        StringBuilder sb = new StringBuilder();
        if (days > 0) {
            sb.append(days).append(" day").append(days == 1 ? "" : "s").append(", ");
        }
        if (hours > 0) {
            sb.append(hours).append(" hour").append(hours == 1 ? "" : "s").append(", ");
        }
        if (minutes > 0) {
            sb.append(minutes).append(" minute").append(minutes == 1 ? "" : "s").append(", ");
        }
        sb.append(seconds).append(" second").append(seconds == 1 ? "" : "s");
        return sb.toString();
    }

    /**
     * Retrieves the player's data from the existing PlayerDataController and sends
     * a large packet to the client containing all the maps, including categories.
     */
    public static void sendPlayerDataInfo(String playerName, EntityPlayerMP player) {
        PlayerData playerdata;
        EntityPlayer pl = MinecraftServer.getServer().getConfigurationManager().func_152612_a(playerName);
        if (pl == null)
            playerdata = PlayerDataController.Instance.getDataFromUsername(playerName);
        else
            playerdata = PlayerData.get(pl);

        // Assemble quest maps:
        Map<String, Integer> questActiveMap = new HashMap<>();
        Map<String, Integer> questFinishedMap = new HashMap<>();
        Map<String, Integer> questCategoriesMap = new HashMap<>();
        QuestController qc = QuestController.Instance;
        PlayerQuestData qData = playerdata.questData;
        for (Integer questId : qData.activeQuests.keySet()) {
            if (!qc.quests.containsKey(questId))
                continue;
            Quest quest = qc.quests.get(questId);
            questActiveMap.put(quest.category.title + ": " + quest.title, questId);
            if (!questCategoriesMap.containsKey(quest.category.title))
                questCategoriesMap.put(quest.category.title, quest.category.id);
        }
        for (Integer questId : qData.finishedQuests.keySet()) {
            if (!qc.quests.containsKey(questId))
                continue;
            Quest quest = qc.quests.get(questId);
            questFinishedMap.put(quest.category.title + ": " + quest.title, questId);
            if (!questCategoriesMap.containsKey(quest.category.title))
                questCategoriesMap.put(quest.category.title, quest.category.id);
        }

        // Assemble dialog maps:
        Map<String, Integer> dialogReadMap = new HashMap<>();
        Map<String, Integer> dialogCategoriesMap = new HashMap<>();
        PlayerDialogData dData = playerdata.dialogData;
        for (Integer dialogId : dData.dialogsRead) {
            if (!DialogController.Instance.dialogs.containsKey(dialogId))
                continue;
            Dialog dialog = DialogController.Instance.dialogs.get(dialogId);
            dialogReadMap.put(dialog.category.title + ": " + dialog.title, dialogId);
            if (!dialogCategoriesMap.containsKey(dialog.category.title))
                dialogCategoriesMap.put(dialog.category.title, dialog.category.id);
        }

        // Assemble transport maps:
        Map<String, Integer> transportLocationsMap = new HashMap<>();
        Map<String, Integer> transportCategoriesMap = new HashMap<>();
        PlayerTransportData tData = playerdata.transportData;
        TransportController tc = TransportController.getInstance();
        for (Integer id : tData.transports) {
            TransportLocation location = tc.getTransport(id);
            if (location == null)
                continue;
            transportLocationsMap.put(location.category.title + ": " + location.name, id);
            if (!transportCategoriesMap.containsKey(location.category.title))
                transportCategoriesMap.put(location.category.title, location.category.id);
        }

        // Assemble bank map:
        Map<String, Integer> bankMap = new HashMap<>();
        PlayerBankData bData = playerdata.bankData;
        BankController bc = BankController.getInstance();
        for (Integer bankId : bData.banks.keySet()) {
            if (!bc.banks.containsKey(bankId))
                continue;
            Bank bank = bc.banks.get(bankId);
            bankMap.put(bank.name, bankId);
        }

        // Assemble faction map:
        Map<String, Integer> factionMap = new HashMap<>();
        PlayerFactionData fData = playerdata.factionData;
        FactionController fc = FactionController.getInstance();
        for (Integer factionId : fData.factionData.keySet()) {
            if (!fc.factions.containsKey(factionId))
                continue;
            Faction faction = fc.factions.get(factionId);
            factionMap.put(faction.name + "(" + fData.getFactionPoints(factionId) + ")", factionId);
        }

        // Send the full packet with categories, active/finished data, dialogs, transports, banks, and factions.
        PlayerDataInfoPacket packet = new PlayerDataInfoPacket(playerName,
            questCategoriesMap, questActiveMap, questFinishedMap,
            dialogCategoriesMap, dialogReadMap,
            transportCategoriesMap, transportLocationsMap,
            bankMap, factionMap, playerdata.magicData);
        PacketHandler.Instance.sendToPlayer(packet, player);
    }

    /**
     * Removes a specific data entry from the player's data.
     * <p>
     * The tabType parameter is used as follows:
     * 0: Quest – remove from both activeQuests and finishedQuests.
     * 1: Dialog – remove from dialogsRead.
     * 2: Transport – remove from transports.
     * 3: Bank – remove from banks.
     * 4: Factions – remove from factionData.
     * 5: Magic - remove from magicData.
     * <p>
     * The selectedKey is expected to be the string representation of the entry's ID.
     */
    public static void removePlayerDataInfo(String playerName, int tabType, int value, EntityPlayerMP player) {
        EntityPlayer pl = MinecraftServer.getServer().getConfigurationManager().func_152612_a(playerName);
        PlayerData playerdata;

        EnumPlayerData enumPlayerData = EnumPlayerData.values()[tabType];
        if (pl == null)
            playerdata = PlayerDataController.Instance.getDataFromUsername(playerName);
        else
            playerdata = PlayerData.get(pl);

        if (enumPlayerData == EnumPlayerData.Quest) { // Quest removal
            playerdata.questData.activeQuests.remove(value);
            playerdata.questData.finishedQuests.remove(value);
        }
        if (enumPlayerData == EnumPlayerData.Dialog) { // Dialog removal
            playerdata.dialogData.dialogsRead.remove(value);
        }
        if (enumPlayerData == EnumPlayerData.Transport) { // Transport removal
            playerdata.transportData.transports.remove(value);
        }
        if (enumPlayerData == EnumPlayerData.Bank) { // Bank removal
            playerdata.bankData.banks.remove(value);
        }
        if (enumPlayerData == EnumPlayerData.Factions) { // Faction removal
            playerdata.factionData.factionData.remove(value);
        }
        if (enumPlayerData == EnumPlayerData.Magic) { // Faction removal
            playerdata.magicData.removeMagic(value);
        }
        playerdata.save();

        if (pl != null) {
            SyncController.syncPlayer((EntityPlayerMP) pl);
        }
    }

    /**
     * Removes a specific data entry from the player's data.
     * <p>
     * The tabType parameter is used as follows:
     * 0: Quest – remove from both activeQuests and finishedQuests.
     * 1: Dialog – remove from dialogsRead.
     * 2: Transport – remove from transports.
     * 3: Bank – remove from banks.
     * 4: Factions – remove from factionData.
     * <p>
     * The selectedKey is expected to be the string representation of the entry's ID.
     */
    public static void savePlayerDataInfo(String playerName, int tabType, NBTTagCompound compound, EntityPlayerMP player) {
        EntityPlayer pl = MinecraftServer.getServer().getConfigurationManager().func_152612_a(playerName);
        PlayerData playerdata;

        EnumPlayerData enumPlayerData = EnumPlayerData.values()[tabType];
        if (pl == null)
            playerdata = PlayerDataController.Instance.getDataFromUsername(playerName);
        else
            playerdata = PlayerData.get(pl);

        if (enumPlayerData == EnumPlayerData.Magic) { // Quest removal
            playerdata.magicData.readToNBT(compound);
        }

        playerdata.save();
        if (pl != null) {
            SyncController.syncPlayer((EntityPlayerMP) pl);
        }
    }
}