package nlib;

import agui.gui.ItemBuffer;
import nlib.commands.Executor;
import nlib.gcooldowns.GlobalCooldowns;
import nlib.groups.Group;
import nlib.groups.GroupHash;
import nlib.groups.commands.SetGroupCommand;
import nlib.inventory.EffectExecutorManager;
import nlib.inventory.Inventory;
import nlib.inventory.Item;
import nlib.packets.PacketToServer;
import nlib.packets.commands.*;
import nlib.packets.commands.directions.ToProfile;
import nlib.packets.commands.types.PlayerOnServerCommand;
import nlib.packets.commands.types.profiles.GetPasswordCommand;
import nlib.packets.commands.types.profiles.GetProfileCommand;
import nlib.packets.commands.types.profiles.NoHasRecieverCommand;
import nlib.packets.commands.types.profiles.SendMessageCommand;
import nlib.packets.commands.types.profiles.android.IntentFromAndroidCommand;
import nlib.packets.commands.types.profiles.android.IntentType;
import nlib.packets.commands.types.profiles.android.PingedProfile;
import nlib.packets.commands.types.profiles.friends.FriendAcceptedCommand;
import nlib.packets.commands.types.profiles.friends.FriendDeleteCommand;
import nlib.packets.commands.types.profiles.friends.FriendInviteCommand;
import nlib.packets.friend.Friend;
import nlib.packets.settings.Setting;
import nlib.packets.settings.Settings;
import nlib.profile.Cacheing;
import nlib.profile.MineProfile;
import nlib.profile.SendProfilePacket;
import nlib.utils.Toast;
import nlib.utils.toasts.FriendToast;
import nlib.wallet.Wallet;
import org.bukkit.Bukkit;
import org.bukkit.Color;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import thingbeen.language.LangManager;
import thingbeen.replacer.Replaceable;
import thingbeen.replacer.StaticReplaceable;
import thingbeen.util.unit.units.time.Time;

import javax.persistence.Embeddable;
import javax.persistence.Embedded;
import javax.persistence.Entity;
import javax.persistence.Transient;
import java.io.Serializable;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Arrays;

import static nlib.commands.Executor.color;
import static nlib.commands.Executor.sendPacketToServer;

@Entity
public class Profile implements Serializable, CommandReciever {

    private String name;
    private String uuid;
    private ArrayList<Wallet> wallets = new ArrayList<>();
    private ArrayList<Friend> friends = new ArrayList<>();
    private ArrayList<String> inInvited = new ArrayList<>();//Приглашения входящие
    private ArrayList<String> outInvited = new ArrayList<>();//Приглашения исходящие
    @Transient
    private Settings accountSettings;
    private MineProfile mineProfile;
    private String currentLanguage = "ru";
    private Inventory inventory;
    private GlobalCooldowns globalCooldowns;
    private transient boolean isLoaded = false;//on Arena
    private Cacheing cacheing = Cacheing.FLUSH;
    private GroupHash groupHashing;

    //Android
    private String password = "";
    public static final String NOT_FOUND = "&cЭтот игрок не найден";
    public static final String NOT_ISFRIEND = "&cИгрок не разрешил отправлять себе личные сообщения.";

    public Profile(String name){
        this.name = name;
        construct();
        System.out.println("CREATED PROFILE: "+name);
        //if(getPlayer() != null){
        //    uuid = getPlayer().getUniqueId().toString();
        //}
        groupHashing = new GroupHash(this);;
    }

    public GroupHash getGroupHashing() {
        return groupHashing;
    }

    public void setUUID(String uuid) {
        this.uuid = uuid;
    }

    public String getUUID() {
        return uuid;
    }

    @Override
    public Command onCallback(Command input, CommandInfo from) {
        if(input instanceof PlayerOnServerCommand){
            return new PlayerOnServerCommand.In(Executor.bungee);
        }
        if(input instanceof GetPasswordCommand){
            return new GetPasswordCommand(getPassword());
        }
        if(input instanceof GetProfileCommand){
            return new GetProfileCommand.In(this);
        }
        if(input instanceof SendMessageCommand){
            if(getPlayer() != null){
                sendMessage(((SendMessageCommand) input).getMessage());
            }
        }
        if(input instanceof FriendInviteCommand){
            FriendInviteCommand invite = (FriendInviteCommand)input;
            String who = invite.getWhoInvited();
            //if(!new_checkInvite(who)){
            //    return new FriendInviteCommand.Result(false);
            //}
            new_addInInvited(who);
            return new FriendInviteCommand.Result(true);
        }
        if(input instanceof FriendAcceptedCommand){
            FriendAcceptedCommand in = (FriendAcceptedCommand)input;
            showToast(new FriendToast(getText("friends.msgs.add.accepttoast", new Replaceable() {
                @Override
                public String replace(String s, Player player) {
                    if(s.equals("player")){
                        return in.getWho();
                    }
                    return null;
                }
            })));
            sendMessage(getText("friends.msgs.add.inaccept", new Replaceable() {
                @Override
                public String replace(String s, Player player) {
                    if(s.equals("player")){
                        return in.getWho();
                    }
                    return null;
                }
            }));
            makeFriend(in.getWho());
        }
        if(input instanceof FriendDeleteCommand){
            FriendDeleteCommand in = (FriendDeleteCommand)input;
            removeFriend(in.getWho());
            showToast(new FriendToast(getText("friends.msgs.errors.indeleted", new Replaceable() {
                @Override
                public String replace(String s, Player player) {
                    if(s.equals("player")){
                        return in.getWho();
                    }
                    return null;
                }
            })));
            sendMessage(getText("friends.msgs.errors.indeleted", new Replaceable() {
                @Override
                public String replace(String s, Player player) {
                    if(s.equals("player")){
                        return in.getWho();
                    }
                    return null;
                }
            }));
        }
        if(input instanceof IntentFromAndroidCommand){
            IntentFromAndroidCommand intent = (IntentFromAndroidCommand)input;
            INTENT(intent.getType(), intent.getObjs());
        }
        if(input instanceof PingedProfile.PPCommand){
            return new PingedProfile.PPCommand.Result(new PingedProfile(this));
        }
        if(input instanceof SetGroupCommand){
            SetGroupCommand cmd = (SetGroupCommand)input;
            Group group = Executor.getMe().getGroupManager().getGroup(cmd.getGroupTag());
            if(group != null) {
                getGroupHashing().setGroupAsNew(group);
            }
            return new SetGroupCommand.In();
        }
        return null;
    }

    private void INTENT(IntentType type, ArrayList<String> args){
        switch (type){
            case FRIEND_INVITE:{
                sendMessageByAndroid("Отправление запроса");
                invite(args.get(0));
                break;
            }
        }
    }

    public void showToast(Toast toast){
        if(getPlayer() != null && getPlayer().isOnline()) {
            getMineProfile().showToast(toast.getMaterial(getPlayer()), toast.getMessage(getPlayer()));
        }
    }

    public void sendMessageByAndroid(String msg){
        sendMessage("&c"+getText("android.title", new Replaceable() {
            @Override
            public String replace(String s, Player player) {
                return null;
            }
        })+" &f"+msg);
    }
    //NEW FRIENDS

    public boolean new_checkInvite(String who){
        return !isFriend(who) && !getOutInvited().contains(who) && !getInInvited().contains(who);
    }

    public void new_addInInvited(String who){
        sendMessage(getText("friends.msgs.add.ininvite", new Replaceable() {
            @Override
            public String replace(String s, Player player) {
                if(s.equals("player")){
                    return who;
                }
                return null;
            }
        }));
        showToast(new FriendToast(getText("friends.msgs.add.invitetoast", new Replaceable() {
            @Override
            public String replace(String s, Player player) {
                if(s.equals("player")){
                    return who;
                }
                return null;
            }
        })));
        getInInvited().add(who);
    }

    public String getText(String tag, Replaceable replaceable){
        return LangManager.getStatic(getPlayer(), tag, new StaticReplaceable(getPlayer()){
            @Override
            public String replaceOther(String from, Player p) {
                return replaceable.replace(from, p);
            }
        });
    }

    public void makeFriend(String nick){
        Friend friend = new Friend(nick);
        getOutInvited().remove(nick);
        getInInvited().remove(nick);
        if(!getFriends().contains(friend)) {
            this.getFriends().add(friend);
        }
    }

    public void removeFriend(String who){
        Friend get = getFriend(who);
        getFriends().remove(get);
    }

    public void remove(String who){
        if(isFriend(who)){
            removeFriend(who);
            sendMessageLang("friends.msgs.errors.deleted");
            new CommandReq(new FriendDeleteCommand(getName()), getMyInfo(), new ToProfile(who)){
                @Override
                public void onRecieved(CommandInfo from, Command answer) {
                    if(answer instanceof NoHasRecieverCommand){
                        sendMessageLang("players.nohas");
                    }
                }
            }.send(Executor.serverChannel);
        }else{
            sendMessageLang("friends.msgs.errors.nofriend");
        }
    }

    public void accept(String who){
        if(getInInvited().contains(who)){
            //Если есть в входящих
            getInInvited().remove(who);
            makeFriend(who);
            new CommandReq(new FriendAcceptedCommand(getName()), getMyInfo(), new ToProfile(who)){
                @Override
                public void onRecieved(CommandInfo from, Command answer) {
                    if(answer instanceof NoHasRecieverCommand){
                        sendMessageLang("players.nohas");
                    }
                }
            }.send(Executor.serverChannel);
            sendMessageLang("friends.msgs.add.accept");
        }else{
            sendMessageLang("friends.msgs.errors.notinvited");
        }
    }

    public void sendMessageLang(String key){
        sendMessage(getText(key, new Replaceable() {
            @Override
            public String replace(String s, Player player) {
                return null;
            }
        }));
    }

    public void invite(String who){
        if (getName().equals(who)) {
            sendMessageLang("friends.msgs.errors.invitetome");
            return;
        }
        if(checkAllExpresionsByFriend(who)) {
            new CommandReq(new FriendInviteCommand(getName()), getMyInfo(), new ToProfile(who)) {
                @Override
                public void onRecieved(CommandInfo from, Command answer) {
                    if(answer instanceof NoHasRecieverCommand){
                        sendMessageLang("players.nohas");
                    }
                    if(answer instanceof FriendInviteCommand.Result){
                        FriendInviteCommand.Result res = (FriendInviteCommand.Result)answer;
                        if(res.isSuccess()){
                            sendMessage(getText("friends.msgs.add.invite", new Replaceable() {
                                @Override
                                public String replace(String s, Player player) {
                                    if(s.equals("player")){
                                        return who;
                                    }
                                    return null;
                                }
                            }));
                            getOutInvited().add(who);
                        }else{
                            sendMessageLang("friends.msgs.error");
                        }
                    }
                }
            }.send(Executor.serverChannel);
        }
    }

    //

    @Override
    public CommandInfo getMyInfo() {
        return new ToProfile(getName());
    }

    @Override
    public void sendToServerCommand(Packet packet) {
        Executor.serverChannel.writeAndFlush(packet);
    }

    public boolean comparePassword(String input){
        String SHA = toSHA(input);
        System.out.println("INPUT: "+SHA);
        System.out.println("ORIG: "+password);
        return SHA.equals(password);
    }

    public String toSHA(String input){
        MessageDigest digest = null;
        try {
            digest = MessageDigest.getInstance("SHA-256");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        byte[] encodedhash = digest.digest(
                input.getBytes(StandardCharsets.UTF_8));
        StringBuffer hexString = new StringBuffer();
        for (int i = 0; i < encodedhash.length; i++) {
            String hex = Integer.toHexString(0xff & encodedhash[i]);
            if(hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public void ban(Time time, String by, String reason){
        getGlobalCooldowns().ban(time, by, reason);
        if(getPlayer() != null){
            Executor.kickBan(this);
        }
        for(Player p : Bukkit.getOnlinePlayers()){
            p.sendMessage(color(getGlobalCooldowns().getBan().getFormatForChat(getName())));
        }
        updateCacheing();
    }

    public void unban(String by){
        getGlobalCooldowns().unban(by);
        for(Player p : Bukkit.getOnlinePlayers()){
            p.sendMessage(getGlobalCooldowns().getBan().getFormatUnBan(getName()));
        }
        updateCacheing();
    }

    public boolean needUpdateing(){//Когда нужно обновлять профиль
        return getGlobalCooldowns().needUpdate();
    }

    public boolean needCacheing(){//Когда нужно сохранять в кэше профиль
        return getGlobalCooldowns().needUpdate();
    }

    public void updateCacheing(){
        if(needCacheing()){
            setCache(Cacheing.CACHE);
        }else{
            setCache(Cacheing.FLUSH);
        }
    }

    public void setCache(Cacheing cache){
        this.cacheing = cache;
    }

    public Cacheing getCacheing() {
        return cacheing;
    }

    public void setAccountSettings(Settings accountSettings) {
        this.accountSettings = accountSettings;
        getAccountSettings().setupGUI("&4Настройки аккаунта");
    }

    public void onLoaded(){
        getGroupHashing().setProfile(this);
        if(Commands.getReciever(getMyInfo()) == null) {
            Commands.Subscribe(this);
        }
    }

    public void setLoaded(boolean loaded) {
        isLoaded = loaded;
    }

    public boolean isLoaded() {
        return isLoaded;
    }

    public String getPathInCfg(){
        return "profiles."+getName();
    }

    private void construct(){
        mineProfile = new MineProfile(this);
        inventory = new Inventory(this);
        globalCooldowns = new GlobalCooldowns();
        setupSettings();
        setupWallets();
    }

    public void updateSecondBeat(){
        getGlobalCooldowns().update();
    }

    public GlobalCooldowns getGlobalCooldowns() {
        return globalCooldowns;
    }

    private void setupWallets(){
        Wallet money = new Wallet("money", 0);
        Wallet crystals = new Wallet("crystal", 0);
        this.wallets.add(money);
        this.wallets.add(crystals);
    }

    public Inventory getInventory() {
        return inventory;
    }

    public void onQuit(){
        EffectExecutorManager.current.clearEffects(getMineProfile().getPlayer());
        if(!inMain()){
            Commands.unSubscribe(this);
        }else{
            if(!needUpdateing()){
                Commands.unSubscribe(this);
            }
        }
    }

    public boolean inMain(){
        return Executor.bungee.equals("main");
    }

    public void onJoined(){
        inventory.setOwner(this);
        LangManager.inst.setFor(mineProfile.getPlayer(), currentLanguage);
        //mineProfile.getProfilePermitted().updateMinecraftPerms();
        getAccountSettings().setupGUI("&4Настройки аккаунта");
        clearEffects();
        updateCurrentEffects();
        //getInventory().updateGadgetSlot();
        if(getGlobalCooldowns().banned()){
            Executor.kickBan(this);
        }
        //setFly(true);
    }

    public static void loadColorArmor(Profile p){
        if(p.getPlayer() != null && p.getPlayer().isOnline()) {
            Group current = p.getMyGroup();
            Color dye = current.getColor();
            ItemBuffer chestplate = new ItemBuffer("&cShade.su", Material.LEATHER_CHESTPLATE);
            chestplate.setDyeColor(dye);
            ItemBuffer boots = new ItemBuffer("&cShade.su", Material.LEATHER_BOOTS);
            boots.setDyeColor(dye);
            p.getPlayer().getInventory().setItem(38, chestplate.buildItem());
            p.getPlayer().getInventory().setItem(36, boots.buildItem());
        }
    }

    public void updateCurrentEffects(){
        for(String effect : getInventory().getEffectHash()){
            String[] args = effect.split("-");
            String clas = args[0];
            String tag = args[1];
            Item item = getInventory().getItem("effect", tag);
            if(item instanceof EffectExecutorManager.EffectItemItem){
                ((EffectExecutorManager.EffectItemItem) item).activateEffect();
            }
        }
    }

    public void clearEffects(){
        EffectExecutorManager.current.clearEffects(getMineProfile().getPlayer());
    }

    public Player getPlayer(){
        return getMineProfile().getPlayer();
    }

    public void fly(){
        if(getPlayer() == null)return;
        setFly(!isFly());
    }

    public void setFly(boolean is){
        Player p = getPlayer();
        if(p == null)return;
        if(p.hasPermission("flying")) {
            if (is) {
                p.setAllowFlight(true);
                sendMessage(LangManager.inst.get(getPlayer(), "fly.on"));
            } else {
                p.setAllowFlight(false);
                sendMessage(LangManager.inst.get(getPlayer(), "fly.off"));
            }
        }else{
            p.setAllowFlight(false);
        }
    }

    public boolean isFly(){
        if(getPlayer() == null)return false;
        return getPlayer().getAllowFlight();
    }

    public void setLanugage(String format){
        this.currentLanguage = format;
        if(mineProfile.getPlayer() != null) {
            LangManager.inst.setFor(mineProfile.getPlayer(), currentLanguage);
        }
    }

    public String getCurrentLanguage() {
        return currentLanguage;
    }

    public void onRefreshedInLobby() {//Здесь может быть getPlayer() == null если он вышел с арены descon
        //mineProfile.getProfilePermitted().updateMinecraftPerms();
        getAccountSettings().setupGUI("&4Настройки аккаунта");
        inventory.setOwner(this);
    }

    private void setupSettings(){
        accountSettings = new Settings("&4Настройки аккаунта");
        setupAccountSettings();
    }

    public void setupAccountSettings(){
        Setting particles = new Setting("Частицы эффектов", "particles", Arrays.asList("Дальность прорисовки частиц", "Меняйте в зависимости от мощьности", "вашего пк."), 2);
        particles.newState("10 блоков", "10");
        particles.newState("3 блока", "3");
        particles.newState("8 блоков", "8");
        particles.newState("16 блоков", "16");
        particles.newState("50 блоков", "50");
        getAccountSettings().addSetting(particles);
        Setting tell = new Setting("Отправка личных сообщений", "tell_cmd", Arrays.asList("Кто может отправлять вам, ","личные сообщения?"), 1);
        tell.newState("Все", "all");
        tell.newState("Только друзья", "onlyfriend");
        tell.newState("Никто", "never");
        getAccountSettings().addSetting(tell);
    }

    public Settings getAccountSettings() {
        return accountSettings;
    }

    public void debug(){
        System.out.println("/// PROFILE "+getName()+" ///");
        System.out.println(" - NAME: '"+getName()+"'");
        System.out.println(" - MONEY: ''");
        System.out.println(" - PERKS: '"+perks.size()+"'");
        System.out.println("//////");
    }
    public void addFriend(String name){
        Friend fr = getFriend(name);
        if(fr == null) {
            getFriends().add(new Friend(name));
        }
    }

    public Friend getFriend(String name){
        for(Friend fr : getFriends()){
            if(fr.getName().equals(name)){
                return fr;
            }
        }
        return null;
    }

    public void sendMessage(String s){
        Executor.sendMessage(Executor.getPlayer(this), s);
    }

    public void sendUpdateProfile(){
        sendPacketToServer(new PacketToServer("main", new SendProfilePacket(this)));
    }

    private boolean checkAllExpresionsByFriend(String to){
        if(isFriend(to)){
            sendMessageLang("friends.msgs.errors.alreadyinfriends");
            return false;
        }
        if(getOutInvited().contains(to)) {
            sendMessageLang("friends.msgs.errors.already");
            return false;
        }
        if(getInInvited().contains(to)) {
            sendMessageLang("friends.msgs.errors.youalready");
            return false;
        }
        return true;
    }

    public boolean isFriend(String name){
        return getFriend(name) != null;
    }

    public ArrayList<String> getInInvited() {
        return inInvited;
    }

    public ArrayList<String> getOutInvited() {
        return outInvited;
    }

    public ArrayList<Perk.Instance> getPerks() {
        return perks;
    }

    public ArrayList<Wallet> getWallets() {
        return wallets;
    }

    public ArrayList<Perk.Instance> getPerks(String tag){
        ArrayList<Perk.Instance> insts = new ArrayList<>();
        for(Perk.Instance inst : getPerks()){
            if(inst.getPerk().getMinigameTag().equals(tag)){
                insts.add(inst);
            }
        }
        return insts;
    }

    public String getFullName(){
        return getGroupHashing().getFullPrefix()+getName();
    }

    public Group getMyGroup(){
        return Executor.getMe().getGroupManager().getGroup(getGroupHashing().getCurrentGroup());
    }

    public String getName() {
        return name;
    }

    public ArrayList<Friend> getFriends() {
        return friends;
    }

    public MineProfile getMineProfile() {
        return mineProfile;
    }

    public Wallet getWallet(String tag){
        for(Wallet wl : getWallets()){
            if(wl.getTag().equals(tag)){
                return wl;
            }
        }
        return null;
    }

    public static Profile as(String name){
        return Executor.getMe().getProfile(name);
    }

    public static Profile as(Player p){
        return as(p.getName());
    }

    @Override
    public String toString() {
        return "("+getName()+";STATE "+getCacheing()+" "+getWallets()+" ;FRIND "+getFriends()+";IN "+ getInInvited()+";OUT "+ getOutInvited()+"; HASH "+getInventory().getEffectHash()+")";
    }
}