#include "ObjReader.h"
#include "gzstream.h"
#include "Triangle3.h"
#include "IntersectableWrapper.h"
#include "BvHierarchy.h"
#include "Preprocessor.h"
#include "OgreEntity.h"
#include "PreprocessorFactory.h"
#include "OgreLogManager.h"



ObjReader::ObjReader(Ogre::SceneManager *sceneManager):
mSceneManager(sceneManager)
{}


ObjReader::~ObjReader()
{}


bool ObjReader::LoadFile(const string &sceneName, 
						 const string &visibilitySolution,
						 Ogre::SceneNode *root)
{
	GtpVisibilityPreprocessor::Debug.open("debug.log");
	// HACK: get any preprocessor to load file
	GtpVisibilityPreprocessor::Preprocessor *preprocessor = 
		GtpVisibilityPreprocessor::PreprocessorFactory::CreatePreprocessor("vss");

	// hack
	preprocessor->mLoadMeshes = false;
	GtpVisibilityPreprocessor::ObjectContainer pvsObjects;

	Ogre::LogManager::getSingleton().logMessage("loading obj scene!!");

	if (preprocessor->LoadScene(sceneName))
	{
		Ogre::LogManager::getSingleton().logMessage("scene loaded, loading objects");
		// form objects from the scene triangles
		if (!preprocessor->LoadObjects(visibilitySolution, pvsObjects, preprocessor->mObjects))
		{
			Ogre::LogManager::getSingleton().logMessage("objects cannot be loaded");
			return false;
		}
	}
	else
	{
		Ogre::LogManager::getSingleton().logMessage("scene cannot be loaded");
		return false;
	}

	std::stringstream d; 
	d << "successfully loaded " << pvsObjects.size() << " objects";

	Ogre::LogManager::getSingleton().logMessage(d.str());

	GtpVisibilityPreprocessor::ObjectContainer::const_iterator oit, oit_end = pvsObjects.end();

	int i = 0;
	for (oit = pvsObjects.begin(); oit != oit_end; ++ oit, ++ i)
	{Ogre::LogManager::getSingleton().logMessage("r");
		const Ogre::String entname = "Object" + i;

		Ogre::Entity *ent = CreateEntity(entname, *oit);

		const Ogre::String nodeName = entname + "/Node";
		root->createChildSceneNode(nodeName);
	}

	delete preprocessor;

	return false;
}


Ogre::Entity *ObjReader::CreateEntity(const std::string &name,
									  GtpVisibilityPreprocessor::Intersectable *object)
{
	using namespace Ogre;
	//using namespace GtpVisibilityPreprocessor;

	Entity *entity;

	GtpVisibilityPreprocessor::BvhLeaf *bvhObj = 
		static_cast<GtpVisibilityPreprocessor::BvhLeaf *>(object);

	std::string meshName = name + "/Mesh";
	std::string entityName = name + "/Entity";

	MeshPtr mesh = MeshManager::getSingleton().createManual(meshName, "ObjGroup");
	SubMesh* submesh = mesh->createSubMesh();

	// We must create the vertex data, indicating how many vertices there will be
	submesh->useSharedVertices = false;
	submesh->vertexData = new VertexData();
	submesh->vertexData->vertexStart = 0;
	submesh->vertexData->vertexCount = (int)bvhObj->mObjects.size() * 3;

	static const unsigned short source = 0;
	size_t offset = 0;

	VertexDeclaration* declaration = HardwareBufferManager::getSingleton().createVertexDeclaration();

	offset += declaration->addElement(source, offset, VET_FLOAT3,VES_POSITION).getSize();
	//	offset += declaration->addElement(source,offset,VET_FLOAT3,VES_NORMAL).getSize();
	//	offset += declaration->addElement(source,offset,VET_FLOAT2,VES_TEXTURE_COORDINATES).getSize();


	int numVertices = 0;

	HardwareVertexBufferSharedPtr vbuffer = HardwareBufferManager::getSingleton().
		createVertexBuffer(declaration->getVertexSize(source),
						   submesh->vertexData->vertexCount,
						   HardwareBuffer::HBU_STATIC_WRITE_ONLY,
						   false);

    // No we get access to the buffer to fill it.  During so we record the bounding box.
	AxisAlignedBox aabox;

	float* vdata = static_cast<float*>(vbuffer->lock(HardwareBuffer::HBL_DISCARD));

	GtpVisibilityPreprocessor::ObjectContainer::const_iterator oit, oit_end = bvhObj->mObjects.end();

	for (oit = bvhObj->mObjects.begin(); oit != oit_end; ++ oit)
	{
		GtpVisibilityPreprocessor::TriangleIntersectable *tObj = 
			static_cast<GtpVisibilityPreprocessor::TriangleIntersectable *>(*oit);
		
		GtpVisibilityPreprocessor::Triangle3 tri = tObj->GetItem();

		for (int i = 0; i < 3; ++ i)
		{
			Vector3 vtx(tri.mVertices[i]);

			*vdata ++ = vtx.x;
			*vdata ++ = vtx.y;
			*vdata ++ = vtx.z;

			aabox.merge(vtx);
		}
	}

	vbuffer->unlock();

	// We must indicate the bounding box
	mesh->_setBounds(aabox); 

	mesh->_setBoundingSphereRadius((aabox.getMaximum()-aabox.getMinimum()).length()/2.0); 
	mesh->load();
	
	// Create an entity with the mesh
	entity = mSceneManager->createEntity(meshName, entityName);

	return entity;
}