#include "world.hpp"
#include "chunk.hpp"
#include "block.hpp"
#include "math.hpp"
#include <iostream>

	//This is necessary for std::map<Vector3i,Chunk> to work
	bool operator<(const ChunkIndex v1, const ChunkIndex v2){
		return(std::make_tuple(v1.x,v1.y,v1.z)<std::make_tuple(v2.x,v2.y,v2.z));
	}

	std::ostream& operator<<(std::ostream &out,ChunkIndex c){
		out << "(" << c.x <<", " << c.y <<", "<< c.z <<")" <<std::endl;
		return out;
	}

	//This tells us how far the player can see.
	//If the player is looking North/South/West/East/Up/Down there
	//will be VIEW_DISTANCE chunks in front of him.
	//This means that there will be in total (2*VIEW_DISTANCE+1)^3
	//chunks loaded
#define VIEW_DISTANCE 3 //In Chunks

	//Loop over a 3-dimensional range
#define Dim3RangeLoop(/*Vector3i*/ from,/*Vector3i*/ to)\
		for(ChunkIndex index = from; index.x<=to.x; index.x++)\
		for(index.y=from.y; index.y<=to.y; index.y++)\
		for(index.z=from.z; index.z<=to.z; index.z++)

	//Loops over all the chunks indices within the VIEW_DISTANCE
#define neighberhoud_loop(index,dist)\
		Dim3RangeLoop(	ChunkIndex(index.x-dist,index.y-dist,index.z-dist),\
				ChunkIndex(index.x+dist,index.y+dist,index.z+dist))

	void World::Read(FILE *f){
		unsigned char version;
		fread(&version,sizeof(unsigned char),1,f);
		if(version!=0){
			std::cerr << "Error: world.bin has an unknown version"<<std::endl;
			return;
		}

		int amChunks;
		if(!fread(&amChunks,sizeof(int),1,f)){
			std::cerr << "Eror reading the amount of chunks from world.bin" << std::endl;
			return;
		}
		for(int i=0;i<amChunks;i++){
			ChunkIndex chunkIndex;
			chunkIndex.Read(f);
			if(!chunks[chunkIndex].read(f,chunkIndex)){
				std::cerr << "Error reading chunk with index " << chunkIndex << std::endl;
				return;
			}
		}
	}

	//Loads in the chunks that need to be loaded given the
	//the chunk that the player is currently standing in
	void World::LoadChunks(ChunkIndex player_index){

		neighberhoud_loop(player_index,VIEW_DISTANCE){
			if(chunks.find(index)==chunks.end()){
				chunks[index].index = index;
				chunks[index].Generate();
				chunks[index].createMesh();
			}
		}
	}

	void World::Draw(Vector3f pos,int blockTexture){
		neighberhoud_loop(ChunkIndex(pos),VIEW_DISTANCE){
			chunks[index].Draw(blockTexture);
		}
	}


BlockID World::GetBlock(Vector3i pos){
	ChunkIndex chunkIndex(pos);
	return chunks[chunkIndex].getBlock(
			mod((int)(pos.x),16),
			mod((int)(pos.y),16),mod((int)(pos.z),16)
	);
}


void World::SetBlock(Vector3i pos,BlockID id){
	ChunkIndex chunkIndex(pos);
	chunks[chunkIndex].setBlock(
			mod((int)(pos.x),16),
			mod((int)(pos.y),16),mod((int)(pos.z),16),id
	);
	chunks[chunkIndex].deleteMesh();
	chunks[chunkIndex].createMesh();
}

void World::Write(FILE*f ){
	unsigned char version = 0;
	fwrite(&version,sizeof(unsigned char),1,f);
	int amChunks = chunks.size();
	fwrite(&amChunks,sizeof(int),1,f);
	for(std::pair<const ChunkIndex, Chunk> pair : chunks){
		ChunkIndex index = std::get<0>(pair);
		index.Write(f);
		std::get<1>(pair).Write(f,index);
	}
}

void World::clear(){
	chunks.clear();
}