#include <iostream>
#include <cmath>
#include <algorithm>

#include <TGeoManager.h>
#include <TGeoNode.h>
#include <TGeoArb8.h>
#include <TVector3.h>
#include <TRandom.h>

#include <ICOMETLog.hxx>
#include <IGeomIdManager.hxx>
#include "IECALGeom.hxx"

#include <IOADatabase.hxx>
#include <COMETGeomId.hxx>
#include <COMETGeomIdDef.hxx>
#include <IGeomIdManager.hxx>

COMET::IECALGeom::IECALGeom() :
  IGeomBase(),
  fECALNodeId(-1),
  fECALCrystalManager(NULL),
  fCrystalWidth(-1),
  fCrystalLength(-1),
  fBlockWidth(-1),
  fBlockLength(-1),
  fNumberOfBlocks(0),
  fNumberOfCrystals(0)
{
  fNodeIdMap.resize(0);
  fNodeId.resize(0);
}

COMET::IECALGeom::~IECALGeom() { Clear(); }


void COMET::IECALGeom::Fill()
{
  fECALCrystalManager = new COMET::IECALCrystalManager();
  IECALGeomVisitor visitor(this);

  visitor.VisitGeometry();
  
  // Dupulicated numbers
  fNumberOfCrystals = fNodeId.size() / fNumberOfBlocks;
  
  BuildNodeIdMap();
  fECALCrystalManager->Init(fNodeIdMap);

  COMETNamedInfo("IECALGeom", "// --------------------------------------------------------------------- ");
  COMETNamedInfo("IECALGeom", "// ECAL geometry ");
  COMETNamedInfo("IECALGeom", "// --------------------------------------------------------------------- ");
  COMETNamedInfo("IECALGeom", "//  Number of Blocks           = " << GetNumberOfBlocks());
  COMETNamedInfo("IECALGeom", "//  Number of Crystals / Block = " << GetNumberOfCrystals());
  COMETNamedInfo("IECALGeom", "//  Number of Crystals         = " << GetNumberOfChannels());  
  COMETNamedInfo("IECALGeom", "// --------------------------------------------------------------------- ");
}


void COMET::IECALGeom::ls(const char *opt)
{
  std::cout << "// --------------------------------------------------------------------- " << std::endl
            << "// ECAL geometry " << std::endl
            << "// --------------------------------------------------------------------- " << std::endl
            << "//  Number of Blocks           = " << GetNumberOfBlocks() << std::endl
            << "//  Number of Crystals / Block = " << GetNumberOfCrystals() << std::endl
            << "//  Number of Crystals         = " << GetNumberOfChannels() << std::endl
            << "// --------------------------------------------------------------------- " << std::endl;
}

void COMET::IECALGeom::Clear(void)
{
  delete fECALCrystalManager;
  fECALCrystalManager = NULL;
}

void COMET::IECALGeom::BuildNodeIdMap()
{
  COMETNamedVerbose("IECALGeom", "COMET::IECALGeom::BuildNodeIdMap");

  std::vector<int> tmp;
  tmp.resize(0);
  for (unsigned int ii=0; ii<fNodeId.size(); ii++) {
    int node_id = fNodeId.at(ii);
    tmp.push_back(node_id);

    if(tmp.size()%fNumberOfCrystals==0){
      fNodeIdMap.push_back(tmp);
      tmp.resize(0);
    }
  }
}


bool COMET::IECALGeom::MasterToECALLocal(const TVector3& global, TVector3& local) const
{
  if (fECALNodeId < 0){
    return false;
  }
  COMET::IOADatabase::Get().GeomId().MasterToLocal(fECALNodeId, global, local);
  return true;
}

bool COMET::IECALGeom::ECALLocalToMaster(const TVector3& local, TVector3& global) const
{
  if (fECALNodeId < 0){
    return false;
  }
  COMET::IOADatabase::Get().GeomId().LocalToMaster(fECALNodeId, local, global);
  return true;
}

bool COMET::IECALGeom::ProjectOnECALPlane(const TVector3& global, TVector3& pos) const
{
  // Get the position on the ECAL coordinate
  if(fECALNodeId < 0){
    pos = global;
    return false;
  }
  
  TVector3 local;
  COMET::IOADatabase::Get().GeomId().MasterToLocal(fECALNodeId, global, local);
  local[2] = 0.0; // Go to the plane of ECAL (Z=0 on ECAL system)
  COMET::IOADatabase::Get().GeomId().LocalToMaster(fECALNodeId, local, pos); // Reverse transform
  
  COMETNamedDebug("IECALGeom", "Projected on ECAL (" << pos.X()
                  << ", " << pos.Y() << ", " << pos.Z() <<").");
  
  return true;
}

// -------------------------------------------------------------------------------------
bool COMET::IECALGeomVisitor::VisitNode(int depth, const std::string& name, const TGeoNode* node)
{
  bool ret = true;

  /// If the node isn't in the Straw Tracker, skip this node.
  gGeoManager->cd(name.c_str());
  
  // Store the home node of ECAL
  if (name == "/comet_1/DetectorSolenoid_0/ECAL_0")
    fECALGeom->fECALNodeId = gGeoManager->GetCurrentNodeId();
  
#define IEGIF_CONTAINS(str) ( name.find(str) != (std::string::npos) )
  else if(IEGIF_CONTAINS("APD"           )) ret = false;
  else if(IEGIF_CONTAINS("Crystal_"      )){
    fECALGeom->fNodeId.push_back(gGeoManager->GetCurrentNodeId());
    // Get shape info.
    if(fECALGeom->fCrystalWidth < 0 || fECALGeom->fCrystalLength < 0){
      TVector3 nodeSize = COMET::IOADatabase::Get().GeomId().NodeSize(node, COMET::IGeomIdManager::kBox);
      fECALGeom->fCrystalWidth  = 2*nodeSize.X();
      fECALGeom->fCrystalLength = 2*nodeSize.Z();
    }
  }
  else if(IEGIF_CONTAINS("Crystal"       ) ||
          IEGIF_CONTAINS("BlockWrapper"  ));
  else if(IEGIF_CONTAINS("BlockModule"   )){
    fECALGeom->fNumberOfBlocks++;
    if(fECALGeom->fBlockWidth < 0 || fECALGeom->fBlockLength < 0){
      TVector3 nodeSize = COMET::IOADatabase::Get().GeomId().NodeSize(node, COMET::IGeomIdManager::kBox);
      fECALGeom->fBlockWidth  = 2*nodeSize.X();
      fECALGeom->fBlockLength = 2*nodeSize.Z();
    }
  }
  
  // Skip the other StrECAL components
  if     (IEGIF_CONTAINS("StrawTrk"      ) ||
          IEGIF_CONTAINS("StrECALTarget" )) ret = false;
#undef IEGIF_CONTAINS
  
  COMETNamedVerbose("IECALGeomVisitor",
                    "IECALGeomVisitor::VisitNode, " << name
                    << " : " << (ret? "true":"false") );
  return ret;
}

COMET::IECALCrystalMap<Int_t> COMET::IECALGeom::ConstructBlockMap() const
{
  Int_t invalidBlockNo = -1;
  COMET::IECALCrystalMap<Int_t> blockMap
    = CreateBlockMapWith<Int_t>(&invalidBlockNo);
  
  // Loop for all the block/crystal
  COMET::IECALTrigChannelId chanId;
  for(Int_t block = 0; block < GetNumberOfBlocks(); block++){
    chanId.SetFromGeomComponentNumber(block);
    COMET::IECALCrystalMap<Int_t>::Pointer point = blockMap.GetPointerAt(chanId);
    *point = block; // Assign the block number
  }
  return blockMap;
}