/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             * 
 *         GNU Lesser General Public Licence version 3 (LGPL) version 3,        *  
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
// -------------------------------------------------------------------------
// -----                PndTimeOffsetFinderTaskT source file             -----
// -------------------------------------------------------------------------

#include "PndTimeOffsetFinderTask.h"

#include "FairLink.h"                   // for FairLink
#include "FairRootManager.h"            // for FairRootManager
#include "FairTimeStamp.h"              // for FairTimeStamp
#include "FairRunAna.h"

#include "PndSdsHit.h"

#include "Riosfwd.h"                    // for ostream
#include "TClass.h"                     // for TClass
#include "TClonesArray.h"               // for TClonesArray

#include <iostream>                     // for operator<<, cout, ostream, etc
#include <iomanip>
#include <vector>                       // for vector

InitStatus PndTimeOffsetFinderTask::ReInit()
{
  return kSUCCESS;
}

// -----   Public method Init   --------------------------------------------
InitStatus PndTimeOffsetFinderTask::Init()
{

  FairRootManager* ioman = FairRootManager::Instance();
  if ( ! ioman ) {
    std::cout << "-E- PndTimeOffsetFinderTaskT::Init: "
              << "RootManager not instantiated!" << std::endl;
    return kFATAL;
  }

  // Create and register output array
  fInputArray = (TClonesArray*)FairRootManager::Instance()->GetObject("MVDHitsPixel");

  //if(fVerbose>1) { Info("Init","Registering this branch: %s/%s",fFolder.Data(),fOutputBranch.Data()); }
  //fOutputArray = ioman->Register(fOutputBranch, fInputArray->GetClass()->GetName(), fFolder, fPersistance);

  fHc0c1 = new TH1D("fHc0c1", "fHc0c1", 2000000, -5000000, 15000000);
  fHc0c2 = new TH1D("fHc0c2", "fHc0c2", 2000000, -5000000, 15000000);
  fHc0c3 = new TH1D("fHc0c3", "fHc0c3", 2000000, -5000000, 15000000);
  fHc1c2 = new TH1D("fHc1c2", "fHc1c2", 2000000, -5000000, 15000000);
  fHc1c3 = new TH1D("fHc1c3", "fHc1c3", 2000000, -5000000, 15000000);
  fHc2c3 = new TH1D("fHc2c3", "fHc2c3", 2000000, -5000000, 15000000);

  FairRootManager::Instance()->InitTSBuffer(fInputBranch, fFunctor);
  FairTSBufferFunctional* buffer = FairRootManager::Instance()->GetTSBuffer(fInputBranch);
  if (buffer != 0){
	buffer->SetBranchIndex(fStartIndex);
	std::cout << "BranchIndex: " << buffer->GetBranchIndex() << std::endl;
  }


  return kSUCCESS;
}
// -------------------------------------------------------------------------

// -----   Public method Exec   --------------------------------------------
void PndTimeOffsetFinderTask::Exec(Option_t* opt)
{
	if (FairRunAna::Instance()->IsTimeStamp() != kTRUE){
		std::cout << "-E- PndTimeOffsetFinderTask::Exec not running in time based mode." << std::endl;
		return;
	}
//	if (fFirstExecute){
//		std::cout << "PndTimeOffsetFinderTask::Exec first execute called with time " << fStartTime << std::endl;
//		fFirstExecute = kFALSE;
//
//		if (fStartIndex > 0){
//			fInputArray = FairRootManager::Instance()->GetData(fInputBranch, fFunctor, 0);
//
//			FairTSBufferFunctional* buffer = FairRootManager::Instance()->GetTSBuffer(fInputBranch);
//			if (buffer != 0){
//				buffer->SetBranchIndex(fStartIndex);
//				std::cout << "BranchIndex: " << buffer->GetBranchIndex() << std::endl;
//			}
//		}
//		fInputArray = FairRootManager::Instance()->GetData(fInputBranch, fFunctor, fStartTime);
//
//		//std::cout << "fInputArray size: " << fInputArray->GetEntriesFast() << std::endl;
//		fInputArray->Delete();
//		fLastTimeStamp = fStartTime;
//	}
	fInputArray = FairRootManager::Instance()->GetData(fInputBranch, fFunctor, fLastTimeStamp + fTimeOffset);
	//std::cout << "Exec called: " << fEntryNr++ << std::endl;
	for (int i = 0; i < fInputArray->GetEntriesFast(); i++){
		PndSdsHit* second = (PndSdsHit*)fInputArray->At(i);
	//	std::cout << i << " : " << std::setw(12) << second->GetTimeStamp() << std::endl;
	}
	PndSdsHit* first;
    //std::cout << "NEntries " << fInputArray->GetEntriesFast() << std::endl;
	if (fInputArray->GetEntriesFast() > 1){
		first = (PndSdsHit*)fInputArray->At(0);
//		std::cout << "first: " << *first << std::endl;
		if (first != 0)
			fLastTimeStamp = first->GetTimeStamp();
	}
	fLastTimeStamp += fTimeOffset;

	if (fLastTimeStamp > fTerminateTime){
		std::cout << "PndTimeOffsetFinderTask::Exec fLastTimeStamp " << fLastTimeStamp << " > TerminateTime " << fTerminateTime << std::endl;
		FairRootManager::Instance()->TerminateTSBuffer(fInputBranch);
		return;
	}
	if (fEntryNr++ % 1000 == 0)
		std::cout << "EventProcessed: " << fEntryNr << " fLastTimeStamp: " << fLastTimeStamp << " TeminateTime " << fTerminateTime << std::endl;


	if (fInputArray->GetEntriesFast() > 1){
		//PndSdsHit* first = (PndSdsHit*)fInputArray->At(0);
		for (int i = 1; i < fInputArray->GetEntriesFast(); i++){
			PndSdsHit* second = (PndSdsHit*)fInputArray->At(i);
		//	std::cout << "first: " << std::setw(12) << first->GetTimeStamp() << " second: " << std::setw(12) << second->GetTimeStamp() <<
		//			" diff " << second->GetTimeStamp() - first->GetTimeStamp() << std::endl;
			if (first->GetSensorID() == second->GetSensorID())
				continue;

			double diff;
			if (first->GetSensorID() < second->GetSensorID())
				diff = 	second->GetTimeStamp() - first->GetTimeStamp();
			else diff = first->GetTimeStamp() - second->GetTimeStamp();

			if ((first->GetSensorID() == 0 && second->GetSensorID() == 1)
					|| (first->GetSensorID() == 1 && second->GetSensorID() == 0))
				fHc0c1->Fill(diff);
			else if ((first->GetSensorID() == 0 && second->GetSensorID() == 2)
					|| (first->GetSensorID() == 2 && second->GetSensorID() == 0))
				fHc0c2->Fill(diff);
			else if ((first->GetSensorID() == 0 && second->GetSensorID() == 3)
					|| (first->GetSensorID() == 3 && second->GetSensorID() == 0))
				fHc0c3->Fill(diff);
			else if ((first->GetSensorID() == 1 && second->GetSensorID() == 2)
					|| (first->GetSensorID() == 2 && second->GetSensorID() == 1))
				fHc1c2->Fill(diff);
			else if ((first->GetSensorID() == 1 && second->GetSensorID() == 3)
					|| (first->GetSensorID() == 3 && second->GetSensorID() == 1))
				fHc1c3->Fill(diff);
			else if ((first->GetSensorID() == 2 && second->GetSensorID() == 3)
					|| (first->GetSensorID() == 3 && second->GetSensorID() == 2))
				fHc2c3->Fill(diff);

		}
		TClonesArray* tempArray = new TClonesArray(fInputArray->GetClass()->GetName());
		tempArray->AbsorbObjects(fInputArray,1,fInputArray->GetEntriesFast()-1);
		fInputArray->Delete();
		fInputArray->AbsorbObjects(tempArray,0,tempArray->GetEntriesFast()-1);
		delete(tempArray);
		//std::cout << "RemoveFirst: " << fInputArray->GetEntriesFast() << std::endl;
	}
}

// -------------------------------------------------------------------------

void PndTimeOffsetFinderTask::FinishEvent()
{
 // fOutputArray->Delete();
}

void PndTimeOffsetFinderTask::FinishTask()
{
	fHc0c1->Write();
	fHc0c2->Write();
	fHc0c3->Write();
	fHc1c2->Write();
	fHc1c3->Write();
	fHc2c3->Write();

}

ClassImp(PndTimeOffsetFinderTask);