// ------------------------------------------------------------------
// -----                     TMbsMappingTofPar                   -----
// -----              Created 09/06/2013 by P.-A. Loizeau       -----
// ------------------------------------------------------------------
#include "TMbsMappingTofPar.h"

// TOF headers
#include "TofTdcDef.h"
#include "TofCaenDef.h"
#include "TofVftxDef.h"
#include "TofTrbTdcDef.h"
#include "TofGet4Def.h"
#include "CbmTofAddress.h"

// FAIR headers
#include "FairLogger.h"
#include "FairParamList.h" 

// ROOT headers
#include "TString.h"

ClassImp(TMbsMappingTofPar)

// TODO: To be defined somewhere else later!!
//                                                     HD  BUC  PLA CRPC Ref  BHD  newBUC
//const Int_t TMbsMappingTofPar::fgkiNbChDetType[7] = { 32,  72,   1,   8,  10,  56,     8 }; 
const Int_t TMbsMappingTofPar::fgkiNbChDetType[fgkiNbDetType] =
//                   P3   Ref   PLA    P2    P5   Dia  2013  USTC  2012   PAD  TsgStr
//                    |     |     |     |     |     |     |     |     |     |     |
                 {   56,   72,    1,   32,   16,    1,   64,   16,   16,   48,    8 };

TMbsMappingTofPar::TMbsMappingTofPar() :
    FairParGenericSet("TMbsMappingTofPar","Tof MBS Mapping Parameters","TestDefaultContext"),
    fuMappingDebug(0),
    fiNbMappedTdc(0),
    fiUseExtendedDigi(0)
{
}

TMbsMappingTofPar::TMbsMappingTofPar(const char* name,
                                  const char* title,
                                  const char* context ) : 
    FairParGenericSet(name,title,context),
    fuMappingDebug(0),
    fiNbMappedTdc(0),
    fiUseExtendedDigi(0)
{
}

TMbsMappingTofPar::~TMbsMappingTofPar()
{
}

void TMbsMappingTofPar::clear(void)
{
	  status = kFALSE;
	  resetInputVersions();
} 

void TMbsMappingTofPar::putParams(FairParamList* l)
{
  if (!l) { return; }

  l->add("MappingDebug", (Int_t)fuMappingDebug);
  l->add("NbMappedTdc",  fiNbMappedTdc);
  l->add("NbChTdc",      fiNbChTdc);
  l->add("TdcUniqueId",  fiTdcUniqueId);
  l->add("Mapping",      fiMapping);
  l->add("UseExtDigi",   fiUseExtendedDigi);
  l->add("NbMappedDet",  fiNbMappedDet);
  l->add("DetUniqueId",  fiDetUniqueId);
}

Bool_t TMbsMappingTofPar::getParams(FairParamList* l)
{
  if (!l) { return kFALSE; }
  
  /*
   * TODO PAL: Thing I am not sure is whether order in readout has to 
   * match order in the ascii file => to check
   */
   
  LOG(DEBUG2)<<"Get the Tof MBS mapping parameters."<<FairLogger::endl;
  
  Int_t iTempCaster = 0;
  if ( ! l->fill("MappingDebug", &iTempCaster) ) return kFALSE;
  fuMappingDebug = (UInt_t)iTempCaster;
  
  if ( ! l->fill("NbMappedTdc",    &fiNbMappedTdc) ) return kFALSE;
  
  if( 0 < fiNbMappedTdc )
  {
      fiNbChTdc.Set( fiNbMappedTdc );
      if ( ! l->fill("NbChanTdc",  &fiNbChTdc) ) return kFALSE;

      fiTdcUniqueId.Set( fiNbMappedTdc );
      if ( ! l->fill("TdcUniqueId", &fiTdcUniqueId) ) return kFALSE;

      Int_t iTotalNbChMapped = 0;
      for( Int_t iMappTdcIndex = 0; iMappTdcIndex < fiNbMappedTdc; iMappTdcIndex++)
         iTotalNbChMapped += fiNbChTdc[iMappTdcIndex];
      if( 0 < iTotalNbChMapped )
      {
         fiMapping.Set( iTotalNbChMapped );
         if ( ! l->fill("Mapping",  &fiMapping) ) return kFALSE;
      } // if( 0 < iTotalNbChMapped )
  } // if( 0 < fiNbMappedTdc )
  if ( ! l->fill("UseExtDigi",     &fiUseExtendedDigi) ) return kFALSE;
  
  if ( ! l->fill("NbMappedDet",    &fiNbMappedDet) ) return kFALSE;
  if( 0 < fiNbMappedDet )
  {
      fiDetUniqueId.Set( fiNbMappedDet );
      if ( ! l->fill("DetUniqueId", &fiDetUniqueId) ) return kFALSE;
  } // if( 0 < fiNbMappedDet )
  
  return kTRUE;
}

void TMbsMappingTofPar::printParams()
{   
   LOG(INFO)<<"Parameter values in TMbsMappingTofPar: "<<FairLogger::endl;
   
   if(1 == fuMappingDebug)
      LOG(INFO)<<"  Mapping Debug                       ON!!!!!!"<<FairLogger::endl;
      else LOG(INFO)<<"  Mapping Debug                       OFF"<<FairLogger::endl;   
      
   LOG(INFO)<<"  Nb of TDC mapped to detectors:      "<<fiNbMappedTdc<<FairLogger::endl;
   
   if( 0 < fiNbMappedTdc )
   {
      TString sTdcInd  = "Tdc #:                --- ";
      TString sNbChTdc = "Nb ch per Mapped TDC: |-> ";
      TString sUnIdTdc = "TDC Unique Id:        |-> ";
      
      TString sChanInd = "Channel Index:               --- ";
      TString sMapping[fiNbMappedTdc];
      
      Int_t iMappingIndex = 0;
      Int_t iMaxChannels  = fiNbChTdc[0];
      for( Int_t iMappTdcIndex = 0; iMappTdcIndex < fiNbMappedTdc; iMappTdcIndex++)
      {
         sTdcInd  += Form("  %8d ",  iMappTdcIndex);
         sNbChTdc += Form("  %8d ",  fiNbChTdc[iMappTdcIndex]);
         sUnIdTdc += Form("0x%08X ", fiTdcUniqueId[iMappTdcIndex]);
         
         sMapping[iMappTdcIndex] = Form("Tdc #%03d, mapped to Det UId: |-> ", iMappTdcIndex);
         if( iMaxChannels < fiNbChTdc[iMappTdcIndex] )
            sChanInd = "Channel Index:           ---";
         for( Int_t iChanInd = 0; iChanInd < fiNbChTdc[iMappTdcIndex]; iChanInd++)
         {
            if( 0xFFFFFFFF == fiMapping[ iMappingIndex + iChanInd ] )
               sMapping[iMappTdcIndex] += "0xFFFFFFFF ";
               else sMapping[iMappTdcIndex] += Form("0x%08X ", fiMapping[ iMappingIndex + iChanInd ]);
            if( 0 == iMappTdcIndex )
               sChanInd += Form("  %8d ", iChanInd);
            else if( iMaxChannels < fiNbChTdc[iMappTdcIndex] )
               sChanInd += Form("  %8d ", iChanInd);
         } // for( Int_t iChanInd = 0; iChanInd < fiNbChTdc[iMappTdcIndex]; iChanInd++)
         if( iMaxChannels < fiNbChTdc[iMappTdcIndex] )
            iMaxChannels = fiNbChTdc[iMappTdcIndex];
         
         iMappingIndex += fiNbChTdc[iMappTdcIndex];
      } // for( Int_t iMappTdcIndex = 0; iMappTdcIndex < fiNbMappedTdc; iMappTdcIndex++)
      LOG(INFO)<<sTdcInd<<FairLogger::endl;
      LOG(INFO)<<sNbChTdc<<FairLogger::endl;
      LOG(INFO)<<sUnIdTdc<<FairLogger::endl;
      LOG(INFO)<<sChanInd<<FairLogger::endl;
      for( Int_t iMappTdcIndex = 0; iMappTdcIndex < fiNbMappedTdc; iMappTdcIndex++)
         LOG(INFO)<<sMapping[iMappTdcIndex]<<FairLogger::endl;
   } // if( 0 < fiNbMappedTdc )
      
   if(1 == fiUseExtendedDigi)
      LOG(INFO)<<"  Type of Digis used:                 Extended"<<FairLogger::endl;
      else LOG(INFO)<<"  Type of Digis used:                 Compressed"<<FairLogger::endl;   
      
   LOG(INFO)<<"  Nb of detectors in mapping:         "<<fiNbMappedDet<<FairLogger::endl;
   if( 0 < fiNbMappedDet )
   {
      TString sDetInd  = "Det #:                --- ";
      TString sUnIdDet = "Det Unique Id:        |-> ";
      for( Int_t iMappDetIndex = 0; iMappDetIndex < fiNbMappedDet; iMappDetIndex++)
      {
         sDetInd  += Form("  %8d ",  iMappDetIndex);
         sUnIdDet += Form("0x%08X ", fiDetUniqueId[iMappDetIndex]);
      } // for( Int_t iMappDetIndex = 0; iMappDetIndex < fiNbMappedDet; iMappDetIndex++)
      LOG(INFO)<<sDetInd<<FairLogger::endl;
      LOG(INFO)<<sUnIdDet<<FairLogger::endl;
   } // if( 0 < fiNbMappedDet )
   return;
}
// ------------------------------------------------------------------ 
Int_t TMbsMappingTofPar::GetMappedTdcUId( Int_t iMappedTdcInd ) const
{
   if( iMappedTdcInd < fiNbMappedTdc )
      return fiTdcUniqueId[iMappedTdcInd];
      else return -1; // Equal to 0xFFFFFFFF => inactive
}
Int_t TMbsMappingTofPar::GetMappedTdcInd( Int_t iTdcUId ) const
{
   for( Int_t iMappedTdcInd = 0; iMappedTdcInd < GetNbMappedTdc(); iMappedTdcInd++)
      if( iTdcUId == GetMappedTdcUId( iMappedTdcInd ) )
         return iMappedTdcInd;
         
   // If none of the TDC matches => return -1, calling function/method has to catch it
   // and ignore the corresponding data object
   return -1;
}
Int_t TMbsMappingTofPar::GetMapping( Int_t iMappedTdcInd, Int_t iMappedChan ) const
{
   if( iMappedTdcInd < fiNbMappedTdc )
   {
      if( iMappedChan < fiNbChTdc[iMappedTdcInd] )
      {
         Int_t iMappingIndex = 0;
         for( Int_t iPrevTdcIndx = 0; iPrevTdcIndx < iMappedTdcInd; iPrevTdcIndx++)
            iMappingIndex += fiNbChTdc[iPrevTdcIndx];
         return fiMapping[ iMappingIndex + iMappedChan ];
      } // if( iMappedChan < fiNbChTdc[iMappedTdcInd] )
      else return -1; // Equal to 0xFFFFFFFF => inactive
   } // if( iMappedTdcInd < fiNbMappedTdc )
      else return -1; // Equal to 0xFFFFFFFF => inactive
}
Int_t TMbsMappingTofPar::GetMappedDetUId( Int_t iMappedDetInd ) const
{
   if( iMappedDetInd < fiNbMappedDet )
      return fiDetUniqueId[iMappedDetInd];
      else return -1; // Equal to 0xFFFFFFFF => inactive
}
Int_t TMbsMappingTofPar::GetMappedDetInd( Int_t iMappedDetUId ) const
{
   if( 0xFFFFFFFF == iMappedDetUId )
      return -1; // Equal to 0xFFFFFFFF => inactive
      
   for( Int_t iDetIndx = 0; iDetIndx < fiNbMappedDet; iDetIndx++)
      if( kTRUE == CbmTofAddress::SameModule( iMappedDetUId, fiDetUniqueId[iDetIndx] ) )
         return iDetIndx;
  
   // If not matching any detector =>
   return -1; // Equal to 0xFFFFFFFF => inactive
}
// ------------------------------------------------------------------ 
Int_t TMbsMappingTofPar::GetSmTypeNbCh(   Int_t iSmType ) const
{
   if( -1 < iSmType && iSmType < fgkiNbDetType )
      return fgkiNbChDetType[iSmType];
      else return 0;
}