/** @file CbmStsTestIo.cxx
 ** @author Volker Friese <v.friese@gsi.de>
 ** @date 16.06.2015
 **/

// --- Include class header
#include "CbmStsTestIo.h"

// --- Includes from C++
#include <iostream>
#include <iomanip>

// --- Includes from ROOT
#include "TClonesArray.h"
#include "TRandom.h"

#include "FairLogger.h"
#include "FairRunAna.h"
#include "FairEventHeader.h"

#include "CbmStsDaughter.h"
#include "CbmStsMother1.h"
#include "CbmStsMother2.h"
#include "CbmStsMother3.h"
#include "CbmStsMother4.h"
#include "CbmStsMother5.h"
#include "CbmStsMother6.h"
#include "CbmStsMother7.h"
#include "CbmMatch.h"

using namespace std;


// -----   Constructor   ---------------------------------------------------
CbmStsTestIo::CbmStsTestIo()
    : FairTask("StsTestIo", 1)
    , fData(NULL)
    , fTimer()
    , fNofEvents(0.)
    , fTimeTot(0.)
    , fNofDataTot(0)
{
}
// -------------------------------------------------------------------------


// -----   Destructor   ----------------------------------------------------
CbmStsTestIo::~CbmStsTestIo() {
}
// -------------------------------------------------------------------------



// -----   Task execution   ------------------------------------------------
void CbmStsTestIo::Exec(Option_t* opt) {

	// --- Event number
	Int_t iEvent =
			FairRunAna::Instance()->GetEventHeader()->GetMCEntryNumber();

	// Start timer and counter
	fTimer.Start();

	// --- Clear output array
	fData->Delete();
	Int_t nOfData = 0;


	/*
	// --- Test 1: Create 10000 objects of type Mother1
	for (Int_t i = 0; i < 10000; i++) {

		Double_t val1 = gRandom->Uniform();
		Double_t val2 = gRandom->Uniform();
		Double_t val3 = gRandom->Uniform();
		Double_t val4 = gRandom->Uniform();
		Double_t val5 = gRandom->Uniform();
		Double_t val6 = gRandom->Uniform();

		Int_t nData = fData->GetEntriesFast();
		new ( (*fData)[nData] ) CbmStsMother1(val1, val2, val3, val4, val5, val6);
		nOfData++;

	}
	 */

	/*
	// --- Test 2: Create 10000 objects of type Mother2 (one daughter member each)
	for (Int_t i = 0; i < 10000; i++) {

		Double_t val1 = gRandom->Uniform();
		Double_t val2 = gRandom->Uniform();
		Double_t val3 = gRandom->Uniform();
		Double_t val4 = gRandom->Uniform();
		Double_t val5 = gRandom->Uniform();
		Double_t val6 = gRandom->Uniform();

		Int_t nData = fData->GetEntriesFast();
		new ( (*fData)[nData] ) CbmStsMother2(val1, val2, val3, val4, val5, val6);
		nOfData++;

	}
	*/


	/*
	// --- Test 3: Create 10000 objects of type Mother3 and 10000 of type Daughter.
	for (Int_t i = 0; i < 10000; i++) {

		Double_t val1 = gRandom->Uniform();
		Double_t val2 = gRandom->Uniform();
		Double_t val3 = gRandom->Uniform();
		Double_t val4 = gRandom->Uniform();
		Double_t val5 = gRandom->Uniform();
		Double_t val6 = gRandom->Uniform();

		CbmStsDaughter* daughter = new CbmStsDaughter(val4, val5, val6);

		Int_t nData = fData->GetEntriesFast();
		new ( (*fData)[nData] ) CbmStsMother3(val1, val2, val3, NULL);
		nOfData++;

	}
	*/

 	// --- Test 4: Create 10000 objects of type mother4, 2 links each
  /*
	for (Int_t i = 0; i < 10000; i++) {

		Double_t weight1 = gRandom->Uniform();
		Int_t index1 = Int_t(gRandom->Uniform(1000));
		Int_t entry1 = Int_t(gRandom->Uniform(1000));
		Int_t file1 = Int_t(gRandom->Uniform(1000));
		Double_t weight2 = gRandom->Uniform();
		Int_t index2 = Int_t(gRandom->Uniform(1000));
		Int_t entry2 = Int_t(gRandom->Uniform(1000));
		Int_t file2 = Int_t(gRandom->Uniform(1000));

		Int_t nData = fData->GetEntriesFast();
		CbmStsMother4* mother = new ( (*fData)[nData] ) CbmStsMother4();
		mother->AddLink(weight1, index1, entry1, file1);
		mother->AddLink(weight2, index2, entry2, file2);
		nOfData++;

	}
	*/


	// --- Test 5: Create 10000 objects of type mother5, 2 links each
	for (Int_t i = 0; i < 10000; i++) {

		Double_t weight1 = gRandom->Uniform();
		Int_t index1 = Int_t(gRandom->Uniform(1000));
		Int_t entry1 = Int_t(gRandom->Uniform(1000));
		Int_t file1 = Int_t(gRandom->Uniform(1000));
		Double_t weight2 = gRandom->Uniform();
		Int_t index2 = Int_t(gRandom->Uniform(1000));
		Int_t entry2 = Int_t(gRandom->Uniform(1000));
		Int_t file2 = Int_t(gRandom->Uniform(1000));

		Int_t nData = fData->GetEntriesFast();
		CbmStsMother5* mother = new ( (*fData)[nData] ) CbmStsMother5();
		mother->AddLink(weight1, index1, entry1, file1);
		mother->AddLink(weight2, index2, entry2, file2);
		nOfData++;

	}


	/*
	// --- Test 6: Create 10000 objects of type mother6 with 2 links each
	for (Int_t i = 0; i < 10000; i++) {

		Double_t weight1 = gRandom->Uniform();
		Int_t index1 = Int_t(gRandom->Uniform(1000));
		Int_t entry1 = Int_t(gRandom->Uniform(1000));
		Int_t file1 = Int_t(gRandom->Uniform(1000));
		Double_t weight2 = gRandom->Uniform();
		Int_t index2 = Int_t(gRandom->Uniform(1000));
		Int_t entry2 = Int_t(gRandom->Uniform(1000));
		Int_t file2 = Int_t(gRandom->Uniform(1000));

		Int_t nData = fData->GetEntriesFast();
		CbmStsMother6* mother = new ( (*fData)[nData] ) CbmStsMother6();
		mother->AddLink(weight1, index1, entry1, file1);
		mother->AddLink(weight2, index2, entry2, file2);
		nOfData++;

	}
	*/

	/*
	// --- Test 7: Create 10000 objects of type mother7 with 2 links each
	for (Int_t i = 0; i < 10000; i++) {

		Double_t weight1 = gRandom->Uniform();
		Int_t index1 = Int_t(gRandom->Uniform(1000));
		Int_t entry1 = Int_t(gRandom->Uniform(1000));
		Int_t file1 = Int_t(gRandom->Uniform(1000));
		Double_t weight2 = gRandom->Uniform();
		Int_t index2 = Int_t(gRandom->Uniform(1000));
		Int_t entry2 = Int_t(gRandom->Uniform(1000));
		Int_t file2 = Int_t(gRandom->Uniform(1000));

		Int_t nData = fData->GetEntriesFast();
		CbmStsMother7* mother = new ( (*fData)[nData] ) CbmStsMother7();
		//mother->AddLink(weight1, index1, entry1, file1);
		//mother->AddLink(weight2, index2, entry2, file2);
		nOfData++;

	}
	*/





  // --- Counters
  fTimer.Stop();
  fNofEvents++;
  fTimeTot        += fTimer.RealTime();
  fNofDataTot += nOfData;

  LOG(INFO) << "+ " << setw(20) << GetName() << ": Event " << setw(6)
  		      << right << iEvent << ", time " << fixed << setprecision(6)
  		      << fTimer.RealTime() << " s, data: " << nOfData
  		      << FairLogger::endl;
}
// -------------------------------------------------------------------------



// -----   End-of-run action   ---------------------------------------------
void CbmStsTestIo::Finish() {
	std::cout << std::endl;
	LOG(INFO) << "=====================================" << FairLogger::endl;
	LOG(INFO) << GetName() << ": Run summary" << FairLogger::endl;
	LOG(INFO) << "Events processed  : " << fNofEvents << FairLogger::endl;
	LOG(INFO) << "Data / event     : " << fNofDataTot / Double_t(fNofEvents)
			      << FairLogger::endl;
	LOG(INFO) << "Time per event    : " << fTimeTot / Double_t(fNofEvents)
			      << " s " << FairLogger::endl;
	LOG(INFO) << "=====================================" << FairLogger::endl;

}
// -------------------------------------------------------------------------





// -----   Initialisation   ------------------------------------------------
InitStatus CbmStsTestIo::Init()
{
    // --- Check IO-Manager
    FairRootManager* ioman = FairRootManager::Instance();
    if (NULL == ioman) {
    	LOG(ERROR) << GetName() << ": No FairRootManager!"
    			       << FairLogger::endl;
    	return kFATAL;
    }


    // --- Register output array

    fData = new TClonesArray("CbmStsMother5", 10000);
    ioman->Register("StsMother", "Data in STS", fData, kFALSE);


    LOG(INFO) << GetName() << ": Initialisation successful"
    		      << FairLogger::endl;
    return kSUCCESS;
}
// -------------------------------------------------------------------------





ClassImp(CbmStsTestIo)