//-*- Mode: C++ -*-
  // *****************************************************************************
  //                                                                             *
  // @Autors: I.Kulakov; M.Zyzak; I.Kisel                                        *
  // @e-mail: I.Kulakov@gsi.de; M.Zyzak@gsi.de; I.Kisel@compeng.uni-frankfurt.de *
  //                                                                             *
  // *****************************************************************************

#ifndef ALIHLTTPCCAGBTRACKER_H
#define ALIHLTTPCCAGBTRACKER_H

#include "AliHLTTPCCADef.h"
#include "AliHLTTPCCATrackParam.h"
#include "AliHLTTPCCAParam.h"
#include "AliHLTArray.h"
#include "AliHLTTPCCAGBHit.h"
#include "ITSCAStrip.h"

#include "AliHLTTPCCAGBTrack.h"

#include "ITSCAStationArray.h"

class ITSCATarget;
class ITSCAHit;
class ITSCASinglet;
class ITSCADoublet;
class ITSCATriplet;
class ITSCATrack;
class ITSCAHits;
class ITSCASinglets;
class ITSCADoublets;
class ITSCATriplets;
class ITSCATracks;
class ITSCAHitV;
class ITSCAHitsV;
class ITSCASingletV;
class ITSCASingletsV;
class ITSCADoubletV;
class ITSCADoubletsV;
class ITSCATripletV;
class ITSCATripletsV;

#include <cstdio>
#include <iostream>
#include <vector>
#include <string>
using std::string;
using std::vector;

class AliHLTTPCCAMerger;

class AliHLTTPCCAGBTracker
{
 public:
  AliHLTTPCCAGBTracker();
  ~AliHLTTPCCAGBTracker();
  void Init();

  void StartEvent();
  void SetNSlices( int N );
  void SetNHits( int nHits );

  const AliHLTTPCCAGBHit *Hits() const { return fHits.Data(); }
  const AliHLTTPCCAGBHit &Hit( int index ) const { return fHits[index]; }
  int NHits() const { return fNHits; }
  double Time() const { return fTime; }
  double StatTime( int iTimer ) const { return fStatTime[iTimer]; }
  int NTimers() const { return fNTimers; }
  int StatNEvents() const { return fStatNEvents; }
  int NTracks() const { return fNTracks; }
  AliHLTTPCCAGBTrack *Tracks() const { return fTracks; }
  AliHLTTPCCAGBTrack *Tracks() { return fTracks; }
  const AliHLTTPCCAGBTrack &Track( int i ) const { return fTracks[i]; }
  int *TrackHits() const { return fTrackHits; }
  int *TrackHits() { return fTrackHits; }
  int TrackHit( int i ) const { return fTrackHits[i]; }

  int NStations() const { return fParameters.NStations(); }
  
  const AliHLTTPCCAParam&  GetParameters() const { return fParameters; }

  void WriteSettings( std::ostream &out ) const;
  void ReadSettings( std::istream &in );
  void WriteEvent( FILE *out ) const;
  void ReadEvent( FILE *in );
  void WriteTracks( std::ostream &out ) const;
  void ReadTracks( std::istream &in );

  void SaveHitsInFile( string prefix ) const; // Save Hits in txt file. @prefix - prefix for file name. Ex: "./data/ev1"
  void SaveSettingsInFile( string prefix ) const; // Save geometry in txt file. @prefix - prefix for file name. Ex: "./data/"
  bool ReadHitsFromFile( std::ifstream &ifile );
  bool ReadSettingsFromFile( string prefix );

  double SliceTrackerTime() const { return fSliceTrackerTime; }
  double SliceTrackerCpuTime() const { return fSliceTrackerCpuTime; }

  void StoreToFile( const char *filename ) const;
  void RestoreFromFile( FILE *f );
    
  void SetHits( std::vector<AliHLTTPCCAGBHit> &hits );     // need for StRoot
  int  GetHitsSize() const {return fHits.Size();}

  void FindTracks();
  void IdealTrackFinder(); // for debug

  void FitTracks();
  sfloat_m FitTrack( AliHLTTPCCATrackParamVector &t, ushort_v &firstHits,
                     ushort_v::Memory &NTrackHits, int &nTracksV, sfloat_m active0, bool dir );

  void InitialTrackApproximation( AliHLTTPCCATrackParamVector &t, ushort_v &firstHits,
                                  ushort_v::Memory &NTrackHits, int &nTracksV, sfloat_m active0 );

  sfloat_m FitTrackCA( AliHLTTPCCATrackParamVector &t, ushort_v &firstHits,
                     ushort_v::Memory &NTrackHits, int &nTracksV, sfloat_m active0, bool dir );

  void CATrackFinder();
    // fuctions used by TrackFinder
  void CreateSinglets( const ITSCATarget& target, const ITSCAHitsV& hits, ITSCASingletsV& singlets );
  void CreateDoublets( const ITSCASingletsV& singlets, ITSCADoubletsV& doublets );
  void CreateTriplets( const ITSCADoubletsV& doublets, ITSCATripletsV& triplets );
  void FindNeighbours( ITSCATriplets& triplets );
  void CreateTracks( const ITSCATriplets& triplets, ITSCATracks& tracks );
  void Merge( ITSCATracks& tracks );
  
  ITSCAElementsOnStation<ITSCASingletV> Combine( const ITSCATarget& t, const ITSCAElementsOnStation<ITSCAHitV>& h);
  ITSCAElementsOnStation<ITSCADoubletV> Combine( const ITSCAElementsOnStation<ITSCASingletV>& a, const ITSCAElementsOnStation<ITSCASingletV>& b);
  ITSCAElementsOnStation<ITSCATripletV> Combine( const ITSCAElementsOnStation<ITSCADoubletV>& a, const ITSCAElementsOnStation<ITSCADoubletV>& b);
  void FindBestCandidate(int ista,
                         ITSCATrack &best_tr,
                         int currITrip,
                         ITSCATrack &curr_tr,
                         unsigned char min_best_l,
                         const ITSCATriplets& triplets);
  sfloat_m IsEqual( const AliHLTTPCCATrackParamVector& p, const ITSCAHit& h);
      
    // private
  
  enum { fNFindIterations = 1 };
  enum { kFastPrimIter,     // primary fast tracks
         kAllPrimIter,      // primary all tracks
         kAllPrimJumpIter,  // primary tracks with jumped triplets
         kAllSecIter       // secondary all tracks
  };
  int fFindIter; // current iteration number

  bool fFindGappedTracks; // = true -> construct triplets with skipped stations
  float fMaxInvMom;     // max considered q/p for tracks
  float fPick_m, // coefficient for size of region on middle station for add middle hits in triplets: Dx = Pick*sigma_x Dy = Pick*sigma_y
    fPick_r,  // same for right hits
    fPick; // pick for current procedure
  float fPickNeighbour; // (PickNeighbour < dp/dp_error)  =>  triplets are neighbours
  float TRACK_CHI2_CUT; // = 10.0;  // cut for tracks candidates. per one DoF
  float TRIPLET_CHI2_CUT; // = 5.0; // cut for selecting triplets before collecting tracks.per one DoF
  float fMaxDX0; // Set correction in order to take into account overlaping
  
      /// Try to group close hits in row formed by one track. After sort hits.
  friend class AliHLTTPCCAPerformance; //dbg
  protected:

    AliHLTResizableArray<AliHLTTPCCAGBHit> fHits;     //* hit array
    AliHLTResizableArray<ITSCAStrip> fFStrips;     //* front strips
    AliHLTResizableArray<ITSCAStrip> fBStrips;     //* back strips
  
    int fNHits;                //* N hits in event
    int *fTrackHits;           //* track->hits reference array
    AliHLTTPCCAGBTrack *fTracks; //* array of tracks
    int fNTracks;              //* N tracks

    double fTime; //* total time
    static const int fNTimers = 25;
    double fStatTime[fNTimers]; //* timers
    int fStatNEvents;    //* n events proceed

    double fSliceTrackerTime; // reco time of the slice tracker;
    double fSliceTrackerCpuTime; // reco time of the slice tracker;

    AliHLTTPCCAParam fParameters;
  
  private:
    AliHLTTPCCAGBTracker( const AliHLTTPCCAGBTracker& );
    AliHLTTPCCAGBTracker &operator=( const AliHLTTPCCAGBTracker& );

};

#endif