//------------------------
// String Header First  --
//------------------------
#include <string>

//-----------------------
// This Class's Header --
//-----------------------
#include "TrackingMods/CTCollResurrector.hh"

//---------------
// C++ Headers --
//---------------
#include <algorithm>
#include <iostream>
#include <vector>

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "AbsEnv/AbsEnv.hh"
#include "TrackingObjects/Storable/CdfTrackView.hh"
#include "TrackingObjects/Storable/CdfTrackColl.hh"
#include "TrackingObjects/Tracks/CorCotTrack.hh"
#include "TrackingCT/CT_ReFit.hh"
#include "TrackingMods/PadTrackMaker.hh"

//-----------------------------------------------------------------------
// Local Macros, Typedefs, Structures, Unions and Forward Declarations --
//-----------------------------------------------------------------------

static const char rcsid[] = "$Id: CTCollResurrector.cc,v 1.8 2003/08/22 20:31:58 hays Exp $";

//----------------
// Constructors --
//----------------
CTCollResurrector::CTCollResurrector( 
    const char* const theName, 
    const char* const theDescription )
    : AppModule( theName, theDescription ),
      _debug("debug", this, false),
      _scaleCOTerrors("scaleCOTerrors", this, false),
      _fitCOT("FitCOT",this,false),
      _COTDebug("COTDebug",this,false),
      _COTRoad("COTRoad",this,0.06)
{
  commands()->append(&_debug);
  commands()->append(&_scaleCOTerrors);
  commands()->append(&_fitCOT);
  commands()->append(&_COTDebug);
  commands()->append(&_COTRoad);
  _debug.addDescription("\tDebug mode");
  _scaleCOTerrors.addDescription("\tInvoke COT error scaling");
  _fitCOT.addDescription("\tRefit COT tracks");
  _COTDebug.addDescription("\tPrint out results of COT refit");
  _COTRoad.addDescription("\tRoad for finding hits on COT track");
  _PionMass = 0.140; 
}

//--------------
// Destructor --
//--------------
CTCollResurrector::~CTCollResurrector( )
{
}

//--------------
// Operations --
//--------------
AppResult CTCollResurrector::beginJob( AbsEvent* anEvent )
{
  _kalFitter = SiKalmanFitter::instance();
  return AppResult::OK;
}

AppResult CTCollResurrector::beginRun( AbsEvent* theRun )
{
  if (_kalFitter){
    _kalFitter->refreshDetector();
  }
  return AppResult::OK;
}

AppResult CTCollResurrector::event( AbsEvent* anEvent )
{
  // iterate over the tracks 
  //
  CdfTrackView_h hTrackView;
  CdfTrackView::allTracks( hTrackView );

  ConstHandle<SiHitSet> siliconHitSet_h;
  EventRecord::ConstIterator siliconHitSetIter(anEvent,"SiHitSet");
  if (siliconHitSetIter.is_valid()) {
    siliconHitSet_h = siliconHitSetIter;
  }

  CdfTrackColl_h CotCollOut = CdfTrackColl_h(new CdfTrackColl(siliconHitSet_h));
  CotCollOut->set_description("COT_Global_Tracking");

  CdfTrackView_h outputView (new CdfTrackView());

  int numtotal=0;
  for (CdfTrackView::const_iterator iTrkLink = hTrackView->contents().begin(); 
       iTrkLink != hTrackView->contents().end(); ++iTrkLink) {
    numtotal++;
  }
  if (_debug.value()) {
    std::cout << "The total number of tracks is " << numtotal << std::endl;
    std::cout << "The Printout of the hTrackView contents follows:" << std::endl;
    std::cout << *hTrackView << std::endl;
  }


  // Loop over the event track collections
  EventRecord::ConstIterator i( anEvent, "CdfTrackColl" );
  for ( ; i.is_valid() ; ++i ) 
  {
    if (_debug.value()) {
      std::cout << "FOUND a new collection with process name " << 
      i->process_name() << " and with description " << 
      i->description() << std::endl;
    }    
    if ( i->description() == "PADTracks") {
      ConstHandle<CdfTrackColl> hTrkColl( i );
      const CdfTrackColl::collection_type & trkVect = hTrkColl->contents();
      CdfTrackColl* trackColl = (CdfTrackColl*) &(*hTrkColl);
      trackColl->set_description("OldPADTracks");
      for ( CdfTrackColl::const_iterator itrk = trkVect.begin(),
	      itrkEnd = trkVect.end();
	    itrk != itrkEnd ; ++itrk ) {
	CdfTrack_clnk tempTrack = (*itrk);
	if (_debug.value()) {
	  std::cout << std::endl << "Iterating to a new track inside " <<
	    i->description() << std::endl;
	  std::cout << "It's track " << (*itrk)->id() 
		    << " with algorithm value " 
		    << (*itrk)->algorithm().value()
		    << std::endl;
	}
	if ( (*itrk)->algorithm().value() == CdfTrack::CotStandAloneAlg ) {
	  if (_debug.value()) {
	    std::cout << "Pushing track " << (*itrk)->id() 
		      << " onto the new collection" << std::endl;
	  }
	  outputView->contents().push_back(*itrk);
	}

      }
    }
  }

  std::sort(outputView->contents().begin(), outputView->contents().end(), 
	    DecrPt());
	
  for (CdfTrackView::const_iterator itrk = outputView->contents().begin();
       itrk != outputView->contents().end(); ++itrk) {
    CdfTrack *outTrack = new CdfTrack(**itrk);
    outTrack->nullChildLink();
    outTrack->setPADQualityFlag(0);

    // optionally refit COT tracks
    if (_fitCOT.value()) {
      const CT_Configuration& cfg = CT_Configuration::reference();
      const int nsl = cfg.numSuperLayers();

      CT_ReFit refit;
      refit.setSearchRoad(_COTRoad.value());
      refit.restore(*outTrack);

      // add hits to track
      for (int sl = 0,ilr=0; sl < nsl ; ++sl ) { 
	for (int wire = 0; wire < cfg.numWires(sl); ++wire, ++ilr) {
	  const CT_ReFit::LayerData& ldat = *(refit.layer_data() + ilr); 
	  if (! ldat.link.is_valid()) continue;
	  if (ilr > outTrack->lastLayerCT()) continue;
	  outTrack->addHit(sl,ldat.link);
	  int hitnumber = ldat.link.offset();
         
	  if (_COTDebug.value())
	    std::cout << "ilr: " << ilr << ", ldat.deltaD(): " << ldat.deltaD() << std::endl;
	  
	}
      }
      
      refit(*outTrack);

      if (_COTDebug.value()) {
	std::cout << "Before COT refit: " << std::endl;
	outTrack->Print();
      }
      
      if (!refit.ok()) {
	outTrack->setFitFailed3d(diverged);
	continue;
      } else {
	// compute chi2
	const int nlr = cfg.layer0(nsl - 1) + cfg.numWires(nsl - 1);      
	double chi2 = 0.;
	double nhits = 0.;
	for (int ilr = 0; ilr < nlr; ++ilr) {
	  const CT_ReFit::LayerData& ldat = *(refit.layer_data() + ilr); 
	  if (! ldat.link.is_valid()) continue;
	  chi2 += ldat.deltaD() * ldat.deltaD() * ldat.weight;
	  nhits++;
	}
	// set new track fit
	outTrack->setFit(Fit<Helix>(chi2,nhits-refit.npar(), refit.par(), refit.cov()));
      }

      if (_COTDebug.value()) {
	std::cout << "After COT refit: " << std::endl;
	outTrack->Print();
      }
      
    }

    if (_scaleCOTerrors.value()) {
      CorCotTrack::CorTrack(outTrack,true);
    }

    CotCollOut->contents().push_back( outTrack );
  }
	
  if (_debug.value())
    std::cout << "CTCollResurrector -- COT global tracking collection was resurrected successfully" << std::endl;
  
  CdfTrackColl_h padOutH(CotCollOut);
  anEvent->append(CotCollOut);
  
  if (_debug.value()) {
    std::cout << "The Printout of CotCollOut follows:" << std::endl;
    std::cout << *CotCollOut << std::endl;
    CotCollOut->Print();
  }

  return AppResult::OK;
}

AppResult CTCollResurrector::endJob( AbsEvent* anEvent )
{
  return AppResult::OK;
}

AppModule* CTCollResurrector::clone( const char* cloneName )
{
  return new CTCollResurrector(cloneName,"this module is a clone CTCollResurrector");
}

const char* CTCollResurrector::rcsId( ) const
{
   return rcsid;
}