//-----------------------------------------------------------
//-----------------------------------------------------------
#include <iostream>
#include <fstream>
#include  "TMath.h"
#include "PndDchDrifter.h"
#include "TMath.h"

using std::ifstream;
using std::cout;
using std::endl;

PndDchDrifter* PndDchDrifter::fDrifterInstance = 0;

PndDchDrifter* PndDchDrifter::Instance() {
  if (0 == fDrifterInstance){
    cout<<"First call of PndDchDrifter::Instance(...)"<<
      " must be with filename and cellsize!!"<<endl;
    abort();
  } else
    return fDrifterInstance;
}

PndDchDrifter* PndDchDrifter::Instance(TString filename, Double_t cellsize) {
  if (0 != fDrifterInstance) {
    cout<<"An instance of PndDchDrifter already existed, "<<
      "I replace it with a new one"<<endl;
    delete fDrifterInstance;
  }
  return fDrifterInstance = new PndDchDrifter(filename, cellsize);
}


PndDchDrifter::PndDchDrifter(TString fileName, Double_t splaneWidth) 
  : fCellSize(splaneWidth)
{
  Double_t timeUnit2ns  ; //read from the file to recalculate tim and distance 
                             // in  proper units. I assume to have time in [ns]
  Double_t distanceUnit2cm; //I assume to have distance in [cm]
                               //reading the calibration distance to drift time file  
  ifstream infile(fileName.Data(),std::fstream::in);
  if(!infile.good()){
    cout<<"The drift time parametrization file "<<fileName<<" is not found"<<endl;
    abort();
  }
  infile>> fNumberOfPoints;
  infile>> distanceUnit2cm >> timeUnit2ns; 
  fDistance.reserve(fNumberOfPoints);
  fDriftTime.reserve(fNumberOfPoints);
  for (Int_t i=0; i<fNumberOfPoints; i++) {
    infile >> fDistance[i] >> fDriftTime[i];
    fDriftTime[i] *= timeUnit2ns; 
    fDistance[i]  *= distanceUnit2cm; 
  }
  infile.close();
}

Bool_t PndDchDrifter::CalculateDriftTime(Double_t &time, Double_t distance) const {

  Double_t bin = 0.5*fCellSize/fNumberOfPoints;
  Int_t index1 = (Int_t) TMath::Floor(distance/bin);
  Int_t index2 = (Int_t) TMath::Ceil(distance/bin);
  if (index1 < 0 || index2 >= fNumberOfPoints) 
    return kFALSE;
  Double_t weight1 = 0.;
  Double_t weight2 = 0.;
  if (index1 == index2)
    time = fDriftTime[index1];
  else{
    weight1 = TMath::Abs(distance-index1*bin)/bin;
    weight2 = TMath::Abs(index2*bin-distance)/bin;
    time = weight1*fDriftTime[index1]+weight2*fDriftTime[index2];
  }
  return kTRUE;
}

Bool_t PndDchDrifter::CalculateDistance(Double_t time, Double_t &distance) const {
  distance = 0;
  if (time<10e-9){
    return kFALSE;    
  }
  Double_t bin = 0.5*fCellSize/fNumberOfPoints;
  Int_t i=0;
  for (i=0; i<fNumberOfPoints && fDriftTime[i]<time; i++){;}

  if (i>0 && i<fNumberOfPoints){
    Double_t w1 = TMath::Abs(time-fDriftTime[i-1]);
    Double_t w2 = TMath::Abs(time-fDriftTime[i]);
    distance = (i-1 + w1/(w2+w1))*bin;
    if(distance<fCellSize/2)
      return kTRUE;
    else
      return kFALSE;
  }else{
    return kFALSE;
  }
}

void PndDchDrifter::Print(const Option_t* option) const {
  cout << "PndDchDrifter: \n";
}


ClassImp(PndDchDrifter)