#ifndef _SYS_MQUEUE_H_INCLUDED_
#define _SYS_MQUEUE_H_INCLUDED_

namespace Engine
{
	namespace System
	{
		// MessageQueue Class
		// - Thread-safe message queue for inter-process communications.
		class MessageQueue
		{
		private:
			Data::Message* Buffer;
			const size_t BufferSize;

			volatile size_t ReadOffset;
			volatile size_t WriteOffset;

		public:
			MessageQueue(size_t = 512);
			~MessageQueue();

			bool PushMessage(const Data::Message&);
			bool PopMessage(Data::Message& Msg);
		};
	};
};

#endif // _SYS_MQUEUE_H_INCLUDED_

#include <assert.h>

#include <string>

#include "util_strconv.h"
#include "data_dator.h"
#include "data_msg.h"
#include "sys_mqueue.h"

/* BEGIN: CLASS MessageQueue IMPLEMENTATION */

// Default constructor.
// - size_t argument dictates size of message queue buffer.
Engine::System::MessageQueue::MessageQueue(size_t bs) : BufferSize(bs), ReadOffset(0), WriteOffset(1)
{
	// Allocate buffer where messages will be stored:
	Buffer = new Data::Message[BufferSize];

	// Check to make sure memory was allocated successfully:
	if(Buffer == 0)
	{
		assert(0 && "Failed to allocate memory for message queue.");
	};

	return;
};

// Default destructor.
Engine::System::MessageQueue::~MessageQueue()
{
	// Free buffer to keep from leaking memory.
	delete[] Buffer;

	return;
};

// PushMessage()
// - Adds message to Message Queue.
bool Engine::System::MessageQueue::PushMessage(const Engine::Data::Message& msg)
{
	if(WriteOffset == ReadOffset)
	{
		// Not enough room in queue to add message.
		return false;
	}
	else
	{
		if(WriteOffset == 0)
		{
			Buffer[BufferSize - 1] = msg;
		}
		else
		{
			Buffer[WriteOffset - 1] = msg;
		};

		++WriteOffset;

		if(WriteOffset == BufferSize)
		{
			WriteOffset = 0;
		};

		// Message successfully added.
		return true;
	};
};

// PopMessage()
// - Removes message from queue for processing.
bool Engine::System::MessageQueue::PopMessage(Engine::Data::Message& msg)
{
	if(ReadOffset == (WriteOffset - 1))
	{
		// No messages in queue.
		return false;
	}
	else if((WriteOffset == 0) && (ReadOffset == (BufferSize - 1)))
	{
		// No messages in queue.
		return false;
	}
	else
	{
		msg = Buffer[ReadOffset];

		++ReadOffset;
		if(ReadOffset == BufferSize)
		{
			// Read offset has reached the end of the queue.
			// Bring it back to start position.
			ReadOffset = 0;
		};

		return true;
	};
};

/* END: CLASS MessageQueue IMPLEMENTATION */

#include "command_matchers.h"
#include <boost/spirit.hpp>
#include "construct_new.h"
#include "at_startup.h"
#include <boost/spirit/phoenix/primitives.hpp>
#include <boost/spirit/phoenix/operators.hpp>
#include <boost/spirit/phoenix/functions.hpp>
#include <list>

using namespace command_parser;
using namespace phoenix;
using namespace boost::spirit;

namespace
{

	struct push_back_impl
    {
        template <typename Container, typename Item>
        struct result
        {
            typedef void type;
        };

        template <typename Container, typename Item>
        void operator()(Container& c, Item const& item) const
        {
            c.push_back(item);
        }
    };

	function<push_back_impl> const f_push_back = push_back_impl();

	struct sequential_creation_impl
	{
		template <typename LIST>
		struct result
		{
			typedef Matcher type;
		};

		template <typename LIST>
		Matcher operator()(LIST list) const
		{
			if (list.size() == 1) return list.front();
			return Matcher(new SequentialMatch(list.front(), (*this)(LIST( (++list.begin()), list.end() ))));
		}
	};

	function<sequential_creation_impl> const f_sequential_creation = sequential_creation_impl();

	template <typename T> 
	struct closure_1 : boost::spirit::closure<closure_1<T>, T>
	{
		member1 _result;
	};

	template <typename T, typename _2> 
	struct closure_2 : boost::spirit::closure<closure_2<T,_2>, T, _2>
	{
		member1 _result;
		member2 _second;
	};

	template <typename T, typename _2, typename _3> 
	struct closure_3 : boost::spirit::closure<closure_3<T,_2,_3>, T, _2, _3>
	{
		member1 _result;
		member2 _second;
		member3 _third;
	};

	rule<boost::spirit::scanner<>, closure_1<Matcher>::context_t> node;

	rule<boost::spirit::scanner<>, closure_2<Matcher, std::list<Matcher> >::context_t> sequential;
	rule<boost::spirit::scanner<>, closure_2<Matcher, Word>::context_t> keyword;
	rule<boost::spirit::scanner<>, closure_1<Matcher>::context_t> optional;
	rule<boost::spirit::scanner<>, closure_1<Matcher>::context_t> rest;
	rule<boost::spirit::scanner<>, closure_1<Matcher>::context_t> none;
	rule<boost::spirit::scanner<>, closure_3<Matcher,Matcher,Matcher>::context_t> pivot;
	rule<boost::spirit::scanner<>, closure_2<Matcher, Word>::context_t> capture;
	rule<boost::spirit::scanner<>, closure_2<Matcher, Word>::context_t> object;
	rule<boost::spirit::scanner<>, closure_1<Matcher>::context_t> word;

	rule<boost::spirit::scanner<>, closure_1<Word>::context_t> identifier;

	OPEN_AT_STARTUP(A)
	
	node = (
		sequential[node._result = arg1]
		| keyword[node._result = arg1]
		| optional[node._result = arg1]
		| rest[node._result = arg1]
		| none[node._result = arg1]
		| pivot[node._result = arg1]
		| capture[node._result = arg1]
		| object[node._result = arg1]
		| word[node._result = arg1]
	);

	identifier = (+boost::spirit::alnum_p)
		[identifier._result = construct_<Word>(arg1,arg2)];

#define CREATE_MATCHER(TYPE) construct_<Matcher>(construct_new_<TYPE>())
#define CREATE_MATCHER_1(TYPE,A) construct_<Matcher>(construct_new_<TYPE>(A))
#define CREATE_MATCHER_2(TYPE,A,B) construct_<Matcher>(construct_new_<TYPE>(A,B))
#define CREATE_MATCHER_3(TYPE,A,B,C) construct_<Matcher>(construct_new_<TYPE>(A,B,C))


	sequential = ( ch_p('(') >> node[f_push_back(sequential._second,arg1)] >> 
		*( ch_p(',') >> node[f_push_back(sequential._second,arg1)] ) >> ch_p(')') )
		[sequential._result = f_sequential_creation(sequential._second)];

	keyword = ( identifier[keyword._second = arg1] )
		[keyword._result = CREATE_MATCHER_1(KeywordMatch,keyword._second)];

	optional = ( ch_p('?') >> node[optional._result = arg1] )
		[optional._result = CREATE_MATCHER_1(OptionalMatch,optional._result)];

	rest = ( ch_p('+') )
		[rest._result = CREATE_MATCHER(RestMatch)];

	none = ( ch_p('$') )
		[none._result = CREATE_MATCHER(NoneMatch)];

	pivot = ( str_p("[") >> node[pivot._result = arg1] >> ',' >> node[pivot._second = arg1] >> ',' >>
		node[pivot._third = arg1] >> ']')
		[pivot._result = CREATE_MATCHER_3(PivotMatch,pivot._result,pivot._second,pivot._third)];

	capture = ( ch_p('[') >> node[capture._result = arg1] >> ch_p('>') >> identifier[capture._second = arg1] >> ch_p(']') )
		[capture._result = CREATE_MATCHER_2(CaptureMatch,capture._result,capture._second)];

	object = ( str_p(":[") >> identifier[object._second = arg1] >> ch_p(']') )
		[object._result = CREATE_MATCHER_1(ObjectMatch,object._second)];

	word = ( ch_p('.') )
		[word._result = CREATE_MATCHER(WordMatch)];

	CLOSE_AT_STARTUP(A)
}

bool command_parser::create_matcher(const std::string& def, Matcher& store)
{
	Matcher result;
	if( parse(def.c_str(), (node[ assign_a(result) ])).full )
	{
		store = result;
		return true;
	}
	return false;
}