// Copyright 2006 The Trustees of Indiana University.

// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See copy at http://www.boost.org/LICENSE_1_0.txt)

//  Authors: Douglas Gregor
//           Andrew Lumsdaine

#include <boost/tuple/tuple.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/identity.hpp>
#include <iterator>
#include <boost/utility/enable_if.hpp>

using boost::mpl::int_;

// Begin iterator of a sequence
template<typename Seq>
inline typename Seq::const_iterator
begin(const Seq& seq) { return seq.begin(); }

// End iterator of a sequence
template<typename Seq>
inline typename Seq::const_iterator
end(const Seq& seq) { return seq.end(); }

// Stores state associated with the Ith parameter in a parameter
// sweep.
template<typename State, int I, typename Value>
struct bound_state : public State
{
  bound_state(const State& state, const Value& value)
    : State(state), value(value) { }

  Value value;
};

// Stores a task htat has bound to a particular parameter.
template<typename State, int I, typename Task>
struct bound_task : public State
{
  typedef bound_task self_type;

  bound_task(const State& state, const Task& task)
    : State(state), task(task) { }

  template<int J, typename NewTask>
  inline bound_task<self_type, J, NewTask>
  bind(const NewTask& task)
  {
    return bound_task<self_type, J, NewTask>(*this, task);
  }

  Task task;
};

// Empty state
struct empty_state
{
  template<int I, typename Task>
  inline bound_task<empty_state, I, Task>
  bind(const Task& task)
  {
    return bound_task<empty_state, I, Task>(*this, task);
  }
};

// Iteration through a tuple
template<typename Tuple, int I>
struct tuple_iterator
{
  BOOST_STATIC_CONSTANT(int, length = boost::tuples::length<Tuple>::value);

  typedef typename boost::mpl::if_c<(I < length),
                                    boost::tuples::element<I, Tuple>,
                                    boost::mpl::identity<void> >::type::type
    type;

  explicit tuple_iterator(const Tuple& tuple) : tuple(tuple) { }

  type operator*() const
  {
    using boost::tuples::get;
    return get<I>(tuple);
  }

  tuple_iterator<Tuple, I+1> next() const
  {
    return tuple_iterator<Tuple, I+1>(tuple);
  }

  const Tuple& tuple;
};

template<typename T1>
inline tuple_iterator<boost::tuples::tuple<T1>, 0>
begin(const boost::tuples::tuple<T1>& t)
{ return tuple_iterator<boost::tuples::tuple<T1>, 0>(t); }

template<typename T1>
inline tuple_iterator<boost::tuples::tuple<T1>, 1>
end(const boost::tuples::tuple<T1>& t)
{ return tuple_iterator<boost::tuples::tuple<T1>, 1>(t); }

template<typename T1, typename T2>
inline tuple_iterator<boost::tuples::tuple<T1, T2>, 0>
begin(const boost::tuples::tuple<T1, T2>& t)
{ return tuple_iterator<boost::tuples::tuple<T1, T2>, 0>(t); }

template<typename T1, typename T2>
inline tuple_iterator<boost::tuples::tuple<T1, T2>, 2>
end(const boost::tuples::tuple<T1, T2>& t)
{ return tuple_iterator<boost::tuples::tuple<T1, T2>, 2>(t); }

template<typename T1, typename T2, typename T3>
inline tuple_iterator<boost::tuples::tuple<T1, T2, T3>, 0>
begin(const boost::tuples::tuple<T1, T2, T3>& t)
{ return tuple_iterator<boost::tuples::tuple<T1, T2, T3>, 0>(t); }

template<typename T1, typename T2, typename T3>
inline tuple_iterator<boost::tuples::tuple<T1, T2, T3>, 3>
end(const boost::tuples::tuple<T1, T2, T3>& t)
{ return tuple_iterator<boost::tuples::tuple<T1, T2, T3>, 3>(t); }

// Give bound_state a tuple-like interface.
namespace boost { namespace tuples {

  template<int I, typename State, typename Value>
  inline const Value& get(const bound_state<State, I, Value>& state)
  {
   return state.value;
  }

  template<typename State, int I, typename Value>
  struct length<bound_state<State, I, Value> >
  {
    BOOST_STATIC_CONSTANT(int, value = (I + 1));
  };

} }

namespace detail {
  // If there is task bound to the Ith parameter, execute its setup
  // member.
   template<int I, typename RestOfState, typename Task, typename State>
   inline void do_setup(bound_task<RestOfState, I, Task>& task, State& state)
   {
     task.task.setup(state);
   }

   template<int I, typename State>
   inline void do_setup(empty_state&, State) { }

  // If there is task bound to the Ith parameter, execute its cleanup
  // member.
   template<int I, typename RestOfState, typename Task, typename State>
   inline void do_cleanup(bound_task<RestOfState, I, Task>& task, State& state)
   {
     task.task.cleanup(state);
   }

   template<int I, typename State>
   inline void do_cleanup(empty_state&, State) { }


  // Append a value of type Value as the Ith parameter in a parameter
  // sweep. This metafunction produces the return type of
  // append_state().
  template<typename State, int I, typename Value>
  struct append_state_t
  {
    typedef bound_state<State, I, Value> type;
  };

  // Append a value of type Value as the Ith parameter in a parameter
  // sweep and produce a new state containing that value.
  template<typename State, int I, typename Value>
  inline typename append_state_t<State, I, Value>::type
  append_state(const State& state, int_<I>, const Value& value)
  {
    return typename append_state_t<State, I, Value>::type(state, value);
  }

  // Forward declaration needed because sweep_impl is mutually
  // recursive with the sweep_*_param functions.
  template<typename Tuple, typename Experiment, typename State, int I>
  inline
  typename boost::enable_if_c<(I < boost::tuples::length<Tuple>::value)>::type
  sweep_impl(const Tuple& params, Experiment& experiment, State& state,
             int_<I> i);

  template<typename Tuple, typename Experiment, typename State, int I>
  inline
  typename boost::enable_if_c<(I == boost::tuples::length<Tuple>::value)>::type
  sweep_impl(const Tuple&, Experiment& experiment, State& state,
             int_<I>);

  // Iterate over all of the values of the (homogeneous) container of
  // parameters.
  template<typename ForwardIterator, typename Tuple, typename Experiment,
           typename State, int I>
  inline void
  sweep_container_param(ForwardIterator first, ForwardIterator last,
                        const Tuple& params, Experiment& experiment,
                        State& state, int_<I> i)
  {
    typedef typename std::iterator_traits<ForwardIterator>::value_type
      value_type;
    while (first != last) {
      typename append_state_t<State, I, value_type>::type
        new_state = detail::append_state(state, i, *first);

      do_setup<I>(new_state, new_state);
      detail::sweep_impl(params, experiment, new_state, int_<I+1>());
      do_cleanup<I>(new_state, new_state);
      ++first;
    }
  }

  // Termination condition for sweep of heterogenerous parameters.
  template<typename Iterator, typename Tuple,
           typename Experiment, typename State, int I>
  inline void
  sweep_hetero_param(Iterator, Iterator,
                     const Tuple& params, Experiment& experiment,
                     State& state, int_<I> i)
  {
  }

  // Iterate over all of the values of heterogeneous parameters.
  template<typename FIterator, typename LIterator, typename Tuple,
           typename Experiment, typename State, int I>
  inline void
  sweep_hetero_param(FIterator first, LIterator last,
                     const Tuple& params, Experiment& experiment,
                     State& state, int_<I> i)
  {
    typedef typename FIterator::type value_type;

    typename append_state_t<State, I, value_type>::type
      new_state = detail::append_state(state, i, *first);

    do_setup<I>(new_state, new_state);
    detail::sweep_impl(params, experiment, new_state, int_<I+1>());
    do_cleanup<I>(new_state, new_state);

    sweep_hetero_param(first.next(), last, params, experiment, state, i);
  }

  // Iterate over all of the values of the (heterogeneous) container of
  // parameters.
  template<typename FIterator, typename LIterator, typename Tuple,
           typename Experiment, typename State, int I>
  inline void
  sweep_container_param(FIterator first, LIterator last,
                        const Tuple& params, Experiment& experiment,
                        State& state, int_<I> i)
  {
    sweep_hetero_param(first, last, params, experiment, state, i);
  }


  // Sweep over the given parameter, expanding the nested loop. This
  // default implementation assumes that the parameters are actually a
  // collection and that we can get begin/end iterators.
  template<typename Param, typename Tuple, typename Experiment, typename State,
           int I>
  inline void
  sweep_param(const Param& param, const Tuple& params, Experiment& experiment,
              State& state, int_<I> i)
  {
    sweep_container_param(begin(param), end(param), params, experiment,
                          state, i);
  }

  // The body of the inner loop in a parameter sweep. We need only
  // invoke the experiment with the given state.
  template<typename Tuple, typename Experiment, typename State, int I>
  inline
  typename boost::enable_if_c<(I == boost::tuples::length<Tuple>::value)>::type
  sweep_impl(const Tuple&, Experiment& experiment, State& state,
             int_<I>)
  {
    experiment(state);
  }

  // One loop within the loop nest. This expands to a nested loop from
  // the Ith parameter inward.
  template<typename Tuple, typename Experiment, typename State, int I>
  inline
  typename boost::enable_if_c<(I < boost::tuples::length<Tuple>::value)>::type
  sweep_impl(const Tuple& params, Experiment& experiment, State& state,
             int_<I> i)
  {
    using boost::tuples::get;
    sweep_param(get<I>(params), params, experiment, state, i);
  }
}

template<typename Tuple, typename State, typename Experiment>
inline void
sweep(const Tuple& params, const State& state, Experiment experiment)
{
  // Yes, const_cast is evil, but more evil is the fact that we can't
  // bind a temporary to a reference when we need to :)
  detail::sweep_impl(params, experiment, const_cast<State&>(state), int_<0>());
}

template<typename Tuple, typename Experiment>
inline void sweep(const Tuple& params, Experiment experiment)
{
  empty_state state;
  sweep(params, state, experiment);
}