#include <iostream>
#include <queue>

#include "concurrency/thread.h"

using std::cout;
using std::endl;
using std::queue;
using concurrency::condition;
using concurrency::mutex;
using concurrency::lock_guard;

class payload {
public:
	string from;
	int value;

	payload(const string& init_from, int init_value) :
		from(init_from),
		value(init_value)
	{ }
};

class a_producer {
private:
	string who;
	queue<payload>& q;
	mutex& m;
	size_t max_size;
	condition<lock_guard<mutex> >& not_empty;
	condition<lock_guard<mutex> >& not_full;
	int &i;
public:
	a_producer(
		const string& init_who,
		int& init_i,
		queue<payload>& init_q,
		size_t init_max_size,
		mutex& init_mutex,
		condition<lock_guard<mutex> >& init_not_empty,
		condition<lock_guard<mutex> >& init_not_full
	) : who(init_who),
		i(init_i),
		q(init_q),
		max_size(init_max_size),
		not_empty(init_not_empty),
		not_full(init_not_full),
		m(init_mutex)
	{ }
	void operator()() {
		while (i < 1000) {
			lock_guard<mutex> lock(m);
			while (q.size() >= max_size) {
				not_full.wait(lock);
			}
			q.push(payload(who, i++));
			not_empty.notify_one();
		}
	}
};

class a_consumer {
private:
	string who;
	queue<payload>& q;
	mutex& m;
	condition<lock_guard<mutex> >& not_empty;
	condition<lock_guard<mutex> >& not_full;
public:
	a_consumer(
		const string& init_who,
		queue<payload>& init_q,
		mutex& init_mutex,
		condition<lock_guard<mutex> >& init_not_empty,
		condition<lock_guard<mutex> >& init_not_full
	) : who(init_who),
		q(init_q),
		not_empty(init_not_empty),
		not_full(init_not_full),
		m(init_mutex)
	{ }
	void operator()() {
		for (;;) {
			lock_guard<mutex> lock(m);
			while (q.empty()) {
				not_empty.wait(lock);
			}
			payload data = q.front();
			if (data.value >= 999) {
				cout << "k thnx bie" << endl;
				break;
			}
			q.pop();
			not_full.notify_one();
			cout << who << " has an int: " << data.value <<
			  " (" << q.size() << ") from " << data.from << endl;
		}
	}
};

int main() {
	const size_t max_queue_size = 32;

	int i = 0;
	condition<lock_guard<mutex> > not_empty;
	condition<lock_guard<mutex> > not_full;
	mutex m;
	queue<payload> q;

	concurrency::thread_group consumers;
	concurrency::thread_group producers;

	consumers.create_thread(a_consumer("i", q, m, not_empty, not_full));
	consumers.create_thread(a_consumer("i2", q, m, not_empty, not_full));

	producers.create_thread(a_producer("me", i, q, max_queue_size, m, not_empty, not_full));
	producers.create_thread(a_producer("me2", i, q, max_queue_size, m, not_empty, not_full));

	producers.join_all();
	consumers.join_all();
	return 0;
}