/*
 * PndSttCellTrackletGenerator.h
 *
 *  Created on: Jun 13, 2014
 *      Author: schumann
 */

#ifndef PNDSTTCELLTRACKLETGENERATOR_H_
#define PNDSTTCELLTRACKLETGENERATOR_H_

#include "PndSttCellTrackFinderData.h"
#include "PndTrackCand.h"
#include "PndRiemannTrack.h"
#include "PndTrack.h"
#include "FairLink.h"
#include "MacrosForGPUComputing.h"

class PndSttStrawMap;
class FairHit;
class PndSttSkewedHit;

extern "C" int* EvaluateAllStates(int*, int*, int, int, int*);

struct TrackletInf_t {

	TrackletInf_t() :
			numSkewed(0), startID(0), endID(0), maxID(0), straight(false), error(
					0.0), numErrHits(0) {
	}
	;
	std::vector<int> hitIDs; // vector<hit-indices of STTHits of the tracklet>
	int numSkewed;					// number of skewed tubes
	int startID;					// tube-ID of the first tube of the tracklet
	int endID;						// tube-ID of the final tube of the tracklet
	int maxID;						// max tube-ID of all hits of the tracklet
	bool straight;// indicates whether the tracklet runs straight from the center to border of the STT
	PndRiemannTrack riemannTrack;	// riemannTrack of the tracklet
	double error;					// sum of squared error
	int numErrHits;	// number of hits that deviate from circle by more than radius of a straw tube

	void Print() {
		std::cout << "startId: " << startID << ", endId: " << endID
				<< ", maxId: " << maxID << ", straight: " << straight
				<< ", #hits: " << hitIDs.size() << ", numSkewed: " << numSkewed
				<< std::endl;

		if (riemannTrack.getNumHits() != 0) {
			std::cout << ", RiemannTrack created error: " << error
					<< ", #wrong hits: " << numErrHits << " ";
			//std::cout << riemannTrack;
			std::cout << std::endl;
		}
	}
	;
};

struct Combination_t {
	std::set<int> tracklets; 			// status of combined tracklets
	TrackletInf_t trackletInf;		// information about the resulting tracklet

	void Print() {
		std::cout << "combined tracklets: ";
		for (std::set<int>::iterator it = tracklets.begin();
				it != tracklets.end(); ++it) {
			std::cout << *it << ", ";
		}
		std::cout << std::endl;
		trackletInf.Print();
	}
};

class PndSttCellTrackletGenerator {
public:
	PndSttCellTrackletGenerator(const PndSttCellTrackFinderData* data) :
			fTimeStamps(20),fVerbose(0), fBz(2.), fCalcFirstTrackletInf(false), fCalcWithCorrectedHits(
					false), fTUBE_RADIUS(0.5005),  fUseGPU(false), fDev_tubeNeighborings(0), 
          fHits(data->GetHits()), fCombinedSkewedHits(data->GetCombinedSkewedHits()), 
          fStrawMap(data->GetStrawMap()), fMapTubeIdToHit(data->GetMapTubeIdToHit()), 
          fMapTubeIdToPos(data->GetMapTubeIdToPos()), fMapHitToFairLink(data->GetMapHitToFairLink()), 
          fHitNeighbors(data->GetHitNeighbors()), fSeparations(data->GetSeparations()) {

	}

	virtual ~PndSttCellTrackletGenerator() {
	}

	void SetUseGPU(Bool_t val) {
		fUseGPU = val;
	}

	void SetDevTubeNeighboringsPointer(int* dev_pointer) {
		fDev_tubeNeighborings = dev_pointer;
	}

	void FindTracks();

	void SetCorrectedHits(std::map<int, FairHit*> correctedHits);

	/* For refitting all RiemanTracks with correctedHits (if available)*/
	void RefitTracks();

	void PrintInfo();

	void SetCalcWithCorrectedHits(bool calcWithCorrectedHits=true) {
		fCalcWithCorrectedHits = calcWithCorrectedHits;
	}

	int GetNumPrimaryTracklets() {
		return fStartTracklets.size();
	}

	/* Get TrackCands of start-tracklets (before combination)*/
	std::vector<PndTrackCand> GetFirstTrackCands() {
		return fFirstTrackCand;
	}
	;

	/* Get RiemannTracks before combination of tracklets*/
	std::vector<PndRiemannTrack> GetFirstRiemannTracks() {
		return fFirstRiemannTrack;
	}
	;

	/* Get TrackCands of combinated start-tracklets*/
	std::vector<PndTrackCand> GetCombiTrackCands() {
		return fCombiTrackCand;
	}
	;

	std::vector<PndTrack> GetCombiTracks() {
		return fCombiTrack;
	}
	;

	bool CalcWithCorrectedHits() {
		return fCalcWithCorrectedHits;
	}

	/* Get RiemannTracks of combinated tracklets*/
	std::vector<PndRiemannTrack> GetCombiRiemannTracks() {
		return fCombiRiemannTrack;
	}
	;

	void SetCalcFirstTrackletInf(Bool_t val) {
		fCalcFirstTrackletInf = val;
	}
	;

	void SetVerbose(Int_t val) {
		fVerbose = val;
	}
	;

	void SetBz(Double_t val) {
		fBz = val;
	}
	;

	std::vector<Double_t> GetTimeStamps() {
		return fTimeStamps;
	}
	;

private:

	std::vector<Double_t> fTimeStamps;

	Int_t fVerbose;
	Double_t fBz;
	bool fCalcFirstTrackletInf;
	bool fCalcWithCorrectedHits;
	double fTUBE_RADIUS;

	bool fUseGPU;
	int* fDev_tubeNeighborings;

	std::vector<FairHit*> fHits;
	std::multimap<int, PndSttSkewedHit*> fCombinedSkewedHits; //<(inner) Tube-ID of combined stt hits of skewed layers, corresponding hit>

	const PndSttStrawMap* fStrawMap;
	std::map<int, int> fMapTubeIdToHit;
	std::map<int, TVector3> fMapTubeIdToPos;
	std::map<int, FairLink> fMapHitToFairLink;

	map<int, vector<int> > fHitNeighbors;
	map<int, vector<int> > fSeparations;

	map<int, int> fStates; 					// map<straw id, state id>
	map<int, std::set<int> > fMultiStates; // map<straw id, set of neighboring state ids for straws with more than two neighbors

	map<int, TrackletInf_t> fStartTracklets; // map<state of start-tracklets (with more than 2 hits) generated by cellular automaton, TrackletInf>
	map<int, TrackletInf_t> fShortTracklets; // set<state of tracklets with less than 3 hits>

	// for first step of trackfinding
	std::vector<PndTrackCand> fFirstTrackCand; // for saving trackCands after the use of cellular automaton
	std::vector<PndRiemannTrack> fFirstRiemannTrack; //	for saving + plotting the riemann-tracks after the first step

	// for second step of trackfinding
	std::vector<std::set<int> > fStateCombinations; // vector< set<state of start-tracklets that should be combined> >
	std::vector<Combination_t> fCombinedData; // for storing combination of start-tracklets
	std::vector<int> fTrackletsWithoutCombi; // state of tracklets that were not combined

	std::vector<PndTrackCand> fCombiTrackCand; // resulting tracks after combination of tracklets (uncombined too)
	std::vector<PndRiemannTrack> fCombiRiemannTrack; //resulting riemanntracks
	std::vector<PndTrack> fCombiTrack; // resulting PndTrack

	std::map<int, FairHit*> fCorrectedHits;

	/* This Method creates PndTrackCands out of the entries in fCombinedData and
	 *  the not combined tracklets with more than 2 hits.*/
	void CreatePndTrackCands();

	/* Method creates the tracklets by the means of a cellular automaton.*/
	void GenerateTracklets();

	/* Method creates the tracklets by the means of a cellular automaton on the GPU.*/
	void GenerateTrackletsGPU();

	/* Method update the states of each until no state change anymore.*/
	void EvaluateState();

	/* Method update the states of tubes with more than two neighbors until no state changes anymore. */
	void EvaluateMultiState();

	/* Method initialzises fStartTracklets with the states and trackletInf
	 * of the generated tracklets.*/
	void InitStartTracklets();

	/* Method searches for reasonable combination of the start-tracklets with a recursive algorithm.
	 * They are stored in fCombinedData. */
	void CombineTrackletsMultiStages();

	/* Implementation of the recursive algorithm for finding combination of the start-tracklets.*/
	void CombineTrackletsMultiStagesRecursive(int stateToCombine,
			std::set<int> currentCombi);

	/* Method inserts a combination of states if not existing yet.*/
	void InsertCombination(std::set<int> combination);

	/* Method for calculating the trackletInf for a combination of tracklets.*/
	TrackletInf_t GetTrackletInf(std::set<int> tracklets);

	/* Method splits the start tracklets in uncombined and short tracklets*/
	void SplitData();

	void AssignAmbiguousHits();

	/* Method adds the unassigned hits and trackCands with 1 and 2 hits to an
	 * appropriate combination (if possible).*/
	void AddRemainingHits();

	/* Methods adds the uncared hits with 3 and 4 hit-neighbors to the best combination
	 * of tracklets. If the nearest riemann-circle is found and the distance is
	 * smaller than the radius of a tube, the hit is added.*/
	bool AddHitToBestCombi(int hitID);

	/* Method for creating a riemannTrack out of hits.
	 * Hits of skewed tubes were ignored.*/
	PndRiemannTrack CreateRiemannTrack(std::vector<int> hitIDs);

	std::set<std::pair<int, int> > CreatePairCombis(int firstState,
			std::set<int> values);

	/* Method calculates the mean squared deviation of the hits from the riemann-circle.*/
	double CalcDeviationOfRiemannTrack(PndRiemannTrack& track);

	/* Method calculates the deviation of the hit from the riemann-circle.*/
	double CalcDeviation(PndRiemannTrack& track, int hitID);

	/* Method counts the hits of the riemannTrack, that had a distance of more
	 * than r (radius of a straw tube) to the riemann-circle.*/
	int GetDeviationCount(PndRiemannTrack& track);

	/* Method checks if a tubeID belongs to the end-tube of a tracklet.*/
	bool IsEndTubeOfTracklet(int tubeID);

ClassDef(PndSttCellTrackletGenerator,1)
	;
};

#endif /* PNDSTTCELLTRACKLETGENERATOR_H_ */