#define TBB_DEPRECATED_LIMITER_NODE_CONSTRUCTOR 1
#define TBB_PREVIEW_FLOW_GRAPH_NODES 1

#include <iostream>
#include <ipps.h>
#include <tbb/flow_graph.h>
#include <tbb/global_control.h>
#include <tbb\tick_count.h>
#include <tbb/blocked_range.h>
#include <tbb/parallel_for.h>
#include <glog/logging.h>
#include <cstdlib>
#include <atomic>
#include "nbxDataBuffer.h"

using async_node_type = tbb::flow::async_node< double, double>;
using gateway_type = async_node_type::gateway_type;
using msg_t = nbxDataBuffer*;

/// <summary>
/// Input filter 
/// </summary>
class InputFilter
{
public:

	InputFilter(nbxDataBufferMetadata md) :
		next_buffer_index{ 0 },
		buffers_counter{ 0 },
		BUFFERS_CAPACITY(BUFFERS_CAPACITY_DEFAULT)
	{
		//reserve slots for buffers
		this->buffers.reserve(BUFFERS_CAPACITY);

		//add to buffer
		for (auto i = 0; i < this->BUFFERS_CAPACITY; i++)
		{
			//push to container
			this->buffers.emplace_back(std::make_unique<nbxDataBuffer>());
		}

		//allocate
		for (auto const& b : this->buffers)
		{
			//allocate
			b->ConfigureResultsBlock(md);
		}
	}

	///// <summary>
	///// Copy constructor.
	///// </summary>
	//InputFilter(const InputFilter&) :
	//	next_buffer_index{ 0 },
	//	buffers_counter{ 0 },
	//	BUFFERS_CAPACITY(BUFFERS_CAPACITY_DEFAULT)
	//{
	//}

	InputFilter(const InputFilter&) = delete;

	/// <summary>
	/// Disable assign operator
	/// </summary>
	InputFilter& operator = (const InputFilter&) = delete;

	/// <summary>
	/// Move constructor.
	/// </summary>
	/// <param name="other">Object to move.</param>
	/// <returns>Class instance.</returns>
	InputFilter(InputFilter&& other) noexcept :
		next_buffer_index{ 0 },
		buffers_counter{ 0 },
		BUFFERS_CAPACITY(BUFFERS_CAPACITY_DEFAULT)
	{
		//invoke move assignement
		*this = std::move(other);
	}

	/// <summary>
	/// Move assignement.
	/// </summary>
	/// <param name="other">Object to assign to.</param>
	/// <returns>Move object.</returns>
	InputFilter& operator = (InputFilter&& other) noexcept
	{
		//check for self assignement
		if (this != &other)
		{
			//move the buffer
			this->next_buffer_index = other.next_buffer_index;
			this->buffers_counter = other.buffers_counter;
			this->buffers = std::move(other.buffers);
		}

		//done
		return *this;
	}

	/// <summary>
	/// Destructor.
	/// </summary>
	~InputFilter() {};

	/// <summary>
	/// Call operator.
	/// </summary>
	/// <param name="fc">Flow graph control.</param>
	/// <returns>Generated message (data buffer).</returns>
	msg_t operator()(tbb::flow_control& fc) const
	{
		//get item from circular buffer
		auto b = this->buffers.at(this->next_buffer_index).get();

		//set ID
		b->SetID(this->buffers_counter);

		//check flag --> stop reading
		if (this->buffers_counter > 20)
		{
			//log
			LOG(INFO) << "Input completed.";

			//end
			fc.stop();
		}

		//setup next buffer
		this->next_buffer_index = (this->next_buffer_index + 1) % BUFFERS_CAPACITY;

		//info
		LOG(INFO) << "Input node: buffer ID: " << b->GetID();

		//increment
		this->buffers_counter += 1;

		//done
		return b;
	}

private:

	/// <summary>
	/// Buffers capacity. This value decides
	/// maximum number of threads when executing pipeline.
	/// </summary>
	int BUFFERS_CAPACITY;

	/// <summary>
	/// Buffers capacity default capacity
	/// </summary>
	static const int BUFFERS_CAPACITY_DEFAULT = 15;

	/// <summary>
	/// Circular buffer.
	/// </summary>
	std::vector<std::unique_ptr<nbxDataBuffer>> buffers;

	/// <summary>
	/// Index of the next buffer to read.
	/// </summary>
	mutable int next_buffer_index;

	/// <summary>
	/// Counter of data buffers.
	/// </summary>
	mutable int buffers_counter;
};


int build_and_run_GF_g0()
{
	//graph
	tbb::flow::graph g;

	//metadata
	nbxDataBufferMetadata md(10, 20, 1);

	//input filter
	auto input_filter = std::make_shared<InputFilter>(md);

	//InputFilter input_filter(md); // copy constructor works fine

	//source node
	tbb::flow::input_node<msg_t> input_node(g, std::cref(input_filter));

	//limiter
	tbb::flow::limiter_node< msg_t > limiter_node(g, 7);

	//start inpuy
	input_node.activate();

	//wait for completion
	g.wait_for_all();

	//done
	return 0;
}

int main(int argc, char* argv[])
{
	//run graph
	build_and_run_GF_g0();
}