//Purpose:
//  Prototype a stack of indexes for nested for loops.
//
#include <vector>
#include <array>
#include <iostream>
#include <iomanip>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/sequence/intrinsic/at_c.hpp>
#include <boost/fusion/algorithm/transformation/transform.hpp>
#include <boost/fusion/sequence/io.hpp>
#include <boost/utility/enable_if.hpp>

  template
  < unsigned TypeId
  >
struct type_u
{
    type_u(unsigned a_id=0)
      : my_id(a_id)
      {}
      unsigned
    my_id
      ;
};

  template
  < unsigned TypeId
  >
  std::ostream&
operator<<
  ( std::ostream&sout
  , type_u<TypeId>const&x
  )
  {
      sout<<"type_u<"<<TypeId<<">="<<x.my_id;
      return sout;
  }      

  template
  < typename Seq
  >
struct seq_index
{
        typedef
      typename Seq::value_type
    value_type
      ;
    seq_index( Seq const& a_seq)
      : my_seq(a_seq)
      , my_index(0)
      {}
      
      std::size_t
    index()const
      {
          return my_index;
      }
      std::size_t
    size()const
      {
          return my_seq.size();
      }
      bool
    empty()const
      {
        return my_index>=my_seq.size()-1;
      }
      value_type const&
    deref()const
      {
        return my_seq[my_index];
      }
      std::size_t
    operator++()
      {
         return ++my_index;
      }
      std::size_t
    reset()
      {
          my_index=0;
          return my_index;
      }
 private:
      Seq const&
    my_seq
      ;
      std::size_t
    my_index
      ;
};

struct deref_seq_index
{
      template
      < typename Seq
      >
      typename Seq::value_type const&
    operator()( seq_index<Seq>const&a_si)const
      {
          return a_si.deref();
      }
};

namespace boost
{
      template
      < typename Seq
      >
    struct result_of
      < deref_seq_index( seq_index<Seq>const&) 
      >
    {
            typedef
          typename Seq::value_type
        type
        ;
    };
}

using namespace boost;

  template
  < typename... Values
  >
struct outer_product_seqs
{
        typedef 
      fusion::vector
      < seq_index<std::vector<Values> >...
      >
    seq_indices_t
      ;
 private:      
      seq_indices_t
    my_seq_indices
      ;
      unsigned
    my_size
      ;
 public:      
        typedef 
      fusion::vector
      < Values...
      >
    deref_t
      ;
      deref_t
    deref()const
      {
          deref_seq_index dsi;
          return fusion::transform( my_seq_indices, dsi);
      }
    outer_product_seqs
      ( std::vector<Values>const&... seqs
      )
      : my_seq_indices( seqs...)
      , my_size(1)
      {
          std::vector<std::size_t> sizes{ seqs.size()...};
          unsigned const rank=sizes.size();
          std::cout<<"rank="<<rank<<"\n";
          for( unsigned i=0; i<rank; ++i)
            my_size*=sizes[i]; 
      }
      
      unsigned
    size()const
      {
          return my_size;
      }

      template
      < unsigned Depth
      >
      typename enable_if_c
      < 0==Depth
      , int
      >::type
    incr
      (
      )
      {
          //std::cout<<"0==Depth\n";
          return Depth-1;
      }

      template
      < unsigned Depth
      >
      typename enable_if_c
      < 0<Depth
      , int
      >::type
    incr
      (
      )
      {
              typedef
            typename fusion::result_of::at_c<seq_indices_t,Depth-1>::type
          result_t
            ;
            result_t&
          seq_index=fusion::at_c<Depth-1>(my_seq_indices);
        #if 0
          std::cout
            <<"0<Depth="<<Depth
            <<":size="<<seq_index.size()
            <<":index="<<seq_index.index()
            <<"\n";
        #endif
          if(seq_index.empty())
          {
              seq_index.reset();
              return incr<Depth-1>();
          }
          else
          {
              ++seq_index;
          }
          return Depth-1;
      }    
      int
    operator++()
      {
          return this->template incr<sizeof...(Values)>();
      }
};

int main()
{
      std::vector<type_u<0> > 
    d0
      { type_u<0>(0)
      , type_u<0>(1)
      , type_u<0>(2)
      }
      ;
      std::vector<type_u<1> > 
    d1
      { type_u<1>(0)
      , type_u<1>(1)
      }
      ;
      std::vector<type_u<2> > 
    d2
      { type_u<2>(0)
      , type_u<2>(1)
      , type_u<2>(2)
      }
      ;
      outer_product_seqs
      < type_u<0>
      , type_u<1>
      , type_u<2>
      >
    ops(d0,d1,d2);
    unsigned const n=ops.size();
    std::cout<<"ops.size()="<<n<<"\n";
    for(unsigned i=0; i<n; ++i,++ops)
    {
        std::cout<<":i="<<std::setw(3)<<i<<":";
        std::cout<<ops.deref()<<"\n";
    }
    return 0;
}