// -------------------------------------------------------------------------
// -----                CbmStsHitProducerIdeal source file             -----
// -----                  Created 10/01/06  by V. Friese               -----
// -------------------------------------------------------------------------


#include "TClonesArray.h"
#include "TArrayD.h"
#include "TGeoManager.h"

#include "CbmRootManager.h"
#include "PndMvdHybridHitProducer.h"
#include "PndMvdMCPoint.h"
#include "CbmRunAna.h"
#include "CbmRuntimeDb.h"
#include "CbmGeoNode.h"
#include "CbmRuntimeDb.h"
#include "CbmGeoNode.h"
#include "CbmGeoVector.h"
#include "PndStringVector.h"
#include "PndMvdCalcPixel.h"
#include "PndMvdCalcFePixel.h"
#include "PndMvdDigiPixel.h"

// -----   Default constructor   -------------------------------------------
PndMvdHybridHitProducer::PndMvdHybridHitProducer() :
  CbmTask("MVD Hybrid Hit Producer")
{
  fBranchName   = "MVDPoint";
  pixelHits = 0;
  event_Nr = 0;
 // fGeoH = new PndMvdGeoHandling(gGeoManager);
//  fHitArray  = new TClonesArray("PndMvdHit");
//	fPixelArray	= new TClonesArray("PndMvdPixelHit");
}
// -------------------------------------------------------------------------

PndMvdHybridHitProducer::PndMvdHybridHitProducer(Double_t lx, Double_t ly, Double_t threshold, Double_t noise) :
  CbmTask("MVD Hybrid Hit Producer") 
{
  fBranchName   = "MVDPoint";
//  fHitArray  = new TClonesArray("PndMvdHit");
//	fPixelArray	= new TClonesArray("PndMvdPixelHit");
  flx = lx;
  fly = ly;
  fthreshold = threshold;
  fnoise = noise;
  pixelHits = 0;
  event_Nr = 0;
	std::cout << "MVD Hybrid Hit Producer initiated" << std::endl;
}
// -------------------------------------------------------------------------


// -----   Destructor   ----------------------------------------------------
PndMvdHybridHitProducer::~PndMvdHybridHitProducer() 
{ 
	delete fGeoH;
}
// -------------------------------------------------------------------------

// -----   Initialization  of Parameter Containers -------------------------
void PndMvdHybridHitProducer::SetParContainers()
{
  // Get Base Container
  CbmRunAna* ana = CbmRunAna::Instance();
  CbmRuntimeDb* rtdb=ana->GetRuntimeDb();
  fDigiPar = (PndMvdPixelDigiPar*)(rtdb->getContainer("PndMvdPixelDigiPar"));
//  fGeoMappingPar = (PndMvdGeoMappingPar*)(rtdb->getContainer("PndMvdGeoMappingPar"));
}

InitStatus PndMvdHybridHitProducer::ReInit()
{
  CbmRunAna* ana = CbmRunAna::Instance();
  CbmRuntimeDb* rtdb=ana->GetRuntimeDb();
  fDigiPar=(PndMvdPixelDigiPar*)(rtdb->getContainer("PndMvdPixelDigiPar"));
//  fGeoMappingPar = (PndMvdGeoMappingPar*)(rtdb->getContainer("PndMvdGeoMappingPar"));
  
  return kSUCCESS;
}

// -----   Public method Init   --------------------------------------------
InitStatus PndMvdHybridHitProducer::Init() 
{
    CbmRunAna* ana = CbmRunAna::Instance();
  CbmRootManager* ioman = CbmRootManager::Instance();
    fGeoH = new PndMvdGeoHandling(gGeoManager);
  if ( ! ioman ) 
    {
      std::cout << "-E- PndMvdHybridHitProducer::Init: "
     << "RootManager not instantiated!" << std::endl;
      return kFATAL;
    }
  fPointArray = (TClonesArray*) ioman->GetObject(fBranchName);

  if ( ! fPointArray ) 
    {
      std::cout << "-W- PndMvdHybridHitProducer::Init: "
     << "No MVDPoint array!" << std::endl;
      return kERROR;
  }

  // Create and register output array
//  fHitArray = new TClonesArray("PndMvdHit");
//  ioman->Register("MVDHit", "MVD", fHitArray, kTRUE);

  // Create and register output array
  fPixelArray = new TClonesArray("PndMvdDigiPixel");
  ioman->Register("MVDPixelHit", "MVD", fPixelArray, kTRUE);
  
  
  std::cout << "-I- PndMvdHybridHitProducer: Intialisation successfull" << std::endl;
//  std::cout << "-I- Test: " << fGeoMappingPar->detIdPairArray->GetEntries() << std::endl;

//  fDigiPar->dimX = flx;
//  fDigiPar->dimY = fly;
//  fDigiPar->threshold = fthreshold;
//  fDigiPar->noise = fnoise;

//  fDigiPar->setInputVersion(ana->GetRunId(),1);
//  fDigiPar->setChanged();
  
  
  return kSUCCESS;
}
// -------------------------------------------------------------------------

// -----   Public method Exec   --------------------------------------------
void PndMvdHybridHitProducer::Exec(Option_t* opt)
{
  // Reset output array
  if ( ! fPixelArray )
    Fatal("Exec", "No PixelArray");
  //   fHitArray->Clear();
  fPixelArray->Clear();
//   fFePixelArray->Clear();
  
  // Declare some variables
  PndMvdMCPoint *point = NULL;

  Int_t detID = 0;      // Detector ID


  // Loop over PndMvdMCPoints
  Int_t 
    nPoints = fPointArray->GetEntriesFast();
  Int_t iPixel = 0;
  Int_t iFePixel = 0;
  pixelHits = 0;
  
  for (Int_t iPoint = 0; iPoint < nPoints; iPoint++) 
  {
      point = (PndMvdMCPoint*) fPointArray->At(iPoint);
      if ( ! point){
        std::cout<< "No Point!" << std::endl;
         continue;
      }
      if (fVerbose > 1){
        std::cout << "****Global Point: " << std::endl;
        point->Print("");
      }
      CbmGeoVector posInL, posOutL, meanPos, meanPosL;
      GetLocalHitPoints(point, posInL, posOutL);
      
      if (fVerbose > 1){  
        std::cout << "Local Hits: " << std::endl;
        posInL.Print();
        posOutL.Print();
      }
      meanPosL = posInL + posOutL;
      meanPosL /= 2;
      if (fVerbose > 1){
        meanPosL.Print();
        std::cout << "Energy: " << point->GetEnergyLoss() << std::endl;
	//PndMvdGeoHandling *GeoH = new PndMvdGeoHandling(gGeoManager);
        std::cout << point->GetDetName() << std::endl;
        std::cout << fGeoH->GetPath(point->GetDetName()) << std::endl;
      }
      std::vector<PndMvdPixel> myFePixels;
      if ( fGeoH->GetPath(point->GetDetName()).Contains("Pixel")
           ||
           (fGeoH->GetPath(point->GetDetName()).Contains("Sensor") && !fGeoH->GetPath((point->GetDetName()).Contains("Strip")))
         )
      {
        // Define sensor by pixelsizes threshold and noise from macro outside
        PndMvdCalcPixel PixelCalc(flx, fly, fthreshold, fnoise);
        // Calculate a cluster of Pixels fired (in sensor system)
        std::vector<PndMvdPixel> myPixels = PixelCalc.GetPixels (posInL.getX(), posInL.getY(), posInL.getZ(),
                                            posOutL.getX(), posOutL.getY(), posOutL.getZ(),
                                            point->GetEnergyLoss()*1E9 );
        if (myPixels.size() == 0){
          if (fVerbose > 1) std::cout << "Deposited charge below threshold" << std::endl;
        } else {
          pixelHits += myPixels.size();
          if (fVerbose > 1) std::cout  << "SensorPixels: " << std::endl;
          for(uint i = 0; i < myPixels.size(); i++)
          {
            myPixels[i].SetDetName(point->GetDetName().Data());
            if (fVerbose > 1) std::cout << myPixels[i] << std::endl;
          }
          // TODO read Parameters from Database
          // Calculate channel numbers
          PndMvdCalcFePixel feCalc(76, 84, 10);
          myFePixels = feCalc.CalcFEHits(myPixels);
          if (fVerbose > 1){
            std::cout << "FePixels: " << myFePixels.size() << std::endl;
            for(uint i = 0; i < myFePixels.size(); i++){
               std::cout << myFePixels[i] << std::endl;
            }
          }

          detID   = point->GetDetectorID();
          for (uint iPix = 0; iPix < myFePixels.size(); iPix++){
            new ((*fPixelArray)[iFePixel++])
                  PndMvdDigiPixel( iPoint, detID,   point->GetDetName(),myFePixels[iPix].GetFE(),
                               myFePixels[iPix].GetCol(), myFePixels[iPix].GetRow(),
                               myFePixels[iPix].GetCharge());
          }
        }//endif myPixels.size

      }//endif pixel


    }   // Loop over MCPoints

  // Event summary

  std::cout << "-I- PndMvdHybridHitProducer: " << nPoints << " PndMvdMCPoints, "
            << pixelHits << " Hits created." << " " << iFePixel
            << "  (event "<<event_Nr++ <<")"<< std::endl;

}

void PndMvdHybridHitProducer::GetLocalHitPoints(PndMvdMCPoint* myPoint, CbmGeoVector& myHitIn, CbmGeoVector& myHitOut)
{
  
  if (fVerbose > 1)
    std::cout << "GetLocalHitPoints" << std::endl;
  TGeoHMatrix trans = GetTransformation(myPoint->GetDetName().Data());
  
  Double_t posIn[3];
  Double_t posOut[3];
  Double_t posInLocal[3];
  Double_t posOutLocal[3];
  
  posIn[0] = myPoint->GetX();
  posIn[1] = myPoint->GetY();
  posIn[2] = myPoint->GetZ();
  
  posOut[0] = myPoint->GetXOut();
  posOut[1] = myPoint->GetYOut();
  posOut[2] = myPoint->GetZOut();
  
  if (fVerbose > 1){
    for (Int_t i = 0; i < 3; i++)
      std::cout << "posIn "<< i << ": " << posIn[i] << std::endl;
  
    trans.Print("");
  }
  
  trans.MasterToLocal(posIn, posInLocal);
  trans.MasterToLocal(posOut, posOutLocal);
  
  if (fVerbose > 1) {
    for (Int_t i = 0; i < 3; i++){
      std::cout << "posInLocal "<< i << ": " << posInLocal[i] << std::endl;
      std::cout << "posOutLocal "<< i << ": " << posOutLocal[i] << std::endl;
    }
  }

  
  //posIn/OutLocal have the center of the coordinate system in the center of the shape
  //typically sensors have their coordinate system centered at the lower left corner
  
  TVector3 offset = GetSensorDimensions(myPoint->GetDetName().Data());
  
  posInLocal[0] += offset.x();
  posInLocal[1] += offset.y();
  //posInLocal[2] += offset.z();
  
  posOutLocal[0] += offset.x();
  posOutLocal[1] += offset.y();
  //posOutLocal[2] += offset.z();
  
  
  myHitIn.setVector(posInLocal);
  myHitOut.setVector(posOutLocal);
    
}

TGeoHMatrix PndMvdHybridHitProducer::GetTransformation(std::string detName)
{
  //PndMvdGeoHandling GeoH(gGeoManager);
  gGeoManager->cd(fGeoH->GetPath(detName.c_str()));
  TGeoHMatrix* transMat = gGeoManager->GetCurrentMatrix();
  if (fVerbose > 1)
  transMat->Print("");
  return *transMat;
}

TVector3 PndMvdHybridHitProducer::GetSensorDimensions(std::string detName)
{
  //PndMvdGeoHandling GeoH(gGeoManager);
  gGeoManager->cd(fGeoH->GetPath(detName.c_str()));
  TGeoVolume* actVolume = gGeoManager->GetCurrentVolume();
  TGeoBBox* actBox = (TGeoBBox*)(actVolume->GetShape());
  TVector3 result;
  result.SetX(actBox->GetDX());
  result.SetY(actBox->GetDY());
  result.SetZ(actBox->GetDZ());
  
  //result.Dump();
  
  return result;
}
// -------------------------------------------------------------------------


ClassImp(PndMvdHybridHitProducer);