/**
   \file
   implementation of FindtimeOffset

   \author Jose Bellido
   \date 11 Jan 2016
*/
#include <sstream>
#include <iomanip>

#include "FindTimeOffset.h"


#include <fdet/FDetector.h>
#include <fdet/Eye.h>


#include <evt/Event.h>

#include <fevt/FEvent.h>
#include <fevt/Header.h>
#include <fevt/Eye.h>
#include <fevt/EyeHeader.h>
#include <fevt/EyeRecData.h>


#include <utl/ErrorLogger.h>
#include <utl/Trace.h>
#include <utl/AugerUnits.h>
#include <utl/MathConstants.h>
#include <utl/PhysicalConstants.h>
#include <utl/TimeStamp.h>
#include <utl/TabulatedFunctionErrors.h>

#include <utl/Transformation.h>
#include <utl/ReferenceEllipsoid.h>
#include <utl/UTMPoint.h>

#include <fwk/RunController.h>
#include <fwk/LocalCoordinateSystem.h>
#include <fwk/CoordinateSystemRegistry.h>


#include <TFile.h>

//
//========================================
// sd part for hybrid reconstruction
#include <evt/ShowerSRecData.h>
#include <sevt/SEvent.h>
#include <sevt/Station.h>
#include <sevt/StationTriggerData.h>
#include <sevt/StationRecData.h>
#include <sevt/EventTrigger.h>
#include <sdet/SDetector.h>
#include <sdet/Station.h>


using namespace det;
using namespace evt;
using namespace fevt;
using namespace std;
using namespace utl;
using namespace fwk;
// for Hybrid
using namespace sevt;


FindTimeOffset::FindTimeOffset() :
  fOutputFile(0)
{
}

FindTimeOffset::~FindTimeOffset()
{
  delete fOutputFile;
}

VModule::ResultFlag
FindTimeOffset::Init()
{
  return eSuccess;
}


VModule::ResultFlag
FindTimeOffset::Run(Event& event)
{
  if (!event.HasSEvent()) {
    cout<<" don't have SEvent \n";
    return eContinueLoop;
  }

   //=====================================
  //  Identify CLD and XLF events
  if (!event.HasSEvent()) {
    cout<<" don't have SEvent \n";
    return eContinueLoop;
  }
  sevt::SEvent& sevent = event.GetSEvent(); 
  sevt::SEvent::StationIterator sditer;

  fIsCeleste = false;
  fIsRamiro = false;
  
  for(sditer=sevent.StationsBegin(); sditer != sevent.StationsEnd(); ++sditer)
    {
      sevt::Station& station=*sditer;

      if (!sditer->HasRecData())
      sditer->MakeRecData();
      
      if (!sditer->HasRecData()) {
	continue;
      }


      if (station.IsCandidate() && station.GetId() == 203)
	fIsCeleste = true;
      if (station.IsCandidate() && station.GetId() == 805)
	fIsRamiro = true;
      
      
    }
  
  
  cout<<"\n";
  cout<<"==============================================\n";
  cout<<"\n";
  cout<<"\n";
  if (fIsCeleste)
    cout<<"   FindTimeOffset:     This is a CLF event  \n";

  if (fIsRamiro)
    cout<<"   FindTimeOffset:       This is a XLF event \n";

  if (!fIsCeleste && !fIsRamiro) {
    cout<<"    This is NOT a hybrid laser event \n";
    cout<<"            (skipping event) \n";
    return eContinueLoop;
  }
  cout<<"==============================================\n";
  cout<<"\n";
  cout<<"\n";
  //===================================================================
    

  if (!event.HasFEvent())
    return eSuccess;

  
  fevt::Eye& eye = *event.GetFEvent().EyesBegin();

  fCurEvent = &event;

  //sevt::SEvent& sevent = event.GetSEvent(); 

  const unsigned int runno = eye.GetHeader().GetRunNumber();
  const unsigned int evno = eye.GetHeader().GetEventNumber();

  stringstream s; 
  s << "Run" << runno << "Event" << evno;
  s >> fEventId;

  if (event.HasFEvent())
    ExamineFEvent(event);

  return eSuccess;
}


VModule::ResultFlag
FindTimeOffset::Finish()
{ 
  return eSuccess;
}



void
FindTimeOffset::ExamineFEvent(const evt::Event& event)
{
  if (!event.HasFEvent())
    return;
  const fevt::FEvent& fevent = event.GetFEvent();

  // we are reading, so get a ConstIterator, not Iterator
  FEvent::ConstEyeIterator eyeiter;

  // iterate over eyes
  for (eyeiter= fevent.EyesBegin(ComponentSelector::eHasData); 
       eyeiter != fevent.EyesEnd(ComponentSelector::eHasData); ++eyeiter) {

    
    const fevt::Eye::ConstTelescopeIterator teliter;
    const fevt::Eye& eye = *eyeiter; // dereferencing the eye iterator
                                     // gives you a reference to the eye


    FindOffset(eye);

  }
}






void   FindTimeOffset::FindOffset(const fevt::Eye& eye){
  
  
  CoordinateSystemPtr CS =
    det::Detector::GetInstance().GetSiteCoordinateSystem();
  const ReferenceEllipsoid &e = ReferenceEllipsoid::GetWGS84();


 //--------------------------------
  Point eyeposition = 
    det::Detector::GetInstance().GetFDetector().GetEye(eye).GetPosition();
  UTMPoint UTMeye(eyeposition, e);
  Point ThisEye = UTMeye.GetPoint(CS);
  //------------------------
  
 
  const CoordinateSystemPtr xlfCs = fwk::CoordinateSystemRegistry::Get("XLF");
  const CoordinateSystemPtr clfCs = fwk::CoordinateSystemRegistry::Get("CLF");
  CoordinateSystemPtr LaserCS;
    
  Point clf(0,0,0,clfCs);
  const UTMPoint UTMclf(clf, e);
  clf = UTMclf.GetPoint(CS);
 
  Point xlf(0,0,0,xlfCs);
  const UTMPoint UTMxlf(xlf, e);
  xlf = UTMxlf.GetPoint(CS);
  
 
  CoordinateSystemPtr EyeCS = fwk::LocalCoordinateSystem::Create(ThisEye);
  
  Point LaserFacility;
  if (fIsCeleste)  {
    LaserFacility = clf;
    LaserCS = clfCs;
  }
  if (fIsRamiro)   {
    LaserFacility = xlf;
    LaserCS = xlfCs;
  }
  
  Vector vertical_eye(0,0,1,EyeCS);
  Vector eye_LaserFacility = LaserFacility - ThisEye;
  
  //----------------------------
  



  //here we set the orientation of the laser
  
  const EyeRecData& eyerecdata = eye.GetRecData();
  
  double fChi0=eyerecdata.GetChiZero();
  double fRp=eyerecdata.GetRp();

  double fT0=eyerecdata.GetTZero();
  Vector fSDP=eyerecdata.GetSDP();


   //----------------------

  utl::TimeStamp time2 = eye.GetHeader().GetTimeStamp();
 

 
  cout<<" ----------------------------------------------";
  cout<<" \n";
  cout<<"GPSsecond: = "<< time2.GetGPSSecond()<<"\n";
  cout<<" Eye: "<<eye.GetId()<<"\n";
  cout<<" fChi0 "<< fChi0/degree<<"  fRp "<< fRp<<" fT0 "<<fT0<<"\n";

  Vector horizontalInSDP = cross(fSDP,vertical_eye);
  horizontalInSDP /= horizontalInSDP.GetR(EyeCS);

   
  
  Transformation rot2 (Transformation::Rotation(-fChi0,fSDP, EyeCS));
  Vector LaserOrientation (rot2* horizontalInSDP);
  LaserOrientation /= LaserOrientation.GetR(EyeCS);

  cout<<"Laser Orientation-eyeCS (theta,phi): "<<LaserOrientation.GetTheta(EyeCS)/degree<<" ,"<<LaserOrientation.GetPhi(EyeCS)/degree<<"\n";

  //force the direction to be up-going
  //  if (LaserOrientation.GetTheta(LaserCS) /degree > 90)
    LaserOrientation *= -1;


   cout<<" \n";
  cout<<" \n";



 
  double beta = Angle(-eye_LaserFacility, LaserOrientation);
  //  cout<< "Beta: "<<beta/degree<<"  Eye-LaserFacility:  "<<eye_LaserFacility.GetR(EyeCS)<<" EyeId: "<< eye.GetId()<<"\n";

  //double chi_0 = Angle(LaserOrientation, horizontalInSDP);
  double deltaT   = eye_LaserFacility.GetR(EyeCS) * cos(beta)/kSpeedOfLight;
  //double r_p   = -eye_LaserFacility.GetR(EyeCS) * sin(beta) ;

  //double LaserFacility_to_rp   = eye_LaserFacility.GetR(EyeCS) * cos(beta) ;

  double t_0 = 0;

  
  evt::Event& event = *fCurEvent;
  sevt::SEvent& sevent = event.GetSEvent(); 
  SEvent::StationIterator sditer;

  double OffsetFromFit;
  for(sditer=sevent.StationsBegin(); sditer != sevent.StationsEnd(); ++sditer)
    {
      sevt::Station& station=*sditer;

      if (!sditer->HasRecData())
      sditer->MakeRecData();
      
      if (!sditer->HasRecData()) {
	continue;
      }


      if (station.IsCandidate() && (station.GetId() == 203 ||station.GetId() == 805) )
	{

	  sevt::Station& station=*sditer;

	  // estimated time at Rp (t_0) using the time at celeste
	  //nanosecond is for the station time
	  
	  double nanosecond = station.GetRecData().GetSignalStartTime().GetGPSNanoSecond();

	  //nanosecond = 249999600;
	

	  double eye_trigger_time = double(time2.GetGPSNanoSecond());
	  eye_trigger_time -= 1000 *100;

	  t_0 =  nanosecond - 180 + deltaT - eye_trigger_time;

	  
	  OffsetFromFit = t_0-fT0;

	  

          cout<<" SD/FD Time Offset:  "<<t_0-fT0<<" ns \n"; 
	  // t_0 is the estimated to, and fT0 is the fitted to.
	  fT0 = t_0;


	  double AZimuth_reconstructed = LaserOrientation.GetPhi(LaserCS)/degree;
	  if (AZimuth_reconstructed < 0) 
	    AZimuth_reconstructed += 360; 
	  


	  if(OffsetFromFit != OffsetFromFit) {
	    cout<<"test \n";
	  }
	  else {
	    ofstream fout("offset.dat",ios::app);
	    fout <<eye.GetId()<<" "<<OffsetFromFit<<" "<< time2.GetGPSSecond()<<" "<<time2.GetGPSNanoSecond() <<" "<<90-LaserOrientation.GetTheta(LaserCS)/degree<<" "<<AZimuth_reconstructed<<" "<<station.GetRecData().GetTotalSignal()<<" "<<fIsCeleste<<"\n";
	    fout.close();
	  }
	  cout<<" \n"; 
	  cout<<" Laser aiming direction, Elevation: "<<90-LaserOrientation.GetTheta(LaserCS)/degree<<" deg.  Azimuth:  "<<AZimuth_reconstructed<<" deg. \n";
	  cout<<" \n";
	 
	}
    }
  
}





// Configure (x)emacs for this file ...
// Local Variables:
// mode:c++
// compile-command: "make -k"
// End: