#include "AsapIOVTreeImpl.hh"
#include "AsapSensorSummary.hh"
#include "AsapCorrection.hh"
#include "AsapSensorResidual.hh"
#include "ScopedLock.hh"
#include "TFile.h"
#include "TROOT.h"

using namespace asap::pilot::facade::corba;
using namespace asap::jdbtree::facade::corba;

AsapIOVTreeFactoryImpl* AsapIOVTreeFactoryImpl::iovtreeFactory = NULL;


#include <iostream>
using namespace std;

AsapIOVTreeFactoryImpl::AsapIOVTreeFactoryImpl()  :
  PortableServer::RefCountServantBase(),
  POA_asap::pilot::facade::corba::AsapIOVTreeFactory()
{
}

AsapIOVTreeFactoryImpl::~AsapIOVTreeFactoryImpl() {
}


AsapIOVTree_ptr AsapIOVTreeFactoryImpl::createTree(const char* name,
						      const char* title,
						      const char* cacheFilePath) {
  // Synchronize this method
  ScopedLock lock;

  TFile* rootFile = NULL;
  if (cacheFilePath && cacheFilePath[0] != '\0') {
    rootFile = TFile::Open(cacheFilePath, "RECREATE");
    if (!rootFile) throw RootException(Form("Cannot open file %s",cacheFilePath));
    rootFile->cd();
  } else {
    gROOT->cd();
  }

  AsapIOVTreeImpl* impl = new AsapIOVTreeImpl(new TTree(name, title), rootFile);
  // ServantBase takes ownership of the new object. This is mandatory for correct reference counting.
  PortableServer::ServantBase_var servant = impl;
  AsapIOVTree_var rootTree = impl->POA_asap::pilot::facade::corba::AsapIOVTree::_this(); // side effect: increment reference count.
  return rootTree._retn(); // give up ownership of the servant
}

AsapIOVTreeFactoryImpl* AsapIOVTreeFactoryImpl::getInstance() {
  if(!iovtreeFactory) {
    iovtreeFactory = new AsapIOVTreeFactoryImpl;
  }
  return iovtreeFactory;	
}


AsapIOVTreeImpl::AsapIOVTreeImpl(TTree *tree, TFile *rootFile)
  : RootTreeImpl (tree, rootFile)
 {
  _iov = new AsapIOV();
  tree->Branch("iov", "AsapIOV", &_iov);
  // a few aliases for easy command line plotting
  tree->SetAlias("rh", "iov.resultHeader");
  tree->SetAlias("dr", "iov.resultHeader.distanceResult");
  tree->SetAlias("cr", "iov.resultHeader.correction");
  tree->SetAlias("sr", "iov.resultHeader.sensorResidual");
  tree->SetAlias("fr", "iov.resultHeader.fitresult");
}
AsapIOVTreeImpl::~AsapIOVTreeImpl() {

}
void AsapIOVTreeImpl::addIOV(const AlignIOV& corbaIOV) {
  // Synchronize this method
  ScopedLock lock;

  _iov -> Clear ();

  _iov -> setSinceT (corbaIOV.since);
  _iov -> setTillT  (corbaIOV.till);
  _iov -> setIovId  (corbaIOV.iov_id);
  _iov -> setTag ("");

  if (corbaIOV.results.length() == 0) return;
  const AlignResult& corbaResult = corbaIOV.results[0];
  AsapResultHeader* header = _iov -> newResultHeader ();
  header -> setSinceT     (corbaResult.icarasSince);
  header -> setTillT      (corbaResult.icarasTill);
  header -> setCycleStart (corbaResult.cycleStart);
  header -> setCycleEnd   (corbaResult.cycleEnd);
  header -> setChi2       (corbaResult.chi2);
  header -> setNDOF       (corbaResult.nDOF);
  header -> setChi2Norm   (corbaResult.chi2norm);

  header -> setNIteration (corbaResult.nIteration);
  header -> setNMaxIteration (corbaResult.nMaxIteration);
  header -> setExitReason (corbaResult.exitReason);

  int nSensorSummary = corbaIOV.sensorsummary.length();
  for (int i=0; i<nSensorSummary; i++) {
    AsapSensorSummary* summary = header -> newSensorSummary ();
    summary -> setSensorType ((const char*)corbaIOV.sensorsummary[i].sensorType);
    summary -> setNSensorsTotal (corbaIOV.sensorsummary[i].nSensorTotal);
    summary -> setNSensorsFailure (corbaIOV.sensorsummary[i].nSensorFailure);
  }

  int nCorr = corbaIOV.corrections.length();
  for (int i=0; i<nCorr; i++) {
    AsapCorrection* corr = header -> newCorrection ();
    const AlignCorrection& corbaCorr = corbaIOV.corrections[i];

    corr -> setSinceT   (corbaIOV.since);
    corr -> setTillT    (corbaIOV.till);
    corr -> setAsapID   ((const char*)corbaCorr.asap_id);
    corr -> setAsapType ((const char*)corbaCorr.asap_type);

    corr -> setAmdbTyp ((const char*)corbaCorr.amdb_typ);
    corr -> setAmdbJff (corbaCorr.amdb_jff);
    corr -> setAmdbJzz (corbaCorr.amdb_jzz);
    corr -> setAmdbJob (corbaCorr.amdb_job);

    corr -> setS      (corbaCorr.s);
    corr -> setZ      (corbaCorr.z);
    corr -> setT      (corbaCorr.t);
    corr -> setThetaS (corbaCorr.thetas);
    corr -> setThetaZ (corbaCorr.thetaz);
    corr -> setThetaT (corbaCorr.thetat);

    corr -> setXAtlas (corbaCorr.xatlas);
    corr -> setYAtlas (corbaCorr.yatlas);
    
//     corr -> setTORTION(corbaCorr.tortion);
//     corr -> setSAGRO  (corbaCorr.sagro );
//     corr -> setSAGHV  (corbaCorr.saghv );
//     corr -> setDWRO   (corbaCorr.dwro  );
//     corr -> setDWHV   (corbaCorr.dwhv  );
//     corr -> setSAGLBV (corbaCorr.saglbv);
//     corr -> setSAGLBH (corbaCorr.saglbh);
//     corr -> setDWAC   (corbaCorr.dwac  );
//     corr -> setTEMP   (corbaCorr.temp  );
  }

  int nSensorResidual = corbaIOV.sensorresidual.length();
  for(int i = 0; i < nSensorResidual; i++) {
    AsapSensorResidual* res = header -> newSensorResidual ();
    const AlignSensorResidual& corbaSensorResidual = corbaIOV.sensorresidual[i];

    res -> setChannelName ((const char*)corbaSensorResidual.channelName );
    res -> setType        ((const char*)corbaSensorResidual.type	   );
    res -> setNMeas       (corbaSensorResidual.nmeas	   );
    res -> setDistCL      (corbaSensorResidual.distCL	   );
    res -> setDistLM      (corbaSensorResidual.distLM	   );

    for (int imes = 0; imes < res->getNMeas(); imes++) {
      AsapSensorMeasurement& m = res->at(imes);
      const AlignSensorMeasurement& c = corbaSensorResidual.meas[imes];
      m.setId             ((const char*)c.id);
      m.setMeas           (c.meas          );
      m.setModel          (c.model	   );
      m.setError          (c.error	   );
      m.setMeasraw        (c.measraw	   );
      m.setMeasrawerror   (c.measrawerror  );
      m.setMeasrawnpoints (c.measrawnpoints);
    }
  }

  tree -> Fill ();

}