#include "SceneGraph.h"
#include "KdTree.h"
#include "RssPreprocessor.h"
#include "X3dExporter.h"
#include "Environment.h"
#include "MutualVisibility.h"
#include "Polygon3.h"
#include "ViewCell.h"
#include "VssRay.h"
#include "RssTree.h"
#include "ViewCellsManager.h"
#include "RenderSimulator.h"

static bool useViewSpaceBox = false;
static bool use2dSampling = false;
static bool fromBoxVisibility = false;


RssPreprocessor::RssPreprocessor():
  mPass(0),
  mVssRays()
{
  // this should increase coherence of the samples
  environment->GetIntValue("RssPreprocessor.samplesPerPass", mSamplesPerPass);
  environment->GetIntValue("RssPreprocessor.initialSamples", mInitialSamples);
  environment->GetIntValue("RssPreprocessor.vssSamples", mRssSamples);
  environment->GetIntValue("RssPreprocessor.vssSamplesPerPass", mRssSamplesPerPass);
  environment->GetBoolValue("RssPreprocessor.useImportanceSampling", mUseImportanceSampling);

  environment->GetBoolValue("RssPreprocessor.Export.pvs", mExportPvs);
  environment->GetBoolValue("RssPreprocessor.Export.rssTree", mExportRssTree);
  environment->GetBoolValue("RssPreprocessor.Export.rays", mExportRays);
  environment->GetIntValue("RssPreprocessor.Export.numRays", mExportNumRays);
  environment->GetBoolValue("RssPreprocessor.useViewcells", mUseViewcells);
  environment->GetBoolValue("RssPreprocessor.useViewcells", mUseViewcells);

  environment->GetBoolValue("RssPreprocessor.loadInitialSamples", mLoadInitialSamples);
  environment->GetBoolValue("RssPreprocessor.storeInitialSamples", mStoreInitialSamples);
  
  mStats.open("stats.log");
}

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

void
RssPreprocessor::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
RssPreprocessor::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) {
	// check if the viewpoint lies on the line segment AB
	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,
						  mPass
						  );
	  vssRays.push_back(vssRay);
	  hits ++;
	}
	
	if (objectB) {
	  vssRay = new VssRay(pointA,
						  pointB,
						  objectA,
						  objectB,
						  mPass
						  );
	  vssRays.push_back(vssRay);
	  hits ++;
	}
  }
	
  return hits;
}


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

Vector3
RssPreprocessor::GetDirection(const Vector3 &viewpoint,
							  AxisAlignedBox3 *viewSpaceBox
							  )
{
  Vector3 point;
  if (!use2dSampling) {
	Vector3 normal;
	int i = (int)RandomValue(0, (Real)((int)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
RssPreprocessor::GenerateImportanceRays(RssTree *rssTree,
										const int desiredSamples,
										SimpleRayContainer &rays
										)
{
  int num;


  
  float avgPvsSize;
  float avgRayContribution;
  float avgPvsEntropy;
  float avgRayLengthEntropy;
  float avgImportance;
  float avgRays;
  rssTree->GetTreeStatistics(
							 avgPvsSize,
							 avgRays,
							 avgRayContribution,
							 avgPvsEntropy,
							 avgRayLengthEntropy,
							 avgImportance);
  
  cout<<
	"#RSS_AVG_PVS_SIZE\n"<<avgPvsSize<<endl<<
	"#RSS_AVG_RAYS\n"<<avgRays<<endl<<
	"#RSS_AVG_RAY_CONTRIB\n"<<avgRayContribution<<endl<<
	"#RSS_AVG_PVS_ENTROPY\n"<<avgPvsEntropy<<endl<<
	"#RSS_AVG_RAY_LENGTH_ENTROPY\n"<<avgRayLengthEntropy<<endl<<
	"#RSS_AVG_IMPORTANCE\n"<<avgImportance<<endl;
  
  if (0) {
	float p = desiredSamples/(float)(avgRayContribution*rssTree->stat.Leaves());
	num = rssTree->GenerateRays(p, rays);
  } else {
	int leaves = rssTree->stat.Leaves()/1;
	num = rssTree->GenerateRays(desiredSamples, leaves, rays);
  }
	
  cout<<"Generated "<<num<<" rays."<<endl;
	
  return num;
}


bool
RssPreprocessor::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,1));
	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
RssPreprocessor::ExportRssTree(char *filename,
							   RssTree *tree,
							   const Vector3 &dir
							   )
{
  Exporter *exporter = Exporter::GetExporter(filename);
  exporter->SetFilled();
  exporter->ExportScene(mSceneGraph->mRoot);
  //  exporter->SetWireframe();
  bool result = exporter->ExportRssTree2( *tree, dir );
  delete exporter;
  return result;
}

bool
RssPreprocessor::ExportRssTreeLeaf(char *filename,
								   RssTree *tree,
								   RssTreeLeaf *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
RssPreprocessor::ExportRssTreeLeaves(RssTree *tree, const int number)
{
  vector<RssTreeLeaf *> 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, "rss-leaf-%04d.x3d", num);
	  ExportRssTreeLeaf(filename, tree, leaves[i]);
	  num++;
	}
	if (num >= number)
	  break;
  }
}


float
RssPreprocessor::GetAvgPvsSize(RssTree *tree,
							   const vector<AxisAlignedBox3> &viewcells
							   )
{
  vector<AxisAlignedBox3>::const_iterator it, it_end = viewcells.end();

  int sum = 0;
  for (it = viewcells.begin(); it != it_end; ++ it)
	sum += tree->GetPvsSize(*it);
	
  return sum/(float)viewcells.size();
}


void
RssPreprocessor::ExportPvs(char *filename,
						   RssTree *rssTree
						   )
{
  ObjectContainer pvs;
  if (rssTree->CollectRootPvs(pvs)) {
	Exporter *exporter = Exporter::GetExporter(filename);
	exporter->SetFilled();
	exporter->ExportGeometry(pvs);
	exporter->SetWireframe();
	exporter->ExportBox(rssTree->bbox);
	exporter->ExportViewpoint(rssTree->bbox.Center(), Vector3(1,0,0));
	delete exporter;
  }
}

bool
RssPreprocessor::ComputeVisibility()
{
  cout<<"Rss Preprocessor started\n"<<flush;
  cout<<"Memory/ray "<<sizeof(VssRay)+sizeof(RssTreeNode::RayInfo)<<endl;
  mSceneGraph->CollectObjects(&mObjects);
	
  long startTime = GetTime();
  
  int totalSamples = 0;

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

  if (fromBoxVisibility) {
	float m = box->Min(1);
	float bsize = box->Size(1);

	float size = 0.02f;
	float s = 0.5f - size;
	float olds = Magnitude(box->Size());
	box->Enlarge(box->Size()*Vector3(-s));
	//	Vector3 translation = Vector3(-olds*0.2f, 0, 0);
	Vector3 translation = Vector3(-0.05f*olds, 0, 0);
	box->SetMin(box->Min() + translation);
	box->SetMax(box->Max() + translation);

	box->SetMin(1,  m + bsize*0.1f);
	box->SetMax(1,  m + bsize*0.6f);

	
  } else {
		
	// sample city like heights
	float m = box->Min(1);
	float bsize = box->Size(1);
	box->SetMin(1,  m + bsize*0.2f);
	box->SetMax(1,  m + bsize*0.3f);
  }

  if (use2dSampling)
	box->SetMax(1, box->Min(1));
	
  if (useViewSpaceBox)
  {
	mViewSpaceBox = box;
	mViewCellsManager->SetViewSpaceBox(*box);
  }
  else
  {
	mViewSpaceBox = NULL;
	mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());
  }
		

  RssTree *rssTree = NULL;

  if (mLoadInitialSamples)
  {
	  cout << "Loading samples from file ... ";
	  LoadSamples(mVssRays, mObjects);
	  cout << "finished\n" << endl;
  }
  else
  {
	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 viewpoint; 
		mViewCellsManager->GetViewPoint(viewpoint);
		Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
				
		sampleContributions = CastRay(viewpoint, direction, mVssRays);
				
				
		//-- CORR matt: put block inside loop
		if (sampleContributions) {
			passContributingSamples ++;
			passSampleContributions += sampleContributions;
		}
		passSamples++;
		totalSamples++;
		}
	    
			
		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<<"%)" 
			<< "avgcontrib=" << 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 <<
		"#AvgRayContrib\n" << avgRayContrib << endl;
		
		mPass++;

	}
  
	cout << "#totalPvsSize=" << mKdTree->CollectLeafPvs() << endl;
  }

  cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl <<flush;
  

  if (mExportRays) {
	char filename[64];
	sprintf(filename, "rss-rays-initial.x3d");
	ExportRays(filename, mVssRays, mExportNumRays);
  }
  
  if (mStoreInitialSamples)
  {
	  cout << "Writing samples to file ... ";
	  WriteSamples(mVssRays);
	  cout << "finished\n" << endl;
  }

  if (mUseViewcells) {
	// construct view cells
	mViewCellsManager->Construct(mObjects, mVssRays);
	
	VssRayContainer selectedRays;
	int desired = Max(
					  mViewCellsManager->GetPostProcessSamples(),
					  mViewCellsManager->GetVisualizationSamples());
	float p = desired/(float)mVssRays.size();
	
	for (int i=0; i < mVssRays.size(); i++) {
	  if (Random(1.0f) < p)
		selectedRays.push_back(mVssRays[i]);
	}
	//-- post process view cells
	mViewCellsManager->PostProcess(mObjects, selectedRays);
	
	//-- several visualizations and statistics
	Debug << "view cells after post processing: " << endl;
	mViewCellsManager->PrintStatistics(Debug);
	
	if (1) 
	  mViewCellsManager->Visualize(mObjects, selectedRays);
  }


  rssTree = new RssTree;
	
  if (mUseImportanceSampling) {
	
	if (fromBoxVisibility)
	  rssTree->Construct(mVssRays, mViewSpaceBox);
	else
	  rssTree->Construct(mVssRays, NULL);
	cout<<"RssTree root PVS size = "<<rssTree->GetRootPvsSize()<<endl;
	
	if (mExportRssTree) {
	  ExportRssTree("rss-tree-100.x3d", rssTree, Vector3(1,0,0));
	  ExportRssTree("rss-tree-001.x3d", rssTree, Vector3(0,0,1));
	  ExportRssTree("rss-tree-101.x3d", rssTree, Vector3(1,0,1));
	  ExportRssTree("rss-tree-101m.x3d", rssTree, Vector3(-1,0,-1));
	  ExportRssTreeLeaves(rssTree, 10);
	}
	
	if (mExportPvs) {
	  ExportPvs("rss-pvs-initial.x3d", rssTree);
	}
  }
  
  // viewcells->UpdatePVS(newVssRays);
  
  int rssPass = 0;
  int rssSamples = 0;
  while (1) {
	int num = mRssSamplesPerPass;
	SimpleRayContainer rays;
	VssRayContainer vssRays;
		
	if (!mUseImportanceSampling) {
	  for (int j=0; j < num; j++) {
	    //changed by matt
		//Vector3 viewpoint = GetViewpoint(mViewSpaceBox); 
		Vector3 viewpoint; 
		mViewCellsManager->GetViewPoint(viewpoint);
		Vector3 direction = GetDirection(viewpoint, mViewSpaceBox);
		rays.push_back(SimpleRay(viewpoint, direction));
	  }
	} else {
	  num = GenerateImportanceRays(rssTree, num, rays);
	}
		
		
	for (int i=0; i < rays.size(); i++)
	  CastRay(rays[i].mOrigin, rays[i].mDirection, vssRays);

	
	totalSamples+=num;
	rssSamples+=num;

	mStats <<
	  "#Pass\n" <<mPass<<endl<<
	  "#RssPass\n" <<rssPass<<endl<<
	  "#Time\n" << TimeDiff(startTime, GetTime())*1e-3<<endl<<
	  "#TotalSamples\n" <<totalSamples<<endl<<
	  "#RssSamples\n" <<rssSamples<<endl;

	if (mUseViewcells) {
	  
	  /// compute view cell contribution of rays
	  mViewCellsManager->ComputeSampleContributions(vssRays);
	  
	  vssRays.PrintStatistics(mStats);
	  mViewCellsManager->PrintPvsStatistics(mStats);
	}

	// add rays to the tree after the viewcells have been cast to have their contributions
	// already when adding into the tree
	// do not add those rays which have too low or no contribution....
	
	if (mUseImportanceSampling) {
	  rssTree->AddRays(vssRays);
	  
	  if (0) {
		cout<<"############# Rss PVS STAT ##################\n";
		cout<<"#AVG_RSS_PVS\n"<<rssTree->GetAvgPvsSize()<<endl;
		cout<<"#RSS_ROOT_PVS\n"<<rssTree->GetRootPvsSize()<<endl;
	  }
	  
	  if (mUpdateSubdivision) {
		int subdivided = rssTree->UpdateSubdivision();
		cout<<"subdivided leafs = "<<subdivided<<endl;
		cout<<"#total leaves = "<<rssTree->stat.Leaves()<<endl;
	  }
	}
	
	if (mExportRays) {
	  char filename[64];
	  if (mUseImportanceSampling)
		sprintf(filename, "rss-rays-i%04d.x3d", rssPass);
	  else
		sprintf(filename, "rss-rays-%04d.x3d", rssPass);
	  
	  ExportRays(filename, vssRays, mExportNumRays);
	}

	
	if (mExportPvs) {
	  char filename[64];
	  sprintf(filename, "rss-pvs-%04d.x3d", rssPass);
	  ExportPvs(filename, rssTree);
	}

	if (totalSamples >= mRssSamples + mInitialSamples)
	  break;

	
	rssPass++;
	mPass++;
  }
  
  if (mUseViewcells) {


  //-- render simulation after merge
  cout << "\nevaluating bsp view cells render time after merge ... ";
  
  mRenderSimulator->RenderScene();
  SimulationStatistics ss;
  mRenderSimulator->GetStatistics(ss);

  cout << " finished" << endl;
  cout << ss << endl;
  Debug << ss << endl;

  }

  delete rssTree;
  
  return true;
}