#include "TH3F.h"
#include "MapsTrackManager.hh"
#include "MapsTrack.hh"
#include "MapsSensor.hh"
#include "MapsException.hh"
#include <cmath>
#include <vector>
#include "TRandom2.h"
#include "TFile.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TApplication.h"
#include "TCanvas.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TThread.h"
#include "TStyle.h"
#include "TPaveText.h"
#include "TText.h"
#include "ToString.h"
#include "TVirtualViewer3D.h"
#include "TGeoBBox.h"
#include "Rtypes.h"
#include "TVirtualGeoPainter.h"
#include "TGLViewer.h"
#include <signal.h>

/** DisplayTrack.cpp
 * 
 * Use this to interactively display tracks on screen. 
 * Use of ROOT's OpenGL viewer is recommended.
 * 
 * Jamie Ballin, Imperial College London
 * 		February 2008
 * 
 * j.ballin06@imperial.ac.uk
 */

TApplication* theApp;
TCanvas * c;
TVirtualViewer3D* v;
TGLViewer* viewer;

bool continueJob=true;

void signalHandler(int signal) {
	std::cerr << "Process "<< getpid() << " received signal "<< signal
			<< std::endl;
	continueJob=false;
}

void startSender(void* inA) {
	MapsTrackManager mtm2;
	char* input = static_cast<char*>(inA);
	mtm2.recreateFromRootFile(input);

	TH3F
			* disp =
					new TH3F("hDisplay", "Event display;x;y;z", 100, -5.0, 5.0, 100, -5.0, 5.0, 64, 0, 64);
	disp->SetMarkerColor(2);
	disp->SetMarkerStyle(22);
	disp->SetMarkerSize(2.0);

	std::cout << "Iterating..." << std::endl;
	std::vector<MapsTrack*>& tracks = mtm2.getTracks();

	for (std::vector<MapsTrack*>::iterator it = tracks.begin(); it
			!= tracks.end(); it++) {
		MapsTrack* t = *it;
		t->eraseGlobalHits();
		std::pair<double, double> error(0.1, 0.1);
		t->setTrackError(error);
		disp->Reset();
		

		if (t->chiSqProb(0) > 0.05 && t->chiSqProb(1) > 0.05 && t->getHits().size() == 4) {
			std::map<MapsSensor*, MapsSensor::physXY > hits =
					t->getGlobalHits();
			diagnose(std::cout, *t);

			for (std::map<MapsSensor*, MapsSensor::physXY >::const_iterator h =
					hits.begin(); h != hits.end(); ++h) {
				MapsSensor::physXY theHit = (*h).second;
				disp->Fill(theHit.first, theHit.second, (*h).first->zPosition()+1);
			}
			disp->Draw("ogl");
			TPaveText tp(0.1, 0.1, 0.4, 0.4);
			tp.AddText("Track diagnosis");
			tp.AddText(("p_{x} = " + toString(t->chiSqProb(0))).c_str());
			tp.AddText(("p_{y} = " + toString(t->chiSqProb(1))).c_str());
			tp.AddText(("#theta = " + toString(t->theta())).c_str());
			tp.Draw("ogl");
			c->Modified();
			c->Update();

			std::cout << "Hit return to display next...\n";
			std::string input;
			std::getline(std::cin, input);

		}
	}

	std::cout << "Finished displaying events. Ctrl-C me. \n";
}

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

	for (int d(0); d < argc; d++) {
		std::cout << argv[d] << "\n";
	}
	if (argc != 2) {
		std::cout << "Usage: DisplayTrack <input file>\n";
		return 0;
	}

	signal(SIGINT, signalHandler);
	signal(SIGTERM, signalHandler);

	std::cout << "Recreating from root file...\n";
	char input[100];
	strcpy(input, argv[1]);

	//mtm2.recreateFromRootFile(input);
	std::cout << "Constructing ROOT application..." << std::endl;
	theApp = new TApplication("App", 0, 0);
	gROOT->Reset();
	gStyle->SetCanvasPreferGL(kTRUE);
	gStyle->SetPalette(1);

	std::cout << "Starting worker thread..." << std::endl;

	c = new TCanvas("c", "The Hello Canvas", 600, 600);

	TThread* guiTh = new TThread("guiTh", startSender, input);
	guiTh->Run();

	std::cout << "Starting gui..." << std::endl;
	while (!gSystem->ProcessEvents() && continueJob) {
		//c->Modified();
		//c->Update();
	}

	std::cout << "Terminating..." << std::endl;

	delete guiTh;
	delete theApp;
}