//-*- Mode: C++ -*-

//* This file is property of and copyright by the ALICE HLT Project        *
//* ALICE Experiment at CERN, All rights reserved.                         *
//* See cxx source for full Copyright notice                               *

#ifndef ALIHLTTPCCADEF_H
#define ALIHLTTPCCADEF_H


/**
 * Definitions needed for AliHLTTPCCATracker
 *
 */

#if defined(HLTCA_STANDALONE)
typedef unsigned char UChar_t;
typedef UChar_t Byte_t;
typedef int Int_t;
typedef double Double_t;
#else
#include "Rtypes.h"
#endif


#ifdef NDEBUG
#define ASSERT(v, msg)
#else
#define ASSERT(v, msg) \
if (v) {} else { \
  std::cerr << __FILE__ << ":" << __LINE__ << " assertion failed: " \
            << #v << " = " << (v) << "\n" << msg << std::endl; \
  abort(); \
}
#endif


struct float2 { float x; float y; };
/*
 * Helper for compile-time verification of correct API usage
 */
namespace
{
  template<bool> struct HLTTPCCA_STATIC_ASSERT_FAILURE;
  template<> struct HLTTPCCA_STATIC_ASSERT_FAILURE<true> {};
}

#define HLTTPCCA_STATIC_ASSERT_CONCAT_HELPER(a, b) a##b
#define HLTTPCCA_STATIC_ASSERT_CONCAT(a, b) HLTTPCCA_STATIC_ASSERT_CONCAT_HELPER(a, b)
#define STATIC_ASSERT(cond, msg) \
  typedef HLTTPCCA_STATIC_ASSERT_FAILURE<cond> HLTTPCCA_STATIC_ASSERT_CONCAT(_STATIC_ASSERTION_FAILED_##msg, __LINE__); \
  HLTTPCCA_STATIC_ASSERT_CONCAT(_STATIC_ASSERTION_FAILED_##msg, __LINE__) Error_##msg; \
  (void) Error_##msg

namespace
{
  template<typename T1>
  void UNUSED_PARAM1( const T1 & ) {}
  template<typename T1, typename T2>
  void UNUSED_PARAM2( const T1 &, const T2 & ) {}
  template<typename T1, typename T2, typename T3>
  void UNUSED_PARAM3( const T1 &, const T2 &, const T3 & ) {}
  template<typename T1, typename T2, typename T3, typename T4>
  void UNUSED_PARAM4( const T1 &, const T2 &, const T3 &, const T4 & ) {}
  template<typename T1, typename T2, typename T3, typename T4, typename T5>
  void UNUSED_PARAM5( const T1 &, const T2 &, const T3 &, const T4 &, const T5 & ) {}
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
  void UNUSED_PARAM6( const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 & ) {}
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
  void UNUSED_PARAM7( const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 & ) {}
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
  void UNUSED_PARAM8( const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 & ) {}
  template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
  void UNUSED_PARAM9( const T1 &, const T2 &, const T3 &, const T4 &, const T5 &, const T6 &, const T7 &, const T8 &, const T9 & ) {}
}

#define unrolled_loop4( _type_, _it_, _start_, _end_, _code_ ) \
if (_start_ +  0 < _end_) { enum { _it_ = (_start_ +  0) < _end_ ? (_start_ +  0) : _start_ }; _code_ } \
if (_start_ +  1 < _end_) { enum { _it_ = (_start_ +  1) < _end_ ? (_start_ +  1) : _start_ }; _code_ } \
if (_start_ +  2 < _end_) { enum { _it_ = (_start_ +  2) < _end_ ? (_start_ +  2) : _start_ }; _code_ } \
if (_start_ +  3 < _end_) { enum { _it_ = (_start_ +  3) < _end_ ? (_start_ +  3) : _start_ }; _code_ } \
do {} while ( false )

#ifdef __GNUC__
#define MAY_ALIAS __attribute__((__may_alias__))
#else
#define MAY_ALIAS
#endif

#if defined( __GNUC__ ) && __GNUC__ - 0 >= 3
# define ISLIKELY(  x )    __builtin_expect( !!( x ),1 )
# define ISUNLIKELY(  x )  __builtin_expect( !!( x ),0 )
#else
# define ISLIKELY(  x )   (  x )
# define ISUNLIKELY(  x )  (  x )
#endif

#include <arbb.hpp>
typedef arbb::i16 THitI_ArBB; // type of index of hit on row\sector
typedef arbb::u16 TRowI_ArBB; // type of index of row in sector // TODO u8
typedef arbb::i16 TRowI2_ArBB; // type of index of row in sector

  // additional to arbb functions, which should be usefull ingiven package

//namespace arbb{
//  using namespace arbb;

using arbb::array;
using arbb::dense;
using arbb::nested;
using arbb::usize;
using arbb::f32;
using arbb::i32;
//using arbb::boolean;
using arbb::indices;
using arbb::fill;





arbb::boolean finite_arbb(const f32 s);
ARBB_ELTWISE_FUNCTION_1( arbb::boolean, finite_arbb, f32 );

template <typename T> // TODO THitI_ArBB -> usize
dense<T, 1> gather(const dense<T, 1>& source, const dense<THitI_ArBB, 1>& index, const T& value, const dense<T, 1>& defaults, const dense<arbb::boolean, 1>& mask)
{
  const dense<T, 1> tmp = gather(source, index, value);
  return select(mask, tmp, defaults);
}


template <typename T>
dense<T, 1> scatter(const dense<T, 1>& source, const dense<THitI_ArBB, 1>& index, const dense<T, 1>& defaults, const dense<arbb::boolean, 1>& mask)
{
  const usize taskSize = defaults.length();
   
#if 0 // TODO - no bounds problem

  const dense<THitI_ArBB, 1> indexInBounds = select(mask, index, 0); // FIXME
  const dense<arbb::boolean, 1> scatteredMask   = scatter( mask,   indexInBounds, fill<arbb::boolean>(false, taskSize) );
  const dense<T, 1>       scatteredSource = scatter( source, indexInBounds, defaults );

  return select( scatteredMask, scatteredSource, defaults);
  
  // const dense<arbb::boolean, 1> scatteredMask   = scatter( mask,   index, fill<arbb::boolean>(false, taskSize) );
  // const dense<T, 1>       scatteredSource = scatter( source, index, defaults );

  // return select( scatteredMask, scatteredSource, defaults);
#else // bounds problem // FIXME
  
  const dense<THitI_ArBB, 1> indexInBounds = select( mask, index, fill<THitI_ArBB>(static_cast<THitI_ArBB>(taskSize), mask.length() ) ); 
  const dense<arbb::boolean, 1> scatteredMask_long   = scatter( mask,   indexInBounds, fill<arbb::boolean>(false, taskSize+1) );
  const dense<T, 1>       defaults_long = cat( defaults, fill<T>( 0, 1 ) );
  const dense<T, 1>       scatteredSource_long = scatter( source, indexInBounds, defaults_long );
  const dense<T, 1> result_long = select( scatteredMask_long, scatteredSource_long, defaults_long);
  
  return section( result_long, 0, taskSize );
#endif // problem
}


/// Returns a three-dimensional dense container with @p nrows rows,
/// where result[x,y,z] = sourse[x,z], y = 0 .. nrows-1 source.
template <typename T>
dense<T, 3>
repeat_row(const dense<T, 2>& source, const usize& nrows)
{
  const usize NCols = source.num_cols();
  const usize NRows = nrows;
  const usize NPages = source.num_rows();
  dense<T, 3> result = dense<T,3>( NCols, NRows, NPages );
  _for (usize i = 0, i < source.num_rows(), ++i) {
    const dense<T, 1> sourceRow  = source.row(i);
    const dense<T, 2> result_tmp = repeat_row(sourceRow, NRows);
    result = replace_page( result, i, result_tmp);
  } _end_for;
  
  return result;
}


/// Computes the minimum of @p source along @p level1 and @p level2, and stores the
/// locations of these minima in @p loc.
template <typename T>
dense<T, 1>
min_reduce_my(const dense<T, 3>& source, // TODO generalize
           dense<usize, 1>& loc1,
           dense<usize, 1>& loc2)
{
  const usize NCols = source.num_cols();
  dense<usize,2> bestIndicesAtPages;
  const dense<T,2> source_reduced1 = min_reduce(source, bestIndicesAtPages, 2);
  
  dense<usize> bestIndicesAtColumns;        
  const dense<T> source_reduced2 = min_reduce(source_reduced1, bestIndicesAtColumns, 1);

  const dense<array<usize, 2>, 1> bestIndicesAtColumns_ziped = bestIndicesAtColumns.zip( arbb::indices<usize>(0,NCols,1) );
  const dense<array<usize, 2>, 2> bestIndicesAtColumns_2D = repeat_row( bestIndicesAtColumns_ziped, 1 );
  
  dense<usize> bestIndices = gather( bestIndicesAtPages, bestIndicesAtColumns_2D, -1 ).row(0);

  loc1 = bestIndicesAtColumns;
  loc2 = bestIndices;
  return source_reduced2;
}


#define ARBB_PRINT( name, p ) {{{{                       \
    std::cout << name << value(p) << std::endl;    \
  }}}}

#define ARBB_PRINT_2( name, p, p2 ) {{{{                       \
    std::cout << name << value(p) << " " << value(p2) << std::endl; \
  }}}}


  /// print all entries in container
template< typename T>
void ARBB_PRINT_ALL( std::string name, const dense<T>& p ) {
  std::cout << name;                          
  _for ( usize i = 0, i < (p).length(), i++ ) { 
    std::cout << value((p)[i]) << " ";
  } _end_for;                                 
  std::cout << std::endl;                     
}

  /// print all entries in container with mask[i] = true
template< typename T>
void ARBB_PRINT_ALL( std::string name, const dense<T>& p, const dense<arbb::boolean>& m ) {
  _if ( any(m) ) { std::cout << name; } _end_if;
  
  _for ( usize i = 0, i < (p).length(), i++ ) { 
    _if( (m)[i] ) { std::cout << value((p)[i]) << " ";
    } _end_if;
  } _end_for;                                 
  _if ( any(m) ) { std::cout << std::endl;  } _end_if;                    
}

 /// print all indices - i such that mask[i] = true
void ARBB_PRINT_INDICES( std::string name, const dense<arbb::boolean>& m );



///   the class has to be like:
/// class className
/// {
///  public:
///   template< size_t D >
///   class TDense;
///   friend class TDense<1>;
///
///   someFunctions
///  private:
///   someTypes someDataMembers;
///
///   typedef someType TArtKey;
///   TArtKey ArtKey();
/// };
/// ARBB_ELTWISE_METHOD_0(someType, className, ArtKey);


// template <typename T>
// class nested_my: public nested<T> {
//   template <typename S, std::size_t N>
//   typename nested<S, 1> get() const {
    
//   };

//   template <std::size_t N, arbb_scalar_type_t S>
//   void set(const nested<scalar<S>, 1>& val) {
//   };
// }


#define ARBB_UDT_DENSE_HELPER_INTRO(className)                        \
  template <std::size_t dim>                                          \
  class className::TDense: public dense<className,dim>                \
  {                                                                   \
    public:                                                               \
    typedef dense<className,dim> TDenseBase;                              \
    TDense():TDenseBase(){};                                              \
    TDense(const TDenseBase& src):TDenseBase(src){};                      \
    TDense(const usize& length):TDenseBase(length){};                     \


#define ARBB_UDT_DENSE_HELPER_SORT_INTRO(className)                     \
  void Sort( arbb::sort_direction dir = arbb::sort_ascending ) {        \
    const dense<className::TArtKey,dim> artKey = className().ArtKey(*reinterpret_cast<TDenseBase*>(this)); \
    dense<usize> rank;                                                  \
    sort(artKey, rank, dir);                                            \


#define ARBB_UDT_DENSE_HELPER_SORT(type, n)                             \
  {                                                                     \
    const dense<type,dim> member = this->template get<type,n>();        \
    this->template set<n>( gather( member, rank ) );                    \
  }

#define ARBB_UDT_DENSE_HELPER_ACCESSORS(type, name, n)                  \
  dense<type,dim> name()                 const { return this->template get<type,n>(); }; \
  void Set##name ( const dense<type,dim>& source ) { this->template set<n>( source ); };    

#define ARBB_UDT_DENSE_1(className, type0, name0)       \
  ARBB_UDT_DENSE_HELPER_INTRO(className);               \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type0, name0, 0);     \
  ARBB_UDT_DENSE_HELPER_SORT_INTRO(className);          \
  ARBB_UDT_DENSE_HELPER_SORT(type0, 0)                  \
  };                                                    \
  };

#define ARBB_UDT_DENSE_2(className, type0, name0, type1, name1) \
  ARBB_UDT_DENSE_HELPER_INTRO(className);                       \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type0, name0, 0);             \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type1, name1, 1);             \
  ARBB_UDT_DENSE_HELPER_SORT_INTRO(className);                  \
  ARBB_UDT_DENSE_HELPER_SORT(type0, 0)                          \
  ARBB_UDT_DENSE_HELPER_SORT(type1, 1)                          \
  };                                                            \
  };

#define ARBB_UDT_DENSE_3(className, type0, name0, type1, name1, type2, name2) \
  ARBB_UDT_DENSE_HELPER_INTRO(className);                               \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type0, name0, 0);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type1, name1, 1);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type2, name2, 2);                     \
  ARBB_UDT_DENSE_HELPER_SORT_INTRO(className);                          \
  ARBB_UDT_DENSE_HELPER_SORT(type0, 0)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type1, 1)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type2, 2)                                  \
  };                                                                    \
  };  

#define ARBB_UDT_DENSE_4(className, type0, name0, type1, name1, type2, name2, type3, name3) \
  ARBB_UDT_DENSE_HELPER_INTRO(className);                               \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type0, name0, 0);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type1, name1, 1);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type2, name2, 2);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type3, name3, 3);                     \
  ARBB_UDT_DENSE_HELPER_SORT_INTRO(className);                          \
  ARBB_UDT_DENSE_HELPER_SORT(type0, 0)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type1, 1)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type2, 2)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type3, 3)                                  \
  };                                                                    \
  };
    

#define ARBB_UDT_DENSE_5(className, type0, name0, type1, name1, type2, name2, type3, name3, type4, name4) \
  ARBB_UDT_DENSE_HELPER_INTRO(className);                               \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type0, name0, 0);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type1, name1, 1);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type2, name2, 2);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type3, name3, 3);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type4, name4, 4);                     \
  ARBB_UDT_DENSE_HELPER_SORT_INTRO(className);                          \
  ARBB_UDT_DENSE_HELPER_SORT(type0, 0)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type1, 1)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type2, 2)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type3, 3)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type4, 4)                                  \
  };                                                                    \
  };  


#define ARBB_UDT_DENSE_6(className, type0, name0, type1, name1, type2, name2, type3, name3, type4, name4, type5, name5) \
  ARBB_UDT_DENSE_HELPER_INTRO(className);                               \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type0, name0, 0);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type1, name1, 1);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type2, name2, 2);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type3, name3, 3);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type4, name4, 4);                     \
  ARBB_UDT_DENSE_HELPER_ACCESSORS(type5, name5, 5);                     \
  ARBB_UDT_DENSE_HELPER_SORT_INTRO(className);                          \
  ARBB_UDT_DENSE_HELPER_SORT(type0, 0)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type1, 1)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type2, 2)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type3, 3)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type4, 4)                                  \
  ARBB_UDT_DENSE_HELPER_SORT(type5, 5)                                  \
  };                                                                    \
  };  

template< typename T >
class nested_my {
 public:
  nested_my():fData(),fLengths(),fStartIndices(){};

  /// Returns a flattened 1D dense container with the data from each
  /// segment in order.
  dense<T, 1> flatten() const{
    return fData;
  };
  
    /// Returns a dense container comprised of the lengths of the segments.
  dense<usize, 1> lengths() const {
    return fLengths;
  };
  
    /// Returns a copy of the segment at index @p i.
  dense<T,1> segment(const usize& index) const {
    dense<T> r;
    _if( fLengths[index] > 0 ) { // FIXME empty container
      r = section( fData, fStartIndices[index], fLengths[index] );
    } _end_if;
    return r;
  };


    // new functions
  nested_my( const dense<T>& data,  const dense<usize, 1>& lengths ):fData(data){
    fLengths = lengths;
    fStartIndices = add_scan( lengths );
  };

  void replace_segment( const usize& index, const dense<T, 1>& value ) {
    _if( value.length() == fLengths[index] ) { 
      fData = replace( fData, fStartIndices[index], fLengths[index], 1, value );
    } _else {
      std::cout << " replace_segment has invalid parameters " << std::endl;
    } _end_if;
  };

    // end new functions
  
 protected:
  dense<T> fData;
  dense<usize, 1> fLengths;
  dense<usize, 1> fStartIndices;
};


/// Returns a nested container with its elements drawn from @p data,
/// partitioned into segments with lengths are provided by @p lengths.
template <typename T>
nested_my<T> reshape_nested_lengths_my(const dense<T, 1>& data, const dense<usize, 1>& lengths){
  return nested_my<T>( data, lengths );
};

/// Returns a nested container with the same segments as @p src, but
/// the segment at index @p i replaced by @p value.
template <typename T>
nested_my<T> replace_segment(const nested_my<T>& src, const usize& i, const dense<T, 1>& value){
  nested_my<T> r = src;
  r.replace_segment(i,value);
  return r; 
};


/// Returns the concatenation of @p source1 followed by @p source2.
template <typename T> // FIXME empty container
dense<T, 1>
cat_my(const dense<T, 1>& source1, const dense<T, 1>& source2)
{
  dense<T, 1> result;
  _if( source1.length() > 0 ) {
    result = cat( source1, source2 );
  } _else {
    result = source2;
  } _end_if;
  return result;
}

#endif