// ------------------------------------------------------------------
// -----                    TMbsUnpackTof                       -----
// -----              Created 05/07/2013 by P.-A. Loizeau       -----
// ------------------------------------------------------------------
#include "TMbsUnpackTof.h"

// SubEvent ProcId from ROC library
#include "commons.h"

// General MBS headers
#include "TofVmeDef.h"
#include "TMbsUnpackTofPar.h"

// ToF specific headers
#include "TTofScomUnpacker.h"
#include "TTofScalerBoard.h"
#include "TTofVftxUnpacker.h"
#include "TTofVftxBoard.h"
#include "TTofTdcBoard.h"

// ROOT headers
#include "TClonesArray.h"
#include "TFile.h"
#include "TDatime.h"
#include "TROOT.h"
#include "TDirectory.h"

// FAIR headers
#include "FairLogger.h"
//#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"

TMbsUnpackTof::TMbsUnpackTof() : 
   FairUnpack( 10, 1, roc::proc_COSY_Nov11, 1, 9  ),
   fiVerbosity(0),
   fMbsUnpackPar(0),
   fiNbEvents(0),
   fiFirstEventNumber(0),
   fiLastEventNumber(0)
{
}

TMbsUnpackTof::TMbsUnpackTof( Int_t verbose ) : 
   FairUnpack( 10, 1, roc::proc_COSY_Nov11, 1, 9 ),
   fiVerbosity(verbose),
   fMbsUnpackPar(0),
   fiNbEvents(0),
   fiFirstEventNumber(0),
   fiLastEventNumber(0)
{
   LOG(INFO)<<"**** TMbsUnpackTof: instance created "<<FairLogger::endl;
}

TMbsUnpackTof::TMbsUnpackTof( Int_t type, Int_t subType, Short_t procId, Int_t verbose,
                                Short_t subCrate, Short_t control) :
   FairUnpack( type, subType, procId, subCrate, control ),
   fiVerbosity(verbose),
   fMbsUnpackPar(0),
   fiNbEvents(0),
   fiFirstEventNumber(0),
   fiLastEventNumber(0)
{
}
      
TMbsUnpackTof::~TMbsUnpackTof()
{      
   LOG(INFO)<<"**** TMbsUnpackTof: Delete instance "<<FairLogger::endl;
   
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      delete fScomUnp;
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      delete fVftxUnp;
}

// --------------------------------------------------
// FairUnpack specific functions
Bool_t TMbsUnpackTof::Init()
{
   LOG(INFO)<<"**** TMbsUnpackTof: Init Params "<<FairLogger::endl;
   if( kFALSE == InitParameters() )
      LOG(ERROR)<<"**** TMbsUnpackTof: Failed to Initialize params"<<FairLogger::endl;
//      return kFALSE;
   LOG(INFO)<<"**** TMbsUnpackTof: Params Initialized "<<FairLogger::endl;
   
   // Create the proper Unpackers and number of output objects for each boards type
//   if( kFALSE == RegisterOutput() )
//      return kFALSE;
   Register(); // FairUnpack Style, I feel unsafe as no check on output Array validity!
   if( kFALSE == CreateUnpackers() )
      LOG(ERROR)<<"**** TMbsUnpackTof: Failed to create unpackers "<<FairLogger::endl;
//      return kFALSE;
   
   return kTRUE;
}
Bool_t TMbsUnpackTof::DoUnpack(Int_t* data, Int_t size)
{   
   Int_t  * pData   = data;
   UInt_t  uNbWords = size/2 - 1; // <= Somehow FAIRROOT transfers the size in words from the subevt header and not the size in longwords reads by the f_evt_get_subevent function
   
   if( 3 < fiVerbosity )
   {
      TString sPrintEvent = "";
      LOG(INFO)<<"----------------------------------------------------------------"<<FairLogger::endl;
      LOG(INFO)<<"TSize: "<<uNbWords<<FairLogger::endl;
      for( UInt_t uWdInd = 0; uWdInd < uNbWords; uWdInd++ )
      {
         if( 0 < uWdInd && 0 == uWdInd%8 )
         {
            LOG(INFO)<<sPrintEvent<<FairLogger::endl;
            sPrintEvent = "";
         } // if( 0 < uWdInd && 0 == uWdInd%8 )
         sPrintEvent += Form("%08x ", pData[uWdInd]);
      } // for( UInt_t uWdInd = 0; uWdInd < uNbWords; uWdInd++ )
      LOG(INFO)<<sPrintEvent<<FairLogger::endl;
      LOG(INFO)<<"----------------------------------------------------------------"<<FairLogger::endl;
   } // if( 3 < fiVerbosity )

   Int_t* iTagPos[ fMbsUnpackPar->GetBoardsNumber() ];
   Int_t  iTagLen[ fMbsUnpackPar->GetBoardsNumber() ];

   for(Int_t iBoard = 0; iBoard < fMbsUnpackPar->GetBoardsNumber(); iBoard++) 
   {
      iTagPos[iBoard] = 0;
      iTagLen[iBoard] = 0;
   } // for(Int_t iBoard = 0; iBoard < fMbsUnpackPar->GetBoardsNumber(); iBoard++) 

   Int_t iLastTag = -1;

   if( 11 > fiNbEvents )
   LOG(INFO)<<"TMbsUnpackTof::ProcessSubevent => Event "<<fiNbEvents<< ", size "<<size<<" nbWords "<<uNbWords<<FairLogger::endl;
 
  for (UInt_t uCurrWord = 0; uCurrWord < uNbWords; ++uCurrWord) 
   {
      ULong64_t* plTag = (ULong64_t*) pData;
      Bool_t bFound = kFALSE;

      // loop over boards until finding a matching one0
      for( Int_t iBoard=0;iBoard< fMbsUnpackPar->GetBoardsNumber(); iBoard++ )
         if( kTRUE == fMbsUnpackPar->IsActive( iBoard ) )
            if ((*plTag == fMbsUnpackPar->GetBoardTag( iBoard )) && (fMbsUnpackPar->GetBoardTag( iBoard )!=0)) 
            {
               if (iLastTag>=0) 
               {
                  // If a tag was already found:
                  // length of corresponding data is nb words since it was found
                  iTagLen[iLastTag] = pData - iTagPos[iLastTag];
                  iLastTag = -1;
               } // if (iLastTag>=0) 

               if (iTagPos[iBoard]==0) 
               {
		 if( 11 > fiNbEvents ) 
		 LOG(INFO)<<"Found board "<<iBoard<<" Tag "
			<<Form("%08llX %08llX", fMbsUnpackPar->GetBoardTag( iBoard )>>32, (fMbsUnpackPar->GetBoardTag( iBoard )&0xFFFFFFFF) )<<" at word "<<uCurrWord<<FairLogger::endl;
                  // if Tag of this board was never found
                  pData+=2; 
                  uCurrWord+=1;
                  iTagPos[iBoard] = pData;
                  iLastTag = iBoard;
               } // if (iTagPos[iBoard]==0) 
                  else 
                  {
                     LOG(ERROR)<<"----------------------------------------------------------------"<<FairLogger::endl;
                     LOG(ERROR)<<"TMbsUnpackTof::ProcessSubevent => size "<<size<<" nbWords "<<uNbWords<<FairLogger::endl;
                     LOG(ERROR)<<"TMbsUnpackTof::ProcessSubevent => FORMAT ERROR found tag "
                               <<Form("%08X %08X", fMbsUnpackPar->GetBoardTag( iBoard )>>32, fMbsUnpackPar->GetBoardTag( iBoard ) )<<" twice in event "<<fiNbEvents<<FairLogger::endl;
                     LOG(ERROR)<<" First: "<<iTagPos[iBoard]<<" Second "<<pData<<" Origin "<<data
                               <<" Last Board "<<iLastTag<<" This Board "<<iBoard<<FairLogger::endl;
                     LOG(ERROR)<<" Current word: "<<uCurrWord<<FairLogger::endl;
                     LOG(ERROR)<<" Buffer: "<<Form("%08llX %08llX", (*plTag)>>32, (*plTag)&0xFFFFFFFF )<<FairLogger::endl;
                     // Display full sub-event for debug
                     TString sPrintEvent = "";
                     for( UInt_t uWdInd = 0; uWdInd < uNbWords; uWdInd++ )
                     {
                        if( 0 < uWdInd && 0 == uWdInd%8 )
                        {
                           LOG(ERROR)<<sPrintEvent<<FairLogger::endl;
                           sPrintEvent = "";
                        } // if( 0 < uWdInd && 0 == uWdInd%8 )
                        sPrintEvent += Form("%08x ", data[uWdInd]);
                     } // for( UInt_t uWdInd = 0; uWdInd < uNbWords; uWdInd++ )
                     LOG(ERROR)<<sPrintEvent<<FairLogger::endl;
                     LOG(ERROR)<<"----------------------------------------------------------------"<<FairLogger::endl;
                     // jump this tag
                     pData+=2; 
                     uCurrWord+=1;
                  } // else of if (iTagPos[iBoard]==0) 

               bFound = kTRUE;
               break;
            } // if ((*plTag == fMbsUnpackPar->GetBoardTag( iBoard )) && (fMbsUnpackPar->GetBoardTag( iBoard )!=0))

      if( kFALSE == bFound ) 
         pData++;
   } // for (UInt_t uCurrWord = 0; uCurrWord < uNbWords; ++uCurrWord) 

   // if t east one TAG found: end of corresponding data is end of subevent
   if (iLastTag>=0)
      iTagLen[iLastTag] = pData - iTagPos[iLastTag];

   // Actually process data in different Unpackers:
   
   for( UInt_t uBoard=0; uBoard < fMbsUnpackPar->GetBoardsNumber(); uBoard++ )
      if( 0 < iTagPos[uBoard] )
      {
         LOG(DEBUG)<<"TMbsUnpackTof::ProcessSubevent => TAG "<<uBoard
                   <<" POS "<<iTagPos[uBoard] - data
                   <<" LEN "<<iTagLen[uBoard]
                   <<" TYP "<<fMbsUnpackPar->GetBoardType( uBoard )<<FairLogger::endl;
         if( 0 < iTagLen[uBoard])
            switch( fMbsUnpackPar->GetBoardType( uBoard ) )
            {
               case tofVme::caenV1290:
                  break;
               case tofVme::vftx:
                  fVftxUnp->ProcessVFTX( fMbsUnpackPar->GetGlobalToActiveInd( uBoard ), 
                                         (UInt_t*) iTagPos[uBoard], iTagLen[uBoard]); 
                  break;
               case tofVme::trb3:
                  break;
               case tofVme::get4:
                  break;
               case tofVme::triglog:
                  break;
               case tofVme::scalormu:
                  fScomUnp->ProcessScom( fMbsUnpackPar->GetGlobalToActiveInd( uBoard ), 
                                         (UInt_t*) iTagPos[uBoard], iTagLen[uBoard]);  // Scaler Or Multiplicity
                  break;
               case tofVme::undef:
               default:
                  LOG(WARNING)<<"TMbsUnpackTof::ProcessSubevent => Unknown board type "
                              <<fMbsUnpackPar->GetBoardType( uBoard )
                              <<"!!!!" <<FairLogger::endl;
            } // switch( fMbsUnpackPar->GetBoardType( uBoard ) )
      } // if (iTagPos[iBoard])
/*
   if (iTagPos[VME__ID_1182] && iTagLen[VME__ID_1182])
      Process1182(0, iTagPos[VME__ID_1182], iTagLen[VME__ID_1182]);  // 1182
   if (iTagPos[VME__ID_1183] && iTagLen[VME__ID_1183])
      Process1182(1, iTagPos[VME__ID_1183], iTagLen[VME__ID_1183]);  // 1183
   for (int tdc=VME__ID_TDC1;tdc<=VME__ID_TDC8;tdc++)
      if (iTagPos[tdc] && iTagLen[tdc])
         Process1290(tdc-VME__ID_TDC1, iTagPos[tdc], iTagLen[tdc]);  // all TDCs
   for (int qdc=VME__ID_QDC1;qdc<=VME__ID_QDC2;qdc++)
      if (iTagPos[qdc] && iTagLen[qdc])
         Process965(qdc-VME__ID_QDC1, iTagPos[qdc], iTagLen[qdc]);  // all QDCs
   if (iTagPos[VME__ID_QFW] && iTagLen[VME__ID_QFW])
      ProcessQFW((uint32_t*)iTagPos[VME__ID_QFW], iTagLen[VME__ID_QFW]);  // QFW
*/
   fiNbEvents++;
   LOG(DEBUG)<<"MBS unpacked!"<<FairLogger::endl;
   return 1;
}

void TMbsUnpackTof::Reset()
{
   ClearOutput();
}
void TMbsUnpackTof::Register()
{
   RegisterOutput();
}
Bool_t TMbsUnpackTof::Finish()
{   
//   fScomUnp->FinishScom();
   return kTRUE;
}

// ------------------------------------------------------------------
Bool_t TMbsUnpackTof::InitParameters()
{
   // Get Base Container
   FairRun* ana = FairRun::Instance();
   FairRuntimeDb* rtdb=ana->GetRuntimeDb();

   // Unpacker parameter
   fMbsUnpackPar = (TMbsUnpackTofPar*) (rtdb->getContainer("TMbsUnpackTofPar"));
   if( 0 == fMbsUnpackPar )
      return kFALSE;

//   rtdb->initContainers(  ana->GetRunId() );
   fMbsUnpackPar->printParams();
     
   return kTRUE;
} 
// ------------------------------------------------------------------
Bool_t TMbsUnpackTof::CreateHistogramms()
{
   TDirectory * oldir = gDirectory; // <= To prevent histos from being sucked in by the param file of the TRootManager!
   gROOT->cd(); // <= To prevent histos from being sucked in by the param file of the TRootManager!
   
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp->CreateHistos();
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp->CreateHistos();
   
   gDirectory->cd( oldir->GetPath() ); // <= To prevent histos from being sucked in by the param file of the TRootManager!
   
   return kTRUE;
}
Bool_t TMbsUnpackTof::FillHistograms()
{
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp->FillHistos();
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp->FillHistos();
   
   return kTRUE;
}
void TMbsUnpackTof::WriteHistogramms()
{
   TDirectory * oldir = gDirectory;
   TFile *fHist;
   
   if( 1 == fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      fHist = new TFile("./tofMbsUnp.hst.root","UPDATE");
      else fHist = new TFile("./tofMbsUnp.hst.root","RECREATE");
      
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp->WriteHistos( fHist );
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp->WriteHistos( fHist );
      
   gDirectory->cd( oldir->GetPath() );
   fHist->Close();
}
void TMbsUnpackTof::DeleteHistograms()
{
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp->DeleteHistos();
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp->DeleteHistos();
}
// ------------------------------------------------------------------
Bool_t TMbsUnpackTof::CreateUnpackers()
{
   if( 0 == fMbsUnpackPar->GetNbActiveBoards() )
   {
      LOG(ERROR)<<"TMbsUnpackTof::CreateUnpackers => No active boards => No unpacker !?!?! "<<FairLogger::endl;
      return kFALSE;
   }
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp    = new TTofScomUnpacker( fMbsUnpackPar );
/*
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::caenV1290 ) )
      fV1290Unp = new TTofV1290Unpacker( fMbsUnpackPar );
*/
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp = new TTofVftxUnpacker( fMbsUnpackPar );
/*
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )
      fGet4Unp = new TTofGet4Unpacker( fMbsUnpackPar );
*/      
   return kTRUE;
}
Bool_t TMbsUnpackTof::RegisterOutput()
{
   if( 0 == fMbsUnpackPar->GetNbActiveBoards() )
   {
      LOG(ERROR)<<"TMbsUnpackTof::RegisterOutput => No active boards => No output objects !?!?! "<<FairLogger::endl;
      return kFALSE;
   }
   // Not sure here what is the best way to group the TDC objects......
   // The vector of data in the board objects kill probably the TClonesArray purpose?
   // Maybe better to have big fixed size array and TTofVftxData::Clear calls in TTofVftxBoard combined
   // with ConstructedAt access in TTofVftxUnpacker
   FairRootManager *fManager = FairRootManager::Instance();
      // Scalers
         // TRIGLOG + Scalormu
   if( 0 < fMbsUnpackPar->GetNbActiveScalersB() && 1 != fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) ) 
   {
      fScalerBoardCollection = new TClonesArray( "TTofScalerBoard", 
                                                  fMbsUnpackPar->GetNbActiveScalersB());
//      fManager->Register("TofRawScalers","TofUnpack",fScalerBoardCollection, kTRUE);
      fManager->Register( "TofRawScalers","TofUnpack",fScalerBoardCollection,
                          fMbsUnpackPar->WriteDataInCbmOut() );
   } // if( 0 < fMbsUnpackPar->GetNbActiveScalersB() )
      //TDC
         // VFTX
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
   {
      fVftxBoardCollection = new TClonesArray( "TTofVftxBoard", 
                                               fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ));
//      fManager->Register("TofVftxTdc","TofUnpack",fVftxBoardCollection, kTRUE);
      fManager->Register( "TofVftxTdc","TofUnpack",fVftxBoardCollection,
                          fMbsUnpackPar->WriteDataInCbmOut());
   } // if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
         // Caen v1290 TDC
         // VFTX
         // TRB3

   return kTRUE;
}
Bool_t TMbsUnpackTof::ClearOutput()
{
   LOG(DEBUG)<<"Clear MBS"<<FairLogger::endl;
   if( 0 < fMbsUnpackPar->GetNbActiveScalersB() && 1 != fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      fScalerBoardCollection->Clear("C");
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) ) 
      fVftxBoardCollection->Clear("C");
   return kTRUE;
}
// ------------------------------------------------------------------