package noppes.npcs.controllers.data;

import net.minecraft.nbt.NBTTagCompound;
import noppes.npcs.NBTTags;
import noppes.npcs.constants.EnumAnimation;
import noppes.npcs.constants.EnumJobType;
import noppes.npcs.constants.EnumRoleType;
import noppes.npcs.entity.EntityCustomNpc;
import noppes.npcs.entity.EntityNPCInterface;

import java.util.Set;

public class DataTransform {
    public NBTTagCompound display;
    public NBTTagCompound ai;
    public NBTTagCompound advanced;
    public NBTTagCompound inv;
    public NBTTagCompound stats;
    public NBTTagCompound role;
    public NBTTagCompound job;

    public boolean hasDisplay, hasAi, hasAdvanced, hasInv, hasStats, hasRole, hasJob, isActive;

    private EntityNPCInterface npc;

    public boolean editingModus = false;

    public DataTransform(EntityNPCInterface npc) {
        this.npc = npc;
    }


    public NBTTagCompound writeToNBT(NBTTagCompound compound) {
        compound.setBoolean("TransformIsActive", isActive);
        writeOptions(compound);
        if (hasDisplay)
            compound.setTag("TransformDisplay", display);
        if (hasAi)
            compound.setTag("TransformAI", ai);
        if (hasAdvanced)
            compound.setTag("TransformAdvanced", advanced);
        if (hasInv)
            compound.setTag("TransformInv", inv);
        if (hasStats)
            compound.setTag("TransformStats", stats);
        if (hasRole)
            compound.setTag("TransformRole", role);
        if (hasJob)
            compound.setTag("TransformJob", job);

        return compound;
    }

    public NBTTagCompound writeOptions(NBTTagCompound compound) {
        compound.setBoolean("TransformHasDisplay", hasDisplay);
        compound.setBoolean("TransformHasAI", hasAi);
        compound.setBoolean("TransformHasAdvanced", hasAdvanced);
        compound.setBoolean("TransformHasInv", hasInv);
        compound.setBoolean("TransformHasStats", hasStats);
        compound.setBoolean("TransformHasRole", hasRole);
        compound.setBoolean("TransformHasJob", hasJob);
        compound.setBoolean("TransformEditingModus", editingModus);
        return compound;
    }


    public void readToNBT(NBTTagCompound compound) {
        isActive = compound.getBoolean("TransformIsActive");
        readOptions(compound);
        display = hasDisplay ? compound.getCompoundTag("TransformDisplay") : getDisplay();
        ai = hasAi ? compound.getCompoundTag("TransformAI") : npc.ais.writeToNBT(new NBTTagCompound());
        advanced = hasAdvanced ? compound.getCompoundTag("TransformAdvanced") : getAdvanced();
        inv = hasInv ? compound.getCompoundTag("TransformInv") : npc.inventory.writeEntityToNBT(new NBTTagCompound());
        stats = hasStats ? compound.getCompoundTag("TransformStats") : npc.stats.writeToNBT(new NBTTagCompound());
        job = hasJob ? compound.getCompoundTag("TransformJob") : getJob();
        role = hasRole ? compound.getCompoundTag("TransformRole") : getRole();
    }

    public NBTTagCompound getJob() {
        NBTTagCompound compound = new NBTTagCompound();

        compound.setInteger("NpcJob", npc.advanced.job.ordinal());
        if (npc.advanced.job != EnumJobType.None && npc.jobInterface != null) {
            npc.jobInterface.writeToNBT(compound);
        }

        return compound;
    }

    public NBTTagCompound getRole() {
        NBTTagCompound compound = new NBTTagCompound();

        compound.setInteger("Role", npc.advanced.role.ordinal());
        if (npc.advanced.role != EnumRoleType.None && npc.roleInterface != null) {
            npc.roleInterface.writeToNBT(compound);
        }

        return compound;
    }

    public NBTTagCompound getDisplay() {
        NBTTagCompound compound = npc.display.writeToNBT(new NBTTagCompound());
        if (npc instanceof EntityCustomNpc) {
            compound.setTag("ModelData", ((EntityCustomNpc) npc).modelData.writeToNBT());
        }

        return compound;
    }

    public NBTTagCompound getAdvanced() {
        EnumJobType jopType = npc.advanced.job;
        EnumRoleType roleType = npc.advanced.role;

        npc.advanced.job = EnumJobType.None;
        npc.advanced.role = EnumRoleType.None;

        NBTTagCompound compound = npc.advanced.writeToNBT(new NBTTagCompound());
        compound.removeTag("Role");
        compound.removeTag("NpcJob");

        npc.advanced.job = jopType;
        npc.advanced.role = roleType;

        return compound;
    }


    public void readOptions(NBTTagCompound compound) {
        boolean hadDisplay = hasDisplay;
        boolean hadAI = hasAi;
        boolean hadAdvanced = hasAdvanced;
        boolean hadInv = hasInv;
        boolean hadStats = hasStats;
        boolean hadRole = hasRole;
        boolean hadJob = hasJob;

        hasDisplay = compound.getBoolean("TransformHasDisplay");
        hasAi = compound.getBoolean("TransformHasAI");
        hasAdvanced = compound.getBoolean("TransformHasAdvanced");
        hasInv = compound.getBoolean("TransformHasInv");
        hasStats = compound.getBoolean("TransformHasStats");
        hasRole = compound.getBoolean("TransformHasRole");
        hasJob = compound.getBoolean("TransformHasJob");
        editingModus = compound.getBoolean("TransformEditingModus");

        if (hasDisplay && !hadDisplay) {
            display = getDisplay();
        }
        if (hasAi && !hadAI)
            ai = npc.ais.writeToNBT(new NBTTagCompound());
        if (hasStats && !hadStats)
            stats = npc.stats.writeToNBT(new NBTTagCompound());
        if (hasInv && !hadInv)
            inv = npc.inventory.writeEntityToNBT(new NBTTagCompound());
        if (hasAdvanced && !hadAdvanced)
            advanced = getAdvanced();
        if (hasJob && !hadJob)
            job = getJob();
        if (hasRole && !hadRole)
            role = getRole();
    }

    public boolean isValid() {
        return hasAdvanced || hasAi || hasDisplay || hasInv || hasStats || hasJob || hasRole;
    }


    public NBTTagCompound processAdvanced(NBTTagCompound compoundAdv,
                                          NBTTagCompound compoundRole, NBTTagCompound compoundJob) {

        if (hasAdvanced)
            compoundAdv = advanced;
        if (hasRole)
            compoundRole = role;
        if (hasJob)
            compoundJob = job;

        Set<String> names = compoundRole.func_150296_c();
        for (String name : names)
            compoundAdv.setTag(name, compoundRole.getTag(name));

        names = compoundJob.func_150296_c();
        for (String name : names)
            compoundAdv.setTag(name, compoundJob.getTag(name));

        return compoundAdv;
    }

    public void transform(boolean isActive) {
        if (this.isActive == isActive)
            return;
        if (hasDisplay) {
            NBTTagCompound compound = getDisplay();
            npc.display.readToNBT(NBTTags.NBTMerge(compound, display));
            if (npc instanceof EntityCustomNpc) {
                ((EntityCustomNpc) npc).modelData.readFromNBT(NBTTags.NBTMerge(compound.getCompoundTag("ModelData"), display.getCompoundTag("ModelData")));
            }
            display = compound;
        }
        if (hasStats) {
            NBTTagCompound compound = npc.stats.writeToNBT(new NBTTagCompound());
            npc.stats.readToNBT(NBTTags.NBTMerge(compound, stats));
            stats = compound;
        }
        if (hasAdvanced || hasJob || hasRole) {
            NBTTagCompound compoundAdv = getAdvanced();
            NBTTagCompound compoundRole = getRole();
            NBTTagCompound compoundJob = getJob();

            NBTTagCompound compound = processAdvanced(compoundAdv, compoundRole, compoundJob);
            npc.advanced.readToNBT(compound);
            if (npc.advanced.role != EnumRoleType.None && npc.roleInterface != null)
                npc.roleInterface.readFromNBT(NBTTags.NBTMerge(compoundRole, compound));
            if (npc.advanced.job != EnumJobType.None && npc.jobInterface != null)
                npc.jobInterface.readFromNBT(NBTTags.NBTMerge(compoundJob, compound));

            if (hasAdvanced)
                advanced = compoundAdv;
            if (hasRole)
                role = compoundRole;
            if (hasJob)
                job = compoundJob;
        }
        if (hasAi) {
            NBTTagCompound compound = npc.ais.writeToNBT(new NBTTagCompound());
            npc.ais.readToNBT(NBTTags.NBTMerge(compound, ai));
            ai = compound;
            npc.setCurrentAnimation(EnumAnimation.NONE);
        }
        if (hasInv) {
            NBTTagCompound compound = npc.inventory.writeEntityToNBT(new NBTTagCompound());
            npc.inventory.readEntityFromNBT(NBTTags.NBTMerge(compound, inv));
            inv = compound;
        }
        npc.updateHitbox();
        npc.updateAI = true;
        this.isActive = isActive;
        npc.updateClient = true;
    }
}