#include "Connection.hpp"
#include "Signal.hpp"
#include "boost/signal.hpp"
#include "boost/bind.hpp"
#include <vector>
#include <sys/time.h>
#include <cstdio>
#include <iostream>


struct X
{
  X(int x = 0) : x_(x) { }
  int x_;
};


void foo(X & x)
{
  x.x_ += 1234;
}

void blarg(X & x)
{
  x.x_ /= 71;
}

struct bar
{
  void operator()(X & x) { x.x_ *= 7; }
};

struct foobar
{
  void doit(X & x) { x.x_ += 7; }
};

struct timing
{
  size_t nslots_;
  size_t ncalls_;
  timeval start1_;
  timeval stop1_;
  timeval start2_;
  timeval stop2_;
};


timeval
operator-(
    timeval const & x,
    timeval const & y)
{
  timeval result;
  timersub(&x, &y, &result);
  return result;
}

double
as_double(
    timeval const & x)
{
  double result = x.tv_usec;
  result /= 1000000;
  result += x.tv_sec;
  return result;
}

int
main(
    int argc,
    char * argv[])
{
  try
  {
    std::vector<timing> timings;
    size_t num_slots[] =
    { 1, 10, 50, 100, 250, 500, 1000, 5000, 10000, 50000, 100000,
      500000, 0 };
    typedef lite::signals::Signal<void (X &)> Signal1;
    Signal1 signal1;
    typedef boost::signal<void (X &)> Signal2;
    Signal2 signal2;
    size_t totcalls[] = { 1000, 10000, 100000, 1000000, 0 };
    for (size_t * tc = totcalls; *tc > 0; ++tc)
    {
      size_t total_calls = *tc;
      for (size_t * ns = num_slots; *ns > 0 && *ns <= total_calls; ++ns)
      {
        size_t nslots = *ns;
        size_t niters = total_calls / nslots;

        signal1.disconnect_all_slots();
        signal1.connect(bar());
        foobar foobar1;
        signal1.connect(boost::bind(&foobar::doit, &foobar1, _1));

        signal2.disconnect_all_slots();
        signal2.connect(bar());
        foobar foobar2;
        signal2.connect(boost::bind(&foobar::doit, &foobar2, _1));

        std::vector<foobar> slots(nslots);
        for (size_t i = 0; i < slots.size(); ++i)
        {
          signal1.connect(boost::bind(&foobar::doit, &slots[i], _1));
          signal2.connect(boost::bind(&foobar::doit, &slots[i], _1));
        }

        X my_x(5);
        timing t;
        t.nslots_ = nslots;
        t.ncalls_ = niters;
        gettimeofday(&t.start1_, 0);
        for (size_t i = 0; i < niters; ++i)
        {
          signal1(my_x);
        }
        gettimeofday(&t.stop1_, 0);

        X bs_x(5);
        gettimeofday(&t.start2_, 0);
        for (size_t i = 0; i < niters; ++i)
        {
          signal2(bs_x);
        }
        gettimeofday(&t.stop2_, 0);

        timings.push_back(t);

        if (my_x.x_ != bs_x.x_)
        {
          std::cerr << "my_x(" << my_x.x_ << ") != bs_x("
              << bs_x.x_ << ")\n";
        }
      }
    }
    size_t last_size = (size_t)-1;
    for (size_t i = 0; i < timings.size(); ++i)
    {
      if (last_size != timings[i].nslots_ * timings[i].ncalls_)
      {
        last_size = timings[i].nslots_ * timings[i].ncalls_;
        fprintf(stdout, "\n===== %u Total Calls =====\n", last_size);
        fprintf(stdout, "Num Slots    Calls/Slot    Boost     Lite\n");
        fprintf(stdout, "---------    ----------    -------   -------\n");
      }
      fprintf(stdout, "%9u%14u%11.4f%10.4f\n",
          timings[i].nslots_,
          timings[i].ncalls_,
          as_double(timings[i].stop2_ - timings[i].start2_),
          as_double(timings[i].stop1_ - timings[i].start1_));
    }
    return 0;
  }
  catch (std::exception const & ex)
  {
    std::cerr << "exception: " << ex.what() << std::endl;
  }
  return 1;
}