#include "stdafx.h"
#include <iostream>
#include <queue>
#include <set>
using namespace std;

template <typename QueryDistr, typename ProcessDistr>
class server
{
private:
	enum event_type {new_query, query_complete};
	struct event
	{
		double time;
		event_type type;
		bool operator<(const event &rhs){ return this->time < rhs.time; }
	};
	size_t buffer_size;
	QueryDistr qd;
	ProcessDistr pd;
	queue<pair<string, double>> buffer;
	bool srv_busy;
	double cur_time;
	set<event> events;
public:
	server(size_t BufferSize, QueryDistr A, ProcessDistr B) :
		buffer_size(BufferSize), qd(A), pd(B){};
	tuple<double, double, double> run_till(double max_time);
};

template <typename QueryDistr, typename ProcessDistr>
tuple<double, double, double> server<QueryDistr, ProcessDistr>::run_till(double max_time)
{
	cur_time = 0;
	srv_busy = false;
	events.insert({ qd(), new_query });

	size_t query_count = 0;
	double sum_buffer_size = 0;
	double sum_query_time = 0;
	size_t denied_query_count = 0;

	while (cur_time < max_time)
	{
		auto ev = *events.begin();
		events.erase(events.begin());
		switch (ev.type)
		{
		case new_query:
			events.insert({ ev.time+qd(), new_query });
			query_count++;
			if (buffer.size < buffer_size)
			{
				if (buffer.size() || srv_busy)
					buffer.push({ "", ev.time })
				else
				{
					events.insert({ ev.time + pd(), query_complete })
					srv_busy = true;
				}
			}
			else
			{
				denied_query_count++;
			}
			break;
		case query_complete:

			break;
		}
	}
}

int main()
{
	cout << "lol";
	return 0;
}