#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <iomanip>
#include <giomm.h>
#include <algorithm>
#include <iterator>

#include <time.h>
#include <sys/time.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>

#include <saftlib/SAFTd.h>
#include <saftlib/iSAFTd.h>
#include <saftlib/TimingReceiver.h>
#include <saftlib/SoftwareActionSink.h>
#include <saftlib/SoftwareCondition.h>
#include <saftlib/iDevice.h>
#include <saftlib/iOwned.h>

#include <ctime>

struct timespec start, stop;
Glib::RefPtr<Glib::MainLoop> loop;
bool measuring;
int measurement_counter = 0;
Glib::RefPtr<saftlib::TimingReceiver_Proxy> receiver;

std::vector<int> histogram(3000);


void on_action(const long unsigned int&, const long unsigned int&, const long unsigned int&, const long unsigned int&, const short unsigned int&)
{
	++measurement_counter;
	measuring = false;
	clock_gettime( CLOCK_REALTIME, &stop);
	double time_diff = ( stop.tv_sec - start.tv_sec )*1000000.
	 				+ ( stop.tv_nsec - start.tv_nsec )/1000.;
	//std::cerr << time_diff/2 << " us" << std::endl;

	int bin = time_diff/2;
	if (bin >= 0 && bin < histogram.size())
	{
		++histogram[bin];
	}
}

bool on_idle()
{
	uint64_t eventID    = UINT64_C(0xffff000000000000);
	uint64_t snoopMask  = UINT64_C(0xffffffffffffffff);
	uint64_t eventParam = UINT64_C(0x0);
	uint64_t eventTime  = UINT64_C(0x0);

	if (measuring == false)
	{
		measuring = true;
		clock_gettime( CLOCK_REALTIME, &start);
		receiver->InjectEvent(eventID, eventParam, eventTime);
	}

	if (measurement_counter<50000) 
	{
		return true; // return true to continue, false when done
	}

	loop->quit();
	return false;
}

int main()
{

	try
	{
		// initialize required stuff
		Gio::init();
		Glib::RefPtr<saftlib::SAFTd_Proxy> saftd = saftlib::SAFTd_Proxy::create();

		// get a specific device
		std::map<Glib::ustring, Glib::ustring> devices = saftlib::SAFTd_Proxy::create()->getDevices();
		receiver = saftlib::TimingReceiver_Proxy::create(devices.begin()->second);

		// create software action sink
		Glib::RefPtr<saftlib::SoftwareActionSink_Proxy> sink = saftlib::SoftwareActionSink_Proxy::create(receiver->NewSoftwareActionSink(""));

		// setup io-condition
		uint64_t eventID    = UINT64_C(0xffff000000000000);
		uint64_t snoopMask  = UINT64_C(0xffffffffffffffff);
		uint64_t eventParam = UINT64_C(0x0);
		uint64_t eventTime  = UINT64_C(0x0);

		Glib::RefPtr<saftlib::SoftwareCondition_Proxy> condition = saftlib::SoftwareCondition_Proxy::create(sink->NewCondition(false, eventID, snoopMask, 0));
		condition->Action.connect(sigc::ptr_fun(&on_action));
		// Accept all errors
		condition->setAcceptLate(true);
		condition->setAcceptEarly(true);
		condition->setAcceptConflict(true);
		condition->setAcceptDelayed(true);
		condition->setActive(true);
		loop = Glib::MainLoop::create();
		Glib::signal_idle().connect( sigc::ptr_fun(on_idle));
		loop->run();


		// output histogram;
		std::ofstream hist("histogram.dat");
		std::copy(histogram.begin(), histogram.end(), std::ostream_iterator<int>(hist,"\n"));

	}
	catch (const Glib::Error& error) 
	{
		std::cerr << "Failed to invoke method: " << error.what() << std::endl;
	}

	return 0;
}