#include "terrain_loader.h"

#include <boost/format.hpp>
#include <boost/filesystem/fstream.hpp>

#include <stdexcept>

TerrainLoader::TerrainLoader(fs::path root) {
	this->root = root;
}

TerrainLoader::~TerrainLoader() {
}

float *TerrainLoader::get_chunk(int64_t x, int64_t y, unsigned int width, unsigned int height) {
	if(has_chunk(x, y))
		return load_chunk(x, y, width, height);
	return NULL;
}

bool TerrainLoader::has_chunk(int64_t x, int64_t y) {
	return fs::exists(root / (boost::format("%d.%d.chunk") % x % y).str());
}

// TODO: Handle big-endian platforms
void TerrainLoader::save_chunk(float *chunk, int64_t x, int64_t y, unsigned int width, unsigned int height) {
	fs::path p = root / (boost::format("%d.%d.chunk") % x % y).str();
	fs::ofstream os(p, std::ios::out | std::ios::binary);

	uint64_t w = width;
	uint64_t h = height;
	os.write((const char*)&w, sizeof(w));
	os.write((const char*)&h, sizeof(h));

	os.write((const char*)chunk, width*height * sizeof(float));
	os.close();
}

// TODO: Handle big-endian platforms
// NOTE: assumes width <= chunk_size+1, likewise for height
float *TerrainLoader::load_chunk(int64_t x, int64_t y, unsigned int width, unsigned int height) {
	fs::path p = root / (boost::format("%d.%d.chunk") % x % y).str();
	fs::ifstream is(p, std::ios::in | std::ios::binary);

	uint64_t w, h;
	w = h = 0;
	is.read((char*)&w, sizeof(w));
	is.read((char*)&h, sizeof(h));

	// TODO: should return w and h, fix calling code
	if(w != width || h != height) {
		throw std::runtime_error("width or height doesn't match");
	}

	float *chunk = new float[width*height];
	is.read((char*)chunk, width*height*sizeof(float));
	is.close();

	return chunk;
}

std::list<Vector3> TerrainLoader::get_objects(int64_t x, int64_t y) {
	std::list<Vector3> objects;

	if(has_objects(x, y))
		objects = load_objects(x, y);

	return objects;
}

bool TerrainLoader::has_objects(int64_t x, int64_t y) {
	return fs::exists(root / (boost::format("%d.%d.objs") % x % y).str());
}

void TerrainLoader::save_objects(std::list<Vector3>& objects, int64_t x, int64_t y) {
	fs::path p = root / (boost::format("%d.%d.objs") % x % y).str();
	fs::ofstream os(p, std::ios::out | std::ios::binary);

	uint32_t count = objects.size();
	os.write((const char*)&count, sizeof(count));

	for(std::list<Vector3>::iterator it = objects.begin(); it != objects.end(); it++) {
		Vector3& obj = *it;
		os.write((const char*)&obj.x, sizeof(obj.x));
		os.write((const char*)&obj.y, sizeof(obj.y));
		os.write((const char*)&obj.z, sizeof(obj.z));
	}
	os.close();
}

std::list<Vector3> TerrainLoader::load_objects(int64_t x, int64_t y) {
	fs::path p = root / (boost::format("%d.%d.objs") % x % y).str();
	fs::ifstream is(p, std::ios::in | std::ios::binary);

	std::list<Vector3> objects;

	uint32_t count;
	is.read((char*)&count, sizeof(count));

	for(uint32_t i = 0; i < count; i++) {
		Vector3 obj;

		is.read((char*)&obj.x, sizeof(obj.x));
		is.read((char*)&obj.y, sizeof(obj.y));
		is.read((char*)&obj.z, sizeof(obj.z));

		objects.push_back(obj);
	}
	is.close();

	return objects;
}