package me.pascal.hook.util;

import me.pascal.hook.Hook;
import me.pascal.hook.module.modules.ESP;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityOtherPlayerMP;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.entity.Entity;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.monster.EntityMob;
import net.minecraft.entity.passive.EntityAnimal;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.math.AxisAlignedBB;
import net.minecraft.util.math.Vec3d;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.GLU;

import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.*;

/**
 * Created by Pascal on 19.02.2017.
 */
public class ScreenPosUtil {
    private static Minecraft mc;
    private static Map<Entity, Vec3d[]> entity2DBounding;


    public static void captureEntity2DBounding() {
        if (entity2DBounding == null) {
            entity2DBounding = new HashMap<Entity, Vec3d[]>();
        }
        if (mc == null) {
            mc = Minecraft.getMinecraft();
        }
        try {
            entity2DBounding.clear();
            List<Entity> sortedList = new ArrayList();

            for (Entity e : mc.world.loadedEntityList) {
                if (valid(e))
                    sortedList.add(e);
            }
            for(Entity entity : sortedList){
                if (entity instanceof EntityPlayerSP) continue;
                Vec3d pos = getEntityRenderPos(entity);
                double x = pos.xCoord;
                double y = pos.yCoord;
                double z = pos.zCoord;
                double entityHeight = entity.height;
                AxisAlignedBB bb = entity.boundingBox;
                double maxX = (bb.maxX - bb.minX) / 2;
                double maxY = (bb.maxY - bb.minY) / 2;
                double maxZ = (bb.maxZ - bb.minZ) / 2;
                double[][] bbox
                        = {
                        {x + maxX, y + maxY + maxY, z + maxZ},
                        {x - maxX, y - maxY + maxY, z + maxZ},
                        {x - maxX, y + maxY + maxY, z + maxZ},
                        {x + maxX, y - maxY + maxY, z + maxZ},
                        {x + maxX, y + maxY + maxY, z - maxZ},
                        {x - maxX, y - maxY + maxY, z - maxZ},
                        {x - maxX, y + maxY + maxY, z - maxZ},
                        {x + maxX, y - maxY + maxY, z - maxZ},
                        {x, y + entityHeight / 2, z},//BB middlepos
                        {x, y + entityHeight, z},//boudingbox end
                        {x, y + entityHeight + 0.9, z}//Nametagpos
                };
                Vec3d[] corners = new Vec3d[bbox.length];
                for (int j = 0; j < corners.length && (entity instanceof EntityPlayer || j <= 7); ++j) {
                    Vec3d vec = getScreenCoords(bbox[j][0], bbox[j][1], bbox[j][2]);
                    if (vec == null) continue;
                    corners[j] = vec;
                }
                entity2DBounding.put(entity, corners);
            }

            return;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static boolean valid(Entity ent) {
        ESP esp = (ESP) Hook.getInstance().getModuleManager().getModuleByName("ESP");

        if (ent instanceof EntityMob && esp.mobs.getValue()) {
            return true;
        } else if (ent instanceof EntityAnimal && esp.animals.getValue()) {
            return true;
        } else if (ent instanceof EntityItem && esp.items.getValue()) {
            return true;
        } else if (ent instanceof EntityOtherPlayerMP && esp.players.getValue()) {
            return true;
        }

        return false;
    }

    public static Vec3d getEntityRenderPos(final Entity player) {
        final double x = player.lastTickPosX + (player.posX - player.lastTickPosX) * mc.timer.renderPartialTicks
                - mc.getRenderManager().renderPosX;
        double y = player.lastTickPosY + (player.posY - player.lastTickPosY) * mc.timer.renderPartialTicks
                - mc.getRenderManager().renderPosY;
        final double z = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * mc.timer.renderPartialTicks
                - mc.getRenderManager().renderPosZ;
        return new Vec3d(x, y, z);
    }

    public static Vec3d getScreenCoords(final double x, final double y, final double z) {
        final FloatBuffer screenCoordinates = BufferUtils.createFloatBuffer(3);
        final IntBuffer viewport = BufferUtils.createIntBuffer(16);
        final FloatBuffer modelView = BufferUtils.createFloatBuffer(16);
        final FloatBuffer projection = BufferUtils.createFloatBuffer(16);
        GL11.glGetFloat(2982, modelView);
        GL11.glGetFloat(2983, projection);
        GL11.glGetInteger(2978, viewport);
        final boolean result = GLU.gluProject((float) x, (float) y, (float) z, modelView, projection, viewport,
                screenCoordinates);
        if (result) {
            return new Vec3d(screenCoordinates.get(0), Display.getHeight() - screenCoordinates.get(1), screenCoordinates.get(2));
        }
        return null;
    }

    public static Map getScreenPoses() {
        return ScreenPosUtil.entity2DBounding;
    }

}