#include "X3dExporter.h"
#include "VrmlExporter.h"
#include "OspTree.h"
#include "KdTree.h"
#include "IntersectableWrapper.h"
#include "BvHierarchy.h"
#include "Triangle3.h"
#include "Polygon3.h"


namespace GtpVisibilityPreprocessor {

Exporter *
Exporter::GetExporter(const string filename)
{
  Exporter *exporter = NULL;

  if (strstr(filename.c_str(), ".x3d")) 
  {
	  exporter = new X3dExporter(filename);
  } 
  else if (strstr(filename.c_str(), ".wrl"))
  {
	  exporter = new VrmlExporter(filename);
  }
  else
  {
	  cerr<<"Error: Currently unsuported export format, filename " << filename << endl;
  }

  return exporter;
}


bool Exporter::ExportOspTree(const OspTree &ospTree, 
							 const int maxPvs
							 )
{
	vector<KdLeaf *> leaves;
	ospTree.CollectLeaves(leaves);
	mUseForcedMaterial = true;

	vector<KdLeaf *>::const_iterator it, it_end = leaves.end();

	Material white; 
	white.mDiffuseColor.r = 1;
	white.mDiffuseColor.g = 1;
	white.mDiffuseColor.b = 1;
	
	for (it = leaves.begin(); it != it_end; ++ it)
	{
		KdLeaf *leaf = *it;

		SetWireframe();
		SetForcedMaterial(white);
		ExportBox(ospTree.GetBoundingBox(leaf));

		SetFilled();

		if (maxPvs) // color code pvs
		{
			mForcedMaterial.mDiffuseColor.b = 1.0f;
  			const float importance = (float)leaf->mObjects.size() / (float)maxPvs;

			mForcedMaterial.mDiffuseColor.r = importance;
			mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
		}
		else
		{
			SetForcedMaterial(RandomMaterial());
		}
		if (0) ExportGeometry(leaf->mObjects);	
	}

	return true;
}


void Exporter::ExportKdIntersectable(const KdIntersectable &kdObj)
{
	KdNode *node = kdObj.GetItem();
	Intersectable::NewMail();

	// todo: traverse to leaves
	if (node->IsLeaf())
	{
		// eyport leaf pvs
		KdLeaf *leaf = dynamic_cast<KdLeaf *>(node);

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

		for (oit = leaf->mObjects.begin(); oit != oit_end; ++ oit)
		{	
			Intersectable *obj = *oit;
        
			if (!obj->Mailed())
			{
				ExportIntersectable(obj);
				obj->Mail();					
			}				
		}
	}
}


bool Exporter::ExportBvHierarchy(const BvHierarchy &bvHierarchy, 
								 const int maxPvs,
								 const AxisAlignedBox3 *box,
								 const bool exportBoundingBoxes)
{
	vector<BvhLeaf *> leaves;
	bvHierarchy.CollectLeaves(leaves);

	mUseForcedMaterial = true;
	vector<BvhLeaf *>::const_iterator it, it_end = leaves.end();

	Material white; 
	white.mDiffuseColor.r = 1;
	white.mDiffuseColor.g = 1;
	white.mDiffuseColor.b = 1;
	
	for (it = leaves.begin(); it != it_end; ++ it)
	{
		BvhLeaf *leaf = *it;

		if (leaf->mObjects.empty() || 
			(box && !Overlap(*box, leaf->GetBoundingBox())))
			continue;

		if (exportBoundingBoxes)
		{
			SetWireframe();
			SetForcedMaterial(white);
			ExportBox(leaf->GetBoundingBox());
		}

        if (maxPvs) // color code pvs
		{
			mForcedMaterial.mDiffuseColor.b = 1.0f;
  			const float importance = (float)leaf->mObjects.size() / (float)maxPvs;

			mForcedMaterial.mDiffuseColor.r = importance;
			mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
		}
		else
		{
			SetForcedMaterial(RandomMaterial());
		}

		SetFilled();
		ExportGeometry(leaf->mObjects, true);
	}

	SetFilled();

	return true;
}


void Exporter::ExportIntersectable(Intersectable *object)
{
	switch (object->Type()) 
	{
	case Intersectable::MESH_INSTANCE:
		ExportMeshInstance((MeshInstance *)object);
		break;
	case Intersectable::TRANSFORMED_MESH_INSTANCE:
		ExportTransformedMeshInstance(dynamic_cast<TransformedMeshInstance *>(object));
		break;
	case Intersectable::VIEW_CELL:
		ExportViewCell(dynamic_cast<ViewCell *>(object));
		break;
	case Intersectable::KD_INTERSECTABLE:
		ExportKdIntersectable(*(dynamic_cast<KdIntersectable *>(object)));
		break;
	case Intersectable::TRIANGLE_INTERSECTABLE:
		{
			const Triangle3 triangle = dynamic_cast<TriangleIntersectable *>(object)->GetItem();
			Polygon3 poly(triangle);
			ExportPolygon(&poly);
			break;
		}
	case Intersectable::BVH_INTERSECTABLE:
		{
			BvhNode *node = dynamic_cast<BvhIntersectable *>(object)->GetItem();
			if (node->IsLeaf())
				ExportGeometry(dynamic_cast<BvhLeaf *>(node)->mObjects, true);
			break;
		}
	default:
		cerr << "Sorry the export for object type " << Intersectable::GetTypeName(object) << " is not available yet" << endl;
		break;
	}
}


void Exporter::ExportMeshInstance(MeshInstance *object)
{
	// $$JB$$
	// in the future check whether the mesh was not already exported
	// and use a reference to the that mesh instead
	ExportMesh(object->GetMesh());
}


void Exporter::ExportTransformedMeshInstance(TransformedMeshInstance *mi)
{
	Mesh mesh(*mi->GetMesh());

	Matrix4x4 m;
	mi->GetWorldTransform(m);
	mesh.ApplyTransformation(m);

	ExportMesh(&mesh);
}


void Exporter::ExportViewCells(const ViewCellContainer &viewCells)
{
	ViewCellContainer::const_iterator it, it_end = viewCells.end();

	for (it = viewCells.begin(); it != it_end; ++ it)
	{
		ExportViewCell(*it);
	}
}


void Exporter::ExportGeometry(const ObjectContainer &objects, 
							  const bool exportSingleMesh,
							  AxisAlignedBox3 *bbox)
{
	ObjectContainer::const_iterator oit, oit_end = objects.end();

	if (!exportSingleMesh)
	{
		for (oit = objects.begin(); oit != oit_end; ++ oit)
		{
			if (!bbox || Overlap(*bbox, (*oit)->GetBox()))
			{
				if (0) SetForcedMaterial(RandomMaterial());
				ExportIntersectable(*oit);
			}
		}
		return;
	}
	

	///////////////////////
	//-- all objects exported as one mesh
	//-- warning: currently works only for triangles

	PolygonContainer polys;

	for (oit = objects.begin(); oit != oit_end; ++ oit)
	{
		Intersectable *obj = *oit;

		if (bbox && !Overlap(*bbox, obj->GetBox()))
		{
			//cout << *bbox << " " << obj->GetBox() << endl;
			continue;
		}

		switch (obj->Type())
		{
		case Intersectable::TRIANGLE_INTERSECTABLE:
			{
				TriangleIntersectable *ti = dynamic_cast<TriangleIntersectable *>(obj);
				polys.push_back(new Polygon3(ti->GetItem()));
                break;
			}
		case Intersectable::MESH_INSTANCE:
			{
				MeshInstance *mi = dynamic_cast<MeshInstance *>(obj);
				ExportMesh(mi->GetMesh());
				//polys.push_back(new Polygon3(ti->GetItem()));
                break;
			}
		default:
			cout << "merging of object type " << obj->Type() << " not implemented yet" << endl;
			break;
		}
	}

	Mesh dummyMesh;
	PolygonContainer::const_iterator pit, pit_end = polys.end();

	for (pit = polys.begin(); pit != pit_end; ++ pit)
	{
		Polygon3 *poly = (*pit);
		IncludePolyInMesh(*poly, dummyMesh);
	}
	
	ExportMesh(&dummyMesh);
	CLEAR_CONTAINER(polys);
}



}