#include <fstream>
#include <iomanip>
#include <cstdlib>
#include <iostream>

#include <vector>
// --> Classes defining a row & managers of TIMESTAMP & the Key
#include "DBObjects/TimeStampDefs.hh"
// --> Classes defining a row & managers of CALIBRUNLISTS + the Key
#include "CalibDB/RunListKey.hh"
// The actual alignment table definition -- code generated from java
#include "AlignmentDB/SiAlignFrame.Defs.hh"
#include "AlignmentDB/SiAlignBarrel.Defs.hh"
#include "AlignmentDB/SiAlignLadder.Defs.hh"
#include "AlignmentDB/SiAlignWafer.Defs.hh"
#include "AlignmentDB/SiAlignWarp.Defs.hh"


#include "Alignment/AlHolderDB.hh"
#include "Alignment/AlDigiCode.hh"

//*********************************************************
int AlHolderDB::putDatabase(string dbid, int run, int version, string status)
{

   SiAlignFrameContainer contFrame;
   SiAlignFrame_mgr iomFrame(dbid,"SiAlignFrame");
   SiAlignBarrelContainer contBarrel;
   SiAlignBarrel_mgr iomBarrel(dbid,"SiAlignBarrel");
   SiAlignLadderContainer contLadder;
   SiAlignLadder_mgr iomLadder(dbid,"SiAlignLadder");
   SiAlignWaferContainer contWafer;
   SiAlignWafer_mgr iomWafer(dbid,"SiAlignWafer");
   SiAlignWarpContainer contWarp;
   SiAlignWarp_mgr iomWarp(dbid,"SiAlignWarp");


   if(iomFrame.isValid()==false) {
     std::cerr << " ERROR: SiAlignFrame_mgr initialisation failure " << std::endl;
     return -1;
   }
   if(iomBarrel.isValid()==false) {
     std::cerr << " ERROR: SiAlignBarrel_mgr initialisation failure " << std::endl;
     return -1;
   }
   if(iomLadder.isValid()==false) {
     std::cerr << " ERROR: SiAlignLadder_mgr initialisation failure " << std::endl;
     return -1;
   }
   if(iomWafer.isValid()==false) {
     std::cerr << " ERROR: SiAlignWafer_mgr initialisation failure " << std::endl;
     return -1;
   }
   if(iomWarp.isValid()==false) {
     std::cerr << " ERROR: SiAlignWafer_mgr initialisation failure " << std::endl;
     return -1;
   }

   // Create a CalibKey for run, version

   int v = version;
   if(version<0) { v = Version::generate; }
   RunListKey qk(run,v) ;
   qk.setDataStatus(status);

   // Fill the container directly with its attributes.

   contFrame.clear();
   contBarrel.clear();
   contLadder.clear();
   contWafer.clear();
   contWarp.clear();
   
   int ichan=0;
   int index;

   SiAlignFrame f(ichan, _spaceframe.tx,  _spaceframe.ty, _spaceframe.tz,
		   _spaceframe.ax,  _spaceframe.ay, _spaceframe.az);
   contFrame.push_back(f);

   AlDigiCode ad;

   ad.setResolution(AlDigiCode::BARREL);
   ad.setUsedDetectors(AlDigiCode::ALL);
   for (ad = 0; ad < ad.getNtotal(); ad++){
     ichan = ad.getCode();
     index = ad;
     SiAlignBarrel f(ichan, _barrel[index].tx,  _barrel[index].ty, 
		     _barrel[index].tz, _barrel[index].ax,  
		     _barrel[index].ay, _barrel[index].az);
     contBarrel.push_back(f);
   }

   ad.setResolution(AlDigiCode::LADDER);
   ad.setUsedDetectors(AlDigiCode::ALL);
   for (ad = 0; ad < ad.getNtotal(); ad++){
     ichan = ad.getCode();
     index = ad;
     SiAlignLadder f(ichan, _ladder[index].tx,  _ladder[index].ty, 
		     _ladder[index].tz, _ladder[index].ax,  
		     _ladder[index].ay, _ladder[index].az);
     contLadder.push_back(f);
   }

   ad.setResolution(AlDigiCode::WAFER);
   ad.setUsedDetectors(AlDigiCode::ALL);
   for (ad = 0; ad < ad.getNtotal(); ad++){
     ichan = ad.getCode();
     index = ad;
     SiAlignWafer f(ichan, _wafer[index].tr.tx,  _wafer[index].tr.ty, 
		     _wafer[index].tr.tz, _wafer[index].tr.ax,  
		     _wafer[index].tr.ay, _wafer[index].tr.az, 
		     _wafer[index].dr,
		     _wafer[index].sty, _wafer[index].stz, _wafer[index].sax );
     contWafer.push_back(f);
     SiAlignWarp g(ichan, _waferwarp[index].byy,  _waferwarp[index].byz, 
		     _waferwarp[index].bzz);
     contWarp.push_back(g);
   }


   if(iomFrame.put(qk,contFrame)!=Result::success) {
     std::cerr << " ERROR: Put failed for SiAlignFrame Run = " << run << std::endl;
     return -1;
   }
   if(iomBarrel.put(qk,contBarrel)!=Result::success) {
     std::cerr << " ERROR: Put failed for SiAlignBarrel Run = " << run << std::endl;
     return -1;
   }
   if(iomLadder.put(qk,contLadder)!=Result::success) {
     std::cerr << " ERROR: Put failed for SiAlignLadder Run = " << run << std::endl;
     return -1;
   }
   if(iomWafer.put(qk,contWafer)!=Result::success) {
     std::cerr << " ERROR: Put failed for SiAlignWafer Run = " << run << std::endl;
     return -1;
   }
   if(iomWarp.put(qk,contWarp)!=Result::success) {
     std::cerr << " ERROR: Put failed for SiAlignWarp Run = " << run << std::endl;
     return -1;
   }


   std::cout << " Filled SiAlignFrame, "<< contFrame.size()<< " Rows" << std::endl;
   std::cout << " Filled SiAlignBarrel, "<< contBarrel.size()<< " Rows" << std::endl;
   std::cout << " Filled SiAlignLadder, "<< contLadder.size()<< " Rows" << std::endl;
   std::cout << " Filled SiAlignWafer, "<< contWafer.size()<< " Rows" << std::endl;
   std::cout << " Filled SiAlignWarp, "<< contWarp.size()<< " Rows" << std::endl;

   return 0;

} // end putDatabase



//*********************************************************
int AlHolderDB::getDatabase(string dbid, int run, int version, string status)
{

   SiAlignFrameContainer_ptr frameCont;
   SiAlignFrame_mgr frameMgr(dbid,"SiAlignFrame");
   if(frameMgr.isValid()==false) {
     std::cerr << " ERROR: SiAlignFrame_mgr initialization failure " << std::endl;
     return -1;
   }

   SiAlignBarrelContainer_ptr barrelCont;
   SiAlignBarrel_mgr barrelMgr(dbid,"SiAlignBarrel");
   if(barrelMgr.isValid()==false) {
     std::cerr << " ERROR: SiAlignBarrel_mgr initialization failure " << std::endl;
     return -1;
   }

   SiAlignLadderContainer_ptr ladderCont;
   SiAlignLadder_mgr ladderMgr(dbid,"SiAlignLadder");
   if(ladderMgr.isValid()==false) {
     std::cerr << " ERROR: SiAlignLadder_mgr initialization failure " << std::endl;
     return -1;
   }

   SiAlignWaferContainer_ptr waferCont;
   SiAlignWafer_mgr waferMgr(dbid,"SiAlignWafer");
   if(waferMgr.isValid()==false) {
     std::cerr << " ERROR: SiAlignWafer_mgr initialization failure " << std::endl;
     return -1;
   }

   SiAlignWarpContainer_ptr warpCont;
   SiAlignWarp_mgr warpMgr(dbid,"SiAlignWarp");
   if(warpMgr.isValid()==false) {
     std::cerr << " ERROR: SiAlignWarp_mgr initialization failure " << std::endl;
     return -1;
   }

   int v = version;
   if(version<=0) v=Version::latest;
   RunListKey qk(run,v);
   qk.setDataStatus(status);


  //read back from DB with this key.

  if(frameMgr.get(qk, frameCont)!=Result::success) {
    std::cerr << "ERROR: Failed to retrieve SiAlignFrame calibration" << std::endl;
    return -1;
  }
  if(barrelMgr.get(qk, barrelCont)!=Result::success) {
    std::cerr << "ERROR: Failed to retrieve SiAlignBarrel calibration" << std::endl;
    return -1;
  }
  if(ladderMgr.get(qk, ladderCont)!=Result::success) {
    std::cerr << "ERROR: Failed to retrieve SiAlignLadder calibration" << std::endl;
    return -1;
  }
  if(waferMgr.get(qk, waferCont)!=Result::success) {
    std::cerr << "ERROR: Failed to retrieve SiAlignWafer calibration" << std::endl;
    return -1;
  }
  if(warpMgr.get(qk, warpCont)!=Result::success) {
    std::cerr << "ERROR: Failed to retrieve SiAlignWarp calibration" << std::endl;
    return -1;
  }

  AlDigiCode al;

  RunListKey k;
  k = frameCont->key();
  std::cout << "SiAlignFrame Contents : # Rows = " << frameCont->size() 
       << "  CID = " << k.id_ << std::endl;
  std::cout << frameCont->size() << " " 
       << k.run() << " " 
       << k.version() << " " 
       << k.dataStatus() << std::endl; 

  SiAlignFrameContainer::iterator fi;
  for(fi=frameCont->begin();fi!=frameCont->end();++fi) {
    SiAlignFrame& table =  *fi;
    int channel = table.ChannelID();
    _spaceframe.tx = table.Tx();
    _spaceframe.ty = table.Ty();
    _spaceframe.tz = table.Tz();
    _spaceframe.ax = table.alpha_x();
    _spaceframe.ay = table.alpha_y();
    _spaceframe.az = table.alpha_z();
  }


  al.setResolution(AlDigiCode::BARREL);
  al.setUsedDetectors(AlDigiCode::ALL);

  k = barrelCont->key();
  std::cout << "SiAlignBarrel Contents : # Rows = " << barrelCont->size() 
       << "  CID = " << k.id_ << std::endl;
  SiAlignBarrelContainer::iterator bi;
  for(bi=barrelCont->begin();bi!=barrelCont->end();++bi) {
    SiAlignBarrel& table =  *bi;
    int channel = table.ChannelID();
    al.setCode(channel);
    _barrel[al].tx = table.Tx();
    _barrel[al].ty = table.Ty();
    _barrel[al].tz = table.Tz();
    _barrel[al].ax = table.alpha_x();
    _barrel[al].ay = table.alpha_y();
    _barrel[al].az = table.alpha_z();
  }


  al.setResolution(AlDigiCode::LADDER);
  al.setUsedDetectors(AlDigiCode::ALL);

  k = ladderCont->key();
  std::cout << "SiAlignLadder Contents : # Rows = " << ladderCont->size() 
       << "  CID = " << k.id_ << std::endl;
  SiAlignLadderContainer::iterator li;
  for(li=ladderCont->begin();li!=ladderCont->end();++li) {
    SiAlignLadder& table =  *li;
    int channel = table.ChannelID();
    al.setCode(channel);
    _ladder[al].tx = table.Tx();
    _ladder[al].ty = table.Ty();
    _ladder[al].tz = table.Tz();
    _ladder[al].ax = table.alpha_x();
    _ladder[al].ay = table.alpha_y();
    _ladder[al].az = table.alpha_z();
  }

  al.setResolution(AlDigiCode::WAFER);
  al.setUsedDetectors(AlDigiCode::ALL);

  k = waferCont->key();
  std::cout << "SiAlignWafer Contents : # Rows = " << waferCont->size() 
       << "  CID = " << k.id_ << std::endl;
  SiAlignWaferContainer::iterator wi;
  for(wi=waferCont->begin();wi!=waferCont->end();++wi) {
    SiAlignWafer& table =  *wi;
    int channel = table.ChannelID();
    al.setCode(channel);
    _wafer[al].tr.tx = table.Tx();
    _wafer[al].tr.ty = table.Ty();
    _wafer[al].tr.tz = table.Tz();
    _wafer[al].tr.ax = table.alpha_x();
    _wafer[al].tr.ay = table.alpha_y();
    _wafer[al].tr.az = table.alpha_z();
    _wafer[al].dr = table.dr();
    _wafer[al].sty= table.STy();
    _wafer[al].stz= table.STz();
    _wafer[al].sax= table.Salpha_x();
  }

  al.setResolution(AlDigiCode::WAFER);
  al.setUsedDetectors(AlDigiCode::ALL);

  k = warpCont->key();
  std::cout << "SiAlignWarp Contents : # Rows = " << warpCont->size() 
       << "  CID = " << k.id_ << std::endl;
  SiAlignWarpContainer::iterator ai;
  for(ai=warpCont->begin();ai!=warpCont->end();++ai) {
    SiAlignWarp& table =  *ai;
    int channel = table.ChannelID();
    al.setCode(channel);
    _waferwarp[al].byy = table.beta_yy();
    _waferwarp[al].byz = table.beta_yz();
    _waferwarp[al].bzz = table.beta_zz();
  }

  return 1;
}