/*
 * PndIsochroneTrackFinder.h
 *
 *  Created on: 10.10.2014
 *      Author: Stockmanns
 */

#ifndef PNDISOCHRONETRACKFINDER_H_
#define PNDISOCHRONETRACKFINDER_H_

#include <set>
#include <map>
#include <vector>
#include <utility>

#include "TObject.h"
#include "TH2D.h"
#include "TGraph.h"

#include "FairHit.h"

#include "PndTrack.h"
#include "PndTrackCand.h"
#include "PndTrackFromCircle.h"
#include "PndSttHit.h"


#include "TClonesArray.h"
class TVector2;

class PndGeneralHoughHit : public FairHit
{
public:
	PndGeneralHoughHit(){};
	~PndGeneralHoughHit(){};
	PndGeneralHoughHit(const FairHit& hit) : FairHit(hit), isochroneRadius(0){};

	void SetIsochroneRadius(Double_t val) {isochroneRadius = val;}
	Double_t GetIsochroneRadius() const {return isochroneRadius;}
private:
	Double_t isochroneRadius;
};

class PndIsochroneTrackFinder : public TObject {
public:
	PndIsochroneTrackFinder();
	virtual ~PndIsochroneTrackFinder();

	void SetTubeArray(TClonesArray* val){fSttTubeArray = val;}
	void SetAngleRange(std::pair<Double_t, Double_t> range) {fAngleRange = range;}
    void SetAngleStepSize(Double_t stepSize) {fAngleStepSize = stepSize;}
    void SetUseGpu(Bool_t gpu);
    void SetEventNumber(int _eventNr) {fEventNumber = _eventNr;};
    void SetNumberOfThreads(int _nThreads) {fNumberOfThreads = _nThreads;};  // DELETE

	void AddHits(TClonesArray* hits, Int_t branchId);
	std::vector<PndTrack> FindTracks();

	TH2D* GetHoughHisto(){return fHoughHisto;}
	void SetSkewedBranchName(TString branchName){fSkewedBranchName = branchName;}
	void SetSkewedArray (TClonesArray* val){ fSttSkewedArray = val; }
	TClonesArray* GetSkewed() const {return fSttSkewedArray;}
	std::vector<PndTrackCand> GetTrackCands(){return fTrackCands;}
	std::vector<TVector2> GetPeakCoordinates(){return fPeakCoordinates;};
    TGraph GetPeakCoordinateGraph();
    int GetEventNumber() {return fEventNumber;};

	void AssignSkewedHits(PndTrackCand& cand, std::vector<std::vector<FairHit> > skewedHits, TVector2 circle);

	void Reset(){
		if (fHoughHisto != 0)
			fHoughHisto->Reset();
		fBinsWithContent.clear();
		for (std::map<Int_t, std::set<Int_t> >::iterator iter = fBinToHit.begin(); iter != fBinToHit.end(); ++iter){
			iter->second.clear();
		}
		fBinToHit.clear();
		fHitsUsed.clear();
		fTrackCands.clear();
		fHitsToFit.clear();
		fSkewedHits.clear();
		if (fSttSkewedArray != 0)
			fSttSkewedArray->Delete();
		fPeakCoordinates.clear();

	}

protected:
	TVector2 IsoCalc(Double_t x0, Double_t y0, Double_t isoR, Double_t phi);
	Int_t GetHistoBin(TH2* histo, Double_t xVal, Double_t yVal);
	void InterpolateHisto(TH2* histo, TVector2& in, TVector2& out, Int_t& hitId, Double_t weight = 1.);
	std::multimap<Int_t, Int_t> FindPeaks(std::set<Int_t>& binsWithContent, TH2* histo, Int_t threshold);
	PndTrackCand FillTrackCand(Int_t histoBin);
	Double_t CalcArcLength(FairHit hit, TVector2 circleCenter);
	PndTrack CalcPndTrack(PndTrackCand& cand, std::vector<std::vector<FairHit> > skewedHits, TVector2 circle, Double_t mag = 2.0);
	FairTrackParP CalcTrackParP(FairHit hit, TVector2 circleCenter, Double_t mag);
	TVector3 CalcHitPosInTrack(FairHit hit, TVector2 circleCenter);
	Double_t CalcPt(Double_t mag, TVector2 circleCenter);
	TVector2 CalcPtDir(TVector2 hit, TVector2 circleCenter);

	std::vector< std::vector <FairHit> > FindSkewedHits(TVector2 circle);
	std::vector<TVector2> GenerateHoughValues(std::vector<float> angles, Double_t xVal, Double_t yVal,
			Double_t isoChrone);
    std::vector<float> GenerateAngles();
	void FillHoughHist(std::vector<TVector2>, Int_t, Double_t);
	std::vector<PndTrack> PeaksToTracks(std::multimap<Int_t, Int_t>);

	//void GetStartEndPointOfTube(PndSttHit*, TVector3& startPoint, TVector3& endPoint);

//	void FillHistogram();

private:
	std::pair<Double_t, Double_t> fAngleRange;
	Double_t fAngleStepSize;
	TH2D* fHoughHisto;
	std::set<Int_t> fBinsWithContent; //!
	std::vector<PndGeneralHoughHit> fHitsToFit;
	std::map<Int_t, std::set<Int_t> > fBinToHit; //Map of BinInHisto(key) to index in TClonesArray
	std::set<Int_t> fHitsUsed;
	Bool_t fClockwise;
	std::vector<PndTrackCand> fTrackCands;
	std::map<TString, Double_t> fWeightMap;
	TClonesArray* fSttTubeArray;
	std::vector<PndSttHit*> fSkewedHits;
	std::map<FairLink, PndGeneralHoughHit> fMapFairLinkHit;
	std::vector<TVector2> fPeakCoordinates;

	PndTrackFromCircle fTrackCalc;


	TString fSkewedBranchName;				//<Output branchName for the calculated hits from the skewed layers
	TClonesArray* fSttSkewedArray;
	int fEventNumber;
	int fNumberOfThreads;  // GPU only! DELETE when not timing stuff anymore
    
    Bool_t fUseGpu;

public:
	ClassDef(PndIsochroneTrackFinder, 1);
};

#endif /* PNDISOCHRONETRACKFINDER_H_ */