//_HADES_CLASS_DESCRIPTION
//////////////////////////////////////////////////////////////////////////////
// HiTofParOra2Io
//
// Interface class to database Oracle for input/output of parameters needed
// by theiTOF for runs since 2022
// (uses the Oracle C/C++ precompiler)
// first sketch: JAM <j.adamczewski@gsi.de>, 02-june-2022
//
//////////////////////////////////////////////////////////////////////////////

using namespace std;
#include "hitofparora2io.h"
#include "hparora2set.h"
#include "hitoftrb3lookup.h"
#include "hitofcalpar.h"
#include "hitofgeompar.h"
#include "hgeomcompositevolume.h"
#include "hora2geomdetversion.h"
#include "hora2geomobj.h"

//#include "fwdetdef.h"
// JAM2022 - here we have const int instead defines. does this work for precompiler arrays?
// better redefine it here:
#define ITOF_MAX_MODULES   6
#define ITOF_MAX_LAYERS    3
#define ITOF_MAX_SLOTS     16

#define ITOF_MAX_GLOBALCELLS \
	ITOF_MAX_MODULES * ITOF_MAX_LAYERS * ITOF_MAX_SLOTS 
// = 7168

#define ITOF_MAX_MODULE_SLOTS ITOF_MAX_LAYERS*ITOF_MAX_SLOTS

#define ITOF_MAX_GLOBAL_LAYERS ITOF_MAX_MODULES * ITOF_MAX_LAYERS
#define ITOF_MAX_LAYER_CELLS ITOF_MAX_SLOTS

#include "TClass.h"
#include "TList.h"
#include <iostream>
#include <iomanip>
#include <unistd.h>

#define SQLCA_STORAGE_CLASS extern
#define ORACA_STORAGE_CLASS extern

// Oracle communication area
#include <oraca.h>
// SQL Communications Area
#include <sqlca.h>

ClassImp(HiTofParOra2Io)



HiTofParOra2Io::HiTofParOra2Io(HOra2Conn* pC) : HDetParOra2Io(pC) {
  // constructor
  // sets the name of the I/O class "HiTofParIo"
  // gets the pointer to the connection class
  fName="HiTofParIo";
  initModules=new TArrayI(ITOF_MAX_GLOBAL_LAYERS);
  geomVers=0;
  sensVolume=0;
}

HiTofParOra2Io::~HiTofParOra2Io(void) {
  // destructor
  if (initModules) delete initModules;
  if (geomVers) delete geomVers;
  if (sensVolume) delete sensVolume;
}

Bool_t HiTofParOra2Io::init(HParSet* pPar,Int_t* set) {
  // calls special read-function for each parameter container
  if (getRunStart(pPar)<0) {
    pPar->setInputVersion(-1,inputNumber);
    return kFALSE;
  }
  const Text_t* name=pPar->IsA()->GetName();
  printf(" HiTofParOra2Io::init for %s", name);
  if (strcmp(name,"HiTofTrb3Lookup")==0) return read(((HiTofTrb3Lookup*)pPar));
  if (strcmp(name,"HiTofCalPar")==0) return read(((HiTofCalPar*)pPar));
  if (strcmp(name,"HiTofGeomPar")==0)    return read(((HiTofGeomPar*)pPar),set);
  cout<<"No read-interface to Oracle for parameter container "
      <<pPar->GetName()<<endl;
  return kFALSE;
}

Int_t HiTofParOra2Io::write(HParSet* pPar) {
  // calls the appropriate write function for the container
  cout <<"HiTofParOra2Io::write... " << endl;
  if (getRunStart(pPar)<=0) return -1;
  const Text_t* name=pPar->IsA()->GetName();
  cout <<"HiTofParOra2Io::write("<<name<<")"<< endl;
  if (strcmp(name,"HiTofTrb3Lookup")==0) return writePar((HiTofTrb3Lookup*)pPar);
  if (strcmp(name,"HiTofCalPar")==0) return writePar((HiTofCalPar*)pPar);
  if (strcmp(name,"HiTofGeomPar")==0)    return writeAlignment((HiTofGeomPar*)pPar);
  cout<<"No write-interface to Oracle for parameter container "
      <<pPar->GetName()<<endl;
  return 0;
}

Bool_t HiTofParOra2Io::getVersion(HParSet* pPar,Int_t& version) {
  // checks, if the parameter container needs to be reinitialized
  // reads the newest version valid for the current event file
  // returns kTRUE, if new parameters must be read
  // returns kFALSE, if no reinitialization needed or not valid version found
  HParOra2Set* oraSet=getOraSet(pPar);
  if (oraSet->contextId==-1 || runStart==-1) {
    pPar->setInputVersion(-1,inputNumber);
    version=-1;
    return kFALSE;
  }
  Int_t contVers=pPar->getInputVersion(inputNumber);
  if (contVers!=-1 && runStart>=oraSet->versDate[0] && runStart<=oraSet->versDate[1]) {
    version=contVers;
    return kFALSE;
  }
  const Char_t* containerClass=pPar->IsA()->GetName();
  oraSet->clearVersDate();
  EXEC SQL BEGIN DECLARE SECTION;
    int context;
    int vers;
    double since;
    double until;
  EXEC SQL END DECLARE SECTION;
  context=oraSet->contextId;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("getVersion(HParSet*,Int_t&)");
  EXEC SQL WHENEVER NOT FOUND GOTO notfound;
  if (strcmp(containerClass,"HiTofTrb3Lookup")==0) {
    EXEC SQL SELECT version,
                    hanadate.date_to_number(valid_since),
                    hanadate.date_to_number(valid_until)
             INTO :vers, :since, :until
               FROM tof_ana2.itof_trb3lookup_vers_at_date
             WHERE context_id = :context;
  }
  else if (strcmp(containerClass,"HiTofCalPar")==0) {
    EXEC SQL SELECT version,
                    hanadate.date_to_number(valid_since),
                    hanadate.date_to_number(valid_until)
            INTO :vers, :since, :until
            FROM tof_ana2.itof_calpar_vers_at_date
            WHERE context_id = :context;
  }
  else {}


  version=vers;
  cout <<"HiTofParOra2Io got version"<<version<< endl;
  oraSet->versDate[0]=since;
  oraSet->versDate[1]=until;
  return kTRUE;
notfound:
  pPar->setInputVersion(-1,inputNumber);
  version=-1;
  cout <<"HiTofParOra2IO invalid  version"<< endl;
  return kFALSE;
};



Bool_t HiTofParOra2Io::read(HiTofTrb3Lookup* pPar) {
  // reads the lookup table for the Trb3 unpacker and fill the container FwdetStrawTrb3Lookup
  Int_t oraVersion=-1;
  Bool_t rc=getVersion(pPar,oraVersion);
  if (oraVersion<0) return kFALSE;
  if (oraVersion>=0&&rc==kFALSE) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int vers;
    struct {
      int  address[ITOF_MAX_GLOBALCELLS];
      int  channel[ITOF_MAX_GLOBALCELLS];
      int  module[ITOF_MAX_GLOBALCELLS];
      int  layer [ITOF_MAX_GLOBALCELLS];
      int  slot[ITOF_MAX_GLOBALCELLS];
    } lookup;
  EXEC SQL END DECLARE SECTION;
  vers=oraVersion;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HiTofTrb3Lookup*)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT trbnet_address, channel,
                  module, layer, slot
           INTO :lookup
           FROM tof_ana2.itof_trb3lookup_data_view
           WHERE vers_id = :vers;
  Int_t nData=sqlca.sqlerrd[2];
  // TODO
  for (Int_t i=0;i<nData;i++) {
    pPar->fill(lookup.address[i],lookup.channel[i],
               lookup.module[i]-1, 0, lookup.layer[i]-1, lookup.slot[i]-1); // "module" is sector, "mod" is always 0 JAM22
  }
  rc=kTRUE;
  if (nData>0) {
    setChanged(pPar,oraVersion);
    cout<<pPar->GetName()<<" initialized from Oracle"<<endl;
  } else {
    pPar->setInputVersion(-1,inputNumber);
    rc=kFALSE;
  }
  return rc;
}

// JAM22 --------------------------------------------------------
Bool_t HiTofParOra2Io::read(HiTofCalPar* pPar) {
  // reads the lookup table for the Trb3 unpacker and fill the containeriTofTrb3Lookup
  Int_t oraVersion=-1;
  Bool_t rc=getVersion(pPar,oraVersion);
  if (oraVersion<0) return kFALSE;
  if (oraVersion>=0&&rc==kFALSE) return kTRUE;
  pPar->clear();
  EXEC SQL BEGIN DECLARE SECTION;
    int vers;
    int globalstrip;
    struct {
      int module[ITOF_MAX_GLOBALCELLS];
      int layer[ITOF_MAX_GLOBALCELLS];
      int slot[ITOF_MAX_GLOBALCELLS];      
      float offset [ITOF_MAX_GLOBALCELLS]; 
      float slope[ITOF_MAX_GLOBALCELLS]; 
      float adc_par_0[ITOF_MAX_GLOBALCELLS]; 
      float adc_par_1[ITOF_MAX_GLOBALCELLS]; 
      float adc_par_2[ITOF_MAX_GLOBALCELLS]; 
      float twc_par_0[ITOF_MAX_GLOBALCELLS]; 
      float twc_par_1[ITOF_MAX_GLOBALCELLS]; 
      float twc_par_2[ITOF_MAX_GLOBALCELLS];        
    } cal;
    struct {
      short module[ITOF_MAX_GLOBALCELLS];
      short layer[ITOF_MAX_GLOBALCELLS];
      short slot[ITOF_MAX_GLOBALCELLS];      
      short offset [ITOF_MAX_GLOBALCELLS]; 
      short slope[ITOF_MAX_GLOBALCELLS]; 
      short adc_par_0[ITOF_MAX_GLOBALCELLS]; 
      short adc_par_1[ITOF_MAX_GLOBALCELLS]; 
      short adc_par_2[ITOF_MAX_GLOBALCELLS]; 
      short twc_par_0[ITOF_MAX_GLOBALCELLS]; 
      short twc_par_1[ITOF_MAX_GLOBALCELLS]; 
      short twc_par_2[ITOF_MAX_GLOBALCELLS];
    } cal_Ind;
    
     EXEC SQL END DECLARE SECTION;
  vers=oraVersion;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("read(HiTofCalPar*,Int_t*)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT  sector, layer_id, slot_number,
	  cal_offset, slope, adc_par_0, adc_par_1, adc_par_2, twc_par_0, twc_par_1, twc_par_2 
           INTO :cal INDICATOR :cal_Ind
           FROM tof_ana2.itof_calpar_data_view
           WHERE vers_id = :vers;
  Int_t nData=sqlca.sqlerrd[2];
  Int_t sec=-1, mod=0, paddle=-1, sl=-1;
  for(Int_t i=0;i<nData;i++) {
    
    sec=cal.module[i]-1;
    mod=0;
    paddle=cal.layer[i]-1;
    sl=cal.slot[i]-1;
// JAM disable check for completeness for the moment...    
//     pos=sec* ITOF_MAX_LAYERS + paddle
//     
//     if (set[pos]) 
    {
      HiTofCalParCell& cell=(*pPar)[sec][mod][paddle];
      cell.setOffset(sl, cal.offset[i]);
      cell.setSlope(sl, cal.slope[i]);
      cell.setAdcPar0(sl, cal.adc_par_0[i]);
      cell.setAdcPar1(sl, cal.adc_par_1[i]);
      cell.setAdcPar2(sl, cal.adc_par_2[i]);
      cell.setTwcPar0(sl, cal.twc_par_0[i]);
      cell.setTwcPar1(sl, cal.twc_par_1[i]);
      cell.setTwcPar2(sl, cal.twc_par_2[i]);
      //initModules->AddAt(1,pos);
    }
  }     
  Bool_t allFound=kTRUE;
  
//   if (nData>0) {
//     for(Int_t i=0;i<FRPC_MAX_SECTORS * FRPC_MAX_STRIPS;i++) {
//       if (set[i]==1 && initModules->At(i)==0) allFound=kFALSE;
//     }
//   } else allFound=kFALSE;
//   
  if (allFound) {
    setChanged(pPar,oraVersion);
    printInfo(pPar->GetName());
  } else {
    pPar->setInputVersion(-1,inputNumber);
  }
  return allFound;
    

    

}





/////////////////////////// GEOMETRY follows ///////////////////////////////////


/// following is taken from TOF:

Bool_t HiTofParOra2Io::read(HiTofGeomPar* pPar, Int_t* set) {
  // reads the geometry of the TOF and fills the TofGeomPar container
  Bool_t allFound=kTRUE;
  Int_t detId=-1;
  if (!geomVers) {
      TString detName="TOF";  // geometry is part of TOF!
       detId=getDetectorId(detName.Data());
       geomVers=new HOra2GeomDetVersion(detName.Data(),detId); 
      
      
    //detId=getDetectorId(pPar->getDetectorName());
    //geomVers=new HOra2GeomDetVersion(pPar->getDetectorName(),detId);
  } else {
    detId=geomVers->getDetectorId();
  }
  printf("************* HiTofParOra2Io::read(HiTofGeomPar* : got detector id %d from name %s, geom version=%d \n",detId, pPar->getDetectorName(),geomVers->getGeomVersion());
  if (detId<=0) {
    allFound=kFALSE;
    delete geomVers;
    geomVers=0;
  }
  if (detId>0&&pPar->isFirstInitialization()) {
    if (!readModGeomNames(pPar,set) || !readCompGeomNames(pPar,set)) {
      allFound=kFALSE;
      pPar->clear();
    } else addGeomOraSet(pPar);
  }  
  printf("************* HiTofParOra2Io::read(HiTofGeomPar* s: allFound before readDetectorGeometry: %d\n",allFound);
  if (allFound) allFound=readDetectorGeometry(pPar,set,geomVers);
  printf("************* HiTofParOra2Io::read(HiTofGeomPar* s: allFound after readDetectorGeometry: %d\n",allFound);
  return allFound;    
}

Bool_t HiTofParOra2Io::readModGeomNames(HiTofGeomPar* pPar,Int_t* set) {
  // reads the tof_pos_id of all modules
  EXEC SQL BEGIN DECLARE SECTION;
    struct {
      int module[ITOF_MAX_MODULES];
      varchar oname[ITOF_MAX_MODULES][9];
    } mods;
    struct {
      short mod_Ind[ITOF_MAX_MODULES];
      short oname_Ind[ITOF_MAX_MODULES];
    } mods_Ind;
  EXEC SQL END DECLARE SECTION;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("readModGeomNames()");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  EXEC SQL SELECT module_id, geom_obj_name
    INTO :mods INDICATOR :mods_Ind
    FROM tof_ana2.itof_detector_setup_at_date;
  Int_t pos, mod; 
  Char_t ref[10];
  initModules->Reset();
  
  printf("************* HiTofParOra2Io::readModGeomNames: found nCells=%d\n",sqlca.sqlerrd[2]);
  for(Int_t i=0;i<sqlca.sqlerrd[2];i++) {
    mod=mods.module[i]-1;
    HModGeomPar* pMod=pPar->getModule(mod);
    //pos=sec*TOF_TOTSECMODS + mod;
    pos=mod;
    if (pMod && set[pos]) {
      if (mods_Ind.oname_Ind[i]!=-1) {
        mods.oname[i].arr[mods.oname[i].len]='\0';
        printf(" ** module %d has oname:%s \t",pos, mods.oname[i].arr);
        pMod->SetName((Char_t*)(mods.oname[i].arr));
        initModules->AddAt(pos+1,pos);
        strcpy(ref,(Char_t*)(mods.oname[i].arr));
        ref[3]='1'; // reference module in sector 1 ???? JAM24 from tofino way
                    //rather use different reference modules for each sector, since the component names also contain module/sector number!
        ref[4]='\0'; // JAM24- for printf
        printf("\t refmodame:%s\n",ref);
        pMod->setRefName(ref);
        Int_t mr=pPar->getModNumInMod(ref);
        //Int_t mr=pPar->getSecNum(ref);
        HGeomCompositeVolume* refMod=pPar->getRefVolume(mr);
        if (refMod==0) {
          refMod=new HGeomCompositeVolume(pPar->getNumComponents());
          refMod->SetName(ref);
          pPar->addRefVolume(refMod,mr);
          printf("added reference volume, modnum:%d numcomponents:%d\n",mr,pPar->getNumComponents());
        }
        pMod->setVolume(refMod);
      }
    }
  }
  Bool_t allFound=kTRUE;
  for(Int_t i=0;i<ITOF_MAX_MODULES;i++) {
     
    if (set[i]>0 && initModules->At(i)==0) allFound=kFALSE;
    printf(" ** ALLFOUND check: module %d, set[%d]=%d allfound=%d\n",i, i, set[i], allFound);
    
  }
  return allFound;
}



//      TODO below change to ITOF_MAX_MODULE_SLOTS

Bool_t HiTofParOra2Io::readCompGeomNames(HiTofGeomPar* pPar,Int_t* set) {
  // reads the names of all pads in the geometry tables
  EXEC SQL BEGIN DECLARE SECTION;
    struct {
      int module[ITOF_MAX_GLOBALCELLS]; 
      int layer [ITOF_MAX_GLOBALCELLS];
      varchar oname[ITOF_MAX_GLOBALCELLS][9];
    } pads;
    struct {
      short mod_Ind[ITOF_MAX_GLOBALCELLS];
      short layer_Ind[ITOF_MAX_GLOBALCELLS];
      short oname_Ind[ITOF_MAX_GLOBALCELLS];
    } pads_Ind;
  EXEC SQL END DECLARE SECTION;
  EXEC SQL WHENEVER SQLERROR DO showSqlError("readCompGeomNames(...)");
  EXEC SQL WHENEVER NOT FOUND CONTINUE;
  //EXEC SQL SELECT DISTINCT c.module_id, c.layer_id, c.geom_obj_name
  //FROM   tof_ana2.itof_detector_cell c
  EXEC SQL SELECT distinct c.module_id, c.layer_id, c.geom_obj_name    
  INTO :pads INDICATOR :pads_Ind  
  //FROM tof_ana2.itof_detector_setup_at_date s,  
  FROM   tof_ana2.itof_detector_cell c
//    WHERE s.module_id=c.module_id;   
    WHERE c.module_id=1;         // reference module in sector 1, like in tofino JAM24
  Int_t pos, sec, lay;
  Int_t nCells=sqlca.sqlerrd[2];
  printf("************* HiTofParOra2Io::readCompGeomNames: found nCells=%d\n",nCells);
  for(Int_t k=0;k<nCells;k++) {      
    sec=pads.module[k]-1;
    lay=pads.layer[k]-1;
    printf("************* sector:%d layer:%d ",sec,lay);
    HModGeomPar* pMod=pPar->getModule(sec);    
    if (pMod && set[sec]) {
      HGeomCompositeVolume* pRefMod=pMod->getRefVolume();  
      if (pads_Ind.oname_Ind[k]!=-1) {
        pads.oname[k].arr[pads.oname[k].len]='\0';
        printf("\t oname:%s\n",pads.oname[k].arr);
        printf("*** set name to component %d of refvolume %s\n", pads.layer[k]-1, pRefMod->GetName());
        HGeomVolume* volu=pRefMod->getComponent((pads.layer[k]-1));
        volu->SetName((Char_t*)(pads.oname[k].arr));
      }
    }
  }
  
  
  return (nCells>0) ? kTRUE : kFALSE;
  
 
}



// pendant from mdc looks like this:

//Bool_t HMdcParOra2Io::readLayerGeomNames(HMdcGeomPar* pPar,Int_t* set) {
//  // reads the names of all layers in the geometry tables
//  EXEC SQL BEGIN DECLARE SECTION;
//    struct {
//      int     pla[MDC_MAXLAYS];
//      int     lay[MDC_MAXLAYS];
//      varchar oname[MDC_MAXLAYS][9];
//    } layers;
//    struct {
//      short pla_Ind[MDC_MAXLAYS];
//      short lay_Ind[MDC_MAXLAYS];
//      short oname_Ind[MDC_MAXLAYS];
//    } layers_Ind;
//  EXEC SQL END DECLARE SECTION;
//  EXEC SQL WHENEVER SQLERROR DO showSqlError("readLayerGeomNames(...)");
//  EXEC SQL WHENEVER NOT FOUND CONTINUE;
//  EXEC SQL SELECT plane, layer_nr, geom_obj_name
//           INTO :layers INDICATOR :layers_Ind
//           FROM mdc_ana2.mdc_layer;
//  Int_t numLayers=sqlca.sqlerrd[2];
//  if (numLayers<MDC_MAXLAYS) return kFALSE;
//  for(Int_t i=0;i<numLayers;i++) {
//    if (layers_Ind.oname_Ind[i]!=-1) {
//      layers.oname[i].arr[layers.oname[i].len]='\0';
//      for(Int_t s=0;s<6;s++) {
//        HModGeomPar* pMod=pPar->getModule(s,layers.pla[i]-1);
//        if (pMod) {
//          HGeomVolume* volu=pMod->getRefVolume()->getComponent((layers.lay[i]-1));
//          volu->SetName((Char_t*)(layers.oname[i].arr)); 
//          break;
//        }
//      }
//    }
//  }
//  return kTRUE;    
//}
//
//


//////////////// TOFINO example from hydra1


//Bool_t HTofinoParOraIo::read(HTofinoGeomPar* pPar, Int_t* set) {
//  // reads the geometry of the MDC and fills the MdcGeomPar container
//  Bool_t allFound=kTRUE;
//  Int_t detId=-1;
//  if (!geomVers) {
//    TString detName="TOF";  // geometry is part of TOF!
//    detId=getDetectorId(detName.Data());
//    geomVers=new HGeomOraDetVersion(detName.Data(),detId);
//  } else {
//    detId=geomVers->getDetectorId();
//  }
//  if (detId<=0) {
//    allFound=kFALSE;
//    delete geomVers;
//    geomVers=0;
//  }
//  if (detId>0&&pPar->isFirstInitialization()) {
//    if (!readModGeomNames(pPar,set) || !readCompGeomNames(pPar,set)) {
//      allFound=kFALSE;
//      pPar->clear();
//    } else addGeomOraSet(pPar);
//  }  
//  if (allFound) allFound=readDetectorGeometry(pPar,set,geomVers);
//  return allFound;    
//}
//
//
//Bool_t HTofinoParOraIo::readModGeomNames(HTofinoGeomPar* pPar,Int_t* set) {
//  // reads the tofino_pos_id of all modules
//  EXEC SQL BEGIN DECLARE SECTION;
//    struct {
//      int id[TOFINO_MAXMODS];
//      varchar oname[TOFINO_MAXMODS][9];
//    } mods;
//    struct {
//      short id_Ind[TOFINO_MAXMODS];
//      short oname_Ind[TOFINO_MAXMODS];
//    } mods_Ind;
//  EXEC SQL END DECLARE SECTION;
//  EXEC SQL WHENEVER SQLERROR DO showSqlError("readModGeomNames()");
//  EXEC SQL WHENEVER NOT FOUND CONTINUE;
//  EXEC SQL SELECT module, geom_obj
//           INTO :mods INDICATOR :mods_Ind
//           FROM tofino_ana.det_setup_at_run_hist;
//  Char_t ref[10];
//  initModules->Reset();
//  for(Int_t i=0;i<sqlca.sqlerrd[2];i++) {
//    Int_t s=mods.id[i]-1;
//    HModGeomPar* pMod=pPar->getModule(s,0);
//    if (pMod && set[s]) {
//      if (mods_Ind.oname_Ind[i]!=-1) {
//        mods.oname[i].arr[mods.oname[i].len]='\0';
//        pMod->SetName((Char_t*)(mods.oname[i].arr));
//        initModules->AddAt(s+1,s);
//        strcpy(ref,(Char_t*)(mods.oname[i].arr));
//        ref[3]='1'; // reference module in sector 1
//                    // not yet introduced in database
//        pMod->setRefName(ref);
//        Int_t mr=pPar->getModNumInMod(ref);
//        HGeomCompositeVolume* refMod=pPar->getRefVolume(mr);
//        if (refMod==0) {
//          refMod=new HGeomCompositeVolume(pPar->getNumComponents());
//          refMod->SetName(ref);
//          pPar->addRefVolume(refMod,mr);
//        }
//        pMod->setVolume(refMod);
//      }
//    }
//  }
//  Bool_t allFound=kTRUE;
//  for(Int_t i=0;i<TOFINO_MAXMODS;i++) {
//    if (set[i]>0 && initModules->At(i)==0) allFound=kFALSE;
//  }
//  return allFound;
//}
//
//
//Bool_t HTofinoParOraIo::readCompGeomNames(HTofinoGeomPar* pPar,Int_t* set) {
//  // reads the names of all paddles in the geometry tables
//  EXEC SQL BEGIN DECLARE SECTION;
//    struct {
//      int cell[TOFINO_MAXCELL];
//      varchar oname[TOFINO_MAXCELL][9];
//    } comps;
//    struct {
//      short cell_Ind[TOFINO_MAXCELL];
//      short oname_Ind[TOFINO_MAXCELL];
//    } comps_Ind;
//  EXEC SQL END DECLARE SECTION;
//  EXEC SQL WHENEVER SQLERROR DO showSqlError("readCompGeomNames(...)");
//  EXEC SQL WHENEVER NOT FOUND CONTINUE;
//  EXEC SQL SELECT paddle_nr, geom_obj_name
//           INTO :comps INDICATOR :comps_Ind
//           FROM tofino_ana.paddle
//           WHERE det_module_id=1;         // reference module in sector 1
//  HModGeomPar* pMod=0;
//  for(Int_t s=0;s<TOFINO_MAXMODS;s++) {
//    pMod=pPar->getModule(s,0);
//    if (pMod) break;
//  }
//  if (pMod) {
//    HGeomCompositeVolume* pRefMod=pMod->getRefVolume();
//    for(Int_t k=0;k<sqlca.sqlerrd[2];k++) {
//      if (comps_Ind.oname_Ind[k]!=-1) {
//        comps.oname[k].arr[comps.oname[k].len]='\0';
//        HGeomVolume* volu=pRefMod->getComponent((comps.cell[k]-1));
//        volu->SetName((Char_t*)(comps.oname[k].arr));
//      }
//    }
//  }
//  if (sqlca.sqlerrd[2]>0) return kTRUE;
//  else return kFALSE;
//}
//
//
//
//////////////////////////////////////////////////////////////77


Int_t HiTofParOra2Io::createVers(HParSet* pPar) {
  // creates a new version for parameters
  // returns the new version
  cout<<"---------------  "<<pPar->GetName()<<"   ---------------\n";
  if (strlen(pPar->getAuthor())==0) {
    Error("createVers(HParSet*)",
          "author of parameters not defined");
    return -1;
  }
  if (strlen(pPar->getDescription())==0) {
    Error("createVers(HParSet*)",
          "descriction of parameters not defined");
    return -1;
  }
  const Char_t* contName=pPar->IsA()->GetName();
  EXEC SQL BEGIN DECLARE SECTION;
    int   vers=-1;
    int   context;
    int   run;
    char* creator;
    char* descript;
  EXEC SQL END DECLARE SECTION;
  context = getContextId(contName,pPar->getParamContext());
  if (context==-1) return -1;
  run=getActRunId();
  creator=(Char_t*)pPar->getAuthor();
  descript=(Char_t*)pPar->getDescription();
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  if (strcmp(contName,"HiTofTrb3Lookup")==0) {
    EXEC SQL EXECUTE
      BEGIN
        SELECT tof_ana2.itof_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO tof_ana2.itof_trb3lookup_vers
                   (vers_id, orig_context_id, run_id, author, description)
            VALUES (:vers, :context, :run, :creator, :descript);
      END;
    END-EXEC;
  }
  else if (strcmp(contName,"HiTofCalPar")==0) {
    EXEC SQL EXECUTE
      BEGIN
        SELECT tof_ana2.itof_par_query.next_version INTO :vers FROM DUAL;
        INSERT INTO tof_ana2.itof_calpar_vers
                   (vers_id, orig_context_id, run_id, author, description)
            VALUES (:vers, :context, :run, :creator, :descript);
      END;
    END-EXEC;
  }
  
  
  
  else { }
  cout<<"Oracle version for "<<pPar->GetName()<<" created:  "<<vers<<endl;
  return vers;
not_found:
  showSqlError("createVers(HParSet*)");
  return vers;
}


// TODO
Int_t HiTofParOra2Io::writePar(HiTofTrb3Lookup* pPar) {
  // creates a new version and writes the lookup table to Oracle
  cout <<"writePar(HiTofTrb3Lookup* "<< endl;
  Int_t version=createVers(pPar);
  if (version==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
    int   rows_to_insert;
    int   vers[ITOF_MAX_GLOBALCELLS];
    int   address[ITOF_MAX_GLOBALCELLS];
    int   channel[ITOF_MAX_GLOBALCELLS];
    int   sector[ITOF_MAX_GLOBALCELLS];
    int   layer [ITOF_MAX_GLOBALCELLS];
    int   slot[ITOF_MAX_GLOBALCELLS];
  EXEC SQL END DECLARE SECTION;
  Int_t nChan=0;
  Int_t arrayOffset=pPar->getArrayOffset();


  for(Int_t t=0;t<pPar->getSize();t++) {
	  HiTofTrb3LookupTdc* tdc=(*pPar)[t];
    if (tdc) {
      nChan=0;
      for(Int_t c=0;c<tdc->getSize();c++) {
    	  HiTofTrb3LookupChan& rChan=(*tdc)[c];
        if (rChan.getSector()!=-1 && rChan.getModule()!=-1 && rChan.getCell()!=-1  && rChan.getSlot()!=-1) {
          vers[nChan]=version;
          address[nChan]=arrayOffset+t;
          channel[nChan]=c;
          sector[nChan]=rChan.getSector() +1;
          layer[nChan]=rChan.getCell() +1;
          slot[nChan]=rChan.getSlot() +1;
          nChan++;
        }
      }

      rows_to_insert=nChan;

      EXEC SQL WHENEVER SQLERROR GOTO errorfound;
      EXEC SQL WHENEVER NOT FOUND GOTO errorfound;
      EXEC SQL FOR :rows_to_insert
      INSERT INTO tof_ana2.itof_trb3lookup_data
                  (vers_id, trbnet_address, channel_id, cell_id)
             VALUES (:vers,
            	     :address,
            	     :channel,
            	     tof_ana2.itof_par_query.get_cell_id(:sector, :layer, :slot)
            	     );
      cout<<"Trbnet-address "<<"0x"<<hex<<(arrayOffset+t)<<dec<<":  "<<rows_to_insert<<" rows inserted\n";
    }
  }

  commit();
  pPar->setChanged(kFALSE);
  return version;
errorfound:
  showSqlError("writePar(HiTofTrb3Lookup*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}


// JAM TODO
Int_t HiTofParOra2Io::writePar(HiTofCalPar* pPar) {
  // creates a new version and writes the lookup table to Oracle
  Int_t version=createVers(pPar);
  if (version==-1) return -1;
  EXEC SQL BEGIN DECLARE SECTION;
   int sector[ITOF_MAX_GLOBALCELLS];
      int layer[ITOF_MAX_GLOBALCELLS];
      int slot[ITOF_MAX_GLOBALCELLS];
      int vers[ITOF_MAX_GLOBALCELLS];
      float offset [ITOF_MAX_GLOBALCELLS]; 
      float slope[ITOF_MAX_GLOBALCELLS]; 
      float adc_par_0[ITOF_MAX_GLOBALCELLS]; 
      float adc_par_1[ITOF_MAX_GLOBALCELLS]; 
      float adc_par_2[ITOF_MAX_GLOBALCELLS]; 
      float twc_par_0[ITOF_MAX_GLOBALCELLS]; 
      float twc_par_1[ITOF_MAX_GLOBALCELLS]; 
      float twc_par_2[ITOF_MAX_GLOBALCELLS];
  int rows_to_insert;
  EXEC SQL END DECLARE SECTION;
  Int_t nRod=0;
  for(Int_t s=0; s<pPar->getSize(); s++) {
    HiTofCalParSec& rSec=(*pPar)[s];   
    for(Int_t m=0; m<rSec.getSize(); m++) {
      HiTofCalParMod& rMod= rSec[m];
      for(Int_t c=0; c<rMod.getSize() ; c++) {   
 	 HiTofCalParCell& cell= rMod[c];
         for(Int_t k=0; k<15 ; k++) {  

	  sector[nRod]=s+1;
	  layer[nRod]=c+1;
	  slot[nRod]=k+1;
	  vers[nRod]=version;
          offset [nRod]	= cell.getOffset(k);	  
          slope[nRod] = cell.getSlope(k);
          adc_par_0[nRod] = cell.getAdcPar0(k);
	  adc_par_1[nRod] = cell.getAdcPar1(k);
          adc_par_2[nRod] = cell.getAdcPar2(k);
	  twc_par_0[nRod]	= cell.getTwcPar0(k); 
	  twc_par_1[nRod]	= cell.getTwcPar1(k);
	  twc_par_2[nRod]	= cell.getTwcPar2(k);
	  nRod++;
	 }
      }
    }
  }
  rows_to_insert=nRod;
  EXEC SQL WHENEVER SQLERROR GOTO not_found;
  EXEC SQL WHENEVER NOT FOUND GOTO not_found;
  EXEC SQL FOR :rows_to_insert
     INSERT INTO tof_ana2.itof_calpar_data
                  (vers_id, cell_id,
		    cal_offset, slope, 
		    adc_par_0 , adc_par_1, adc_par_2 , 
		    twc_par_0, twc_par_1, twc_par_2
		  )
             VALUES (:vers,
            	     tof_ana2.itof_par_query.get_cell_id(:sector, :layer, :slot),
		      :offset, :slope, :adc_par_0, :adc_par_1, :adc_par_2,
		      :twc_par_0, :twc_par_1, :twc_par_2
            	     );
  cout<<rows_to_insert<<" rows inserted\n";
  commit();
  pPar->setChanged(kFALSE);
  return version;
not_found:
  showSqlError("writePar(HiTofCalPar*)");
  rollback();
  pPar->setChanged(kFALSE);
  return -1;
}


void HiTofParOra2Io::printInfo(const Char_t* contName) {
  // prints the sectors initialized from Oracle
  Bool_t first=kTRUE;
  for(Int_t i=0;i<ITOF_MAX_GLOBAL_LAYERS;i++) {
    if (initModules->At(i)) {
      if (first) {
        cout<<contName<<": layer initialized from Oracle: ";
        first=kFALSE;
      }
      cout<<i<<" ";
    }
  }
  cout<<'\n';
}