Core/src/main/java/eu/univento/core/api/player/CustomPlayer.java

package eu.univento.core.api.player;

import com.mojang.authlib.GameProfile;
import com.mojang.authlib.properties.Property;
import com.mongodb.BasicDBObject;
import com.mongodb.CursorType;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import eu.univento.core.Core;
import eu.univento.core.antihack.Hack;
import eu.univento.core.api.Actionbar;
import eu.univento.core.api.Utils;
import eu.univento.core.api.database.MongoDB;
import eu.univento.core.api.effects.Effects;
import eu.univento.core.api.languages.Language;
import eu.univento.core.api.languages.Messages;
import eu.univento.core.api.server.ServerSettings;
import eu.univento.core.api.server.Servers;
import eu.univento.core.api.utils.GameProfileBuilder;
import eu.univento.core.api.utils.UUIDFetcher;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import net.minecraft.server.v1_10_R1.*;
import net.minecraft.server.v1_10_R1.World;
import org.bson.Document;
import org.bukkit.*;
import org.bukkit.attribute.Attribute;
import org.bukkit.attribute.AttributeInstance;
import org.bukkit.attribute.AttributeModifier;
import org.bukkit.craftbukkit.v1_10_R1.CraftServer;
import org.bukkit.craftbukkit.v1_10_R1.CraftWorld;
import org.bukkit.craftbukkit.v1_10_R1.entity.CraftPlayer;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scoreboard.Scoreboard;
import org.bukkit.scoreboard.Team;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.*;
import java.util.logging.Level;

public class CustomPlayer extends CraftPlayer {


    private static final HashMap<String, CustomPlayer> PLAYERS = new HashMap<>();
    private final Player PLAYER;

    private String customPrefix;
    private String customSuffix;
    private String customColor;
    private String nickname;

    private boolean openInventory;

    private MongoCollection<Document> playerCollection;
    private MongoCollection<Document> friendCollection;
    private MongoCollection<Document> onlinePlayerCollection;

    private CustomPlayer(Player player) {
        super((CraftServer) Bukkit.getServer(), ((CraftPlayer) player).getHandle());
        PLAYERS.put(player.getName().toLowerCase(), this);
        PLAYER = player;
        MongoDB mongoDB = Core.getMongoDB();
        playerCollection = mongoDB.getDatabase().getCollection("players");
        friendCollection = mongoDB.getDatabase().getCollection("friends");
        onlinePlayerCollection = mongoDB.getDatabase().getCollection("online-players");

    }

    public void onLeave() {
        Date date = new Date();
        setInDatabase("lastOnline", date);

        HashMap<String, Object> location = new HashMap<>();
        location.put("X", getLocation().getX());
        location.put("Y", getLocation().getY());
        location.put("Z", getLocation().getZ());
        location.put("Yaw", getLocation().getYaw());
        location.put("Pitch", getLocation().getPitch());

        if (ServerSettings.isLobby()) setInDatabase("Pos", new BasicDBObject(location));

        if (PLAYERS.containsKey(getName().toLowerCase())) PLAYERS.remove(getName().toLowerCase());
    }

    public static CustomPlayer getPlayer(String player) {
        if (PLAYERS.containsKey(player.toLowerCase())) {
            return PLAYERS.get(player.toLowerCase());
        } else {
            Player p = Bukkit.getPlayer(player);
            return p == null ? null : new CustomPlayer(p);
        }
    }


    public static CustomPlayer getPlayer(Player player) {
        return getPlayer(player.getName());
    }

    public static CustomPlayer getPlayer(UUID uuid) {
        return getPlayer(UUIDFetcher.getName(uuid));
    }


    public Player getPLAYER() {
        return PLAYER;
    }

    public void insertToDatabase() {
        Document doc = new Document("uuid", getUniqueId().toString());

        HashMap<String, Object> location = new HashMap<>();
        location.put("X", getLocation().getX());
        location.put("Y", getLocation().getY());
        location.put("Z", getLocation().getZ());
        location.put("Yaw", getLocation().getYaw());
        location.put("Pitch", getLocation().getPitch());

        doc.put("Pos", new BasicDBObject(location));
        playerCollection.insertOne(doc);
    }


    @Override
    public boolean hasPlayedBefore() {
        FindIterable<Document> cursor = playerCollection.find(new Document("uuid", getUniqueId().toString()));
        cursor.cursorType(CursorType.NonTailable);

        Document obj = cursor.first();
        if (obj == null)
            return false;
        return true;
    }

    public void setRank(Rank rank) {
        setInDatabase("rank", rank.toString());
    }

    public void setTSID(int id) {
        setInDatabase("tsid", id);
    }

    public void setCoins(int coins) {
        setInDatabase("coins", coins);
    }

    public void setExperience(int experience) {
        setInDatabase("experience", experience);
    }

    private void setFoundSecrets(ArrayList<String> secrets) {
        setInDatabase("foundSecrets", secrets);
    }

    public void addSecret(String name) {
        ArrayList<String> list = getFoundSecrets();
        list.add(name);
        setFoundSecrets(list);
    }

    private void setFoundEggs(ArrayList<String> eggs) {
        setInDatabase("foundEggs", eggs);
    }

    public void addEgg(String name) {
        ArrayList<String> list = getFoundEggs();
        list.add(name);
        setFoundEggs(list);
    }

    private void setSettings(Map<String, Object> settings) {
        setInDatabase("Settings", settings);
    }

    private void setSetting(String name, java.io.Serializable setting) {
        Map<String, Object> list = getSettings();
        list.put(name, setting);
        setSettings(list);
    }

    public Rank getRank() {
        return Rank.valueOf(getStringFromDatabase("rank"));
    }

    public Date getFirstLogin() {
        return getDateFromDatabase("firstLogin");
    }

    public Date getLastLogin() {
        return getDateFromDatabase("lastLogin");
    }

    public Date getLastOnline() {
        return getDateFromDatabase("lastOnline");
    }

    public String getLastIP() {
        return getStringFromDatabase("lastIP");
    }

    public int getTSID() {
        return getIntegerFromDatabase("tsid");
    }

    private int getTimesJoined() {
        return getIntegerFromDatabase("timesJoined");
    }

    public int getCoins() {
        return getIntegerFromDatabase("coins");
    }

    public int getExperience() {
        return getIntegerFromDatabase("experience");
    }

    public int getSecrets() {
        return getFoundSecrets().size();
    }

    public ArrayList<String> getFoundSecrets() {
        return getArrayListFromDatabase("foundSecrets");
    }

    public int getEggs() {
        return getFoundEggs().size();
    }

    private ArrayList<String> getFoundEggs() {
        return getArrayListFromDatabase("foundEggs");
    }

    private Map<String, Object> getSettings() {
        return getMapFromDatabase("Settings");
    }

    public Location getLastLocation() {
        Map<String, Object> map = getMapFromDatabase("Pos");
        return new Location(Bukkit.getWorld("world"), (double) map.get("X"), (double) map.get("Y"), (double) map.get("Z"), (float) map.get("Yaw"), (float) map.get("Pitch"));
    }

    public String getPlayerVisibility() {
        return (String) getSettings().get("playerVisibility");
    }

    public boolean hasInventoryAnimation() {
        return (boolean) getSettings().get("inventoryAnimation");
    }

    public boolean hasTeleportAnimation() {
        return (boolean) getSettings().get("teleportAnimation");
    }

    public boolean hasPartyRequests() {
        return (boolean) getSettings().get("partyRequests");
    }

    public boolean hasFriendRequests() {
        return (boolean) getSettings().get("friendRequests");
    }

    public boolean hasFriendJump() {
        return (boolean) getSettings().get("friendJump");
    }

    public boolean hasChatSounds() {
        return (boolean) getSettings().get("chatSounds");
    }

    public boolean hasEffects() {
        return (boolean) getSettings().get("effects");
    }

    public boolean hasStoryMode() {
        return (boolean) getSettings().get("storyMode");
    }

    public String getLanguage() {
        return (String) getSettings().get("language");
    }

    public boolean hasTsMove() {
        return (boolean) getSettings().get("tsMove");
    }

    public boolean hasScoreboard() {
        return (boolean) getSettings().get("scoreboard");
    }

    public void setPlayerVisibility(String visibility) {
        setSetting("playerVisibility", visibility);
    }

    public void setInventoryAnimation(boolean animation) {
        setSetting("inventoryAnimation", animation);
    }

    public void setTeleportAnimation(boolean animation) {
        setSetting("teleportAnimation", animation);
    }

    public void setPartyRequests(boolean requests) {
        setSetting("partyRequests", requests);
    }

    public void setFriendRequests(boolean requests) {
        setSetting("friendRequests", requests);
    }

    public void setFriendJump(boolean jump) {
        setSetting("friendJump", jump);
    }

    public void setChatSounds(boolean sounds) {
        setSetting("chatSounds", sounds);
    }

    public void setEffects(boolean effects) {
        setSetting("effects", effects);
    }

    public void setStoryMode(boolean storyMode) {
        setSetting("storyMode", storyMode);
    }

    public void setLanguage(String language) {
        setSetting("language", language);
    }

    public void setTsMove(boolean tsMove) {
        setSetting("tsMove", tsMove);
    }

    public void setScoreboard(boolean scoreboard) {
        setSetting("scoreboard", scoreboard);
    }

    public void connectToServer(String server) {
        Servers.connectServer(PLAYER, server);
    }

    public boolean isAllowed(Rank rank) {
        return getRank().getValue() >= rank.getValue();
    }


    public ArrayList<UUID> getFriends() {
        FindIterable<Document> cursor = friendCollection.find(new Document("uuid", getUniqueId().toString()));
        cursor.cursorType(CursorType.NonTailable);

        Document doc = cursor.first();
        if (doc == null) return null;

        return (ArrayList<UUID>) doc.get("friends");
    }

    private void setFriends(ArrayList<UUID> friends) {
        friendCollection.updateOne(new Document("uuid", getUniqueId().toString()), new Document("$set", new Document("friends", friends)));
    }

    public boolean isFriend(UUID uuid) {
        return getFriends().contains(uuid);
    }

    public void addFriend(UUID uuid) {
        ArrayList<UUID> list = getFriends();
        list.add(uuid);
        setFriends(list);
    }

    public void warn(Hack hack) {
        //TODO: add actual function
    }

    public String getPrefix() {
        if (customPrefix != null) return customPrefix;
        if (isNicked()) return Rank.Premium.getPrefix();
        return getRank().getPrefix();
    }

    public String getSuffix() {
        if (customSuffix != null) return customSuffix;
        if (isNicked()) return Rank.Premium.getSuffix();
        return getRank().getSuffix();
    }

    public String getColor() {
        if (customColor != null) return customColor;
        if (isNicked()) return Rank.Premium.getColor();
        return getRank().getColor();
    }

    public Team getTeam() {
        if (isNicked()) getScoreboard().getTeam(Rank.Premium.getTeam());
        return getScoreboard().getTeam(getRank().getTeam());
    }

    public void setCustomPrefix(String prefix) {
        customPrefix = prefix;
    }

    public void setCustomSuffix(String suffix) {
        customSuffix = suffix;
    }

    public void setCustomColor(String color) {
        customColor = color;
    }

    public boolean hasEmptyInventory() {
        return Utils.hasEmptyInventory(PLAYER);
    }

    public void clearPotionEffects() {
        Utils.clearPotionEffects(PLAYER);
    }

    public boolean hasOpenInventory() {
        return openInventory;
    }


    public void setOpenInventory(boolean openInventory) {
        this.openInventory = openInventory;
    }

    public void addCoins(int coins) {
        setCoins(getCoins() + coins);
    }

    public void substractCoins(int coins) {
        setCoins(getCoins() - coins);
    }


    public void sendActionBar(String text) {
        Actionbar.send(PLAYER, text);
    }

    public void addExperience(int experience) {
        setExperience(getExperience() + experience);
        setExp(0F);
        giveExp(getExperience());
        playSound(getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1.0F, 1.0F);
    }

    public void substractExperience(int experience) {
        setExperience(getExperience() - experience);
        setExp(0F);
        giveExp(getExperience());
    }

    public void refreshExperience() {
        setLevel(0);
        setExp(0F);
        giveExp(getExperience());
    }

    public void playParticle(Location loc, EnumParticle ep, float f, int count) {
        if (hasEffects()) Effects.playEffectToPlayer(PLAYER, loc, ep, f, count);
    }

    public void setAttackSpeed(double speed) {
        AttributeModifier modifier = new AttributeModifier("Core", speed, AttributeModifier.Operation.ADD_NUMBER);
        getAttribute(Attribute.GENERIC_ATTACK_SPEED).addModifier(modifier);
    }

    public double getAttackSpeed() {
        return getAttribute(Attribute.GENERIC_ATTACK_SPEED).getValue();
    }

    public void resetAttackSpeed() {
        AttributeModifier modifier = new AttributeModifier("Core", getAttackSpeed(), AttributeModifier.Operation.ADD_NUMBER);
        getAttribute(Attribute.GENERIC_ATTACK_SPEED).removeModifier(modifier);
        AttributeInstance instance = getAttribute(Attribute.GENERIC_ATTACK_SPEED);
        instance.setBaseValue(16.0D);
    }

    public Messages getMessages() {
        return new Messages(this);
    }

    public String getMessage(String message) {
        return new Language(getLanguage()).getWord(message);
    }

    public boolean isNicked() {
        return (boolean) getSettings().get("nicked");
    }

    public void setNicked(boolean nicked) {
        setSetting("nicked", nicked);
    }

    private void loadSkin(String name) {
        //Skin skin = new Skin(UUIDFetcher.getUUID(name).toString());
        GameProfile skin;
        GameProfile gp = getProfile();
        try {
            skin = GameProfileBuilder.fetch(UUIDFetcher.getUUID(name));
            Collection<Property> properties = skin.getProperties().get("textures");
            gp.getProperties().removeAll("textures");
            gp.getProperties().putAll("textures", properties);
            PacketPlayOutEntityDestroy destroy = new PacketPlayOutEntityDestroy(getEntityId());
            sendPacket(destroy);
            PacketPlayOutPlayerInfo remove = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.REMOVE_PLAYER, getHandle());
            sendPacket(remove);
            setHealth(0.0D);
            new BukkitRunnable() {
                @Override
                public void run() {
                    PacketPlayOutPlayerInfo add = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.ADD_PLAYER, getHandle());
                    sendPacket(add);
                    PacketPlayOutNamedEntitySpawn spawn = new PacketPlayOutNamedEntitySpawn(getHandle());
                    Core.getOnlinePlayers().stream().filter(player -> !player.getName().equals(getName())).forEach(player -> sendPacket(spawn));
                }
            }.runTaskLater(Core.getInstance(), 4);
        } catch (IOException e) {
            e.printStackTrace();
            Core.log(Level.SEVERE, "Mojang Skin Server offline");
            sendMessage("§cSkin Server sind offline");
        }
    }

    public void removeNick() {
        setNick(getName());
    }

    public String getNick() {
        if (nickname != null) return nickname;
        return null;
    }

    public void setNick(String name) {
        setDisplayName(name);
        Field nameField = getField(GameProfile.class, "name");
        try {
            nameField.set(getProfile(), name);
            PacketPlayOutEntityDestroy destroy = new PacketPlayOutEntityDestroy(getEntityId());
            sendPacket(destroy);
            PacketPlayOutPlayerInfo remove = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.REMOVE_PLAYER, getHandle());
            sendPacket(remove);

            new BukkitRunnable() {
                @Override
                public void run() {
                    PacketPlayOutPlayerInfo add = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.ADD_PLAYER, getHandle());
                    sendPacket(add);
                    PacketPlayOutNamedEntitySpawn spawn = new PacketPlayOutNamedEntitySpawn(getHandle());
                    Core.getOnlinePlayers().stream().filter(players -> !players.equals(this)).forEach(players -> players.sendPacket(spawn));
                }
            }.runTaskLater(Core.getInstance(), 4);

            loadSkin(name);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public void strikeLightning(Location loc) {
        World nmsWorld = ((CraftWorld)loc.getWorld()).getHandle();
        EntityLightning lightning = new EntityLightning(nmsWorld, loc.getX(), loc.getY(), loc.getZ(), true);
        sendPacket(new PacketPlayOutSpawnEntityWeather(lightning));
        playSound(loc, Sound.ENTITY_LIGHTNING_IMPACT, 20.0F, 1.0F);
        playSound(loc, Sound.ENTITY_LIGHTNING_THUNDER, 20.0F, 1.0F);
    }

    @Override
    public boolean isOnline() {
        FindIterable<Document> cursor = onlinePlayerCollection.find(new Document("uuid", getUniqueId().toString()));
        cursor.cursorType(CursorType.NonTailable);
        Document doc = cursor.first();
        return doc != null;
    }

    private void setInDatabase(String name, Object obj) {
        playerCollection.updateOne(new Document("uuid", getUniqueId().toString()), new Document("$set", new Document(name, obj)));
    }

    private Object getObjectFromDatbase(String name) {
        FindIterable<Document> cursor = playerCollection.find(new Document("uuid", getUniqueId().toString()));
        cursor.cursorType(CursorType.NonTailable);

        Document doc = cursor.first();
        if (doc == null) return null;

        return doc.get(name);
    }

    private int getIntegerFromDatabase(String name) {
        FindIterable<Document> cursor = playerCollection.find(new Document("uuid", getUniqueId().toString()));
        cursor.cursorType(CursorType.NonTailable);

        Document doc = cursor.first();
        if (doc == null) return 0;

        return doc.getInteger(name);
    }

    private String getStringFromDatabase(String name) {
        FindIterable<Document> cursor = playerCollection.find(new Document("uuid", getUniqueId().toString()));
        cursor.cursorType(CursorType.NonTailable);

        Document doc = cursor.first();
        if (doc == null) return null;

        return doc.getString(name);
    }

    private Date getDateFromDatabase(String name) {
        FindIterable<Document> cursor = playerCollection.find(new Document("uuid", getUniqueId().toString()));
        cursor.cursorType(CursorType.NonTailable);

        Document doc = cursor.first();
        if (doc == null) return null;

        return doc.getDate(name);
    }

    private ArrayList<String> getArrayListFromDatabase(String name) {
        return (ArrayList<String>) getObjectFromDatbase(name);
    }

    private Map<String, Object> getMapFromDatabase(String name) {
        return (Map<String, Object>) getObjectFromDatbase(name);
    }

    public void initScoreboard() {
        Scoreboard board = getScoreboard();
        board.getTeams().forEach(Team::unregister);

        for(Rank rank : Rank.values()) {
            Team team = board.registerNewTeam(rank.getTeam());
            team.setPrefix(rank.getTab());
            team.setOption(Team.Option.NAME_TAG_VISIBILITY, Team.OptionStatus.ALWAYS);
        }
    }

    public void setLabyModFeatures(HashMap<LabyMod, Boolean> list) {
        HashMap<String, Boolean> temp = new HashMap<>();
        for (LabyMod feature : list.keySet())
            temp.put(feature.name(), list.get(feature));

        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        try {
            ObjectOutputStream out = new ObjectOutputStream(byteOut);
            out.writeObject(temp);
            ByteBuf byteBuf = Unpooled.copiedBuffer(byteOut.toByteArray());
            PacketDataSerializer packetDataSerializer = new PacketDataSerializer(byteBuf);
            PacketPlayOutCustomPayload packet = new PacketPlayOutCustomPayload("LABYMOD", packetDataSerializer);
            getHandle().playerConnection.sendPacket(packet);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public void crashClient() {
        sendPacket(new PacketPlayOutExplosion(9999999999D,
                9999999999D, 9999999999D, 9999999999F,
                new ArrayList<>(), new Vec3D(9999999999D,
                9999999999D, 9999999999D)));
    }

    public void sendPacket(Packet<?> packet) {
        getHandle().playerConnection.sendPacket(packet);
    }

    private Field getField(Class<?> clazz, String name) {
        try {
            Field field = clazz.getDeclaredField(name);
            field.setAccessible(true);
            return field;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public void refreshTablist() {
        for (CustomPlayer player : Core.getOnlinePlayers()) {
            setScoreboard(Bukkit.getScoreboardManager().getNewScoreboard());
            getScoreboard().getTeam(player.getTeam().getName()).addEntry(player.getDisplayName());
        }
    }

    public Player.Spigot spigot() {
        return PLAYER.spigot();
    }

}