#include "SceneGraph.h"
#include "KdTree.h"
#include "VssPreprocessor.h"
#include "X3dExporter.h"
#include "Environment.h"
#include "MutualVisibility.h"
#include "Polygon3.h"
#include "ViewCell.h"
#include "VssRay.h"
#include "VssTree.h"


bool useViewSpaceBox = true;
bool use2dSampling = false;
bool useViewspacePlane = false;

VssPreprocessor::VssPreprocessor():
	mPass(0),
	mVssRays()
{
  // this should increase coherence of the samples
  environment->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass);
  environment->GetIntValue("VssPreprocessor.initialSamples", mInitialSamples);
  environment->GetIntValue("VssPreprocessor.vssSamples", mVssSamples);
  environment->GetIntValue("VssPreprocessor.vssSamplesPerPass", mVssSamplesPerPass);
	environment->GetBoolValue("VssPreprocessor.useImportanceSampling", mUseImportanceSampling);
	
  mStats.open("stats.log");
}

VssPreprocessor::~VssPreprocessor()
{
	CLEAR_CONTAINER(mVssRays);
}

void
VssPreprocessor::SetupRay(Ray &ray, 
													const Vector3 &point, 
													const Vector3 &direction
													)
{
  ray.intersections.clear();
	// do not store anything else then intersections at the ray
  ray.Init(point, direction, Ray::LOCAL_RAY);
}

int
VssPreprocessor::CastRay(
												 Vector3 &viewPoint,
												 Vector3 &direction,
												 VssRayContainer &vssRays
												 )
{
	int hits = 0;
	static Ray ray;
	AxisAlignedBox3 box = mKdTree->GetBox();

	AxisAlignedBox3 sbox = box;
	sbox.Enlarge(Vector3(-Limits::Small));
	if (!sbox.IsInside(viewPoint))
		return 0;
	
	SetupRay(ray, viewPoint, direction);
	// cast ray to KD tree to find intersection with other objects
	Intersectable *objectA, *objectB;
	Vector3 pointA, pointB;
	float bsize = Magnitude(box.Size());
	if (mKdTree->CastRay(ray)) {
		objectA = ray.intersections[0].mObject;
		pointA = ray.Extrap(ray.intersections[0].mT);
	} else {
		objectA = NULL;
		// compute intersection with the scene bounding box
		float tmin, tmax;
		box.ComputeMinMaxT(ray, &tmin, &tmax);
		if (tmax > bsize) {
			//			cerr<<"Warning: tmax > box size tmax="<<tmax<<" tmin="<<tmin<<" size="<<bsize<<endl;
			//			cerr<<"ray"<<ray<<endl;
		}
		pointA = ray.Extrap(tmax);
		
	}

	bool detectEmptyViewSpace = true;
	
	if (detectEmptyViewSpace) {
		SetupRay(ray, pointA, -direction);
	} else
		SetupRay(ray, viewPoint, -direction);
	
	
	if (mKdTree->CastRay(ray)) {
		
		objectB = ray.intersections[0].mObject;
	  pointB = ray.Extrap(ray.intersections[0].mT);

	} else {
		objectB = NULL;
		float tmin, tmax;
		box.ComputeMinMaxT(ray, &tmin, &tmax);
		if (tmax > bsize) {
			//			cerr<<"Warning: tmax > box size tmax="<<tmax<<" tmin="<<tmin<<" size="<<bsize<<endl;
			//			cerr<<"ray"<<ray<<endl;
		}
		
		pointB = ray.Extrap(tmax);
	}

	VssRay *vssRay  = NULL;

	bool validSample = true;
	if (detectEmptyViewSpace) {
		if (Distance(pointA, pointB) <
				Distance(viewPoint, pointA) + Distance(viewPoint, pointB) - Limits::Small) {
			validSample = false;
		}
	}
	
	if (validSample) {
		if (objectA) {
			vssRay = new VssRay(pointB,
													pointA,
													objectB,
													objectA);
			vssRays.push_back(vssRay);
			hits ++;
		}
		
		if (objectB) {
			vssRay = new VssRay(pointA,
													pointB,
													objectA,
													objectB);
			vssRays.push_back(vssRay);
			hits ++;
		}
	}
	
	return hits;
}


Vector3
VssPreprocessor::GetViewpoint(AxisAlignedBox3 *viewSpaceBox)
{
	AxisAlignedBox3 box;
	
	if (viewSpaceBox)
		box =*viewSpaceBox;
	else 
		box = mKdTree->GetBox();
	
	// shrink the box in the y direction
	return box.GetRandomPoint();
}

Vector3
VssPreprocessor::GetDirection(const Vector3 &viewpoint,
															AxisAlignedBox3 *viewSpaceBox
															)
{
	Vector3 point;
	if (!use2dSampling) {
		Vector3 normal;
		int i = RandomValue(0, mObjects.size()-1);
		Intersectable *object = mObjects[i];
		object->GetRandomSurfacePoint(point, normal);
	} else {
		AxisAlignedBox3 box;
		
		if (viewSpaceBox)
			box =*viewSpaceBox;
		else 
			box = mKdTree->GetBox();
		
		point = box.GetRandomPoint();
		point.y = viewpoint.y;
	}
	
	return point - viewpoint;
}

int
VssPreprocessor::GenerateImportanceRays(VssTree *vssTree,
																				const int desiredSamples,
																				SimpleRayContainer &rays
																				)
{
	int num;
	if (0) {
		float minRayContribution;
		float maxRayContribution;
		float avgRayContribution;
		
		vssTree->GetRayContributionStatistics(minRayContribution,
																					maxRayContribution,
																					avgRayContribution);
		
		cout<<
			"#MIN_RAY_CONTRIB\n"<<minRayContribution<<endl<<
			"#MAX_RAY_CONTRIB\n"<<maxRayContribution<<endl<<
			"#AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl;
		
		float p = desiredSamples/(float)(avgRayContribution*vssTree->stat.Leaves());
		num = vssTree->GenerateRays(p, rays);
	} else {
		int leaves = vssTree->stat.Leaves()/2;
		num = vssTree->GenerateRays(desiredSamples, leaves, rays);
	}
	
	cout<<"Generated "<<num<<" rays."<<endl;
	
	return num;
}


bool
VssPreprocessor::ExportRays(const char *filename,
														const VssRayContainer &vssRays,
														const int number
														)
{
	cout<<"Exporting vss rays..."<<endl<<flush;
	
	float prob = number/(float)vssRays.size();


	Exporter *exporter = NULL;
	exporter = Exporter::GetExporter(filename);
	//	exporter->SetWireframe();
	//	exporter->ExportKdTree(*mKdTree);
	exporter->SetFilled();
	exporter->ExportScene(mSceneGraph->mRoot);
	exporter->SetWireframe();

	if (mViewSpaceBox) {
		exporter->SetForcedMaterial(RgbColor(1,0,0));
		exporter->ExportBox(*mViewSpaceBox);
		exporter->ResetForcedMaterial();
	}
	
	VssRayContainer rays;	for (int i=0; i < vssRays.size(); i++)
		if (RandomValue(0,1) < prob)
			rays.push_back(vssRays[i]);

	exporter->ExportRays(rays, RgbColor(1, 0, 0));
	
	delete exporter;

	cout<<"done."<<endl<<flush;

	return true;
}


bool
VssPreprocessor::ExportVssTreeLeaf(char *filename,
																	 VssTree *tree,
																	 VssTreeLeaf *leaf)
{
	Exporter *exporter = NULL;
	exporter = Exporter::GetExporter(filename);
	exporter->SetWireframe();
	exporter->ExportKdTree(*mKdTree);
	
	if (mViewSpaceBox) {
		exporter->SetForcedMaterial(RgbColor(1,0,0));
		exporter->ExportBox(*mViewSpaceBox);
		exporter->ResetForcedMaterial();
	}
	
	exporter->SetForcedMaterial(RgbColor(0,0,1));
	exporter->ExportBox(tree->GetBBox(leaf));
	exporter->ResetForcedMaterial();
	
	VssRayContainer rays[4];
	for (int i=0; i < leaf->rays.size(); i++) {
		int k = leaf->rays[i].GetRayClass();
		rays[k].push_back(leaf->rays[i].mRay);
	}
	
	// SOURCE RAY
	exporter->ExportRays(rays[0], RgbColor(1, 0, 0));
	// TERMINATION RAY
	exporter->ExportRays(rays[1], RgbColor(1, 1, 1));
	// PASSING_RAY
	exporter->ExportRays(rays[2], RgbColor(1, 1, 0));
	// CONTAINED_RAY
	exporter->ExportRays(rays[3], RgbColor(0, 0, 1));

	delete exporter;
	return true;
}

void
VssPreprocessor::ExportVssTreeLeaves(VssTree *tree, const int number)
{
	vector<VssTreeLeaf *> leaves;
	tree->CollectLeaves(leaves);

	int num = 0;
	int i;
	float p = number / (float)leaves.size();
	for (i=0; i < leaves.size(); i++) {
		if (RandomValue(0,1) < p) {
			char filename[64];
			sprintf(filename, "vss-leaf-%04d.x3d", num);
			ExportVssTreeLeaf(filename, tree, leaves[i]);
			num++;
		}
		if (num >= number)
			break;
	}
}

bool
VssPreprocessor::ComputeVisibility()
{
  
  mSceneGraph->CollectObjects(&mObjects);
	
  long startTime = GetTime();
  
  int totalSamples = 0;


	AxisAlignedBox3 *box = new AxisAlignedBox3(mKdTree->GetBox());

	if (!useViewspacePlane) {
		float size = 0.01f;
		float s = 0.5f - size;
		float olds = Magnitude(box->Size());
		box->Enlarge(box->Size()*Vector3(-s));
		Vector3 translation = Vector3(-olds*0.1f, 0, 0);
		box->SetMin(box->Min() + translation);
		box->SetMax(box->Max() + translation);
	} else {
		
		// sample city like heights
		box->SetMin(1, box->Min(1) + box->Size(1)*0.1);
		box->SetMax(1, box->Min(1) + box->Size(1)*0.2);
	}

	if (use2dSampling)
		box->SetMax(1, box->Min(1));
	
	if (useViewSpaceBox)
		mViewSpaceBox = box;
	else
		mViewSpaceBox = NULL;
		

	VssTree *vssTree = NULL;

  while (totalSamples < mInitialSamples) {
		int passContributingSamples = 0;
		int passSampleContributions = 0;
		int passSamples = 0;
		int index = 0;
		
		int sampleContributions;
		
		int s = Min(mSamplesPerPass, mInitialSamples);
		for (int k=0; k < s; k++) {
			
			Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
			Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
			
			sampleContributions = CastRay(viewpoint, direction, mVssRays);
			
			
			//-- CORR matt: put block inside loop
			if (sampleContributions) {
				passContributingSamples ++;
				passSampleContributions += sampleContributions;
			}
			passSamples++;
			totalSamples++;
		}
    
		mPass++;
		
		int pvsSize = 0;
		float avgRayContrib = (passContributingSamples > 0) ? 
			passSampleContributions/(float)passContributingSamples : 0;
		
		cout << "#Pass " << mPass << " : t = " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
		cout << "#TotalSamples=" << totalSamples/1000 
				 << "k   #SampleContributions=" << passSampleContributions << " (" 
				 << 100*passContributingSamples/(float)passSamples<<"%)" << " avgPVS="
				 << pvsSize/(float)mObjects.size() << endl 
				 << "avg ray contrib=" << avgRayContrib << endl;
		
		mStats <<
			"#Pass\n" <<mPass<<endl<<
			"#Time\n" << TimeDiff(startTime, GetTime())*1e-3 << endl<<
			"#TotalSamples\n" << totalSamples<< endl<<
			"#SampleContributions\n" << passSampleContributions << endl << 
			"#PContributingSamples\n"<<100*passContributingSamples/(float)passSamples<<endl <<
			"#AvgPVS\n"<< pvsSize/(float)mObjects.size() << endl <<
			"#AvgRayContrib\n" << avgRayContrib << endl;



		
	}
	
	cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
	cout << "#totalRayStackSize=" << mVssRays.size() << endl <<flush;

	
	//	int numExportRays = 10000;

	int numExportRays = 0;

	if (numExportRays) {
		char filename[64];
		sprintf(filename, "vss-rays-initial.x3d");
		ExportRays(filename, mVssRays, numExportRays);
	}




	vssTree = new VssTree;
	
	vssTree->Construct(mVssRays, mViewSpaceBox);

	cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;

	ExportVssTreeLeaves(vssTree, 10);
	
	int samples = 0;
	int pass = 0;
	while (1) {
		int num = mVssSamplesPerPass;
		SimpleRayContainer rays;
		VssRayContainer vssRays;
		
		if (!mUseImportanceSampling) {
			for (int j=0; j < num; j++) {
				Vector3 viewpoint = GetViewpoint(mViewSpaceBox);
				Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
				rays.push_back(SimpleRay(viewpoint, direction));
			}
		} else {
			num = GenerateImportanceRays(vssTree, num, rays);
		}
		
		
		for (int i=0; i < rays.size(); i++)
			CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);
		
		vssTree->AddRays(vssRays);
		
		if (1) {
			int subdivided = vssTree->UpdateSubdivision();
			cout<<"subdivided leafs = "<<subdivided<<endl;
		}
		
		if (numExportRays) {
			char filename[64];
			if (mUseImportanceSampling)
				sprintf(filename, "vss-rays-i%04d.x3d", pass);
			else
				sprintf(filename, "vss-rays-%04d.x3d", pass);
			
			ExportRays(filename, vssRays, numExportRays);
		}

		
		samples+=num;
		float pvs = vssTree->GetAvgPvsSize();
		cout<<"*****************************\n";
		cout<<samples<<" avgPVS ="<<pvs<<endl;
		cout<<"VssTree root PVS size = "<<vssTree->GetRootPvsSize()<<endl;
		cout<<"*****************************\n";
		if (samples >= mVssSamples)
			break;
		pass++;
	}

	delete vssTree;
	
  return true;
}