#ifndef _TFITTING_H_
#define _TFITTING_H_

#include <string>
#include <vector>
#include <algorithm>

#include "TMinuit.h"
#include "ToolsLib.h"
#include "TCdFShowerParams.h"
#include "TDataToFit.h"
#include "TSmSp.h"
#include "TCdasUtil.h"

/**
   @file TFitting.h
*/

enum FitVariable
{
  kFitX0 = 0,
  kFitY0,
  kFitZ0,
  kFitT0,
  kFitU,
  kFitV,
  kFitC, // is 1/(2R)
  kFitS,
  kFitE,
  kFitBeta,
  kFitXMAX,
  kFitNumber // MUST BE THE LAST !
};


//! TFitting class : contains all functions to deal with Minuit and to do the fit.


class TFitting : public TCdFShowerParams,
  public TDataToFit {

public:

  TFitting(int verbosity=-1);
  virtual ~TFitting();
  void SetContext(int verbosity = -1,
                  int warnings = 0,
                  string method = "MIGRAD",
                  string statistics = "CHI2");

  string	fMethod; ///< MIGRAD or MINOS
  string	fStatistics; ///< CHI2 or LOG (log-likelihood)
  int		fVerbosity;
  bool		fWarnings;

  TMinuit *	fMinuit;

  double *	fArgList;
  double *	fVStart;
  double *	fVStep;
  double *	fMin;
  double *	fMax;
  double *	fParameters;
  int 		fCount;
  vector<bool> 	fParameterSet;
  int 	        fIerFlg;
  string 	fLDFType;
  int           fPrimary; ///< used in LOG-LOG algorithms

  static TSMSPEstim *fpSmspEstim;

  /********************/
  /* Minuit interface */
  /********************/
  void SetVerbosity(int verbosity = 1);///< -1 : silent, 3 : maximum verbose
  void SetWarnings(bool warnings = 0);
  void SetMinimizationMethod(string method = "MIGRAD");
  void SetStatistics(string method = "CHI2");
  void SetLDFType(string ldf="HP");
  void SetFCN(void (*fcn)(Int_t &, Double_t *, Double_t &f, Double_t *, Int_t));
  void SetInstance();

  void SetFreeParameter(int parameter, double start, double step, double min=0, double max=0);
  void SetFreeParameters(int numpar, int * parameters, double * vstart, double * step, double * min=0x0, double *max=0x0);
  void SetMin(int numpar, double min);
  void SetMax(int numpar, double max);
  void ReleaseParameter(int parameter, double value, double step=-1);
  void RemoveParameter(int parameter);
  void RemoveParameters();
  void SetFixParameter(int parameternumber, double value);
  void PrepareParameters(); ///< orders correctly the parameters in Minuit
  void Minimize();
  bool GetValues(FitVariable fv);
  void ComputeResults();
  void MinuitStatus() const;

  /********/
  /* Chi2 */
  /********/
  double ComputeChi2GlobalHP(double * par);///< all variables
  double ComputeChi2GlobalLOG(double * par);///< all variables
  double ComputeChi2Global2EXPO(double * par);///< all variables
  double ComputeChi2Plane(double * par);///< plane fit, only geometry
  double ComputeChi2Curvature(double * par);///< curved fit
  double ComputeChi2CurvatureVariable(double * par);///< curved fit with variable R
  double ComputeChi2SMSP(double* par); ///< SMSP method fit

  /******************/
  /* Fit Algorithms */
  /******************/
  double FitPlane(double x, double y, double z, double * par) const; ///< fit front wave with a plane
  double FitCurvature(double x, double y, double z, double dist, double *par) const; ///< fit front wave with a parabole
  double FitCurvatureVariable(double x, double y, double z, double dist, double *par) const; ///< fit front wave with a parabole
  double FitLDFHP(double dist, double theta, double* parameter) const;
  double FitLDFLOG(double dist, double theta, double* parameter);
  double FitLDFPhoton(double dist, double theta, double energy, double* parameter) const;
  double FitLDF2EXPO(double dist, double theta, double energy, int primary) const;


  void Print(ostream&) const;
  void InitFitting(bool noparams=0);

};

void FCNPlane(int& npar, double *gin, double& f, double *par, int iflag);
void FCNCurvature(int& npar, double *gin, double& f, double *par, int iflag);
void FCNCurvatureVariable(int& npar, double *gin, double& f, double *par, int iflag);
void FCNGlobalHP(int& npar, double *gin, double& f, double *par, int iflag);
void FCNGlobalLOG(int& npar, double *gin, double& f, double *par, int iflag);
void FCNGlobal2EXPO(int& npar, double *gin, double& f, double *par, int iflag);
void FCNHorizontal(int& npar, double *gin, double& f, double *par, int iflag);
void FCNSMSP(int& npar, double *gin, double& f, double *par, int iflag);

inline ostream& operator<<(ostream& s, TFitting& tf) {
  tf.Print(s);
  return s;
}

#endif