// $Id$
// Author: Thomas.Eberl@ph.tum.de, last modified : 2006-12-29 12:17:08
//
#include "evtmix.h"
#include <TUnixSystem.h>
#include <fstream>

Int_t mixer(TString aaa,Int_t nEvents=0, Int_t startEvt=0)
{
  
    cout<<"file list :"<<aaa.Data()<<", nEvts :"<<nEvents<<", startEvt :"<<startEvt<<endl;
    Hades *myHades=new Hades;

    TString inputDir="/d/hades12/data/aug04_exp/gen3/leptons/FullTarget/BAD_MDC_HV/root/";
    TString inputFile=aaa;
//----------------------------------------------------------------------------
    Int_t   nEvtsToProcess=nEvents;
//----------------------------------------------------------------------------
    TString evtType = "real";
//----------------------------------------------------------------------------
    TString paramSource="ORACLE";
    TString paramFile="";
//----------------------------------------------------------------------------
    TString outputFile="test_pairs.root";
    TString outputFileSuffix="_pairs";
    TString outputDir="/d/hades05/data/evtmix/aug04/";
    outputFile.Prepend(outputDir.Data());
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
    HRootSource *source=new HRootSource;
    source->setDirectory((Text_t*)inputDir.Data());
    source->setGlobalRefId(590861486);

    ifstream input;
    input.open(inputFile.Data());
    Char_t line[4000];
    Int_t ct=0;
    while(input.good()&&!input.eof()){
	input.getline(line,4000);
	ct++;
	TString tmp=line;
        if(tmp.CompareTo("")==0) continue;
	cout<<ct<<" file : "<<line<<endl;
	source->addFile((Text_t*)line);
    }
    gHades->setDataSource(source);
//----------------------------------------------------------------------------
#if 1
// do not read this category from the tree
    Cat_t SubstituteCat[] = 
	{
	    catPairs
	};
    Bool_t substituteCategories = kTRUE;
    if (substituteCategories)
    {
	for(UInt_t j=0;j<sizeof(SubstituteCat)/sizeof(Cat_t);j++)
	{
	    source->disableCategory(SubstituteCat[j]);
	}
    }
#endif
//----------------------------------------------------------------------------
    HRuntimeDb* rtdb=gHades->getRuntimeDb();
    if (paramSource.Contains("ORACLE"))
    {
	HParOraIo* input=new HParOraIo;
	input->open();
	if (!input->check()) 
	{
	    Error("input->check","no connection to Oracle\nexiting...!");
	    exit(1);
	}
	rtdb->setFirstInput(input);
        input->setHistoryDate("now");
    }
    //----------------------------------------------------------------------------
# if 1

    HTask *pSkipEvent = new HPidSkipTrigger("Skip Trigger","Skip Trigger","TRIGM4");

#endif

    //----------------------------------------------------------------------------
    // set up task list for event mixing
    HTaskSet *pPairAnalysisTasks = new HTaskSet("Pair Analysis",
						"Pair Analysis");

//-----------------------------------------------------------
#if 0
    // execute event filter, mult of non-lepton particles
    HPairEvtFilter* pEvtFilter = new HPairEvtFilter("HPairEvtFilter",
						    "HPairEvtFilter",
						    "multrange",
						    0,  // pidpart min mult
						    100); // max mult
        pPairAnalysisTasks->add(pEvtFilter);
#endif
//-----------------------------------------------------------
    // execute same-event pair creation
    HPairFiller* pFiller = new HPairFiller("HPairFiller","HPairFiller");     
    pPairAnalysisTasks->add(pFiller);
//-----------------------------------------------------------
#if 1
    // execute same-event pair filtering
    HPairFilter* pFilter = new HPairFilter("HPairFilter","HPairFilter");     
    TString sQAFileName1("filter_249_bad.root");
//    sQAFileName1.Remove(sQAFileName1.Length()-5,sQAFileName1.Length());
//    sQAFileName1.Append("_filter.root");
    sQAFileName1.Prepend(outputDir);
    pFilter->setQAFileName((Char_t*) sQAFileName1.Data());
    pPairAnalysisTasks->add(pFilter);
#endif
//-----------------------------------------------------------

#if 1
    // execute mixed-event pair creator
    HPairEvtMixer* pMix = new HPairEvtMixer("HPairEvtMixer","HPairEvtMixer",
					  100,   // buffer size
					    1,   // buffer method, 1:ring
					    1,   // 1: use pairana for trk sel
					    1,   // ring buffer shift size
					    0,   // 0: all sel. tracks in evt
					    1);  // 0: min nb leps per evt
//                                            1);
    TString sQAFileName("pairs_mix_249_bad.root");
    sQAFileName.Prepend(outputDir);
    pMix->setQAFileName((Char_t*) sQAFileName.Data());

    pPairAnalysisTasks->add(pMix);
#endif
//----------------------------------------------------------------------------
    HTaskSet *masterTaskSet = gHades->getTaskSet((Text_t*)evtType.Data());
    masterTaskSet->add(pSkipEvent);
    masterTaskSet->add(pPairAnalysisTasks);

    gHades->getTaskSet((Text_t*)evtType.Data())->isTimed(kTRUE);
//----------------------------------------------------------------------------
    gHades->makeCounter(500);
    if (!gHades->init()) 
    {
	printf("Error in initialization, exiting\n");
	delete myHades;
	return kFALSE;
    }
//----------------------------------------------------------------------------
    HEvent *event = gHades->getCurrentEvent();
    // switch off output of all categories
    for(Int_t i=0;i<500;i++) // FIXME
    {
	if (event->getCategory(i))
	{
	        event->getCategory(i)->setPersistency(kFALSE);
	}
    }
#if 1
    // switch on some of them again
    Cat_t PersistentCat[] = 
	{
	    catPairs, catPairsHeader
	};
    for(UInt_t j=0;j<sizeof(PersistentCat)/sizeof(Cat_t);j++)
    {
	if (event->getCategory(PersistentCat[j]))
	{
	    HCategory* pC =  ((HCategory *)event
			      ->getCategory(PersistentCat[j]));
	    pC->setPersistency(kTRUE);
	    cout << "Branching level: " << pC->getBranchingLevel() <<endl;
	}
    }
#endif
    
//----------------------------------------------------------------------------
#if 0
     gHades->setOutputFile((Text_t*)outputFile.Data(),"RECREATE","Test",2);
     gHades->makeTree();
#endif
//----------------------------------------------------------------------------
    TStopwatch timer;
    timer.Reset();
    timer.Start();
    Int_t evN=0;
    if (nEvtsToProcess<1) 
    {
	evN=gHades->eventLoop();
    } 
    else 
    {
	evN=gHades->eventLoop(nEvtsToProcess,0);
    }
    timer.Stop();
//----------------------------------------------------------------------------
    if (evN) gHades->getTaskSet((Text_t*)evtType.Data())->printTimer();
    delete myHades;
    printf("------------------------------------------------------\n");
    if (evN)
    {
	printf("Events processed\t: %i\n",evN);
	printf("Real time\t\t: %f\n",timer.RealTime());
	printf("Cpu time\t\t: %f\n",timer.CpuTime());
	printf("Performance\t\t: %f cpu-s/ev\n",timer.CpuTime()/evN);
	printf("Performance (real)\t: %f ev/s\n",evN/timer.RealTime());
	  
	return kTRUE;
    }
    else
    {
	cout<<"ERROR: no events processed"<<endl;
	return kFALSE;
	  
    }

  return 0;
}

/*

void printEnvironment()
{
    const char* cInputDir      = gSystem->Getenv("MIXER_INPUTDIR");
    const char* cInputFile     = gSystem->Getenv("MIXER_INPUTFILE");
    const char* cOutputDir_Hld = gSystem->Getenv("MIXER_OUTPUTDIR_HLD");
    const char* cOutputDir_Dst = gSystem->Getenv("MIXER_OUTPUTDIR_DST");
    const char* cOutputDir_Tup = gSystem->Getenv("MIXER_OUTPUTDIR_TUP");
    const char* cParamDir      = gSystem->Getenv("MIXER_PARAMDIR");
    const char* cParamFile     = gSystem->Getenv("MIXER_PARAMFILE");

    TString sInputDir(cInputDir);
    TString sInputFile(cInputFile);
    TString sOutputDir_Hld(cOutputDir_Hld);
    TString  sOutputDir_Dst(cOutputDir_Dst);
    TString sOutputDir_Tup(cOutputDir_Tup);
    TString sParamDir(cParamDir);
    TString sParamFile(cParamFile);

    cout << endl;
    cout << "=========================================================="<<endl;
    cout << " HLD source directory (MIXER_INPUTDIR)       : " << sInputDir.Data() <<endl;
    cout << " HLD source file      (MIXER_INPUTFILE)      : " << sInputFile.Data() <<endl;
    cout << " HLD target directory (MIXER_OUTPUTDIR_HLD)  : " << sOutputDir_Hld.Data() <<endl;
    cout << " DST target directory (MIXER_OUTPUTDIR_DST)  : " << sOutputDir_Dst.Data() <<endl;
    cout << " TUP target directory (MIXER_OUTPUTDIR_TUP)  : " << sOutputDir_Tup.Data() <<endl;
    cout << " PARAMETER  file      (MIXER_PARAMFILE)      : " << sParamFile.Data() <<endl;
    cout << "=========================================================="<<endl;
    cout << endl;

}
  */
Int_t usage(const TString name)
{
    cout << endl;
    cout<<"======================================================="<<endl;
  Info(name.Data(),"Usage:");

  cout << "evtmix file [nr of evts, start evt number]" << endl;
  cout << "The following env variables need to be specified: " <<endl;
//  printEnvironment();
  return EXIT_SUCCESS;
}

#ifndef __CINT__
int main(int argc, char **argv)
{
  TROOT MIXER("MIXER","MIXER");
  switch (argc)
    {
    case 1:
	cout<<"This is case 1 !!!"<<endl;
	//printEnvironment();
	if (!mixer(argv[0],1000000,0)) return 0;
	usage(TString(argv[0]));
	return EXIT_SUCCESS;
	break;
    case 2:
	//	cout<<"This is case 2 !!!"<<endl;
//	printEnvironment();
	if (!mixer(argv[1],1000000,0)) return 0;
	//usage(TString(argv[0]));
	return EXIT_SUCCESS;
	break;
	
    case 3:
//	printEnvironment();
	cout << "Number of requested events: " << argv[2] <<endl;
	if (!mixer(argv[1],atoi(argv[2]),0 )) return 0;
	//	usage(TString(argv[0]));
	return EXIT_SUCCESS;
	break;
	/*
    case 3:
	//printEnvironment();
	cout << "Number of requested events: " << argv[1] <<endl;
	cout << "Starting from event:        " << argv[2] <<endl;
	if (!mixer( atoi(argv[1]),atoi(argv[2]) )) return 0;
	usage(TString(argv[0]));
	return EXIT_SUCCESS;
	break;
	*/
    default:
	usage(TString(argv[0]));
	return EXIT_SUCCESS;
    }
}
#endif