#pragma once

#include <Array.h>
#include <Datei.h>
#include <Either.h>
#include <Punkt.h>
#include <Vec3.h>

#include "Block.h"
#include "Constants.h"
#include "DoLaterHandler.h"
#include "Entity.h"
#include "InformationObserver.h"
#include "Tickable.h"

class ChunkMap;

class Chunk : public virtual Framework::ReferenceCounter,
              public Tickable
{
private:
    int dimensionId;
    Framework::Punkt location;
    Block*** blocks;
    Chunk* zNeighbours[4];
    unsigned short** blockIds;
    Framework::Either<Block*, int> zBlockNeighbor(
        Framework::Vec3<int> location, OUT Chunk** zNeighborChunk);
    bool added;
    Framework::Critical cs;
    Framework::RCArray<InformationObserver> observers;
    Framework::Array<int> lightSources;
    Framework::Array<Block*> tickSourcesEachTick;
    Framework::Array<Block*> tickSourcesAfterUpdate;
    bool worldUpdated;
    unsigned char* lightData;
    bool currentlyLoading;
    Framework::RCArray<Entity> entitiesInChunk;
    Framework::Array<int> lastSavedEntityIds;

    void addLightSource(int z, int index);
    void removeLightSource(int z, int index);
    void sendToClient(Framework::StreamWriter* zWriter, bool* instanceMap);
    void sendLightToClient(Framework::StreamWriter* zWriter, bool* instanceMap);
    void broadcastLightData(int z, int index, bool foreground);
    const Block* zBlockConst(int z, int index) const;
    bool isVisible(int z, int index) const;

public:
    Chunk(Framework::Punkt location, int dimensionId);
    Chunk(Framework::Punkt location,
        int dimensionId,
        Framework::StreamReader* zReader);
    ~Chunk();

    void lock();
    void unlock();

    void tick(TickQueue* zQueue) override;
    void postTick() override;

    void notifyObservers(NetworkMessage* msg);
    void addObserver(Entity* zEntity, DoLaterHandler& laterHandler);
    void removeObserver(Entity* zEntity);
    void api(Framework::StreamReader* zRequest,
        Entity* zSource,
        DoLaterHandler& laterHandler);
    void initializeLightning();
    void updateLightSources();

    Framework::Either<Block*, int> zBlockAt(
        Framework::Vec3<int> cLocation) const;
    const Block* zBlockConst(Framework::Vec3<int> location) const;
    void instantiateBlock(Framework::Vec3<int> location);
    void generateBlock(Framework::Vec3<int> location);
    void putBlockAt(Framework::Vec3<int> location, Block* block);
    void putBlockTypeAt(Framework::Vec3<int> location, int type);
    void sendBlockInfo(Framework::Vec3<int> location);
    void setNeighbor(Direction dir, Chunk* zChunk);
    Chunk* zNeighbor(Direction dir) const;
    void load(Framework::StreamReader* zReader);
    void save(Framework::StreamWriter* zWriter,
        Framework::Array<Framework::Punkt>& otherChunksToSave);
    void removeUnusedBlocks();
    int getDimensionId() const;
    void onLoaded();
    void onUnloaded();
    Framework::Punkt getCenter() const;
    Framework::Vec3<int> getMin() const;
    Framework::Vec3<int> getMax() const;
    void prepareRemove();
    void setAdded();
    bool hasObservers() const;
    unsigned char* getLightData(Framework::Vec3<int> location) const;
    void setLightData(
        Framework::Vec3<int> location, unsigned char* data, bool foreground);
    int getBlockTypeAt(Framework::Vec3<int> location) const;
    int getBlockTypeAtWC(int x, int y, int z) const;
    void onEntityEnters(Entity* zEntity, Chunk* lastChunk);
    void onEntityLeaves(Entity* zEntity, Chunk* zNextChunk);
    bool hasObserver(int entityId) const;
    void addGeneratedEntity(Entity* entity);
    const Framework::RCArray<Entity>& getEntitiesInChunk() const;

    inline static int index(int x, int y)
    {
        return x * CHUNK_SIZE + y;
    }

    friend ChunkMap;
};