///////////////////////////////////////////////////////////////////////////////
//  P.Murat: STNTUPLE beam manager - want to do this only in one place
///////////////////////////////////////////////////////////////////////////////

#include "AbsEnv/AbsEnv.hh"
//#include "CotGeometry/CT_Calibration.hh"
#include "Stntuple/mod/StntupleBeamManager.hh"
#include "Alignment/CotBeam.hh"
#include "Alignment/SvxBeam.hh"
#include "VertexObjects/Beamline.hh"
#include "Stntuple/obj/TStnDBManager.hh"
#include "Stntuple/data/TStnBeamPos.hh"
#include "Stntuple/data/TStnBeamPosBlock.hh"

#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Geometry/Point3D.h"
#include "CLHEP/Geometry/Vector3D.h"

ClassImp(StntupleBeamManager)

StntupleBeamManager*  StntupleBeamManager::fgInstance = 0;

//_____________________________________________________________________________
StntupleBeamManager::StntupleBeamManager(const char* Name) :
  TNamed(Name,Name) 
{
  fCotBeam     = 0;
  fSvxBeam     = 0;
  fHistoryCode = -1;
  fLastRun     = -1;
}


//_____________________________________________________________________________
StntupleBeamManager::~StntupleBeamManager() {
  if (! fCotBeam) {
    delete fCotBeam;
    delete fSvxBeam;
  }
}

//_____________________________________________________________________________
StntupleBeamManager*  StntupleBeamManager::Instance() { 
  static Cleaner cleaner;
  return (fgInstance) ? fgInstance : (fgInstance = new StntupleBeamManager());
}

//------------------------------------------------------------------------------
StntupleBeamManager::Cleaner::Cleaner() {
}

//------------------------------------------------------------------------------
StntupleBeamManager::Cleaner::~Cleaner() {
  if (StntupleBeamManager::fgInstance) {
    delete StntupleBeamManager::fgInstance;
    StntupleBeamManager::fgInstance = 0;
  }
}


//_____________________________________________________________________________
int StntupleBeamManager::BeginRun(Int_t  RunNumber, Int_t  McFlag) {

  // initialize beam constants for a given run
  // -----------------------------------------
  // CotCode =  0 : full success (COT OK, SVX OK)
  //         =  1 : failed to load COT beam position with HistoryCode, 
  //         = -1 : fallback also failed
  // SvxCode      : same as for CotCode
  // Jul 11 2003  : moving to used-set based model, have to use 
  //                PAD_PHYSCIS_CDF 09

  static Beamline beam;

  int    cot_code, svx_code;

  if (! fCotBeam) {
//-----------------------------------------------------------------------------
// create beamline objects at begin run: the procedure depends on whether it
// is real data or MC and we can't answer this question in the constructor
// or at BeginJob
//-----------------------------------------------------------------------------
    fCotBeam = new CotBeam();
    fSvxBeam = new SvxBeam();
  }

  if (RunNumber != fLastRun) {
    fLastRun = RunNumber;
//-----------------------------------------------------------------------------
// load beam positions, do it only for the data, MC uses calibration manager
// with the default constructor used history codes are ignored
// DSW, 28.05.03. Ray C. says always call loadRun() :
//-----------------------------------------------------------------------------
//      fCotBeam->setHistoryCode(fHistoryCode);
//      fSvxBeam->setHistoryCode(fHistoryCode);

    fCotBeam->loadRun();
    fSvxBeam->loadRun();

    if (fCotBeam->isValid()) cot_code = 0;
    else                     cot_code = -1;
    if (fSvxBeam->isValid()) svx_code = 0;
    else                     svx_code = -1;
  }

//-----------------------------------------------------------------------------
//  initialize TStnDBManager
//-----------------------------------------------------------------------------
  TStnDBManager* dbm = TStnDBManager::Instance();
  int n = 0;
  Beamline b;

//-----------------------------------------------------------------------------
//  step 1: COT beam position
//-----------------------------------------------------------------------------
  int history = fCotBeam->getRecord().Flag0() & 0xFFFF;

  //b = fCotBeam->getBeamline();
  //
  //TStnBeamPos* cot_beam_pos = (TStnBeamPos*) dbm->GetTable("CotBeamPos");
  //
  //cot_beam_pos->Init(RunNumber,cot_code,history,
  //		     b.position(0.).x(),b.position(0.).y(),0.,
  //		     b.slope().x(),b.slope().y(),
  //		     b.FitCov00 (),b.FitCov01 (),b.FitCov02 (),b.FitCov03 (),
  //		     b.FitCov11 (),b.FitCov12 (),b.FitCov13 (),b.FitCov22 (),
  //		     b.FitCov23 (),b.FitCov33 (),b.EmittXFit(),b.EmittYFit(),
  //		     b.BstarXFit(),b.BstarYFit(),b.ZzeroXFit(),b.ZzeroYFit(),
  //		     b.WidthX   (),b.WidthY   (),b.WidthXY());

  //---------------------------------------------------------------------------
  // Modern version with full time dependent beamlines
  //---------------------------------------------------------------------------
  // Get the full AC++ container
  BeamVector cotBeams = fCotBeam->getBeamlines();

  // Get Stntuple storage in the "database"
  TStnBeamPosBlock* cotBeamLines =
    (TStnBeamPosBlock*) dbm->GetTable("CotBeamPosBlock");
  if (! cotBeamLines)
    printf(" .. CRASH .. CotBeamPosBlock not found.\n");

  cotBeamLines->Clear();

  // Loop through and convert: AC++ -> Stntuple
  n = 0;
  for (BeamIter it = cotBeams.begin(); it != cotBeams.end(); it++) {
    Beamline     &b = *it;
    HepSymMatrix  c = b.cov3(0.);
    // Store this info into the stntuple structure
    TStnBeamPos* cotBeamLine = cotBeamLines->NewBeamPos();
    cotBeamLine->Init(RunNumber,cot_code,history,
		      b.position(0.).x(),b.position(0.).y(),0.,
		      b.slope().x(),b.slope().y(),
		      b.FitCov00 (),b.FitCov01 (),b.FitCov02 (),b.FitCov03 (),
		      b.FitCov11 (),b.FitCov12 (),b.FitCov13 (),b.FitCov22 (),
		      b.FitCov23 (),b.FitCov33 (),b.EmittXFit(),b.EmittYFit(),
		      b.BstarXFit(),b.BstarYFit(),b.ZzeroXFit(),b.ZzeroYFit(),
		      b.WidthX   (),b.WidthY   (),b.WidthXY());
  }

//-----------------------------------------------------------------------------
//  step 2: SVX beam position
//-----------------------------------------------------------------------------
  history = fSvxBeam->getRecord().Flag0() & 0xFFFF;

  //TStnBeamPos* svx_beam_pos = (TStnBeamPos*) dbm->GetTable("SvxBeamPos");
  //
  //b = fSvxBeam->getBeamline();
  //
  //svx_beam_pos->Init(RunNumber,cot_code,history,
  //		     b.position(0.).x(),b.position(0.).y(),0.,
  //		     b.slope().x(),b.slope().y(),
  //		     b.FitCov00 (),b.FitCov01 (),b.FitCov02 (),b.FitCov03 (),
  //		     b.FitCov11 (),b.FitCov12 (),b.FitCov13 (),b.FitCov22 (),
  //		     b.FitCov23 (),b.FitCov33 (),b.EmittXFit(),b.EmittYFit(),
  //		     b.BstarXFit(),b.BstarYFit(),b.ZzeroXFit(),b.ZzeroYFit(),
  //		     b.WidthX   (),b.WidthY   (),b.WidthXY());

  //---------------------------------------------------------------------------
  // Modern version with full time dependent beamlines
  //---------------------------------------------------------------------------
  // Get the full AC++ container
  BeamVector svxBeams = fSvxBeam->getBeamlines();

  // Get Stntuple storage in the "database"
  TStnBeamPosBlock* svxBeamLines =
    (TStnBeamPosBlock*) dbm->GetTable("SvxBeamPosBlock");
  if (! svxBeamLines)
    printf(" .. CRASH .. SvxBeamPosBlock not found.\n");

  svxBeamLines->Clear();

  // Loop through and convert: AC++ -> Stntuple
  n = 0;
  for (BeamIter it = svxBeams.begin(); it != svxBeams.end(); it++) {
    Beamline     &b = *it;
    HepSymMatrix  c = b.cov3(0.);
    // Store this info into the stntuple structure
    TStnBeamPos* svxBeamLine = svxBeamLines->NewBeamPos();
    svxBeamLine->Init(RunNumber,cot_code,history,
		      b.position(0.).x(),b.position(0.).y(),0.,
		      b.slope().x(),b.slope().y(),
		      b.FitCov00 (),b.FitCov01 (),b.FitCov02 (),b.FitCov03 (),
		      b.FitCov11 (),b.FitCov12 (),b.FitCov13 (),b.FitCov22 (),
		      b.FitCov23 (),b.FitCov33 (),b.EmittXFit(),b.EmittYFit(),
		      b.BstarXFit(),b.BstarYFit(),b.ZzeroXFit(),b.ZzeroYFit(),
		      b.WidthX   (),b.WidthY   (),b.WidthXY());
  }

  // create a temp entry for average beamline 
  // so that request for "SvxBeamPos" works
  dbm->MakeAvgBeamline();

  return 0;
}

//_____________________________________________________________________________
void StntupleBeamManager::Clear(const char* Opt) {
}

//_____________________________________________________________________________
void StntupleBeamManager::Print(const char* Opt) const {
  printf(" StntupleBeamManager::Print not implemented yet\n");
}