//-*- 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 ITSCATRACKS_H
#define ITSCATRACKS_H

#include "ITSCAHits.h"

class ITSCATrack {
 public:
  int NHits() const { return fIHits.size(); }
  
  vector<TES>& IHits(){ return fIHits; }
  const vector<TES>& IHits() const { return fIHits; }

  void AddHit( char iS, int iH ) { fIHits.push_back( TES(iS, iH) ); }
  void AddHit( const TES& iH )          { fIHits.push_back( iH ); }
 
  float&       Chi2()       { return fChi2; }
  const float& Chi2() const { return fChi2; }
  
  static bool Compare(const ITSCATrack *a, const ITSCATrack *b){
    return (a->fIHits.size() > b->fIHits.size()) ||
           ( (a->fIHits.size() == b->fIHits.size()) &&
             ( (a->fIHits[0].s <  b->fIHits[0].s) ||
               ( (a->fIHits[0].s == b->fIHits[0].s) && (a->fChi2 < b->fChi2)
               )
             )
           );
  }

  bool IsUsedHits(const ITSCAHits& hits) const {
    int nused = 0;
    for ( unsigned int iH = 0; iH < fIHits.size(); ++iH ) {
      const ITSCAHit &h = hits[fIHits[iH]];
      if ( h.IsUsed() ) nused++;
    }
    return nused > 0; // don't allow tracks have shared hits. Track will be shorter, leave it for the next iteration
  }

  void SetHitsAsUsed(ITSCAHits& hits) const {
    for ( unsigned int iH = 0; iH < fIHits.size(); ++iH ) {
      ITSCAHit &h = hits[fIHits[iH]];
      h.SetAsUsed();
    }
  }
  
 private:
  float fChi2;
  vector<TES> fIHits; // index in ITSCATracks::fHits array
};

// typedef vector<ITSCATrack> ITSCATracks;

class ITSCATracks;

class ITSCATracks: public vector<ITSCATrack> {
 public:
  ITSCATracks( ITSCAHits* hits ):fHitsRef(hits){};

  const ITSCAHit& Hit( int iH, int iT ) const { return (*fHitsRef)[ (*this)[iT].IHits()[iH] ]; }

    // selects tracks and marks all hits as used
  void SelectAndSaveTracks(ITSCATracks& tracks);

  ITSCAHits* HitsRef() { return fHitsRef; }
 private:
  ITSCAHits* fHitsRef;
};


inline void ITSCATracks::SelectAndSaveTracks(ITSCATracks& tracks)
{
  vector<ITSCATrack*> vptrackcandidate;  // vptrackcandidate - array of pointers to vtrackcandidate
  vptrackcandidate.resize(size());

  for ( unsigned int iC = 0; iC < size(); ++iC ) {
    vptrackcandidate[iC] = &((*this)[iC]);
  }
      
  sort(vptrackcandidate.begin(), vptrackcandidate.end(), ITSCATrack::Compare);

  for (vector<ITSCATrack*>::iterator   trIt = vptrackcandidate.begin();
       trIt != vptrackcandidate.end(); ++trIt){
    ITSCATrack *tr = *trIt;
        
    if( tr->IsUsedHits(*fHitsRef) ) continue;
      
    tr->SetHitsAsUsed(*fHitsRef);

    tracks.push_back(*tr);
  } // i_trackCandidate
}



#endif