/*
 *  Author:
 *      Stjepan Rajko
 *      Arts, Media and Engineering Program
 *      Arizona State University
 *
 *  Copyright 2008 Arizona Board of Regents.
 *
 *  This file is part of the Arts, Media and Engineering Library Assortment (AMELiA).
 *
 *  AMELiA is free software: you can redistribute it
 *  and/or modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation, either version 3 of the License,
 *  or (at your option) any later version.
 *
 *  AMELiA is distributed in the hope that it will be
 *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with AMELiA.
 *  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once

#include <boost/fusion/include/accumulate.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/fusion/include/mpl.hpp>
#include <boost/fusion/include/transform.hpp>
#include <boost/fusion/include/zip.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/range/adaptor/transformed.hpp>
 
namespace ame { namespace utility {

namespace detail
{
    
    // accesses the specified index of a Sequence - used to transform a Range
    template<typename RangeRange, int Index, int Depth>
    struct access_index
    {
        typedef access_index<typename RangeRange::value_type, Index, Depth-1> next_access_index;
        
        typedef boost::range_detail::transform_range<next_access_index, const typename RangeRange::value_type> result_type;
        
        result_type operator()(const typename RangeRange::value_type &element) const
        {
            return element | boost::adaptors::transformed(
                    next_access_index());
        }
    };
    
    template<typename Range, int Index>
    struct access_index<Range, Index, 0>
    {
        typedef typename boost::fusion::result_of::at_c<const typename Range::value_type, Index>::type result_type;
        
        result_type operator()(const typename Range::value_type &element) const
        {
            return boost::fusion::at_c<Index>(element);
        }
    };
    
    template<typename Range, typename F, int Depth>
    struct for_each_element_and_slice
    {
        typedef void result_type;
        
        for_each_element_and_slice(const Range &range, const F &f)
            : range(range), f(f) {}
        
        // Pair is a 
        template<typename Pair>
        result_type operator()(const Pair &pair) const
        {
            namespace fusion=boost::fusion;
            namespace mpl = boost::mpl;
            
            f(fusion::at_c<1>(pair),
                range | boost::adaptors::transformed(
                    access_index<Range, mpl::at_c<Pair, 0>::type::value, Depth>()));
        }
        
        const Range &range;
        F f;
    };
}


template<int Depth, typename Sequence, typename Range, typename F>
void for_each_element_and_slice(Sequence &sequence, const Range &range, const F &f)
{
    namespace fusion=boost::fusion;
    namespace mpl=boost::mpl;

    typedef mpl::range_c<int, 0, mpl::size<Sequence>::value> indices_type;
    indices_type indices;
    typedef fusion::vector<indices_type &, Sequence &> zipped_sequence;

    fusion::for_each(
        fusion::zip_view<zipped_sequence>(zipped_sequence(indices, sequence)),
        detail::for_each_element_and_slice<Range, F, Depth>(range, f));
}

 
} }