#ifndef __TTrackFitter_hh__
#define __TTrackFitter_hh__

#include "TObject.h"
#include "TVector2.h"
#include "TMath.h"
#include "TF1.h"
#include "TFitResult.h"
#include <Math/Minimizer.h>
#include <Math/Factory.h>
#include <Math/Functor.h>
#include <Fit/Fitter.h>
#include <Fit/FitResult.h>

class TFitResult;

struct TWireHitInfo
{
  Int_t    strCh;
  Double_t distance;
  TWireHitInfo(const Int_t _strCh = 0, const Double_t _distance = 0.0) :
    strCh(_strCh), distance(_distance) 
  {}
};
typedef std::vector<TWireHitInfo> TWireHitInfoCollection;  

struct TFibreHitInfo
{
  Double_t x, y;
  Double_t err;
  TFibreHitInfo(const Double_t _x = 0.0, const Double_t _y = 0.0, 
	      const Double_t _err = 1.0/TMath::Sqrt(12.0)) :
    x(_x), y(_y), err(_err)
  {}
};
typedef std::vector<TFibreHitInfo> TFibreHitInfoCollection;  

// ==========================================================================
// Track Minimizer
// ==========================================================================
class TrackMinimizer
{  
private:
  const TWireHitInfoCollection* fWireHits;
  const TFibreHitInfoCollection*   fFibreHits;
  const TF1* fPositionResolution;

public:
  TrackMinimizer(const TWireHitInfoCollection* wireHits,
		 const TFibreHitInfoCollection*   fibreHits,
		 const TF1* positionResolution = NULL );
  virtual ~TrackMinimizer();
  
  static Double_t CalcDistance(const Int_t ch, const Double_t slope, const Double_t offset,
			       Double_t* err = NULL,
			       const Double_t slopeErr = 0.0,
			       const Double_t offsetErr = 0.0);
  static void GetSlopeAndOffsetCandidates(TWireHitInfo hit1, TWireHitInfo hit0, 
					  Double_t *slope, Double_t *offset);

  Double_t operator () (const Double_t* par);

  Int_t GetDataSize() const;
  
private:
  Double_t GetSigmaR(const Double_t x);
  
};


// ==========================================================================
// TTrackFitter
// ==========================================================================
class TTrackFitter : public TObject
{
private:
  ROOT::Fit::Fitter fFitter;
  
  // Fitted data
  TWireHitInfoCollection fWireHits;
  TFibreHitInfoCollection   fFibreHits;
  const TF1* fPositionResolution;
  
  // Fit results
  ROOT::Fit::FitResult fFitResult;
  
public:
  TTrackFitter(const Char_t* minimizerType = "Minuit2",
	       const Char_t* algoType = "Migrad");
  ~TTrackFitter();

  void Reset();
  void SetWireHitInfoCollection(TWireHitInfoCollection& collection) { fWireHits = collection; }
  void AddWireHitInfo(TWireHitInfo& info) { fWireHits.push_back(info); }
  void SetFibreHitInfoCollection(TFibreHitInfoCollection& collection) { fFibreHits = collection; }
  void AddFibreHitInfo(TFibreHitInfo& info) { fFibreHits.push_back(info); }
  
  void SetPositionResolution(const TF1* f = NULL) { fPositionResolution = f; }

  Double_t GetSlope()        const { return fFitResult.GetParams()[0];  }
  Double_t GetOffset()       const { return fFitResult.GetParams()[1]; }
  Double_t GetSlopeError()   const { return fFitResult.GetErrors()[0];  }
  Double_t GetOffsetError()  const { return fFitResult.GetErrors()[1]; }
  Double_t GetChi2()         const { return fFitResult.Chi2();   }
  Int_t    GetNDF()          const { return fFitResult.Ndf();    }
  Int_t    GetStatus()       const { return fFitResult.Status(); }
  TFitResult* GetFitResult() const { return new TFitResult(fFitResult); }

  Bool_t Fit(const Double_t initSlope, const Double_t initOffset,
	     const Double_t limitSlope = 0.1, const Double_t limitOffset = 0.5);
  
  ClassDef(TTrackFitter,1)
};

#endif