#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"
#include "GlRenderer.h"

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


// not supported anymore!
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.objectBasedSampling", mObjectBasedSampling);
  environment->GetBoolValue("RssPreprocessor.directionalSampling", mDirectionalSampling);

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


bool
RssPreprocessor::GenerateRays(
							  const int number,
							  const int sampleType,
							  SimpleRayContainer &rays
							  )
{
  bool result = false;

  switch (sampleType) {
  case RSS_BASED_DISTRIBUTION:
  case RSS_SILHOUETTE_BASED_DISTRIBUTION:
	if (mRssTree) {
	  GenerateImportanceRays(mRssTree, number, rays);
	  result = true;
	  //	  rays.NormalizePdf();
	}
	break;
  default:
	result = Preprocessor::GenerateRays(number, sampleType, rays);
  }

  return result;
}

void
RssPreprocessor::CastRays(
						  SimpleRayContainer &rays,
						  VssRayContainer &vssRays
						  )
{
  for (int i=0; i < rays.size(); i++)
	CastRay(rays[i].mOrigin, rays[i].mDirection, rays[i].mPdf, vssRays);
}


RssPreprocessor::~RssPreprocessor()
{
  // mVssRays get deleted in the tree
  //  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,
						 const float probability,
						 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);

  if (!mDetectEmptyViewSpace)
	ray.mFlags &= ~Ray::CULL_BACKFACES;
  else
	ray.mFlags |= Ray::CULL_BACKFACES;


  // 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;
	if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
	  pointA = ray.Extrap(tmax);
	else
	  return 0;
  }


  if (mDetectEmptyViewSpace) {
	SetupRay(ray, pointA, -direction);
  } else
	SetupRay(ray, viewPoint, -direction);
	
  if (!mDetectEmptyViewSpace)
	ray.mFlags &= ~Ray::CULL_BACKFACES;
  else
	ray.mFlags |= Ray::CULL_BACKFACES;

  if (mKdTree->CastRay(ray)) {
	objectB = ray.intersections[0].mObject;
	pointB = ray.Extrap(ray.intersections[0].mT);
  } else {
	objectB = NULL;
	float tmin, tmax;
	if (box.ComputeMinMaxT(ray, &tmin, &tmax) && tmin < tmax)
	  pointB = ray.Extrap(tmax);
	else
	  return 0;
  }

  //  if (objectA == NULL && objectB != NULL) {
  if (mDetectEmptyViewSpace) {
	// cast again to ensure that there is no objectA
	SetupRay(ray, pointB, direction);
	ray.mFlags |= Ray::CULL_BACKFACES;
	if (mKdTree->CastRay(ray)) {
	  objectA = ray.intersections[0].mObject;
	  pointA = ray.Extrap(ray.intersections[0].mT);
	}
  }
  
  
  VssRay *vssRay  = NULL;

  bool validSample = (objectA != objectB);
  if (validSample) {
	if (objectA) {
	  vssRay = new VssRay(pointB,
						  pointA,
						  objectB,
						  objectA,
						  mPass,
						  probability
						  );
	  vssRays.push_back(vssRay);
	  hits ++;

	}
	
	if (objectB) {
	  vssRay = new VssRay(pointA,
						  pointB,
						  objectA,
						  objectB,
						  mPass,
						  probability
						  );
	  vssRays.push_back(vssRay);
	  hits ++;
	}
  }
  
  return hits;
}


void
RssPreprocessor::ExportObjectRays(VssRayContainer &rays,
								  const int objectId)
{
  ObjectContainer::const_iterator oi;

  Intersectable *object = NULL;
  for (oi = mObjects.begin(); oi != mObjects.end(); ++oi)
	if (objectId == (*oi)->GetId()) {
	  object = *oi;
	  break;
	}

  if (object == NULL)
	return;
  
  VssRayContainer selectedRays;
  VssRayContainer::const_iterator it= rays.begin(), it_end = rays.end();

  
  for (; it != it_end; ++it) {
	if ((*it)->mTerminationObject == object)
	  selectedRays.push_back(*it);
  }
  

  Exporter *exporter = Exporter::GetExporter("object-rays.x3d");
  //	exporter->SetWireframe();
  //	exporter->ExportKdTree(*mKdTree);
  exporter->SetFilled();
  exporter->ExportIntersectable(object);
  exporter->ExportRays(selectedRays, RgbColor(1, 0, 0));
  
  delete exporter;
  
}


int
RssPreprocessor::GenerateImportanceRays(RssTree *rssTree,
										const int desiredSamples,
										SimpleRayContainer &rays
										)
{
  int num;

  rssTree->UpdateTreeStatistics();

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


bool
RssPreprocessor::ExportRays(const char *filename,
							const VssRayContainer &vssRays,
							const int number
							)
{
  cout<<"Exporting vss rays..."<<endl<<flush;
	
  Exporter *exporter = NULL;
  exporter = Exporter::GetExporter(filename);
  //	exporter->SetWireframe();
  //	exporter->ExportKdTree(*mKdTree);
  exporter->SetFilled();
  // $$JB temporarily do not export the scene
  if (0)
	exporter->ExportScene(mSceneGraph->mRoot);
  exporter->SetWireframe();

  if (mViewSpaceBox) {
	exporter->SetForcedMaterial(RgbColor(1,0,1));
	exporter->ExportBox(*mViewSpaceBox);
	exporter->ResetForcedMaterial();
  }
	
  VssRayContainer rays;
  
  vssRays.SelectRays( number, rays);

  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;
  }
}


void
RssPreprocessor::ComputeRenderError()
{
  // compute rendering error
  if (renderer) {
	//	emit EvalPvsStat();
	//	QMutex mutex;
	//	mutex.lock();
	//	renderer->mRenderingFinished.wait(&mutex);
	//	mutex.unlock();

	renderer->EvalPvsStat();
	mStats <<
	  "#AvgPvsRenderError\n" <<renderer->mPvsStat.GetAvgError()<<endl<<
	  "#MaxPvsRenderError\n" <<renderer->mPvsStat.GetMaxError()<<endl<<
	  "#ErrorFreeFrames\n" <<renderer->mPvsStat.GetErrorFreeFrames()<<endl;
  }
}



bool
RssPreprocessor::ComputeVisibility()
{

	Debug << "type: rss" << endl;

  cout<<"Rss Preprocessor started\n"<<flush;
  //  cout<<"Memory/ray "<<sizeof(VssRay)+sizeof(RssTreeNode::RayInfo)<<endl;

  Randomize(0);
  
	
  long startTime = GetTime();
  
  int totalSamples = 0;

  mViewSpaceBox = NULL;

  // if not already loaded, construct view cells from file
  if (!mLoadViewCells) {	
	
	  mViewCellsManager->SetViewSpaceBox(mKdTree->GetBox());

	  // construct view cells using it's own set of samples
	  mViewCellsManager->Construct(this);

	  //-- several visualizations and statistics
	  Debug << "view cells after construction: " << endl;
	  mViewCellsManager->PrintStatistics(Debug);
  }


  int rssPass = 0;
  int rssSamples = 0;
  
  if (mLoadInitialSamples) {
	cout << "Loading samples from file ... ";
	LoadSamples(mVssRays, mObjects);
	cout << "finished\n" << endl;
  } else {
	SimpleRayContainer rays;

	GenerateRays(mInitialSamples/4, SPATIAL_BOX_BASED_DISTRIBUTION, rays);
	GenerateRays(mInitialSamples/4, OBJECT_BASED_DISTRIBUTION, rays);
	GenerateRays(mInitialSamples/4, DIRECTION_BASED_DISTRIBUTION, rays);
	GenerateRays(mInitialSamples/4, OBJECT_DIRECTION_BASED_DISTRIBUTION, rays);
	
	CastRays(rays, mVssRays);

	ExportObjectRays(mVssRays, 1546);
  }
  
  cout << "#totalRayStackSize=" << (int)mVssRays.size() << endl <<flush;
  
  rssSamples += (int)mVssRays.size();
  totalSamples += mInitialSamples;
  mPass++;
  
  if (mExportRays) {
	
	char filename[64];
	sprintf(filename, "rss-rays-initial.x3d");
	ExportRays(filename, mVssRays, mExportNumRays);
	
  }
  
  if (mStoreInitialSamples) {
	cout << "Writing samples to file ... ";
	ExportSamples(mVssRays);
	cout << "finished\n" << endl;
  }
	
  if (mUseViewcells) {

	// evaluate contributions of the intitial rays
	mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);
	
	
	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;

	{
	  VssRayContainer contributingRays;
	  mVssRays.GetContributingRays(contributingRays, mPass);
	  mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
	}
	
	mVssRays.PrintStatistics(mStats);
	mViewCellsManager->PrintPvsStatistics(mStats);
	  
	// viewcells->UpdatePVS(newVssRays);
	Debug<<"Valid viewcells before set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;
	// cull viewcells with PVS > median (0.5f)
	mViewCellsManager->SetValidityPercentage(0, 0.5f); 
	Debug<<"Valid viewcells after set validity: "<<mViewCellsManager->CountValidViewcells()<<endl;
	
	ComputeRenderError();
  }
  
  rssPass++;
  
  mRssTree = new RssTree;
  mRssTree->SetPass(mPass);
  
  /// compute view cell contribution of rays if view cells manager already constructed
  mViewCellsManager->ComputeSampleContributions(mVssRays, true, false);

  if (mUseImportanceSampling) {
	
	mRssTree->Construct(mObjects, mVssRays);
	
	mRssTree->stat.Print(mStats);
	cout<<"RssTree root PVS size = "<<mRssTree->GetRootPvsSize()<<endl;
	
	if (mExportRssTree) {
	  ExportRssTree("rss-tree-100.x3d", mRssTree, Vector3(1,0,0));
	  ExportRssTree("rss-tree-001.x3d", mRssTree, Vector3(0,0,1));
	  ExportRssTree("rss-tree-101.x3d", mRssTree, Vector3(1,0,1));
	  ExportRssTree("rss-tree-101m.x3d", mRssTree, Vector3(-1,0,-1));
	  ExportRssTreeLeaves(mRssTree, 10);
	}
	
	if (mExportPvs) {
	  ExportPvs("rss-pvs-initial.x3d", mRssTree);
	}
  }
  
  
  while (1) {
	SimpleRayContainer rays;
	VssRayContainer vssRays;
	int castRays = 0;
	if (mUseImportanceSampling) {
	  VssRayContainer tmpVssRays;

	  float ratios[] = {0.8f,0.1f,0.1f};

	  
	  
	  GenerateRays(mRssSamplesPerPass*ratios[0], RSS_BASED_DISTRIBUTION, rays);
	  CastRays(rays, tmpVssRays);
	  castRays += rays.size();
	  float c1 = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
	  mStats<<"#RssRelContrib"<<endl<<c1/rays.size()<<endl;

	  vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
	  rays.clear();
	  tmpVssRays.clear();

	  if (ratios[1]!=0.0f) {
		GenerateRays(mRssSamplesPerPass*ratios[1], SPATIAL_BOX_BASED_DISTRIBUTION, rays);
		CastRays(rays, tmpVssRays);
		castRays += rays.size();
		float c2 = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
		mStats<<"#SpatialRelContrib"<<endl<<c2/rays.size()<<endl;
		
		vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
		
		rays.clear();
		tmpVssRays.clear();
	  }
	  
	  
	  if (ratios[2]!=0.0f) {
		GenerateRays(mRssSamplesPerPass*ratios[2], DIRECTION_BASED_DISTRIBUTION, rays);
		CastRays(rays, tmpVssRays);
		castRays += rays.size();
		float c3 = mViewCellsManager->ComputeSampleContributions(tmpVssRays, false, true);
		mStats<<"#DirectionalRelContrib"<<endl<<c3/rays.size()<<endl;
		
		vssRays.insert(vssRays.end(), tmpVssRays.begin(), tmpVssRays.end() );
		
		rays.clear();
		tmpVssRays.clear();
	  }
	  
	  // add contributions of all rays at once...
	  mViewCellsManager->AddSampleContributions(vssRays);
	  
	}
	else {
	  int rayType = SPATIAL_BOX_BASED_DISTRIBUTION;
	  if (mObjectBasedSampling)
		rayType = OBJECT_BASED_DISTRIBUTION;
	  else
		if (mDirectionalSampling)
		  rayType = DIRECTION_BASED_DISTRIBUTION;
	  
	  GenerateRays(mRssSamplesPerPass, rayType, rays);
	  CastRays(rays, vssRays);
	  castRays += rays.size();
	  if (mUseViewcells) {
		/// compute view cell contribution of rays
		mViewCellsManager->ComputeSampleContributions(vssRays, true, false);
	  }
	  	
	  
	}
	totalSamples += castRays;
	rssSamples += (int)vssRays.size();

	cout<<"Generated "<<castRays<<" rays, progress "<<totalSamples/((float) mRssSamples +
																	mInitialSamples)<<"%\n";
	
	
	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) {
	  vssRays.PrintStatistics(mStats);
	  mViewCellsManager->PrintPvsStatistics(mStats);
	}

	if (0 && mPass > 0) {
	  if (mUseImportanceSampling)
		renderer->mSnapPrefix.sprintf("snap/i-%02d-", mPass);
	  else
		renderer->mSnapPrefix.sprintf("snap/r-%02d-", mPass);
	  renderer->mSnapErrorFrames = true;
	}

	ComputeRenderError();
	
	// epxort rays before adding them to the tree -> some of them can be deleted

	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);

	  // now export all contributing rays
	  VssRayContainer contributingRays;
	  vssRays.GetContributingRays(contributingRays, mPass);
	  mStats<<"#NUM_CONTRIBUTING_RAYS\n"<<(int)contributingRays.size()<<endl;
	  sprintf(filename, "rss-crays-%04d.x3d", rssPass);
	  ExportRays(filename, contributingRays, mExportNumRays);
	}

	
	// 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) {
	  mRssTree->AddRays(vssRays);
	  
	  if (mUpdateSubdivision) {
		int updatePasses = 1;
		if (mPass % updatePasses == 0) {
		  int subdivided = mRssTree->UpdateSubdivision();
		  cout<<"subdivided leafs = "<<subdivided<<endl;
		  cout<<"#total leaves = "<<mRssTree->stat.Leaves()<<endl;
		}
	  }
	}
	
	if (mExportPvs) {
	  char filename[64];
	  sprintf(filename, "rss-pvs-%04d.x3d", rssPass);
	  ExportPvs(filename, mRssTree);
	}
	
	
	if (!mUseImportanceSampling) 
	  CLEAR_CONTAINER(vssRays);
	// otherwise the rays get deleted by the rss tree update according to RssTree.maxRays ....

	if (totalSamples >= mRssSamples + mInitialSamples)
	  break;

	
	rssPass++;
	mPass++;
	mRssTree->SetPass(mPass);
  }
  
  if (mUseViewcells) {

	  if(0)
	  {
		  VssRayContainer selectedRays;
		  int desired = mViewCellsManager->GetVisualizationSamples();

		  mVssRays.SelectRays(desired, selectedRays);

		  mViewCellsManager->Visualize(mObjects, selectedRays);
	  }
	  
	  // view cells after sampling
	  mViewCellsManager->PrintStatistics(Debug);
      
	  //-- render simulation after merge
	  cout << "\nevaluating bsp view cells render time after sampling ... ";
	  
	  mRenderSimulator->RenderScene();
	  SimulationStatistics ss;
	  mRenderSimulator->GetStatistics(ss);
	  
	  cout << " finished" << endl;
	  cout << ss << endl;
	  Debug << ss << endl;
	
  }
  
  Debug<<"Deleting RSS tree...\n";
  delete mRssTree;
  Debug<<"Done.\n";

  
  return true;
}