// 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 "metasweep.hpp"
#include <vector>
#include <boost/array.hpp>
#include <string>
#include <iostream>

class print_experiment
{
 public:
  template<typename State>
  void operator()(const State& state)
  {
    using boost::mpl::int_;
    using boost::tuples::length;
    std::cout << "(";
    print(state, int_<0>(), int_<length<State>::value>());
    std::cout << ")\n";
  }

 private:
  template<typename State, int I, int N>
  void print(const State& state, boost::mpl::int_<I>, boost::mpl::int_<N> n)
  {
    using boost::tuples::get;
    using boost::mpl::int_;
    if (I > 0) std::cout << ", ";
    std::cout << get<I>(state);
    print(state, int_<I+1>(), n);
  }

  template<typename State, int N>
  void print(const State&, boost::mpl::int_<N>, boost::mpl::int_<N>)
  {
    // Done.
  }
};

struct print_last_param
{
  template<typename State>
  void operator()(State& state) const
  {
    using boost::tuples::length;
    using boost::tuples::get;
    const int len = length<State>::value;
    std::cout << get<len-1>(state);
  }
};

// Print out a table whose title is the parameter we're sweeping over.
struct table_task
{
  template<typename State>
  void setup(State& state)
  {
    std::cout << "<table title=\"";
    print_last_param()(state);
    std::cout << "\">\n";
  }

  template<typename State>
  void cleanup(State&)
  {
    std::cout << "</table>\n";
  }
};

// Print out a table row whose first element is a <th> containing the
// parameter we're sweeping over.
struct table_row_task
{
  template<typename State>
  void setup(State& state)
  {
    using boost::tuples::length;
    using boost::tuples::get;
    const int len = length<State>::value;
    std::cout << "  <tr>\n";
    std::cout << "    <th>";
    print_last_param()(state);
    std::cout << "</th>\n";
  }

  template<typename State>
  void cleanup(State&)
  {
    std::cout << "  </tr>\n";
  }
};

// Print out a table data cell with nothing in it.
struct table_data_task
{
  template<typename State>
  void setup(State& state)
  {
    std::cout << "    <td>";
  }

  template<typename State>
  void cleanup(State&)
  {
    std::cout << "</td>\n";
  }
};

int main()
{
  using boost::make_tuple;

  // Any kind of container that has begin() and end() member functions
  // returning iterators will work. We can hack up simple contains for
  // common cases, e.g., range(0, 100, 0.5), if we want them for
  // presentation purposes. Here, we demonstrate the use of arrays and
  // vectors.
  boost::array<int, 4> procs = { 1, 2, 17, 31 };
  std::vector<std::string> algorithms;
  algorithms.push_back("all_reduce");
  algorithms.push_back("all_gather");
  algorithms.push_back("broadcast");

  // Sweep the parameter space of procs X algorithms X [ -1, 3.14159,
  // "honk"] print_experiment just prints out the parameters passed
  // into it.
  sweep(make_tuple(procs, algorithms,
                   make_tuple(-1, 3.14159, std::string("honk!"))),
        print_experiment());

  // Use the same parameter sweep above, but bind tasks to parameters
  // so that we get output in a bunch of tables.
  sweep(make_tuple(procs, algorithms,
                   make_tuple(-1, 3.14159, std::string("honk!"))),
        empty_state().
          bind<1>(table_row_task()).
          bind<0>(table_task()).
          bind<2>(table_data_task()),
        print_last_param());

  return 0;
}