/*
 * Copyright 2008, Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 * 		Alexandre Deckner <alex@zappotek.com>
 */

#include "StaticMesh.h"

#include <Application.h>
#include <Resources.h>
#include <Roster.h>
#include <File.h>
#include <String.h>

#include <stdlib.h>
#include <stdio.h>

StaticMesh::StaticMesh(const char* name)
	:
	fFaces(NULL),
	fFaceCount(0)
{
	// TODO : move that in a utility class
	//BString fileName;
	//fileName << "data/" << name << ".hk3d";
	//_LoadText(fileName);

	//fileName << ".bin";
	//_WriteBinary(fileName);

	_ReadResource(name);
}


StaticMesh::~StaticMesh()
{
	delete [] fFaces;
}


void
StaticMesh::_ReadText(const char* fileName)
{
	FILE* f = fopen(fileName, "r");
	if (f == NULL) {
		printf("Mesh::_ReadText, error accessing %s\n", fileName);
		return;
	}

	fscanf(f, "%" B_PRIu32, &fFaceCount);
	fFaces = new Face[fFaceCount];

	for (uint32 i = 0; i < fFaceCount; i++) {

		uint32 vertexCount = 0;
		fscanf(f, "%" B_PRIu32, &vertexCount);
		fFaces[i].vertexCount = vertexCount;

		for (uint32 vi = 0; vi < vertexCount; vi++) {
			float x, y, z, u, v;
			fscanf(f, "%f %f %f %f %f",	&x,	&y,	&z,	&v,	&u);
			fFaces[i].v[vi].p.setValue(x, y, z);
			fFaces[i].v[vi].u = v;
			fFaces[i].v[vi].v = 1.0 - u;
		}
	}

	fclose(f);
	printf("Mesh::_ReadText, loaded %s (%" B_PRIu32 " faces)\n",
		fileName, fFaceCount);
}


void
StaticMesh::_WriteBinary(const char* fileName)
{
	BFile file(fileName, B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE);

	if (file.InitCheck() != B_OK) {
		printf("Mesh::_WriteBinary, error accessing %s\n", fileName);
		return;
	}

	file.Write(&fFaceCount, sizeof(uint32));
	for (uint32 i = 0; i < fFaceCount; i++) {
		file.Write(&fFaces[i].vertexCount, sizeof(uint16));
		for (uint32 vi = 0; vi < fFaces[i].vertexCount; vi++) {
			file.Write(&fFaces[i].v[vi], sizeof(Vertex));
		}
	}
	printf("Mesh::_WriteBinary, wrote %s (%" B_PRIu32 " faces)\n",
		fileName, fFaceCount);
}


void
StaticMesh::_ReadBinary(const char* fileName)
{
	BFile file(fileName, B_READ_ONLY);

	if (file.InitCheck() != B_OK) {
		printf("Mesh::_ReadBinary, error accessing %s\n", fileName);
		return;
	}

	file.Read(&fFaceCount, sizeof(uint32));
	fFaces = new Face[fFaceCount];
	for (uint32 i = 0; i < fFaceCount; i++) {
		file.Read(&fFaces[i].vertexCount, sizeof(uint16));
		for (uint32 vi = 0; vi < fFaces[i].vertexCount; vi++) {
			file.Read(&fFaces[i].v[vi], sizeof(Vertex));
		}
	}
	printf("Mesh::_ReadBinary, loaded %s (%" B_PRIu32 " faces)\n",
		fileName, fFaceCount);
}


void
StaticMesh::_ReadResource(const char* resourceName)
{
	// TODO: factorize with _ReadBinary
	app_info info;
	be_app->GetAppInfo(&info);
	BFile file(&info.ref, B_READ_ONLY);

	BResources res;
	if (res.SetTo(&file) != B_OK) {
		printf("Mesh::_ReadResource, error accessing resources data\n");
		return;
	}

	size_t size;
	const void* data = res.LoadResource(B_RAW_TYPE, resourceName, &size);
	if (data == NULL) {
		printf("Mesh::_ReadResource, can't access resource %s\n", resourceName);
		return;
	}

	BMemoryIO memoryIO(data, size);

	memoryIO.Read(&fFaceCount, sizeof(uint32));
	fFaces = new Face[fFaceCount];
	for (uint32 i = 0; i < fFaceCount; i++) {
		memoryIO.Read(&fFaces[i].vertexCount, sizeof(uint16));
		for (uint32 vi = 0; vi < fFaces[i].vertexCount; vi++) {
			memoryIO.Read(&fFaces[i].v[vi], sizeof(Vertex));
		}
	}
	printf("Mesh::_ReadResource, loaded %s (%" B_PRIu32 " faces)\n",
		resourceName, fFaceCount);
}


Face&
StaticMesh::GetFace(uint32 index) const
{
	return fFaces[index];
}


uint32
StaticMesh::FaceCount() const
{
	return fFaceCount;
}