#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/containers/map.hpp>

#include <sys/time.h>
#include <unistd.h>
#include <cstdio>
#include <string.h>

using namespace boost::interprocess;

// I'm lazy to invent The Proper Type for Routes Dictionary Keys
// timeval + pid would perfectly work and cheap to implement
struct RouteKey: timeval {
protected:
	bool init(const char* _id) {
		return (3 == sscanf(_id, "%lX.%lX.%X", &this->tv_sec, &this->tv_usec, &this->pid));
	}
public:
	pid_t pid;
	bool operator==(const RouteKey& _o) const {
		return (this->tv_sec == _o.tv_sec &&
				this->tv_usec == _o.tv_usec &&
				this->pid == _o.pid
				);
	}

	bool operator<(const RouteKey& _o) const {
		return (this->tv_sec < _o.tv_sec ||
				this->tv_usec < _o.tv_usec ||
				this->pid < _o.pid
				);
	}
	RouteKey(const char* _id) {
		if (!init(_id)) {
			throw std::invalid_argument("Invalid Route Key format");
		}
	}

	// no-throw variant of the construct-from-id
	RouteKey(bool& _success, const char* _id) throw () {
		_success = init(_id);
	}

	operator const std::string() const {
		char buf[40 + 1 + 40 + 1 + 40 + 1];
		sprintf(buf, "%lX.%lX.%X", this->tv_sec, this->tv_usec, this->pid);
		return std::string(buf);
	}
};

#define ROUTE_SEGMENT_NAME "TestSegment"
#define ROUTE_MAP_NAME "TestRoutes"
#define ROUTE_SEGMENT_SIZE 1024 * 1024 * 20

typedef std::pair<const RouteKey, int> RouteMapValue;
typedef allocator<RouteMapValue, managed_shared_memory::segment_manager> RouteMapValueAllocator;
typedef map<RouteKey, int, std::less<RouteKey>,  RouteMapValueAllocator> RouteMap;

void addItem(const char* _k)
{
	managed_shared_memory segment(open_only, ROUTE_SEGMENT_NAME);
	RouteMapValueAllocator alloc(segment.get_segment_manager());
	RouteMap *mymap = segment.find<RouteMap>(ROUTE_MAP_NAME).first;
	RouteKey k(_k);
	RouteMapValue v(k, 1);
	mymap->insert(v);
}

int findItem(const char* _k)
{
	managed_shared_memory segment(open_only, ROUTE_SEGMENT_NAME);
	RouteMapValueAllocator alloc(segment.get_segment_manager());
	RouteMap *mymap = segment.find<RouteMap>(ROUTE_MAP_NAME).first;
	RouteKey k(_k);
	RouteMap::const_iterator it = mymap->find(k);
	if (it == mymap->end()) {
		printf("element %s is NOT found\n", ((const std::string&)k).c_str());
		return 55;
	}
	printf("element %s is in the map\n", ((const std::string&)k).c_str());
	return 0;
}

void listItems()
{
	managed_shared_memory segment(open_only, ROUTE_SEGMENT_NAME);
	RouteMapValueAllocator alloc(segment.get_segment_manager());
	RouteMap *mymap = segment.find<RouteMap>(ROUTE_MAP_NAME).first;
	printf("RouteMap content (%zd element(s)):\n", mymap->size());
	for(RouteMap::const_iterator it = mymap->begin(); it != mymap->end(); ++it) {
		printf("   \"%s\"\n", ((const std::string&)it->first).c_str());
	}
	printf("end of RouteMap content\n");
}

void createSegment()
{
	managed_shared_memory segment(open_or_create, ROUTE_SEGMENT_NAME, ROUTE_SEGMENT_SIZE);
	RouteMapValueAllocator alloc(segment.get_segment_manager());
	RouteMap *mymap = segment.find_or_construct<RouteMap>(ROUTE_MAP_NAME)      //object name
	                                 (std::less<RouteKey>() //first  ctor parameter
	                                 ,alloc);     //second ctor parameter
}

int main(int argc, char* argv[])
{
	if (argc < 2) {
		fprintf(stderr, "Invalid usage\n");
		return 2;
	}
	if (0 == strcmp("create", argv[1])) {
		createSegment();
		return 0;
	} else if (0 == strcmp("add", argv[1])) {
		if (argc < 3) {
			fprintf(stderr, "insufficient parameters for add\n");
			return 3;
		}
		addItem(argv[2]);
		return 0;
	} else if (0 == strcmp("find", argv[1])) {
		if (argc < 3) {
			fprintf(stderr, "insufficient parameters for find\n");
			return 4;
		}
		return findItem(argv[2]);
	} if (0 == strcmp("list", argv[1])) {
		listItems();
		return 0;
	} else {
		fprintf(stderr, "unknown command\n");
		return 5;
	}
}