#ifndef __CREATEHADES__
#define __CREATEHADES__


#include "hades.h"
#include "hruntimedb.h"
#include "hdatasource.h"
#include "hrootsource.h"
#include "hldsource.h"
#include "hldfilesource.h"
#include "hldgrepfilesource.h"
#include "hldremotesource.h"
#include "hparora2io.h"
#include "hparasciifileio.h"
#include "hparrootfileio.h"
#include "htask.h"
#include "htaskset.h"

#include "hspectrometer.h"
#include "hstart2detector.h"
#include "htboxdetector.h"
#include "hrichdetector.h"
#include "hmdcdetector.h"
#include "htofdetector.h"
#include "hshowerdetector.h"
#include "hrpcdetector.h"
#include "hwalldetector.h"

#include "hstarttaskset.h"
#include "hrichtaskset.h"
#include "hmdctaskset.h"
#include "htoftaskset.h"
#include "hwalltaskset.h"
#include "hshowertaskset.h"
#include "hrpctaskset.h"
#include "hsplinetaskset.h"

#include "hparticlecandfiller.h"
#include "hparticletrackcleaner.h"
#include "hparticleevtinfofiller.h"


#include "hmdcunpacker.h"
#include "hrichunpacker.h"
#include "hrpctrb2unpacker.h"
#include "htoftrb2unpacker.h"
#include "hstart2trb2unpacker.h"
#include "hwalltrb2unpacker.h"
#include "hshowerunpacker.h"
#include "hlatchunpacker.h"
#include "htboxunpacker.h"

#include "hmdcsetup.h"
#include "hmdclayercorrpar.h"
#include "hmdctrackdset.h"
#include "hmdctrackfinder.h"
#include "hmdc34clfinder.h"
#include "hmdcidealtracking.h"

#include "hmdcsizescells.h"
#include "hmdcgetcontainers.h"

#include "hedhelpers.h"

#include "TOrdCollection.h"

Bool_t initDetectorSetup();
Bool_t setDataSource (Int_t sourceType,TString inDir,TString inFile="", Int_t refId   = -1 ,TString eventbuilder = "lxhadeb02.gsi.de");
Bool_t setParamSource(TString paramSource,TString asciiParFile,TString rootParFile);

Bool_t createHades(Int_t   datasource,
		   TString inputDir,
		   TString inputFile,
		   Int_t   refId,
                   TString eventbuilder,
		   TString paramSource,
		   TString asciiParFile,
                   TString rootParFile
		  )
{

    cout<<"-----------------------------------------------------------------------------"<<endl;
    cout<<"EVENT DISPLAY : INPUT FILE: "<<inputDir.Data()<<inputFile.Data()<<endl;
    cout<<"-----------------------------------------------------------------------------"<<endl;
    Hades* myHades = new Hades();
    gHades->setTreeBufferSize(8000);
    gHades->setQuietMode(2);
    gHades->makeCounter(1);
    HRuntimeDb* rtdb = gHades->getRuntimeDb();

    // ------------ Set input data file: NO NEED TO CHANGE  --------------
    if(!setDataSource(datasource,inputDir,inputFile,refId,eventbuilder))  exit(1); // 0 = hld, 1 = hld grep 2= hldremote
    // ----------Add detectors to the setup: NO NEED TO CHANGE -----------
    if(!initDetectorSetup())                                 exit(1);
    //--------------------------------------------------------------------
    //  PARAMETER SOURCES
    if(!setParamSource(paramSource,asciiParFile,rootParFile))exit(1);
    //--------------------------------------------------------------------

    Int_t mdcUnpackers   [12] = {0x1100,0x1110,0x1120,0x1130,0x1140,0x1150,0x1000,0x1010,0x1020,0x1030,0x1040,0x1050};
    Int_t rpcUnpackers   [2]  = {0x8400,0x8410}; //
    Int_t startUnpackers [1]  = {0x8800};        //
    Int_t tofUnpackers   [1]  = {0x8600};        //
    Int_t wallUnpackers  [1]  = {0x8700};        //
    Int_t showerUnpackers[6]  = {0x3200,0x3210,0x3220,0x3230,0x3240,0x3250};        //
    Int_t richUnpackers  [3]  = {0x8300,0x8310,0x8320};


    HldSource* source = (HldSource*)gHades->getDataSource();


    for(UInt_t i=0; i<(sizeof(wallUnpackers)/sizeof(Int_t)); i++)
    {
	HWallTrb2Unpacker* wallUnpacker=new HWallTrb2Unpacker(wallUnpackers[i]);
	wallUnpacker->setQuietMode();
	wallUnpacker->setQuietMode();
	wallUnpacker->removeTimeRef();
	wallUnpacker->shiftTimes(7200.);

	source->addUnpacker( wallUnpacker);
    }

    source->addUnpacker( new HLatchUnpacker(startUnpackers[0]) );
    source->addUnpacker( new HTBoxUnpacker(startUnpackers[0]) );

    for(UInt_t i=0; i<(sizeof(richUnpackers)/sizeof(Int_t)); i++){
	source->addUnpacker( new HRichUnpacker(richUnpackers[i]) );
    }



    for(UInt_t i=0; i<(sizeof(mdcUnpackers)/sizeof(Int_t)); i++) {
	HMdcUnpacker* mdc_unpacker = new HMdcUnpacker(  mdcUnpackers[i], kTRUE );
	mdc_unpacker->setQuietMode(kTRUE);
	
	mdc_unpacker->setFillDataWord(kFALSE);
	mdc_unpacker->setFillOepStatus(kTRUE);
	mdc_unpacker->setPersistencyDataword(kTRUE);
	mdc_unpacker->setPersistencyOepStatusData(kFALSE);
	//mdc_unpacker->setStandaloneMode(kTRUE,1);
	source->addUnpacker( (HMdcUnpacker*)mdc_unpacker );
    }


    for(UInt_t i=0; i<(sizeof(showerUnpackers)/sizeof(Int_t)); i++) {
	source->addUnpacker( new HShowerUnpacker(showerUnpackers[i]) );
    }

    for(UInt_t i=0; i<(sizeof(tofUnpackers)/sizeof(Int_t)); i++){
	HTofTrb2Unpacker *tofUnp = new HTofTrb2Unpacker(tofUnpackers[i]);
	tofUnp->setDebugFlag(0);
	//tofUnp->setQuietMode();
	//tofUnp->setcorrectINL();
	//tofUnp->disableTimeRef();
	tofUnp->removeTimeRef();
	tofUnp->shiftTimes(7200.);
	source->addUnpacker( tofUnp );
    }

    for(UInt_t i=0; i<(sizeof(startUnpackers)/sizeof(Int_t)); i++){
	HStart2Trb2Unpacker *startUnp = new HStart2Trb2Unpacker(startUnpackers[i]);
	startUnp->setDebugFlag(0);
	//startUnp->setQuietMode();
	//startUnp->disableTimeRef();
    source->addUnpacker( startUnp );
    }

    for(UInt_t i=0; i<(sizeof(rpcUnpackers)/sizeof(Int_t)); i++){

	HRpcTrb2Unpacker *rpcTrb2Unpacker = new HRpcTrb2Unpacker(rpcUnpackers[i]);
	//rpcTrb2Unpacker->setQuietMode();
	rpcTrb2Unpacker->setDebugFlag(0);
	rpcTrb2Unpacker->setDebugFlag1(1);
	rpcTrb2Unpacker->storeSpareChannelsData();
	//rpcTrb2Unpacker->disableTimeRef();
	source->addUnpacker(rpcTrb2Unpacker);
    }


    //--------------------------------------------------------------------
    // ALIGNMENT OF WIRE PLANES
    HMdcLayerCorrPar* fMdcLayerCorrPar =  (HMdcLayerCorrPar*)rtdb->getContainer("MdcLayerCorrPar");
    //  fMdcLayerCorrPar->setDefaultPar();
    fMdcLayerCorrPar->setStatic();
    //--------------------------------------------------------------------

    // ----------- Build TASK SETS (using H***TaskSet::make) -------------
    HStartTaskSet        *startTaskSet        = new HStartTaskSet();
    HRichTaskSet         *richTaskSet         = new HRichTaskSet();
    HRpcTaskSet          *rpcTaskSet          = new HRpcTaskSet();
    HShowerTaskSet       *showerTaskSet       = new HShowerTaskSet();
    HTofTaskSet          *tofTaskSet          = new HTofTaskSet();
    HWallTaskSet         *wallTaskSet         = new HWallTaskSet();
    HMdcTaskSet          *mdcTaskSet          = new HMdcTaskSet();
    mdcTaskSet->setVersionDeDx(1); // 0 = no dEdx, 1 = HMdcDeDx2


    HTask *startTasks         = startTaskSet       ->make("","");
    HTask *richTasks          = richTaskSet        ->make("real","");
    HTask *tofTasks           = tofTaskSet         ->make("real");
    HTask *wallTasks          = wallTaskSet        ->make("real");
    HTask *rpcTasks           = rpcTaskSet         ->make("real");
    HTask *showerTasks        = showerTaskSet      ->make("","lowshowerefficiency");
    HTask *mdcTasks           = mdcTaskSet         ->make("","hit,NoStartAndCal,NoTimeCuts,MagnetOff");

    /*
     //  ----------- MDC ------------------------------------------------------
     HTask *mdcTasks           = mdcTaskSet         ->make("rtdb","");
     HMdcTrackFinder* trackfinder = HMdcTrackDSet::getMdcTrackFinder();
     if(trackfinder) {
     trackfinder->setMetaMatchFlag(kFALSE,kFALSE); // no metamatching, no metamacth plots
     }
     */
    //----------------SPLINE and RUNGE TACKING----------------------------------------
    HSplineTaskSet         *splineTaskSet       = new HSplineTaskSet("","");
    HTask *splineTasks=splineTaskSet->make("","spline,runge");

    //-----------------------------------------------------------------------
    //HParticleCandFiller  *pParticleCandFiller = new HParticleCandFiller("particlecandfiller","particlecandfiller","debug,goodseg0,goodseg1,goodmeta,goodrk");
    HParticleCandFiller   *pParticleCandFiller = new HParticleCandFiller  ("particlecandfiller","particlecandfiller","");
    HParticleTrackCleaner *pParticleCleaner    = new HParticleTrackCleaner("particlecleaner"   ,"particlecleaner");
    HParticleEvtInfoFiller *pParticleEvtInfo   = new HParticleEvtInfoFiller("particleevtinfo"  ,"particleevtinfo");

    //------------------------ Master task set --------------------------

    HTaskSet *masterTaskSet = gHades->getTaskSet("real");

    masterTaskSet->add(startTasks);
    masterTaskSet->add(tofTasks);
    masterTaskSet->add(wallTasks);
    masterTaskSet->add(rpcTasks);
    masterTaskSet->add(richTasks);
    masterTaskSet->add(showerTasks);
    masterTaskSet->add(mdcTasks);

    /*
     masterTaskSet->add(splineTasks);
     masterTaskSet->add(pParticleCandFiller);
     masterTaskSet->add(pParticleCleaner);
     masterTaskSet->add(pParticleEvtInfo);
     */


    masterTaskSet->isTimed(kTRUE);


    //--------------------------------------------------------------------
    if (!gHades->init())
    {
	cerr<<"EVENT DISPLAY : ERROR IN INIT, EXITING! #####################################"<<endl;
	delete myHades;
	return kFALSE;
    }
    //--------------------------------------------------------------------


    return kTRUE;
}



Bool_t initDetectorSetup()
{
    // Detectors setup configuration
    Int_t richMods[1]   = {1};

    Int_t mdcMods[6][4] = {
	{1,1,1,1},
	{1,1,1,1},
	{1,1,1,1},
	{1,1,1,1},
	{1,1,1,1},
	{1,1,1,1} };

    Int_t tofMods   [22] = {1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    Int_t rpcMods   [1]  = {1};
    Int_t showerMods[3]  = {1,2,3};
    Int_t startMods [10] = {1,1,1,1,0,0,0,0,0,0};
    Int_t wallMods  [1]  = {1};
    Int_t nTrigMods[]    = {1};

    HSpectrometer* spec = gHades->getSetup();

    spec->addDetector(new HTBoxDetector);
    spec->addDetector(new HStart2Detector);
    spec->addDetector(new HRichDetector);
    spec->addDetector(new HMdcDetector);
    spec->addDetector(new HTofDetector);
    spec->addDetector(new HRpcDetector);
    spec->addDetector(new HWallDetector);
    spec->addDetector(new HShowerDetector);


    spec->getDetector("TBox")->setModules(-1,nTrigMods);
    spec->getDetector("Start")->setModules(-1,startMods);
    spec->getDetector("Wall")->setModules(-1,wallMods);

    for (Int_t is=0; is<6; is++) {
	spec->getDetector("Rich")  ->setModules(is,richMods);
	spec->getDetector("Mdc")   ->setModules(is,mdcMods[is]);
	spec->getDetector("Tof")   ->setModules(is,tofMods);
	spec->getDetector("Rpc")   ->setModules(is,rpcMods);
	spec->getDetector("Shower")->setModules(is,showerMods);
    }

    return kTRUE;
}

Bool_t setDataSource(Int_t sourceType,
		     TString inDir,
		     TString inFile,
		     Int_t refId,
                     TString eventbuilder
		    )
{

    if( sourceType == 0 ){
	HldFileSource* source = new HldFileSource;
	source->setDirectory((Text_t*) inDir.Data());
	source->addFile((Text_t*) inFile.Data(),refId);
	gHades->setDataSource(source);
    } else if ( sourceType == 1 ){
	Int_t GrepInterval   = 5 ; // look for new file each n seconds
	Int_t GrepTimeOffset = 10; // at least n seconds old
        Int_t GrepFileOffset = 0;  // latest - GrepFileOffset file (minimum 0)
	HldGrepFileSource* source = new HldGrepFileSource(inDir,"Grep",GrepInterval,refId,GrepTimeOffset,GrepFileOffset);
	gHades->setDataSource(source);
    } else if ( sourceType == 2 ){
	HldRemoteSource* source = new HldRemoteSource(eventbuilder.Data());
	source->setRefId(refId);
	gHades->setDataSource(source);
    } else {
	cout<<"Error setDataSource(): Unknown source type = "<<sourceType<<"!"<<endl;
	return kFALSE;
    }
    return kTRUE;
}

Bool_t setParamSource(TString paramSource,TString asciiParFile,TString rootParFile)
{
    if(paramSource == "" ||
       (!paramSource.Contains("ROOT")  &&
	!paramSource.Contains("ASCII") &&
	!paramSource.Contains("ORACLE")
       )
      ){
	cout<<"Error: setDataSource(): Unknown parameter source = "<<paramSource.Data()<<"!"<<endl;
	return kFALSE;
    }
    HRuntimeDb *rtdb = gHades->getRuntimeDb();

    if (paramSource.Contains("ROOT"))
    {
	HParRootFileIo *input1=new HParRootFileIo;
	input1->open(((Char_t *)rootParFile.Data()),"READ");
	if(paramSource.Contains("ASCII") == 0) rtdb->setFirstInput(input1);
	else                                   rtdb->setSecondInput(input1);
    }


    if (paramSource.Contains("ASCII"))
    {
	HParAsciiFileIo *input2 = new HParAsciiFileIo();
	input2->open((Text_t*)asciiParFile.Data(),"in");
	rtdb->setFirstInput(input2);
    }

    // ----- SECOND PARAM INPUT FOR PID

    if (paramSource.Contains("ORACLE"))
    {
	HParOra2Io* ora=new HParOra2Io;
	ora->open();
	ora->setHistoryDate("now");
	rtdb->setSecondInput(ora);
    }

    return kTRUE;
}














#endif