////////////////////////////////////////////////////////////
// $Id: ISingleHit.cxx,v 1.22 2012/06/18 15:32:24 mcgrew Exp $
//
#include <cmath>

#include <TGeoManager.h>
#include <TVector3.h>

#include "IGeomIdManager.hxx"
#include "ISingleHit.hxx"
#include "IOADatabase.hxx"
#include "HEPUnits.hxx"
#include "COMETGeomId.hxx"

ClassImp(COMET::ISingleHit);

COMET::ISingleHit::ISingleHit() 
    : COMET::IHit(), fCharge(0), fTime(0), fChannelID(0),
      fInitialized(false),
      fPosition(0,0,0), 
      fIsXHit(false), fIsYHit(false), fIsZHit(false),
      fSpread(100*unit::meter,100*unit::meter,100*unit::meter),
      fUncertainty(100*unit::meter,100*unit::meter,100*unit::meter),
      fTimeUncertainty(1*unit::ns){
    SetBit(kCanDelete,false);
}

COMET::ISingleHit::ISingleHit(const COMET::ISingleHit& h) 
    : COMET::IHit(h), 
      fCharge(h.fCharge), fTime(h.fTime), 
      fChannelID(h.fChannelID),
      fInitialized(h.fInitialized),
      fPosition(h.fPosition),
      fIsXHit(h.fIsXHit), fIsYHit(h.fIsYHit), fIsZHit(h.fIsZHit),
      fSpread(h.fSpread),
      fUncertainty(h.fUncertainty),
      fTimeUncertainty(h.fTimeUncertainty) {
    SetBit(kCanDelete,false);
}

COMET::ISingleHit::~ISingleHit() { }

//////////////////////////////////////////////////
// Getter methods for COMET::ISingleHit
//////////////////////////////////////////////////

double COMET::ISingleHit::GetCharge(void) const {return fCharge;}

double COMET::ISingleHit::GetTime(void) const {return fTime;}

// Return the associated channel id.
COMET::IChannelId COMET::ISingleHit::GetChannelID(int i) const {return fChannelID;}

// Return the number of channel ids associated with this hit.
int COMET::ISingleHit::GetChannelIDCount() const {
    if (!fChannelID.IsValid()) return 0;
    return 1;
}

const TVector3& COMET::ISingleHit::GetPosition(void) const {
    if (!fInitialized) const_cast<COMET::ISingleHit*>(this)->Initialize();
    return fPosition;
}

const TVector3& COMET::ISingleHit::GetSpread(void) const {
    if (!fInitialized) const_cast<COMET::ISingleHit*>(this)->Initialize(); 
    return fSpread;
}

const TVector3& COMET::ISingleHit::GetUncertainty(void) const {
    if (!fInitialized) const_cast<COMET::ISingleHit*>(this)->Initialize();
    return fUncertainty;
}

double COMET::ISingleHit::GetTimeUncertainty(void) const {
    if (!fInitialized) const_cast<COMET::ISingleHit*>(this)->Initialize();
    return fTimeUncertainty;
}

bool COMET::ISingleHit::IsXHit(void) const {
    if (!fInitialized) const_cast<COMET::ISingleHit*>(this)->Initialize();
    return fIsXHit;
}

bool COMET::ISingleHit::IsYHit(void) const {
    if (!fInitialized) const_cast<COMET::ISingleHit*>(this)->Initialize();
    return fIsYHit;
}

bool COMET::ISingleHit::IsZHit(void) const {
    if (!fInitialized) const_cast<COMET::ISingleHit*>(this)->Initialize();
    return fIsZHit;
}

bool COMET::ISingleHit::InitializeGeneric() {
    const COMET::IGeometryId geomID = GetGeomID();
    TGeoNode* node = COMET::IOADatabase::Get().GeomId().GetNode(geomID);
    if (!node){
        COMETError("GeomID is not valid for this hit!");
        return true;
    }

    // Find the global position
    COMET::IOADatabase::Get().GeomId().LocalToMaster(geomID,0,0,0,fPosition);
    
    // Find the spread.
    fSpread = COMET::IOADatabase::Get().GeomId().NodeExtent(geomID,COMET::IGeomIdManager::kBox);

    fUncertainty = fSpread*(2.0/std::sqrt(12.0*fCharge));

    /*
    COMETDebug("spread[0] = " << spread[0]
         << "\tspread[1] = " << spread[1] 
         << "\tspread[2] = " << spread[2] 
         << "\tCharge = " << fCharge 
         << "\tUncert[X] = " << fUncertainty.X() 
         << "\tUncert[Y] = " << fUncertainty.Y() 
         << "\tUncert[Z] = " << fUncertainty.Z() 
         );
    */
    
    if (HasValidTime()) {
        fTimeUncertainty = 2.5*unit::ns/std::sqrt(12.0);
    }
    else {
        fTimeUncertainty = 580*unit::ns/std::sqrt(12.0);
    }

    // Determine if the hit is an X, Y, or Z hit.
    fIsXHit = (fSpread.X() < 10*unit::cm); // what 10cm means?
    fIsYHit = (fSpread.Y() < 10*unit::cm); // what 10cm means?
    fIsZHit = (fSpread.Z() < 10*unit::cm); // what 10cm means?

    return true;
}

void COMET::ISingleHit::Initialize(void) {
#ifdef TSINGLE_HIT_SAVE_POSITION
    TVector3 origPos = fPosition;
#endif
  
    try {
        do {
            // Try initializations looking for the first one to work.  The
            // initializations should be ordered from the most specific to the
            // most general.
            InitializeGeneric();
        } while (false);
        fInitialized = true;
    }
    catch (std::exception& e) {
        COMETSevere("ISingleHit Exception: " << e.what());
        return;
    }
    catch (...) {
        // Just don't crash!
        COMETSevere("ISingleHit Exception: unknown");
        return;
    }
  
#ifdef TSINGLE_HIT_SAVE_POSITION
    if (origPos.Mag()>1*unit::mm
        && (fPosition-origPos).Mag()>1*unit::mm) {
        COMETError("Position and node position mismatch"
                   << std::endl
                   << "  Geometry ID " << GetGeomID().AsInt() << std::endl
                   << "  Saved Position is " 
                   << " " << fPosition.X()
                   << " " << fPosition.Y()
                   << " " << fPosition.Z()
                   << std::endl
                   << "  Node Position is  " 
                   << " " << origPos.X()
                   << " " << origPos.Y()
                   << " " << origPos.Z());
    }
#endif
}