#include "CbmMcbm2018UnpackerTaskTrdR.h"
#include "CbmMcbm2018UnpackerAlgoTrdR.h"

#include "FairLogger.h"
#include "FairRootManager.h"
#include "FairRun.h"
#include "FairRunOnline.h"
#include "FairRuntimeDb.h"

#include <THttpServer.h>
#include <TFile.h>

/* Default Constructor */
CbmMcbm2018UnpackerTaskTrdR::CbmMcbm2018UnpackerTaskTrdR()
	: CbmMcbmUnpack()
	  , fbMonitorMode(kFALSE)
	  , fbDebugMonitorMode(kFALSE)
	  , fbWriteOutput(kTRUE)
	  , fbDebugWriteOutput(kFALSE)
	  , fbBaselineAvg(kFALSE)
	  , fSystemIdentifier((std::uint8_t)fles::SubsystemIdentifier::TRD)
	  , fMonitorHistoFileName("")
	  , fTrdDigiVector(nullptr)
	  , fTrdRawMessageVector(nullptr)
	  , fSpadicInfoMsgVector(nullptr)
	  , fUnpackerAlgo(nullptr)
{
	fUnpackerAlgo = new CbmMcbm2018UnpackerAlgoTrdR();
}

/* Default Destructor */
CbmMcbm2018UnpackerTaskTrdR::~CbmMcbm2018UnpackerTaskTrdR()
{
	delete fUnpackerAlgo;
}

Bool_t CbmMcbm2018UnpackerTaskTrdR::Init()
{
	LOG(info) << "Initializing CbmMcbm2018UnpackerTaskTrdR...";
	Bool_t initOK = 1;

	FairRootManager *ioman = nullptr ;
	ioman = FairRootManager::Instance();
	if (ioman == nullptr )
	{
		LOG(fatal) << "No FairRootManager instance";
	}

	/// Register Digi output vector.
	fTrdDigiVector = new std::vector<CbmTrdDigi>();
	if (fTrdDigiVector)
	{
		ioman->RegisterAny("TrdDigi", fTrdDigiVector, fbWriteOutput);
		initOK &= fUnpackerAlgo->SetDigiOutputPointer(fTrdDigiVector);
	}
	else
	{
		LOG(fatal) << "fTrdDigiVector could not be registered at FairRootManager.";
	}

	/// Register RawMessage output vector, if DebugWrite is enabled.
	if (fbDebugWriteOutput)
	{
		fTrdRawMessageVector = new std::vector<CbmTrdRawMessageSpadic>();
		fSpadicInfoMsgVector = new std::vector< std::pair<std::uint64_t, std::uint64_t> > ();
		if (fTrdRawMessageVector && fSpadicInfoMsgVector )
		{
			ioman->RegisterAny("CbmTrdSpadicRawMessages", fTrdRawMessageVector, kTRUE);
			ioman->RegisterAny("CbmTrdSpadicInfoMessages", fSpadicInfoMsgVector, kTRUE);
			initOK &= fUnpackerAlgo->SetRawOutputPointer(fTrdRawMessageVector, fSpadicInfoMsgVector);
		}
		else
		{
			LOG(fatal) << "[CbmMcbm2018UnpackerTaskTrdR::Init] Raw output could not be registered at FairRootManager.";
		}
	}

	initOK &= fUnpackerAlgo->Init() ;

	if ( initOK ){
		LOG(info) << "Initialization of CbmMcbm2018UnpackerTaskTrdR and CbmMcbm2018UnpackerAlgoTrdR successfull!" ;
	}
	else {
		LOG(fatal) << "Init of CbmMcbm2018UnpackerAlgoTrdR failed!";
	}

	return initOK;
}

Bool_t CbmMcbm2018UnpackerTaskTrdR::DoUnpack(const fles::Timeslice &ts, size_t /*component*/)
{
	/// Call the Algorithm to unpack the given TS.
	if (kFALSE == fUnpackerAlgo->ProcessTs(ts))
	{
		LOG(error) << "CbmMcbm2018UnpackerTaskTrdR: Failed processing TS " << ts.index()
				   << " in unpacker algorithm class.";
		return kFALSE;
	}


	// sts does a time sorting of fTrdDigiVector here. but this could also be done in the algo?!


	return kTRUE;
}

void CbmMcbm2018UnpackerTaskTrdR::Reset()
{
	if(fTrdDigiVector)			fTrdDigiVector->clear();
	if(fTrdRawMessageVector)	fTrdRawMessageVector->clear();
	if(fSpadicInfoMsgVector)	fSpadicInfoMsgVector->clear();
	if(fUnpackerAlgo)			fUnpackerAlgo->Reset();
}

void CbmMcbm2018UnpackerTaskTrdR::Finish()
{
	LOG(info) << "Finish of CbmMcbm2018UnpackerTaskTrdR";
	fUnpackerAlgo->Finish();

	if ( (fbMonitorMode == kTRUE || fbDebugMonitorMode == kTRUE) && fMonitorHistoFileName != "" )
	{
		/// Obtain vector of pointers on each histo from the algo (+ optionally desired folder)
		std::vector<std::pair<TNamed *, std::string>> vHistos = fUnpackerAlgo->GetHistoVector();

		/// (Re-)Create ROOT file to store the histos
		TDirectory *oldDir = nullptr;
		TFile *histoFile = nullptr;
		// Store current directory position to allow restore later
		oldDir = gDirectory;
		// open separate histo file in recreate mode
		TString histoFileName = fMonitorHistoFileName;
		histoFile = new TFile(histoFileName.Data(), "RECREATE");
		histoFile->cd();
		/// Write all the histograms to the file.
		for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto)
		{
			// Make sure we end up in chosen folder
			TString sFolder = vHistos[uHisto].second.data();
			if (nullptr == gDirectory->Get(sFolder))
				gDirectory->mkdir(sFolder);
			gDirectory->cd(sFolder);
			// Write histogram
			vHistos[uHisto].first->Write();
			histoFile->cd();
		}
		// Restore original directory position
		oldDir->cd();
		histoFile->Close();
	}

}

void CbmMcbm2018UnpackerTaskTrdR::SetParContainers()
{
	LOG(info) << "Setting parameter containers for " << GetName();

   	TList* fParContList = fUnpackerAlgo->GetParList();

	Int_t iParCont(0);
	for(auto parSetIt : *fParContList)
	{
		CbmTrdParSet* tempObj = (CbmTrdParSet*)(parSetIt);
		fParContList->Remove(tempObj);
		std::string sParamName{ tempObj->GetName() };
		delete tempObj;
		CbmTrdParSet* updatedParSet = nullptr;
		updatedParSet = dynamic_cast<CbmTrdParSet*>( FairRun::Instance()->GetRuntimeDb()->getContainer( sParamName.data() ) );

		if( !updatedParSet )
		{
			LOG(error) << "Failed to obtain parameter container " << sParamName
						<< ", for parameter index " << iParCont;
			return;
		}
		fParContList->AddAt(updatedParSet, iParCont);
	}
}

Bool_t CbmMcbm2018UnpackerTaskTrdR::InitContainers()
{
	if (fUnpackerAlgo == nullptr){
		LOG(error) << "CbmMcbm2018UnpackerTaskTrdR::InitContainers failed! No Unpacker Algo." ;
		return kFALSE;
	}
	LOG(info) << "Init containers for CbmMcbm2018UnpackerTaskTrdR";

	/// Hand over control flags to the algorithm.
	fUnpackerAlgo->SetMonitorMode(fbMonitorMode);
	fUnpackerAlgo->SetDebugMonitorMode(fbDebugMonitorMode);
	fUnpackerAlgo->SetWriteOutput(fbWriteOutput);
	fUnpackerAlgo->SetDebugWriteOutput(fbDebugWriteOutput);
	fUnpackerAlgo->SetBaselineAvg(fbBaselineAvg);

	Bool_t initOK = fUnpackerAlgo->InitContainers();

	/// If monitor mode enabled, trigger histos creation,
	/// obtain pointer on them and add them to the HTTP server.
	if (fbMonitorMode == kTRUE || fbDebugMonitorMode == kTRUE)
	{
		/// Trigger Histo creation in the algo.
		initOK &= fUnpackerAlgo->CreateHistograms();

		/// Obtain vector of pointers on each histo from the algo (+ optionally desired folder).
		std::vector<std::pair<TNamed *, std::string>> vHistos = fUnpackerAlgo->GetHistoVector();

		/// Register the histos in the HTTP server
		THttpServer *server = FairRunOnline::Instance()->GetHttpServer();
		if (nullptr != server)
		{
			for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto)
			{
				server->Register(Form("/%s", vHistos[uHisto].second.data()), vHistos[uHisto].first);
			}
			// FIXME: register the correct command
			//server->RegisterCommand("/Reset_UnpSts_Hist", "bMcbm2018UnpackerTaskStsResetHistos=kTRUE");
			//server->Restrict("/Reset_UnpSts_Hist", "allow=admin");
		}
		else
		{
			initOK &= 0;
		} // end if( nullptr != server )
	}	 // end if (fbMonitorMode == kTRUE || fbDebugMonitorMode == kTRUE)

	return initOK;
}

Bool_t CbmMcbm2018UnpackerTaskTrdR::ReInitContainers()
{
	if (fUnpackerAlgo == nullptr)
		return kFALSE;

	LOG(info) << "ReInit parameter containers for CbmMcbm2018UnpackerTaskTrdR";

	Bool_t initOK = fUnpackerAlgo->ReInitContainers();
	return initOK;
}

void CbmMcbm2018UnpackerTaskTrdR::AddMsComponentToList(size_t component, UShort_t usDetectorId)
{
	if ( usDetectorId != (UShort_t)fSystemIdentifier )
	{
		LOG(error) << "CbmMcbm2018UnpackerTaskTrdR::AddMsComponentToList : Wrong Detector ID!" ;
		return;
	}
	if ( fUnpackerAlgo != nullptr )
		fUnpackerAlgo->AddMsComponentToList(component, usDetectorId);
}

void CbmMcbm2018UnpackerTaskTrdR::SetNbMsInTs(size_t uCoreMsNb, size_t uOverlapMsNb)
{
	if ( fUnpackerAlgo != nullptr )
		fUnpackerAlgo->SetNbMsInTs(uCoreMsNb,uOverlapMsNb);
}

void CbmMcbm2018UnpackerTaskTrdR::SetHistoFileName(TString filename)
{
	fMonitorHistoFileName = filename;
	SetMonitorMode(kTRUE);
}


ClassImp(CbmMcbm2018UnpackerTaskTrdR)