// @(#) $Id: AliHLTTPCCATrackletSelector.cxx,v 1.4 2010/08/09 17:51:15 mzyzak Exp $
// **************************************************************************
// This file is property of and copyright by the ALICE HLT Project          *
// ALICE Experiment at CERN, All rights reserved.                           *
//                                                                          *
// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
//                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
//                  for The ALICE HLT Project.                              *
//                                                                          *
// Developed by:   Igor Kulakov <I.Kulakov@gsi.de>                          *
//                 Maksym Zyzak <M.Zyzak@gsi.de>                            *
//                                                                          *
// Permission to use, copy, modify and distribute this software and its     *
// documentation strictly for non-commercial purposes is hereby granted     *
// without fee, provided that the above copyright notice appears in all     *
// copies and that both the copyright notice and this permission notice     *
// appear in the supporting documentation. The authors make no claims       *
// about the suitability of this software for any purpose. It is            *
// provided "as is" without express or implied warranty.                    *
//                                                                          *
//***************************************************************************

//#define USE_ARBB
//#define USE_CALL

#include "AliHLTTPCCATrackletSelector.h"
#include "AliHLTTPCCATrack.h"
#include "AliHLTTPCCATracker.h"
#include "AliHLTTPCCATrackParamVector.h"
#include "AliHLTTPCCATracklet.h"
#include "AliHLTTPCCAMath.h"
#include "AliHLTTPCCAParameters.h"
#include <stack>
#undef USE_TBB
#ifdef USE_TBB
#include <tbb/atomic.h>
#endif //USE_TBB

#ifndef NVALGRIND
#include <valgrind/memcheck.h>
#endif

#include "debug.h"

#ifdef USE_ARBB
#include <arbb.hpp>
using namespace arbb;
#endif // USE_ARBB

#ifdef DRAW3
#include "AliHLTTPCCADisplay.h"
#endif //DRAW

using std::endl;

dense<arbb::boolean> AliHLTTPCCATrackletSelector::TakeOwnHits( AliHLTTPCCARowHit::TDense<1>& row, const dense<THitI_ArBB>& hitIndices, const dense<arbb::boolean>& mask, const dense<u16>& weights )
{
  const usize taskSize = mask.length();
  
  const dense<u16> storedWeights = gather( row.Weight(), hitIndices, static_cast<u16>(0), fill<u16>( 0, taskSize ), mask );
  const dense<arbb::boolean> own = storedWeights == weights && mask;
  const dense<u16> takenMarker = fill<u16>(std::numeric_limits<u16>::max(), taskSize);
  row.SetWeight( scatter( takenMarker, hitIndices, row.Weight(), own ) );
  return own;
} // AliHLTTPCCATrackletSelector::TakeOwnHits()

void AliHLTTPCCATrackletSelector::run_ArBB( nested_my<AliHLTTPCCARowHit>& rowsData, const AliHLTTPCCATrackletVector_ArBB& trackletVector, AliHLTTPCCATrack_ArBB& tracks )
{

 
  const u16 taskSize = trackletVector.NHits().length();
  const dense<TRowI_ArBB> zero = fill<TRowI_ArBB>( 0, taskSize );

  const dense<TRowI_ArBB> tNHits = trackletVector.NHits();
  const dense<arbb::boolean> &valid = tNHits > 0;

  const dense<f32> kMaximumSharedPerHits = fill<f32>( 1 / AliHLTTPCCAParameters::MinimumHitsPerShared, taskSize );

  const dense<TRowI_ArBB> &firstRow = trackletVector.FirstRow();
  const dense<TRowI_ArBB> &lastRow  = trackletVector.LastRow();
  dense<TRowI_ArBB> tNHitsNew = zero;

    //const dense<u16> &weight = SliceData::CalculateHitWeight( tNHits, trackletVectorIndices );
  const dense<u16> weight = ( static_cast< dense<u16> >(tNHits) << 8 ) | ( indices<u16>(0, taskSize, 1) & 0 ); // TODO function


  tracks.Resize(taskSize);

    //const int nRows = fTracker.Param().NRows(); // number of rows (Tracker global)
    //  dense<u16> gap( zero ); // count how many rows are missing a hit // CHECKME gaps was not checked here
  dense<u16> nShared( zero );
  const TRowI_ArBB minRowIndex = min_reduce(firstRow);
  const TRowI_ArBB maxRowIndex = max_reduce(lastRow);
  _for ( TRowI_ArBB rowIndex = minRowIndex, rowIndex <= maxRowIndex, ++rowIndex ) {
    _if ( rowsData.lengths()[rowIndex] <= 0 ) { _continue; } _end_if;
    AliHLTTPCCARowHit::TDense<1> row =  rowsData.segment(rowIndex);
//    ++gap;
    const dense<THitI_ArBB> &hitIndexes = trackletVector.HitIndexAtRow( rowIndex ); // hit index for the current row
    const dense<arbb::boolean> validHits = valid && ( hitIndexes >= 0 );
    const dense<arbb::boolean> own = TakeOwnHits( row, hitIndexes, validHits, weight );
    rowsData = replace_segment( rowsData, rowIndex, row );
    const dense<arbb::boolean> sharedOK = nShared < static_cast< dense<u16> >( static_cast< dense<f32> >(tNHitsNew) * kMaximumSharedPerHits );
    const dense<arbb::boolean> outHit = validHits && ( own || sharedOK );

    _for ( u16 i = 0, i < taskSize, ++i ) { // TODO optimize
      _if ( outHit[i] ) { // TODO rid of if

        const dense<arbb::boolean> maskI = outHit && indices<u16>(0, taskSize, 1) == i;

        tracks.SetHitId( tracks.fNumberOfHits[i], fill(rowIndex,taskSize), hitIndexes, maskI );
        tracks.fNumberOfHits = select( maskI, tracks.fNumberOfHits + 1, tracks.fNumberOfHits );
          // } _else_if ( gap[i] > AliHLTTPCCAParameters::MaximumRowGap ) {
          //   _if ( tracks.fNumberOfHits[i] >= AliHLTTPCCAParameters::MinimumHitsForTrack ) {
          //     // tracks[i] = new Track;
          //     // fTracks[++numberOfTracks] = tracks[i];
          //   } _else {
          //     tracks.fNumberOfHits[i] = 0;
          //   } _end_if;
      } _end_if;
    } _end_for;
      //    gap = select( outHit, 0, gap );
    tNHitsNew = select( outHit, tNHitsNew + 1, tNHitsNew );
      //    tNHitsNew = select( gap > AliHLTTPCCAParameters::MaximumRowGap, 0, tNHitsNew );
    nShared = select( !own && outHit, nShared + 1, nShared );
  } _end_for; // rowIndex
  tracks.fParam = trackletVector.Param();
  
  dense<arbb::boolean> packMask = tracks.fNumberOfHits >= AliHLTTPCCAParameters::MinimumHitsForTrack;
  _if ( !any( packMask ) ) { // leave one element in the dense (otherwise arbb doesn't work)
    packMask[0] = true;
    tracks.fNumberOfHits[0] = 0;
  } _end_if;
  tracks.Pack( packMask );
} // run_ArBB


void AliHLTTPCCATrackletSelector::run()
{
  run_ArBB( fRows_ArBB, fTrackletVectors_ArBB, fTracks ); 
}