#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 int_producer {
private:
	queue<int>& q;
	mutex& m;
	size_t max_size;
	condition<lock_guard<mutex> >& not_empty;
	condition<lock_guard<mutex> >& not_full;
	int i;
public:
	int_producer(
		queue<int>& init_q,
		size_t init_max_size,
		mutex& init_mutex,
		condition<lock_guard<mutex> >& init_not_empty,
		condition<lock_guard<mutex> >& init_not_full
	) : q(init_q),
		max_size(init_max_size),
		not_empty(init_not_empty),
		not_full(init_not_full),
		m(init_mutex),
		i(0)
	{ }
	void operator()() {
		while (i < 1000) {
			lock_guard<mutex> lock(m);
			while (q.size() >= max_size) {
				not_full.wait(lock);
			}
			q.push(i++);
			not_empty.notify_one();
		}
	}
};

class int_consumer {
private:
	string who;
	queue<int>& q;
	mutex& m;
	condition<lock_guard<mutex> >& not_empty;
	condition<lock_guard<mutex> >& not_full;
public:
	int_consumer(
		const string& init_who,
		queue<int>& 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);
			}
			int value = q.front();
			if (value >= 999) {
				cout << "k thnx bie" << endl;
				break;
			}
			q.pop();
			not_full.notify_one();
			cout << who << " has an int: " << value << " (" << q.size() << ") " << endl;
		}
	}
};

int main() {
	const size_t max_queue_size = 32;

	condition<lock_guard<mutex> > not_empty;
	condition<lock_guard<mutex> > not_full;
	mutex m;
	queue<int> q;

	concurrency::thread_group consumers;

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

	concurrency::thread t1(int_producer(q, max_queue_size, m, not_empty, not_full));

	t1.join();
	consumers.join_all();
	return 0;
}