package com.boydti.fawe.jnbt.anvil;

import com.boydti.fawe.FaweCache;
import com.boydti.fawe.jnbt.NBTStreamer;
import com.boydti.fawe.object.FaweChunk;
import com.boydti.fawe.object.FaweQueue;
import com.boydti.fawe.object.RunnableVal2;
import com.boydti.fawe.object.io.FastByteArrayOutputStream;
import com.boydti.fawe.object.number.MutableLong;
import com.boydti.fawe.util.ArrayUtil;
import com.boydti.fawe.util.MainUtil;
import com.boydti.fawe.util.MathMan;
import com.boydti.fawe.util.ReflectionUtils;
import com.sk89q.jnbt.CompoundTag;
import com.sk89q.jnbt.IntTag;
import com.sk89q.jnbt.ListTag;
import com.sk89q.jnbt.NBTConstants;
import com.sk89q.jnbt.NBTInputStream;
import com.sk89q.jnbt.NBTOutputStream;
import com.sk89q.jnbt.Tag;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

public class MCAChunk extends FaweChunk<Void> {

//    ids: byte[16][4096]
//    data: byte[16][2048]
//    skylight: byte[16][2048]
//    blocklight: byte[16][2048]
//    entities: Map<Short, CompoundTag>
//    tiles: List<CompoundTag>
//    biomes: byte[256]
//    compressedSize: int
//    modified: boolean
//    deleted: boolean

    public byte[][] ids;
    public byte[][] data;
    public byte[][] skyLight;
    public byte[][] blockLight;
    public byte[] biomes;
    public Map<Short, CompoundTag> tiles = new HashMap<>();
    public Map<UUID, CompoundTag> entities = new HashMap<>();
    private long inhabitedTime;
    private long lastUpdate;
    private int[] heightMap;

    private int modified;
    private boolean deleted;

    public MCAChunk(FaweQueue queue, int x, int z) {
        super(queue, x, z);
        this.ids = new byte[16][];
        this.data = new byte[16][];
        this.skyLight = new byte[16][];
        this.blockLight = new byte[16][];
        this.biomes = new byte[256];
        this.tiles = new HashMap<>();
        this.entities = new HashMap<>();
        this.lastUpdate = System.currentTimeMillis();
        this.heightMap = new int[256];
        this.setModified();
    }

    public MCAChunk(MCAChunk parent, boolean shallow) {
        super(parent.getParent(), parent.getX(), parent.getZ());
        if (shallow) {
            this.ids = parent.ids;
            this.data = parent.data;
            this.skyLight = parent.skyLight;
            this.blockLight = parent.blockLight;
            this.biomes = parent.biomes;
            this.tiles = parent.tiles;
            this.entities = parent.entities;
            this.inhabitedTime = parent.inhabitedTime;
            this.lastUpdate = parent.lastUpdate;
            this.heightMap = parent.heightMap;
            this.modified = parent.modified;
            this.deleted = parent.deleted;
        } else {
            this.ids = (byte[][]) MainUtil.copyNd(parent.ids);
            this.data = (byte[][]) MainUtil.copyNd(parent.data);
            this.skyLight = (byte[][]) MainUtil.copyNd(parent.skyLight);
            this.blockLight = (byte[][]) MainUtil.copyNd(parent.blockLight);
            this.biomes = parent.biomes.clone();
            this.tiles = new HashMap<>(parent.tiles);
            this.entities = new HashMap<>(parent.entities);
            this.inhabitedTime = parent.inhabitedTime;
            this.lastUpdate = parent.lastUpdate;
            this.heightMap = parent.heightMap.clone();
            this.modified = parent.modified;
            this.deleted = parent.deleted;
        }
    }

    public byte[] toBytes(byte[] buffer) throws IOException {
        if (buffer == null) {
            buffer = new byte[8192];
        }
        FastByteArrayOutputStream buffered = new FastByteArrayOutputStream(buffer);
        DataOutputStream dataOut = new DataOutputStream(buffered);
        NBTOutputStream nbtOut = new NBTOutputStream((DataOutput) dataOut);
        nbtOut.writeNamedTagName("", NBTConstants.TYPE_COMPOUND);
        nbtOut.writeLazyCompoundTag("Level", new NBTOutputStream.LazyWrite() {
            @Override
            public void write(NBTOutputStream out) throws IOException {
                out.writeNamedTag("V", (byte) 1);
                out.writeNamedTag("xPos", getX());
                out.writeNamedTag("zPos", getZ());
                out.writeNamedTag("LightPopulated", (byte) 0);
                out.writeNamedTag("TerrainPopulated", (byte) 1);
                if (entities.isEmpty()) {
                    out.writeNamedEmptyList("Entities");
                } else {
                    out.writeNamedTag("Entities", new ListTag(CompoundTag.class, new ArrayList<CompoundTag>(entities.values())));
                }
                if (tiles.isEmpty()) {
                    out.writeNamedEmptyList("TileEntities");
                } else {
                    out.writeNamedTag("TileEntities", new ListTag(CompoundTag.class, new ArrayList<CompoundTag>(tiles.values())));
                }
                out.writeNamedTag("InhabitedTime", inhabitedTime);
                out.writeNamedTag("LastUpdate", lastUpdate);
                if (biomes != null) {
                    out.writeNamedTag("Biomes", biomes);
                }
                out.writeNamedTag("HeightMap", heightMap);
                out.writeNamedTagName("Sections", NBTConstants.TYPE_LIST);
                dataOut.writeByte(NBTConstants.TYPE_COMPOUND);
                int len = 0;
                for (int layer = 0; layer < ids.length; layer++) {
                    if (ids[layer] != null) len++;
                }
                dataOut.writeInt(len);
                for (int layer = 0; layer < ids.length; layer++) {
                    byte[] idLayer = ids[layer];
                    if (idLayer == null) {
                        continue;
                    }
                    out.writeNamedTag("Y", (byte) layer);
                    out.writeNamedTag("BlockLight", blockLight[layer]);
                    out.writeNamedTag("SkyLight", skyLight[layer]);
                    out.writeNamedTag("Blocks", idLayer);
                    out.writeNamedTag("Data", data[layer]);
                    out.writeEndTag();
                }
            }
        });
        nbtOut.writeEndTag();
        nbtOut.close();
        return buffered.toByteArray();
    }

    public long getInhabitedTime() {
        return inhabitedTime;
    }

    public long getLastUpdate() {
        return lastUpdate;
    }

    public void setInhabitedTime(long inhabitedTime) {
        this.inhabitedTime = inhabitedTime;
    }

    public void setLastUpdate(long lastUpdate) {
        this.lastUpdate = lastUpdate;
    }

    public void copyFrom(MCAChunk other, int minX, int maxX, int minY, int maxY, int minZ, int maxZ, int offsetX, int offsetY, int offsetZ) {
        minY = Math.max(-offsetY - minY, minY);
        maxY = Math.min(255 - offsetY, maxY);
        minZ = Math.max(-offsetZ - minZ, minZ);
        maxZ = Math.min(15 - offsetZ, maxZ);
        minX = Math.max(-offsetX - minX, minX);
        maxX = Math.min(15 - offsetX, maxX);
        if (minX > maxX || minZ > maxZ || minY > maxY) return;
        int startLayer = minY >> 4;
        int endLayer = maxY >> 4;
        for (int otherY = minY, thisY = minY + offsetY; otherY <= maxY; otherY++, thisY++) {
            int thisLayer = thisY >> 4;
            int otherLayer = otherY >> 4;
            byte[] thisIds = ids[thisLayer];
            byte[] otherIds = other.ids[otherLayer];
            if (otherIds == null) {
                if (thisIds != null) {
                    int indexY = (thisY & 15) << 8;
                    byte[] thisData = data[thisLayer];
                    byte[] thisSkyLight = skyLight[thisLayer];
                    byte[] thisBlockLight = blockLight[thisLayer];
                    for (int otherZ = minZ, thisZ = minZ + offsetZ; otherZ <= maxZ; otherZ++, thisZ++) {
                        int startIndex = indexY + (thisZ << 4) + minX + offsetX;
                        int endIndex = startIndex + maxX - minX;
                        ArrayUtil.fill(thisIds, startIndex, endIndex + 1, (byte) 0);
                        int startIndexShift = startIndex >> 1;
                        int endIndexShift = endIndex >> 1;
                        if ((startIndex & 1) != 0) {
                            startIndexShift++;
                            setNibble(startIndex, thisData, (byte) 0);
                            setNibble(startIndex, thisSkyLight, (byte) 0);
                            setNibble(startIndex, thisBlockLight, (byte) 0);
                        }
                        if ((endIndex & 1) != 1) {
                            endIndexShift--;
                            setNibble(endIndex, thisData, (byte) 0);
                            setNibble(endIndex, thisSkyLight, (byte) 0);
                            setNibble(endIndex, thisBlockLight, (byte) 0);
                        }
                        ArrayUtil.fill(thisData, startIndexShift, endIndexShift + 1, (byte) 0);
                        ArrayUtil.fill(thisSkyLight, startIndexShift, endIndexShift + 1, (byte) 0);
                        ArrayUtil.fill(thisBlockLight, startIndexShift, endIndexShift + 1, (byte) 0);
                    }
                }
                continue;
            } else if (thisIds == null) {
                ids[thisLayer] = thisIds = new byte[4096];
                data[thisLayer] = new byte[2048];
                skyLight[thisLayer] = new byte[2048];
                blockLight[thisLayer] = new byte[2048];
            }
            int indexY = (thisY & 15) << 8;
            int otherIndexY = (otherY & 15) << 8;
            byte[] thisData = data[thisLayer];
            byte[] thisSkyLight = skyLight[thisLayer];
            byte[] thisBlockLight = blockLight[thisLayer];
            byte[] otherData = other.data[otherLayer];
            byte[] otherSkyLight = other.skyLight[otherLayer];
            byte[] otherBlockLight = other.blockLight[otherLayer];
            for (int otherZ = minZ, thisZ = minZ + offsetZ; otherZ <= maxZ; otherZ++, thisZ++) {
                int startIndex = indexY + (thisZ << 4) + minX + offsetX;
                int endIndex = startIndex + maxX - minX;
                int otherStartIndex = otherIndexY + (otherZ << 4) + minX;
                int otherEndIndex = otherStartIndex + maxX - minX;
                System.arraycopy(otherIds, otherStartIndex, thisIds, startIndex, endIndex - startIndex + 1);
                if ((startIndex & 1) == (otherStartIndex & 1)) {
                    int startIndexShift = startIndex >> 1;
                    int endIndexShift = endIndex >> 1;
                    int otherStartIndexShift = otherStartIndex >> 1;
                    int otherEndIndexShift = otherEndIndex >> 1;
                    if ((startIndex & 1) != 0) {
                        startIndexShift++;
                        otherStartIndexShift++;
                        setNibble(startIndex, thisData, getNibble(otherStartIndex, otherData));
                        setNibble(startIndex, thisSkyLight, getNibble(otherStartIndex, otherSkyLight));
                        setNibble(startIndex, thisBlockLight, getNibble(otherStartIndex, otherBlockLight));
                    }
                    if ((endIndex & 1) != 1) {
                        endIndexShift--;
                        otherEndIndexShift--;
                        setNibble(endIndex, thisData, getNibble(otherEndIndex, otherData));
                        setNibble(endIndex, thisSkyLight, getNibble(otherEndIndex, otherSkyLight));
                        setNibble(endIndex, thisBlockLight, getNibble(otherEndIndex, otherBlockLight));
                    }
                    System.arraycopy(otherData, otherStartIndexShift, thisData, startIndexShift, endIndexShift - startIndexShift + 1);
                    System.arraycopy(otherSkyLight, otherStartIndexShift, thisSkyLight, startIndexShift, endIndexShift - startIndexShift + 1);
                    System.arraycopy(otherBlockLight, otherStartIndexShift, thisBlockLight, startIndexShift, endIndexShift - startIndexShift + 1);
                } else {
                    for (int thisIndex = startIndex, otherIndex = otherStartIndex; thisIndex <= endIndex; thisIndex++, otherIndex++) {
                        setNibble(thisIndex, thisData, getNibble(otherIndex, otherData));
                        setNibble(thisIndex, thisSkyLight, getNibble(otherIndex, otherSkyLight));
                        setNibble(thisIndex, thisBlockLight, getNibble(otherIndex, otherBlockLight));
                    }
                }
            }
        }
        if (!other.tiles.isEmpty()) {
            for (Map.Entry<Short, CompoundTag> entry : other.tiles.entrySet()) {
                int key = entry.getKey();
                int x = MathMan.untripleBlockCoordX(key);
                int y = MathMan.untripleBlockCoordY(key);
                int z = MathMan.untripleBlockCoordZ(key);
                if (x < minX || x > maxX) continue;
                if (z < minZ || z > maxZ) continue;
                if (y < minY || y > maxY) continue;
                x += offsetX;
                y += offsetY;
                z += offsetZ;
                short pair = MathMan.tripleBlockCoord(x, y, z);
                CompoundTag tag = entry.getValue();
                Map<String, Tag> map = ReflectionUtils.getMap(tag.getValue());
                map.put("x", new IntTag(x + (getX() << 4)));
                map.put("y", new IntTag(y));
                map.put("z", new IntTag(z + (getZ() << 4)));
                tiles.put(pair, tag);
            }
        }
    }

    public void copyFrom(MCAChunk other, int minY, int maxY, int offsetY) {
        minY = Math.max(-offsetY - minY, minY);
        maxY = Math.min(255 - offsetY, maxY);
        if (minY > maxY) return;
        if ((offsetY & 15) == 0) {
            int offsetLayer = offsetY >> 4;
            int startLayer = minY >> 4;
            int endLayer = maxY >> 4;
            for (int thisLayer = startLayer + offsetLayer, otherLayer = startLayer; thisLayer <= endLayer; thisLayer++, otherLayer++) {
                byte[] otherIds = other.ids[otherLayer];
                byte[] currentIds = ids[thisLayer];
                int by = otherLayer << 4;
                int ty = by + 15;
                if (by >= minY && ty <= maxY) {
                    if (otherIds != null) {
                        ids[thisLayer] = otherIds;
                        data[thisLayer] = other.data[otherLayer];
                        skyLight[thisLayer] = other.skyLight[otherLayer];
                        blockLight[thisLayer] = other.blockLight[otherLayer];
                    } else {
                        ids[thisLayer] = null;
                    }
                } else {
                    by = Math.max(by, minY) & 15;
                    ty = Math.min(ty, maxY) & 15;
                    int indexStart = by << 8;
                    int indexEnd = 256 + (ty << 8);
                    int indexStartShift = indexStart >> 1;
                    int indexEndShift = indexEnd >> 1;
                    if (otherIds == null) {
                        if (currentIds != null) {
                            ArrayUtil.fill(currentIds, indexStart, indexEnd, (byte) 0);
                            ArrayUtil.fill(data[thisLayer], indexStartShift, indexEndShift, (byte) 0);
                            ArrayUtil.fill(skyLight[thisLayer], indexStartShift, indexEndShift, (byte) 0);
                            ArrayUtil.fill(blockLight[thisLayer], indexStartShift, indexEndShift, (byte) 0);
                        }
                    } else {
                        if (currentIds == null) {
                            currentIds = this.ids[thisLayer] = new byte[4096];
                            this.data[thisLayer] = new byte[2048];
                            this.skyLight[thisLayer] = new byte[2048];
                            this.blockLight[thisLayer] = new byte[2048];
                        }
                        System.arraycopy(other.ids[otherLayer], indexStart, currentIds, indexStart, indexEnd - indexStart);
                        System.arraycopy(other.data[otherLayer], indexStartShift, data[thisLayer], indexStartShift, indexEndShift - indexStartShift);
                        System.arraycopy(other.skyLight[otherLayer], indexStartShift, skyLight[thisLayer], indexStartShift, indexEndShift - indexStartShift);
                        System.arraycopy(other.blockLight[otherLayer], indexStartShift, blockLight[thisLayer], indexStartShift, indexEndShift - indexStartShift);
                    }
                }
            }
        } else {
            for (int otherY = minY, thisY = minY + offsetY; otherY <= maxY; otherY++, thisY++) {
                int otherLayer = otherY >> 4;
                int thisLayer = thisY >> 4;
                byte[] thisIds = this.ids[thisLayer];
                byte[] otherIds = other.ids[otherLayer];
                int thisStartIndex = (thisY & 15) << 8;
                int thisStartIndexShift = thisStartIndex >> 1;
                if (otherIds == null) {
                    if (thisIds == null) {
                        continue;
                    }
                    ArrayUtil.fill(thisIds, thisStartIndex, thisStartIndex + 256, (byte) 0);
                    ArrayUtil.fill(this.data[thisLayer], thisStartIndexShift, thisStartIndexShift + 128, (byte) 0);
                    ArrayUtil.fill(this.skyLight[thisLayer], thisStartIndexShift, thisStartIndexShift + 128, (byte) 0);
                    ArrayUtil.fill(this.blockLight[thisLayer], thisStartIndexShift, thisStartIndexShift + 128, (byte) 0);
                    continue;
                } else if (thisIds == null) {
                    ids[thisLayer] = thisIds = new byte[4096];
                    data[thisLayer] = new byte[2048];
                    skyLight[thisLayer] = new byte[2048];
                    blockLight[thisLayer] = new byte[2048];
                }
                int otherStartIndex = (otherY & 15) << 8;
                int otherStartIndexShift = otherStartIndex >> 1;
                System.arraycopy(other.ids[otherLayer], otherStartIndex, thisIds, thisStartIndex, 256);
                System.arraycopy(other.data[otherLayer], otherStartIndexShift, data[thisLayer], thisStartIndexShift, 128);
                System.arraycopy(other.skyLight[otherLayer], otherStartIndexShift, skyLight[thisLayer], thisStartIndexShift, 128);
                System.arraycopy(other.blockLight[otherLayer], otherStartIndexShift, blockLight[thisLayer], thisStartIndexShift, 128);
            }
        }
        // Copy nbt
        int thisMinY = minY + offsetY;
        int thisMaxY = maxY + offsetY;
        if (!tiles.isEmpty()) {
            Iterator<Map.Entry<Short, CompoundTag>> iter = tiles.entrySet().iterator();
            while (iter.hasNext()) {
                int y = MathMan.untripleBlockCoordY(iter.next().getKey());
                if (y >= thisMinY && y <= thisMaxY) iter.remove();
            }
        }
        if (!other.tiles.isEmpty()) {
            for (Map.Entry<Short, CompoundTag> entry : other.tiles.entrySet()) {
                int key = entry.getKey();
                int y = MathMan.untripleBlockCoordY(key);
                if (y >= minY && y <= maxY) {
                    tiles.put((short) (key + offsetY), entry.getValue());
                }
            }
        }
        if (!other.entities.isEmpty()) {
            for (Map.Entry<UUID, CompoundTag> entry : other.entities.entrySet()) {
                // TODO
            }
        }
    }

    public int getMinLayer() {
        for (int layer = 0; layer < ids.length; layer++) {
            if (ids[layer] != null) {
                return layer;
            }
        }
        return Integer.MAX_VALUE;
    }

    public int getMaxLayer() {
        for (int layer = ids.length - 1; layer >= 0; layer--) {
            if (ids[layer] != null) {
                return layer;
            }
        }
        return Integer.MIN_VALUE;
    }

    /**
     * Deprecated, use the toBytes method
     *
     * @return
     */
    @Deprecated
    public CompoundTag toTag() {
        if (deleted) {
            return null;
        }
        // e.g. by precalculating the length
        HashMap<String, Object> level = new HashMap<String, Object>();
        level.put("Entities", new ListTag(CompoundTag.class, new ArrayList<CompoundTag>(entities.values())));
        level.put("TileEntities", new ListTag(CompoundTag.class, new ArrayList<CompoundTag>(tiles.values())));
        level.put("InhabitedTime", inhabitedTime);
        level.put("LastUpdate", lastUpdate);
        level.put("LightPopulated", (byte) 0);
        level.put("TerrainPopulated", (byte) 1);
        level.put("V", (byte) 1);
        level.put("xPos", getX());
        level.put("zPos", getZ());
        if (biomes != null) {
            level.put("Biomes", biomes);
        }
        level.put("HeightMap", heightMap);
        ArrayList<HashMap<String, Object>> sections = new ArrayList<>();
        for (int layer = 0; layer < ids.length; layer++) {
            byte[] idLayer = ids[layer];
            if (idLayer == null) {
                continue;
            }
            HashMap<String, Object> map = new HashMap<String, Object>();
            map.put("Y", (byte) layer);
            map.put("BlockLight", blockLight[layer]);
            map.put("SkyLight", skyLight[layer]);
            map.put("Blocks", idLayer);
            map.put("Data", data[layer]);
            sections.add(map);
        }
        level.put("Sections", sections);
        HashMap<String, Object> root = new HashMap<>();
        root.put("Level", level);
        return FaweCache.asTag(root);
    }

    public MCAChunk(NBTInputStream nis, FaweQueue parent, int x, int z, int compressedSize) throws IOException {
        super(parent, x, z);
        ids = new byte[16][];
        data = new byte[16][];
        skyLight = new byte[16][];
        blockLight = new byte[16][];
        NBTStreamer streamer = new NBTStreamer(nis);
        streamer.addReader(".Level.InhabitedTime", new RunnableVal2<Integer, Long>() {
            @Override
            public void run(Integer index, Long value) {
                inhabitedTime = value;
            }
        });
        streamer.addReader(".Level.LastUpdate", new RunnableVal2<Integer, Long>() {
            @Override
            public void run(Integer index, Long value) {
                lastUpdate = value;
            }
        });
        streamer.addReader(".Level.Sections.#", new RunnableVal2<Integer, CompoundTag>() {
            @Override
            public void run(Integer index, CompoundTag tag) {
                int layer = tag.getByte("Y");
                ids[layer] = tag.getByteArray("Blocks");
                data[layer] = tag.getByteArray("Data");
                skyLight[layer] = tag.getByteArray("SkyLight");
                blockLight[layer] = tag.getByteArray("BlockLight");
            }
        });
        streamer.addReader(".Level.TileEntities.#", new RunnableVal2<Integer, CompoundTag>() {
            @Override
            public void run(Integer index, CompoundTag tile) {
                int x = tile.getInt("x") & 15;
                int y = tile.getInt("y");
                int z = tile.getInt("z") & 15;
                short pair = MathMan.tripleBlockCoord(x, y, z);
                tiles.put(pair, tile);
            }
        });
        streamer.addReader(".Level.Entities.#", new RunnableVal2<Integer, CompoundTag>() {
            @Override
            public void run(Integer index, CompoundTag entityTag) {
                if (entities == null) {
                    entities = new HashMap<UUID, CompoundTag>();
                }
                long least = entityTag.getLong("UUIDLeast");
                long most = entityTag.getLong("UUIDMost");
                entities.put(new UUID(most, least), entityTag);
            }
        });
        streamer.addReader(".Level.Biomes", new RunnableVal2<Integer, byte[]>() {
            @Override
            public void run(Integer index, byte[] value) {
                biomes = value;
            }
        });
        streamer.addReader(".Level.HeightMap", new RunnableVal2<Integer, int[]>() {
            @Override
            public void run(Integer index, int[] value) {
                heightMap = value;
            }
        });
        streamer.readFully();
    }

    public long filterBlocks(MutableMCABackedBaseBlock mutableBlock, MCAFilter filter) {
        MutableLong result = new MutableLong();
        mutableBlock.setChunk(this);
        int bx = getX() << 4;
        int bz = getZ() << 4;
        int tx = bx + 15;
        int tz = bz + 15;
        for (int layer = 0; layer < ids.length; layer++) {
            if (doesSectionExist(layer)) {
                mutableBlock.setArrays(layer);
                int yStart = layer << 4;
                int yEnd = yStart + 15;
                for (int y = yStart, y0 = (yStart & 15); y <= yEnd; y++, y0++) {
                    int yIndex = ((y0) << 8);
                    mutableBlock.setY(y);
                    for (int z = bz, z0 = bz & 15; z <= tz; z++, z0++) {
                        int zIndex = yIndex + ((z0) << 4);
                        mutableBlock.setZ(z);
                        for (int x = bx, x0 = bx & 15; x <= tx; x++, x0++) {
                            int xIndex = zIndex + x0;
                            mutableBlock.setX(x);
                            mutableBlock.setIndex(xIndex);
                            filter.applyBlock(x, y, z, mutableBlock, result);
                        }
                    }
                }
            }
        }
        return result.get();
    }

    public int[] getHeightMapArray() {
        return heightMap;
    }

    public void setDeleted(boolean deleted) {
        setModified();
        this.deleted = deleted;
    }

    public boolean isDeleted() {
        return deleted;
    }

    public boolean isModified() {
        return modified != 0;
    }

    public int getModified() {
        return modified;
    }

    @Deprecated
    public final void setModified() {
        this.modified++;
    }

    @Override
    public int getBitMask() {
        int bitMask = 0;
        for (int section = 0; section < ids.length; section++) {
            if (ids[section] != null) {
                bitMask += 1 << section;
            }
        }
        return bitMask;
    }

    @Override
    public void setTile(int x, int y, int z, CompoundTag tile) {
        setModified();
        short pair = MathMan.tripleBlockCoord(x, y, z);
        if (tile != null) {
            tiles.put(pair, tile);
        } else {
            tiles.remove(pair);
        }
    }

    @Override
    public void setEntity(CompoundTag entityTag) {
        setModified();
        long least = entityTag.getLong("UUIDLeast");
        long most = entityTag.getLong("UUIDMost");
        entities.put(new UUID(most, least), entityTag);
    }

    @Override
    public void setBiome(int x, int z, byte biome) {
        setModified();
        biomes[x + (z << 4)] = biome;
    }

    @Override
    public Set<CompoundTag> getEntities() {
        return new HashSet<>(entities.values());
    }

    @Override
    public Map<Short, CompoundTag> getTiles() {
        return tiles == null ? new HashMap<Short, CompoundTag>() : tiles;
    }

    @Override
    public CompoundTag getTile(int x, int y, int z) {
        if (tiles == null || tiles.isEmpty()) {
            return null;
        }
        short pair = MathMan.tripleBlockCoord(x, y, z);
        return tiles.get(pair);
    }

    public boolean doesSectionExist(int cy) {
        return ids[cy] != null;
    }

    @Override
    public FaweChunk<Void> copy(boolean shallow) {
        return new MCAChunk(this, shallow);
    }

    @Override
    public int getBlockCombinedId(int x, int y, int z) {
        int layer = y >> 4;
        byte[] idLayer = ids[layer];
        if (idLayer == null) {
            return 0;
        }
        int j = FaweCache.CACHE_J[y][z & 15][x & 15];
        int id = idLayer[j] & 0xFF;
        if (FaweCache.hasData(id)) {
            byte[] dataLayer = data[layer];
            if (dataLayer != null) {
                return (id << 4) + getNibble(j, dataLayer);
            }
        }
        return id << 4;
    }

    @Override
    public byte[] getBiomeArray() {
        return this.biomes;
    }

    @Override
    public Set<UUID> getEntityRemoves() {
        return new HashSet<>();
    }

    public void setSkyLight(int x, int y, int z, int value) {
        setModified();
        int layer = y >> 4;
        byte[] skyLayer = skyLight[layer];
        if (skyLayer == null) {
            return;
        }
        int index = FaweCache.CACHE_J[y][z & 15][x & 15];
        setNibble(index, skyLayer, value);
    }

    public void setBlockLight(int x, int y, int z, int value) {
        setModified();
        int layer = y >> 4;
        byte[] blockLayer = blockLight[layer];
        if (blockLayer == null) {
            return;
        }
        int index = FaweCache.CACHE_J[y][z & 15][x & 15];
        setNibble(index, blockLayer, value);
    }

    public int getSkyLight(int x, int y, int z) {
        int layer = y >> 4;
        byte[] skyLayer = skyLight[layer];
        if (skyLayer == null) {
            return 0;
        }
        int index = FaweCache.CACHE_J[y][z & 15][x & 15];
        return getNibble(index, skyLayer);
    }

    public int getBlockLight(int x, int y, int z) {
        int layer = y >> 4;
        byte[] blockLayer = blockLight[layer];
        if (blockLayer == null) {
            return 0;
        }
        int index = FaweCache.CACHE_J[y][z & 15][x & 15];
        return getNibble(index, blockLayer);
    }

    public void setFullbright() {
        setModified();
        for (byte[] array : skyLight) {
            if (array != null) {
                Arrays.fill(array, (byte) 255);
            }
        }
    }

    public void removeLight() {
        for (int i = 0; i < skyLight.length; i++) {
            removeLight(i);
        }
    }

    public void removeLight(int i) {
        byte[] array1 = skyLight[i];
        if (array1 == null) {
            return;
        }
        byte[] array2 = blockLight[i];
        Arrays.fill(array1, (byte) 0);
        Arrays.fill(array2, (byte) 0);
    }

    public int getNibble(int index, byte[] array) {
        int indexShift = index >> 1;
        if ((index & 1) == 0) {
            return array[indexShift] & 15;
        } else {
            return array[indexShift] >> 4 & 15;
        }
    }

    public void setNibble(int index, byte[] array, int value) {
        int indexShift = index >> 1;
        byte existing = array[indexShift];
        int valueShift = value << 4;
        if (existing == value + valueShift) {
            return;
        }
        if ((index & 1) == 0) {
            array[indexShift] = (byte) (existing & 240 | value);
        } else {
            array[indexShift] = (byte) (existing & 15 | valueShift);
        }
    }

    public void setIdUnsafe(byte[] idsLayer, int index, byte id) {
        idsLayer[index] = id;
    }

    public void setBlockUnsafe(byte[] idsLayer, byte[] dataLayer, int index, byte id, int data) {
        idsLayer[index] = id;
        setNibble(index, dataLayer, data);
    }

    @Override
    public void setBlock(int x, int y, int z, int id, int data) {
        setModified();
        int layer = y >> 4;
        byte[] idsLayer = ids[layer];
        if (idsLayer == null) {
            idsLayer = this.ids[layer] = new byte[4096];
            this.data[layer] = new byte[2048];
            this.skyLight[layer] = new byte[2048];
            this.blockLight[layer] = new byte[2048];
        }
        int j = FaweCache.CACHE_J[y][z & 15][x & 15];
        idsLayer[j] = (byte) id;
        byte[] dataLayer = this.data[layer];
        setNibble(j, dataLayer, data);
    }

    @Override
    public void setBiome(byte biome) {
        Arrays.fill(biomes, biome);
    }

    @Override
    public void removeEntity(UUID uuid) {
        setModified();
        entities.remove(uuid);
    }

    private final boolean idsEqual(byte[] a, byte[] b) {
        // Assumes both are null, or none are (idsEqual - 2d array)
        // Assumes length is 4096
        if (a == b) return true;
        for (char i = 0; i < 4096; i++) {
            if (a[i] != b[i]) return false;
        }
        return true;
    }

    private final boolean idsEqual(byte[][] a, byte[][] b, boolean matchNullToAir) {
        // Assumes length is 16
        for (byte i = 0; i < 16; i++) {
            if ((a[i] == null) != (b[i] == null)) {
                if (matchNullToAir) {
                    if (b[i] != null) {
                        for (byte c : b[i]) {
                            if (c != 0) return false;
                        }
                    } else if (a[i] != null) {
                        for (byte c : a[i]) {
                            if (c != 0) return false;
                        }
                    }
                }
                return false;
            }
        }
        // Check the chunks close to the ground first
        for (byte i = 4; i < 8; i++) {
            if (!idsEqual(a[i], b[i])) return false;
        }
        for (byte i = 3; i >= 0; i--) {
            if (!idsEqual(a[i], b[i])) return false;
        }
        for (byte i = 8; i < 16; i++) {
            if (!idsEqual(a[i], b[i])) return false;
        }
        return true;
    }

    /**
     * Check if the ids match the ids in the other chunk
     * @param other
     * @param matchNullToAir
     * @return
     */
    public boolean idsEqual(MCAChunk other, boolean matchNullToAir) {
        return idsEqual(other.ids, this.ids, matchNullToAir);
    }

    @Override
    public Void getChunk() {
        throw new UnsupportedOperationException("Not applicable for this");
    }

    @Override
    public FaweChunk call() {
        throw new UnsupportedOperationException("Not supported");
    }
}