#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"

VssPreprocessor::VssPreprocessor():
	mPass(0),
	mVssRays()
{
  // this should increase coherence of the samples
  environment->GetIntValue("VssPreprocessor.samplesPerPass", mSamplesPerPass);
  environment->GetIntValue("VssPreprocessor.totalSamples", mTotalSamples);
  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();
	
	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)
{
	int i = RandomValue(0, mObjects.size()-1);
	Intersectable *object = mObjects[i];
	Vector3 point, normal;
	object->GetRandomSurfacePoint(point, normal);
	return point - viewpoint;
}

int
VssPreprocessor::RandomizedImportanceSampling(VssTree *vssTree,
																							const int desiredSamples)
{
	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());
	SimpleRayContainer rays;
	int num = vssTree->GenerateRays(p, rays);
	cout<<"Generated "<<num<<" rays."<<endl;
	
	VssRayContainer  vssRays;
	
	for (int i=0; i < rays.size(); i++)
		CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);

	vssTree->AddRays(vssRays);
	return num;
}


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

	AxisAlignedBox3 *viewSpaceBox = NULL;

	AxisAlignedBox3 box = mKdTree->GetBox();

	
	if (1)
		box.Enlarge(box.Size()*-Vector3(0.45, 0.45, 0.45));
	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);
	}
	
	bool useViewSpaceBox = false;
	if (useViewSpaceBox)
		viewSpaceBox = &box;

	VssTree *vssTree = NULL;

  while (totalSamples < mTotalSamples) {
		int passContributingSamples = 0;
		int passSampleContributions = 0;
		int passSamples = 0;
		int index = 0;
		
		int sampleContributions;
		
		
		for (int k=0; k < mSamplesPerPass; k++) {
			
			Vector3 viewpoint = GetViewpoint(viewSpaceBox);
			Vector3 direction = GetDirection(viewpoint);
			
			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;

	cout<<"Exporting vss rays..."<<endl<<flush;
	
	int exportRays = 10000;

	if (exportRays) {
		float prob = exportRays/(float)mVssRays.size();
		
		Exporter *exporter = NULL;
		exporter = Exporter::GetExporter("vss-rays.x3d");
		exporter->SetWireframe();
		exporter->ExportKdTree(*mKdTree);
		if (viewSpaceBox) {
			exporter->SetForcedMaterial(RgbColor(1,0,0));
			exporter->ExportBox(*viewSpaceBox);
			exporter->ResetForcedMaterial();
		}
		VssRayContainer rays;
		for (int i=0; i < mVssRays.size(); i++)
			if (RandomValue(0,1) < prob)
				rays.push_back(mVssRays[i]);
		exporter->ExportRays(rays, RgbColor(1, 0, 0));

		delete exporter;
	}
	cout<<"done."<<endl<<flush;




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

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

	
	int samples = 0;
	for (int i=0; i < 50; i++) {
		int num = 100000;
		if (0) {
			VssRayContainer vssRays;
			for (int j=0; j < num; j++) {
				Vector3 viewpoint = GetViewpoint(viewSpaceBox);
				Vector3 direction = GetDirection(viewpoint);
				CastRay(viewpoint, direction, vssRays);
			}
			vssTree->AddRays(vssRays);
		} else {
			num = RandomizedImportanceSampling(vssTree, num);
		}
		samples+=num;
		float pvs = vssTree->GetAvgPvsSize();
		cout<<samples<<" avgPVS ="<<pvs<<endl;
	}

	delete vssTree;
	
  return true;
}