package cubicchunks.util;

import net.minecraft.util.math.BlockPos;

public class LightUpdateQueue {
    /**
     * Enables additional error checks
     */
    private static final boolean DEBUG = true;

    private static final int QUEUE_PART_SIZE = 64*1024;
    private static final int POS_BITS = 8;
    private static final int POS_X_OFFSET = POS_BITS*0;
    private static final int POS_Y_OFFSET = POS_BITS*1;
    private static final int POS_Z_OFFSET = POS_BITS*2;

    private static final int VALUE_BITS = 8;
    private static final int VALUE_OFFSET = POS_BITS*3;
    //note: position is signed
    public static final int MIN_POS = Bits.getMinSigned(POS_BITS);
    public static final int MAX_POS = Bits.getMaxSigned(POS_BITS);
    //note: value is unsigned
    public static final int MIN_VALUE = 0;
    public static final int MAX_VALUE = Bits.getMaxUnsigned(VALUE_BITS);

    private ArrayQueueSegment start = new ArrayQueueSegment(QUEUE_PART_SIZE);
    private ArrayQueueSegment currentReadQueue;
    private ArrayQueueSegment currentWriteQueue;
    /**
     * Index of the next previously read entry from current queue array
     */
    private int currentReadIndex;
    /**
     * Index of the next entry to write to in current queue array
     */
    private int nextWriteIndex;
    private int centerX;
    private int centerY;
    private int centerZ;

    //the read data:
    private int readValue;
    private int readX;
    private int readY;
    private int readZ;

    public void begin(BlockPos pos) {
        begin(pos.getX(), pos.getY(), pos.getZ());
    }

    public void begin(int centerX, int centerY, int centerZ) {
        if (currentReadQueue != null) {
            throw new IllegalStateException("Called begin() in unclean state! Did you forget to call end()?");
        }
        this.currentReadQueue = start;
        this.currentWriteQueue = start;
        this.currentReadIndex = -1;//start at -1 so that next read is at 0
        this.nextWriteIndex = 0;
        this.centerX = centerX;
        this.centerY = centerY;
        this.centerZ = centerZ;
    }

    public void put(BlockPos pos, int value) {
        put(pos.getX(), pos.getY(), pos.getZ(), value);
    }

    public void put(int x, int y, int z, int value) {
        x -= this.centerX;
        y -= this.centerY;
        z -= this.centerZ;
        if (DEBUG) {
            if (x < MIN_POS || x > MAX_POS || y < MIN_POS || y > MAX_POS || z < MIN_POS || z > MAX_POS) {
                throw new IndexOutOfBoundsException("Position is out of bounds: (" +
                    (x + centerX) + ", " + (y + centerY) + ", " + (z + centerZ) + "), minPos is: (" +
                    (centerX + MIN_POS) + ", " + (centerY + MIN_POS) + ", " + (centerZ + MIN_POS) + "), maxPos is: (" +
                    (centerX + MAX_POS) + ", " + (centerY + MAX_POS) + ", " + (centerZ + MAX_POS) + ")");
            }
            if (value < MIN_VALUE || value > MAX_VALUE) {
                throw new RuntimeException("Value is out of bounds: " + value +
                    ", minValue is: " + MIN_VALUE + ", maxValue is: " + MAX_VALUE);
            }
        }
        int packed = Bits.packSignedToInt(x, POS_BITS, POS_X_OFFSET) |
            Bits.packSignedToInt(y, POS_BITS, POS_Y_OFFSET) |
            Bits.packSignedToInt(z, POS_BITS, POS_Z_OFFSET) |
            Bits.packSignedToInt(value, VALUE_BITS, VALUE_OFFSET);
        this.putPacked(packed);
    }

    private void putPacked(int packedValue) {
        currentWriteQueue.data[nextWriteIndex] = packedValue;
        nextWriteIndex++;
        //switch to next queue array?
        if (nextWriteIndex >= QUEUE_PART_SIZE) {
            nextWriteIndex = 0;
            if (currentWriteQueue.next == null) {
                currentWriteQueue.next = new ArrayQueueSegment(QUEUE_PART_SIZE);
            }
            currentWriteQueue = currentWriteQueue.next;
        }
    }

    public int getValue() {
        return readValue;
    }

    public int getX() {
        return readX;
    }

    public int getY() {
        return readY;
    }

    public int getZ() {
        return readZ;
    }

    public BlockPos getPos() {
        return new BlockPos(readX, readY, readZ);
    }

    /**
     * This should be called before reading set of values using getNext*
     *
     * @return true if there is next value, false otherwise
     */
    public boolean next() {
        currentReadIndex++;
        if(currentReadIndex >= QUEUE_PART_SIZE) {
            if(currentReadQueue.next == null) {
                return false;
            }
            currentReadQueue = currentReadQueue.next;
            currentReadIndex = 0;
        }
        if(currentReadQueue == currentWriteQueue && currentReadIndex >= nextWriteIndex) {
            return false;
        }
        int packed = currentReadQueue.data[currentReadIndex];

        readX = centerX + Bits.unpackSigned(packed, POS_BITS, POS_X_OFFSET);
        readY = centerY + Bits.unpackSigned(packed, POS_BITS, POS_Y_OFFSET);
        readZ = centerZ + Bits.unpackSigned(packed, POS_BITS, POS_Z_OFFSET);
        readValue = Bits.unpackUnsigned(packed, VALUE_BITS, VALUE_OFFSET);
        return true;
    }

    public void end() {
        if (currentReadQueue == null) {
            throw new IllegalStateException("Called end() without corresponding begin()!");
        }
        this.currentReadQueue = null;
        this.currentWriteQueue = null;
        this.currentReadIndex = 0;
        this.nextWriteIndex = 0;
        this.centerX = Integer.MAX_VALUE;
        this.centerY = Integer.MAX_VALUE;
        this.centerZ = Integer.MAX_VALUE;
    }

    private static class ArrayQueueSegment {
        private int[] data;
        private ArrayQueueSegment next;

        public ArrayQueueSegment(int initSize) {
            data = new int[initSize];
        }
    }
}