#include "tasks.h"
#include "hades.h"
#include "hmdccalibrater1.h"
#include "hmdclowlevelqa.h"
#include "hrichIPUparthresholds.h"
#include "hrichIPUparlocmax.h"
#include "muEmulationSim.h"
#include "muEmulationExp.h"
#include "TFile.h"

extern TString *masterTaskConfig;
extern TString *detectors;
extern TString *startTaskConfig;
extern Hades *myHades;
extern TString *mdcTaskConfig;
extern Bool_t findVertex;
extern TString *kickTaskConfig;
extern TString *calTaskConfig;
extern TString *momentumTaskConfig;
extern Int_t repRate;
extern Bool_t evalTimer;
extern Bool_t runQa;
extern TString *qaDir;
extern Bool_t runMdcQa;
extern TString *mdcQaName;
extern Int_t qaSamplingRate;
extern Int_t qaInterval;
extern Char_t outname[200];
extern Float_t mdcGlobalOffset1;
extern Float_t mdcGlobalOffset2;
extern Float_t mdcGlobalOffset3;
extern Float_t mdcGlobalOffset4;
extern TString *richTaskConfig;
extern TString *richIPUTaskConfig;
extern TString *showerTaskConfig;
extern TString *showertofinoTaskConfig;
extern TString *triggerTaskConfig;
extern TString *tofTaskConfig;
extern TString *tofinoTaskConfig;
extern HRichIPUParThresholds *riputhr2;
extern HRichIPUParLocMax *ripuloc2;
extern Bool_t makeTree;

Bool_t setupTasksets(void)
{
	TString *tmp;

	if((masterTaskConfig->CompareTo("real") == 0) || (masterTaskConfig->CompareTo("merge") == 0))
		{
			masterTaskSetReal = myHades->getTaskSet("real");
			masterTaskSetCal = myHades->getTaskSet("calibration");
		}
	else
		{
			if(masterTaskConfig->CompareTo("simulation") == 0)
				{
					masterTaskSetReal = myHades->getTaskSet("simulation");
				}
			else
				if(masterTaskConfig->CompareTo("merge") == 0)
					{
						masterTaskSetReal = myHades->getTaskSet("merge");
					}
		}
	if(masterTaskSetReal)
		{
			if(detectors->Contains("START") && (!(masterTaskConfig->CompareTo("simulation") == 0)) || 
				 !(masterTaskConfig->CompareTo("merge") == 0))
				{
					startTaskSet = new HStartTaskSet("start","start");
					startTask = startTaskSet->make(startTaskConfig->Contains("RTDB")==1?"rtdb":"",
																				 startTaskConfig->Contains("RTDB")==0?
																				 startTaskConfig->Data():"");
					masterTaskSetReal->add(startTask);
				}
			if(detectors->Contains("TOF"))
				{
					tofTaskSet = new HTofTaskSet("tof","tof");
					tofTask = tofTaskSet->make((tofTaskConfig->Contains("REAL")==1||
																			tofTaskConfig->Contains("SIMULATION")==1)?
																		 tofTaskConfig->Data()
																		 :"",tofTaskConfig->Contains("CLUS")==1?
																		 tofTaskConfig->Data():"");
					masterTaskSetReal->add(tofTask);
				}
			if(detectors->Contains("TOFINO"))
				{
					tofinoTaskSet = new HTofinoTaskSet("tofino","tofino");
					tofinoTask = tofinoTaskSet->make(tofinoTaskConfig->Contains("RTDB")==1?"rtdb":"",
																					 tofinoTaskConfig->Contains("RTDB")==0?
																					 tofinoTaskConfig->Data():"");
					masterTaskSetReal->add(tofinoTask);
				}
			if((masterTaskConfig->CompareTo("simulation") == 0) || (masterTaskConfig->CompareTo("merge") == 0))
				{
					evtFilterTasks  = new HTaskSet("EvtFilter","List of Evt Filter Tasks");
					richEvtFilterTask = new HRichEvtFilter("Tof+Tofino_Mult","Tof+Tofino_Mult","tofmult",4);
					evtFilterTasks->connect(richEvtFilterTask);
				}
			if(detectors->Contains("RICH"))
				{
					richTaskSet = new HRichTaskSet("rich","rich");
					richTask = richTaskSet->make((richTaskConfig->Contains("REAL")==1||
																							richTaskConfig->Contains("SIMULATION")==1)?
																						 richTaskConfig->Data()
																						 :"",(richTaskConfig->Contains("LOWFIELD")==1||
																									richTaskConfig->Contains("NOISEON")==1)?
																						 richTaskConfig->Data()
																						 :"");
					masterTaskSetReal->add(richTask);
					richIpuTaskSet = new HRichIPUTaskSet("richIPU","richIPU");
					richIpuTask = richIpuTaskSet->make((richIPUTaskConfig->Contains("REAL")==1||
																							richIPUTaskConfig->Contains("SIMULATION")==1)?
																						 richIPUTaskConfig->Data()
																						 :"",richIPUTaskConfig->Contains("CLUS")==1?
																						 richIPUTaskConfig->Data():"");
					masterTaskSetReal->add(richIpuTask);
					if(masterTaskConfig->CompareTo("simulation") == 0)
					{
						richChernovFitter = new HRichChernovRingFitter("HRichChernovRingFitter",
																													 "HRichChernovRingFitter",
																													 kFALSE);
						if(richChernovFitter)
							masterTaskSetReal->add(richChernovFitter);
					}
				}
			if(detectors->Contains("MDC"))
				{
					mdcTaskSet = new HMdcTaskSet("mdc","mdc");
					mdcTask = mdcTaskSet->make(mdcTaskConfig->Contains("RTDB")==1?"rtdb":"",
																		 mdcTaskConfig->Contains("RTDB")==0?
																		 mdcTaskConfig->Data():"");
					if((mdcGlobalOffset1 !=0) || (mdcGlobalOffset2!=0) ||
						 (mdcGlobalOffset3 !=0) || (mdcGlobalOffset4!=0))
						mdcTaskSet->getCalibrater1()->setGlobalOffset(mdcGlobalOffset1,
																													mdcGlobalOffset2,
																													mdcGlobalOffset3,
																													mdcGlobalOffset4);
					if(findVertex)
						{
							vertexFinder = new HMdcVertexFind("vertexfinder","vertexfinder");
							mdcTaskSet->add(vertexFinder);
						}
					masterTaskSetReal->add(mdcTask);
				}
			if(detectors->Contains("SHOWER"))
				{
					showerTaskSet = new HShowerTaskSet("shower","shower");
					showerTask = showerTaskSet->make(showerTaskConfig->Contains("RTDB")==1?"rtdb":"",
																					 showerTaskConfig->Contains("RTDB")==0?
																					 showerTaskConfig->Data():"");
					masterTaskSetReal->add(showerTask);
				}
			if(detectors->Contains("TRIGGER"))
				{
					triggerTaskSet = new HTriggerTaskSet();
					triggerTask    = triggerTaskSet->make(triggerTaskConfig->Data());
					masterTaskSetReal->add(triggerTask);
				}
			if(momentumTaskConfig->Contains("KICKPLANE"))
				{
					kickTaskSet = new HKickTaskSet("kick","kick");
					kickTask = kickTaskSet->make(kickTaskConfig->Contains("RTDB")==1?"rtdb":"",
																			 kickTaskConfig->Contains("RTDB")==0?
																			 kickTaskConfig->Data():"");
					masterTaskSetReal->add(kickTask);
				}
			if((detectors->Contains("SHOWER")) && (detectors->Contains("TOFINO")) &&
				 (momentumTaskConfig->Contains("KICKPLANE")))
				{
					showerTofinoTaskSet = new HShowerTofinoTaskSet("showertofino","showertofino");
					showerTofinoTask = showerTofinoTaskSet->make(showertofinoTaskConfig->Contains("RTDB")==1?"rtdb":"",
																											 showertofinoTaskConfig->Contains("RTDB")==0?
																											 showertofinoTaskConfig->Data():"");
					masterTaskSetReal->add(showerTofinoTask);
				}
			if((momentumTaskConfig->Contains("SPLINE")) || (momentumTaskConfig->Contains("KICKTRACK")))
				{
					metamatchingTaskSet = new HTaskSet("metamatching","metamatching");
					metamatchingf = new HMetaMatchF("metamatching","metamatching");
					metamatchingTaskSet->connect(metamatchingf);
					masterTaskSetReal->add(metamatchingTaskSet);
				}
			if(momentumTaskConfig->Contains("KICKTRACK"))
				{
					kicktrackbaseTaskSet = new HTaskSet("kicktracktask","kicktracktask");
					kickTrackBase        = new HKickTrackBaseF("kicktrackbase","kicktrackbase");
					kicktrackbaseTaskSet->connect(kickTrackBase);
					masterTaskSetReal->add(kicktrackbaseTaskSet);
				}
			if(momentumTaskConfig->Contains("SPLINE"))
				{
					splineTaskSet= new HTaskSet("SplineFit","SplineFit");
					splinetrack = new HSplineTrackF("splinetrack","splinetrack");
					splineTaskSet->connect(splinetrack);
					masterTaskSetReal->add(splineTaskSet);
				}
			if(momentumTaskConfig->Contains("RT"))
				{
					rtTaskSet = new HTaskSet("rt","rt");
					rtTask = new HRtTrackFind("rtTrack","rtTrack");
					rtTaskSet->connect(rtTask);
					masterTaskSetReal->add(rtTaskSet);
				}

			if((runQa) && (makeTree))
				{
					qa = new HQAMaker("qa.maker","qa.maker");
					qa->setOutputDir((Char_t *)qaDir->Data());
					qa->setSamplingRate(qaSamplingRate);
					qa->setIntervalSize(qaInterval);
					masterTaskSetReal->add(qa);
				}
			if(runMdcQa)
				{
					mdcLowLevelQa = new HMdcLowLevelQA("mdcLowLevelQa","mdcLowLevelQa");
					tmp = new TString(qaDir->Data());
					if(!tmp->EndsWith("/"))
						tmp->Append("/");
					tmp->Append(mdcQaName->Data());
					tmp->Append("_llqa.root");
					((HMdcLowLevelQA *)mdcLowLevelQa)->setOutputRoot((char *)tmp->Data());
					delete tmp;
					((HMdcLowLevelQA *)mdcLowLevelQa)->setStepSize(qaInterval);
					mdcLowLevelQaTaskSet = new HTaskSet("mdcLowLevelTaskSet","mdcLowLevelTaskSet");
					mdcLowLevelQaTaskSet->connect(mdcLowLevelQa);
					masterTaskSetReal->add(mdcLowLevelQaTaskSet);
				}
			if(evalTimer)
				masterTaskSetReal->isTimed(kTRUE);
			if(repRate > 0)
				myHades->makeCounter(repRate);
			if((detectors->Contains("TRIGGER")) && ((masterTaskConfig->CompareTo("simulation") == 0) ||
																							(masterTaskConfig->CompareTo("merge") == 0)))
				{
					((HMUEmulationSim*)(triggerTask->getTask("trigger.emu")))->setParThresholds(riputhr2);
					((HMUEmulationExp*)(triggerTask->getTask("trigger.emu")))->setParLocMax(ripuloc2);
				}
		}
	else
		return kFALSE;
	if(!(masterTaskConfig->CompareTo("simulation") == 0))
		{
			if(masterTaskSetCal)
				{
					if(calTaskConfig->Contains("MDC"))
						{
							mdcCalTaskSet = new HTaskSet("mdcCal","mdcCal");
							mdcCalTask = new HMdcSlope("MdcSlope","Mdc slope");
							mdcCalTaskSet->add(mdcCalTask);
							masterTaskSetCal->add(mdcCalTaskSet);
						}
					if(evalTimer)
						masterTaskSetCal->isTimed(kTRUE);
				}
			else
				return kFALSE;
		}
	return kTRUE;
}