import com.google.common.collect.AbstractIterator;

import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3i;

import static java.lang.Math.max;
import static java.lang.Math.min;

class ScalingLerpIBuilderIterator extends AbstractIterator<IBuilder.IEntry> {
    private final int minX;
    private final int minY;
    private final int minZ;
    private final int maxX;
    private final int maxY;
    private final int maxZ;

    private final double xStep;
    private final double yStep;
    private final double zStep;

    private final int minGridX;
    private final int minGridY;
    private final int minGridZ;
    private final int maxGridX;
    private final int maxGridY;
    private final int maxGridZ;
    private final int scaleX;
    private final int scaleY;
    private final int scaleZ;

    private final IBuilder builder;

    private int nextGridX;
    private int nextGridY;
    private int nextGridZ;

    private int nextRelX;
    private int nextRelY;
    private int nextRelZ;

    private double v000, v001, v010, v011, v100, v101, v110, v111;
    private double vx00, vx01, vx10, vx11;
    private double vxy0, vxy1;
    private double vxyz;

    private double dx00, dx01, dx10, dx11;
    private double dxy0, dxy1;
    private double dxyz;

    ScalingLerpIBuilderIterator(IBuilder builder, Vec3i start, Vec3i end, int scaleX, int scaleY, int scaleZ) {
        this.builder = builder;
        this.scaleX = scaleX;
        this.scaleY = scaleY;
        this.scaleZ = scaleZ;

        minX = min(start.getX(), end.getX());
        minY = min(start.getY(), end.getY());
        minZ = min(start.getZ(), end.getZ());
        maxX = max(start.getX(), end.getX());
        maxY = max(start.getY(), end.getY());
        maxZ = max(start.getZ(), end.getZ());

        minGridX = MathHelper.intFloorDiv(minX, scaleX);
        minGridY = MathHelper.intFloorDiv(minY, scaleY);
        minGridZ = MathHelper.intFloorDiv(minZ, scaleZ);
        maxGridX = MathHelper.intFloorDiv(minX, scaleX);
        maxGridY = MathHelper.intFloorDiv(minY, scaleY);
        maxGridZ = MathHelper.intFloorDiv(minZ, scaleZ);

        nextGridX = minGridX;
        nextGridY = minGridY;
        nextGridZ = minGridZ;

        xStep = 1.0/scaleX;
        yStep = 1.0/scaleY;
        zStep = 1.0/scaleZ;

        nextRelX = 0;
        nextRelY = 0;
        nextRelZ = 0;
    }

    @Override public IBuilder.IEntry computeNext() {
        // if everything is out of bounds...
        if (global(nextGridX, scaleX, nextRelX) > maxX &&
            global(nextGridY, scaleY, nextRelY) > maxY &&
            global(nextGridZ, scaleZ, nextRelZ) > maxZ) {
            return null;
        }
        vxyz += dxyz;
        if (nextRelZ == 0) {
            assert nextRelX == 0 && nextRelY == 0;
            recalculateLerpZ();
        }
        if (nextRelY == 0) {
            assert nextRelX == 0;
            recalculateLerpY();
        }
        if (nextRelX == 0) {
            updateCorners();
            recalculateLerpX();
        }

        IBuilder.IEntry entry = new IBuilder.ImmutbleEntry(
            global(nextGridX, scaleX, nextRelX),
            global(nextGridY, scaleY, nextRelY),
            global(nextGridZ, scaleZ, nextRelZ),
            vxyz
        );

        incrementPos();
        return entry;
    }

    private void updateCorners() {
        // get corners
        v000 = builder.get(nextGridX, nextGridY, nextGridZ);
        v001 = builder.get(nextGridX, nextGridY, nextGridZ + 1);
        v010 = builder.get(nextGridX, nextGridY + 1, nextGridZ);
        v011 = builder.get(nextGridX, nextGridY + 1, nextGridZ + 1);
        v100 = builder.get(nextGridX + 1, nextGridY, nextGridZ);
        v101 = builder.get(nextGridX + 1, nextGridY, nextGridZ + 1);
        v110 = builder.get(nextGridX + 1, nextGridY + 1, nextGridZ);
        v111 = builder.get(nextGridX + 1, nextGridY + 1, nextGridZ + 1);
    }

    private void recalculateLerpX() {
        nextRelX = boundClampRelPosMin(nextGridX, scaleX, minX);
        // step 1
        dx00 = (v100 - v000)*xStep;
        dx01 = (v101 - v001)*xStep;
        dx10 = (v110 - v010)*xStep;
        dx11 = (v111 - v011)*xStep;

        vx00 = v000 + dx00*nextRelX;
        vx01 = v001 + dx01*nextRelX;
        vx10 = v010 + dx10*nextRelX;
        vx11 = v011 + dx11*nextRelX;
    }

    private void recalculateLerpY() {
        nextRelY = boundClampRelPosMin(nextGridY, scaleY, minY);
        // step 2
        dxy0 = (vx10 - vx00)*yStep;
        dxy1 = (vx11 - vx01)*yStep;

        vxy0 = vx00 + dxy0*nextRelY;
        vxy1 = vx01 + dxy1*nextRelY;
    }

    private void recalculateLerpZ() {
        nextRelZ = boundClampRelPosMin(nextGridZ, scaleZ, minZ);
        // step 3
        dxyz = (vxy1 - vxy0)*zStep;

        vxyz = vxy0 + dxyz*nextRelZ;
    }

    private void incrementPos() {
        nextRelZ++;
        if (nextRelZ > scaleZ || global(nextGridX, scaleX, nextRelX) > maxX) {
            nextRelZ = 0;
            nextRelY++;
            if (nextRelY > scaleY || global(nextGridY, scaleY, nextRelY) > maxY) {
                nextRelY = 0;
                nextRelX++;
                if (nextRelX > scaleY || global(nextGridY, scaleY, nextRelY) > maxY) {
                    nextRelX = 0;
                    incrementGridPos();
                }
            }
        }
    }

    private void incrementGridPos() {
        nextGridX++;
        if (nextGridX > maxGridX) {
            nextGridX = 0;
            nextGridY++;
            if (nextGridY > maxGridY) {
                nextGridY = 0;
                nextGridZ++;
            }
        }
    }

    private static int boundClampRelPosMin(int gridPos, int scale, int minPos) {
        int globPos = gridPos*scale;//+localPos
        if (globPos < minPos) {
            return minPos - globPos;
        }
        return gridPos;
    }

    private static int global(int gridPos, int scale, int relPos) {
        return gridPos*scale + relPos;
    }
}