#include "SamplingPreprocessor.h"
#include "VssPreprocessor.h"
#include "RssPreprocessor.h"
#include "ExactPreprocessor.h"
#include "Parser.h"
#include "UnigraphicsParser.h"
#include "X3dParser.h"
#include "Environment.h"
#include "Camera.h"
#include "MeshKdTree.h"
#include "Exporter.h"
#include "ViewCell.h"
#include "SceneGraph.h"
#include "BoostPreprocessorThread.h"
#include "RenderSampler.h"
#include "ResourceManager.h"
#include "GlRenderer.h"

#define USE_EXE_PATH false

#include <crtdbg.h>

using namespace GtpVisibilityPreprocessor;

Preprocessor *preprocessor = NULL;
GlRenderWidget *renderWidget = NULL;


void Cleanup()
{
	DEL_PTR(renderWidget);
	DEL_PTR(preprocessor);

	Environment::DelSingleton();
	MeshManager::DelSingleton();
	MaterialManager::DelSingleton();
}


void DisplayWidget()
{
	// note matt: capsulate qt dependent code as good as possible
	renderWidget = 
		new GlRenderWidget(preprocessor->mSceneGraph, 
						   preprocessor->mViewCellsManager, 
						   preprocessor->mKdTree);

	renderWidget->Show();

#if QT_ENABLED

	// create a qt application first (must be created before any opengl widget ...)
	app = new QApplication(argc, argv);

	if (!QGLFormat::hasOpenGL() || !QGLPixelBuffer::hasOpenGLPbuffers()) {
		QMessageBox::information(0, "OpenGL pbuffers", 
			"This system does not support OpenGL/pbuffers.",
			QMessageBox::Ok);
		return -1;
	}
	
	// note matt: capsulate qt dependent code as good as possible
	rendererWidget = 
		new GlRendererWidget(p->mSceneGraph, p->mViewCellsManager, p->mKdTree);

	rendererWidget->resize(640, 480);
	rendererWidget->show();

	if (0 && p->GetRenderer()) 
	{
		cout<<"CONNECTING"<<endl;
		QObject::connect(p->GetRenderer(),
		SIGNAL(UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &)),
				rendererWidget->mControlWidget, 
				SLOT(UpdatePvsErrorItem(int i,
				GlRendererBuffer::PvsErrorEntry &)));

		cout<<"CONNECTED"<<endl;
	}
#endif
}


int
main(int argc, char **argv)
{

	//Now just call this function at the start of your program and if you're
	//compiling in debug mode (F5), any leaks will be displayed in the Output
	//window when the program shuts down. If you're not in debug mode this will
	//be ignored. Use it as you will!
	//note: from GDNet Direct [3.8.04 - 3.14.04] void detectMemoryLeaks() {
	_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);
	_CrtSetReportMode(_CRT_ASSERT,_CRTDBG_MODE_FILE);
	_CrtSetReportFile(_CRT_ASSERT,_CRTDBG_FILE_STDERR); 

	int returnCode = 0;

	InitTiming();

	Debug.open("debug.log");

	Environment::GetSingleton()->Parse(argc, argv, USE_EXE_PATH);
	MeshKdTree::ParseEnvironment();

	char buff[128];
	Environment::GetSingleton()->GetStringValue("Preprocessor.type", buff);
	string preprocessorType(buff);

	if (preprocessorType == "vss")
	{
		preprocessor = new VssPreprocessor();
	}
	else
	{
		if (preprocessorType == "rss")
		{
			preprocessor = new RssPreprocessor();
		}
		else
		{
			if (preprocessorType == "exact")
			{
				preprocessor = new ExactPreprocessor();
			}
			else
			{
				if (preprocessorType == "sampling")
				{
					preprocessor = new SamplingPreprocessor();
				}
				else
				{	
					if (preprocessorType == "render")
					{
						preprocessor = new RenderSampler();
					}
					else {
						Environment::DelSingleton();
						cerr<<"Unknown preprocessor type"<<endl;
						Debug<<"Unknown preprocessor type"<<endl;
						exit(1);
					}
				}
			}
		}
	}
	

	//-- load scene 

	Environment::GetSingleton()->GetStringValue("Scene.filename", buff);
	string filename(buff);
	preprocessor->LoadScene(filename);

	//-- build kd tree from scene geometry

	preprocessor->BuildKdTree();
	preprocessor->KdTreeStatistics(cout);

	// parse view cells related options
	preprocessor->PrepareViewCells();

	//  p->mSceneGraph->Export("soda.x3d");
	if (0) {
		preprocessor->Export(filename + "-out.x3d", true, false, false);
		preprocessor->Export(filename + "-kdtree.x3d", false, true, false);	
	}


	// create a preprocessor thread
	//PreprocessorThread *pt = new PreprocessorThread(p, app);
	BoostPreprocessorThread pt(preprocessor);

	if (preprocessor->mUseGlRenderer || preprocessor->mUseGlDebugger)
	{
		// display the render widget
		DisplayWidget();

		// create and run the preprocessor application in a parallel thread
		pt.InitThread();
		pt.RunThread();
	} 
	else
	{
		// just call the mail method -> will be executed in the main thread
		pt.Main();
	}


	Cleanup();

	return returnCode;
}