package hi.guard.mods;

import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.chunk.RenderChunk;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.Vec3i;
import java.util.WeakHashMap;

public class ChunkAnimator {

    public static boolean enabled = true;
    private final ChunkAnimator animationHandler = new ChunkAnimator();
    public static boolean disableAroundPlayer;
    public static int animDuration = 1000;

    private WeakHashMap<RenderChunk, AnimationData> timeStamps = new WeakHashMap<RenderChunk, AnimationData>();

    public void setPosition(RenderChunk rc, BlockPos bp) {
        if (!ChunkAnimator.enabled) return;
        if (Minecraft.getMinecraft().thePlayer != null) {
            boolean flag = true;
            BlockPos zeroedPlayerPosition = Minecraft.getMinecraft().thePlayer.getPosition();
            zeroedPlayerPosition = zeroedPlayerPosition.add(0, -zeroedPlayerPosition.getY(), 0);
            BlockPos zeroedCenteredChunkPos = bp.add(8, -bp.getY(), 8);

            if (ChunkAnimator.disableAroundPlayer) {
                flag = zeroedPlayerPosition.distanceSq(zeroedCenteredChunkPos) > (64 * 64);
            }

            if (flag) {
                EnumFacing chunkFacing = null;

                    Vec3i dif = zeroedPlayerPosition.subtract(zeroedCenteredChunkPos);
                    int difX = Math.abs(dif.getX());
                    int difZ = Math.abs(dif.getZ());
                    chunkFacing = getFacing(dif, difX, difZ);


                AnimationData animationData = new AnimationData(-1L, chunkFacing);
                timeStamps.put(rc, animationData);
            }
        }
    }

    public void preRenderChunk(RenderChunk renderChunk) {
        if (!ChunkAnimator.enabled) return;
        if (timeStamps.containsKey(renderChunk)) {
            AnimationData animationData = timeStamps.get(renderChunk);
            long time = animationData.timeStamp;
            if (time == -1L) {
                time = System.currentTimeMillis();
                animationData.timeStamp = time;

                    BlockPos zeroedPlayerPosition = Minecraft.getMinecraft().thePlayer.getPosition();
                    zeroedPlayerPosition = zeroedPlayerPosition.add(0, -zeroedPlayerPosition.getY(), 0);
                    BlockPos zeroedCenteredChunkPos = renderChunk.getPosition().add(8, -renderChunk.getPosition().getY(), 8);
                    Vec3i dif = zeroedPlayerPosition.subtract(zeroedCenteredChunkPos);
                    int difX = Math.abs(dif.getX());
                    int difZ = Math.abs(dif.getZ());
                    animationData.chunkFacing = getFacing(dif, difX, difZ);

            }
            long timeDif = System.currentTimeMillis() - time;
            int animationDuration = ChunkAnimator.animDuration;
            if (timeDif < animationDuration) {
                double chunkY = renderChunk.getPosition().getY();


            } else {
                timeStamps.remove(renderChunk);
            }
        }
    }

    private EnumFacing getFacing(Vec3i dif, int difX, int difZ) {
        return difX > difZ ? dif.getX() > 0 ? EnumFacing.EAST : EnumFacing.WEST : dif.getZ() > 0 ? EnumFacing.SOUTH : EnumFacing.NORTH;
    }

    private static class AnimationData {
        long timeStamp;
        EnumFacing chunkFacing;

        AnimationData(long timeStamp, EnumFacing chunkFacing) {
            this.timeStamp = timeStamp;
            this.chunkFacing = chunkFacing;
        }
    }
}