/*******************************************************************************
 * povmscpp.h
 *
 * This module contains all defines, typedefs, and prototypes for the
 * C++ interface version of povms.cpp.
 *
 * ---------------------------------------------------------------------------
 * Persistence of Vision Ray Tracer ('POV-Ray') version 3.7.
 * Copyright 1991-2013 Persistence of Vision Raytracer Pty. Ltd.
 *
 * POV-Ray is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * POV-Ray is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * ---------------------------------------------------------------------------
 * POV-Ray is based on the popular DKB raytracer version 2.12.
 * DKBTrace was originally written by David K. Buck.
 * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
 * ---------------------------------------------------------------------------
 * $File: //depot/public/povray/3.x/source/base/povmscpp.h $
 * $Revision: #1 $
 * $Change: 6069 $
 * $DateTime: 2013/11/06 11:59:40 $
 * $Author: chrisc $
 *******************************************************************************/

#ifndef POVMSCPP_H
#define POVMSCPP_H

#include "base/povms.h"
#include "base/pov_err.h"

#include <string>
#include <vector>

class POVMS_Container;
class POVMS_Attribute;
class POVMS_List;
class POVMS_Object;
class POVMS_Message;
class POVMS_MessageReceiver;

typedef std::basic_string<POVMSUCS2> POVMSUCS2String;

POVMSUCS2String POVMS_ASCIItoUCS2String(const char *s);
std::string POVMS_UCS2toASCIIString(const POVMSUCS2String& s);

class POVMS_Container
{
		friend void POVMS_SendMessage(POVMS_Message&);
		friend void POVMS_SendMessage(POVMSContext, POVMS_Message&, POVMS_Message *, int);
		friend class POVMS_List;
		friend class POVMS_Object;
		friend class POVMS_MessageReceiver;
	public:
		POVMS_Container();
		virtual ~POVMS_Container();

		POVMSType Type() const;
		size_t Size() const;
		bool IsNull() const;
	protected:
		mutable POVMSData data;

		void DetachData();
};

class POVMS_Attribute : public POVMS_Container
{
	public:
		POVMS_Attribute();
		POVMS_Attribute(const char *str);
		POVMS_Attribute(const POVMSUCS2 *str);
		POVMS_Attribute(POVMSInt value);
		POVMS_Attribute(POVMSLong value);
		POVMS_Attribute(POVMSFloat value);
		POVMS_Attribute(bool value);
		POVMS_Attribute(POVMSType value);
		POVMS_Attribute(std::vector<POVMSInt>& value);
		POVMS_Attribute(std::vector<POVMSLong>& value);
		POVMS_Attribute(std::vector<POVMSFloat>& value);
		POVMS_Attribute(std::vector<POVMSType>& value);
		POVMS_Attribute(POVMSAttribute& convert);
		POVMS_Attribute(const POVMS_Attribute& source);
		virtual ~POVMS_Attribute();

		POVMS_Attribute& operator=(const POVMS_Attribute& source);

		void Get(POVMSType type, void *data, int *maxdatasize);
		void Set(POVMSType type, const void *data, int datasize);

		int GetStringLength() const; // Note: Includes trailing \0 character code!
		int GetString(char *str, int maxlen);
		std::string GetString();
		int GetUCS2StringLength() const; // Note: Includes trailing \0 character code!
		int GetUCS2String(POVMSUCS2 *str, int maxlen);
		POVMSUCS2String GetUCS2String();
		POVMSInt GetInt();
		POVMSLong GetLong();
		POVMSFloat GetFloat();
		POVMSBool GetBool();
		POVMSType GetType();

		std::vector<POVMSInt> GetIntVector();
		std::vector<POVMSLong> GetLongVector();
		std::vector<POVMSFloat> GetFloatVector();
		std::vector<POVMSType> GetTypeVector();

		int GetVectorSize() const;
};

class POVMS_List : public POVMS_Container
{
	public:
		POVMS_List();
		POVMS_List(POVMSAttributeList& convert);
		POVMS_List(const POVMS_List& source);
		virtual ~POVMS_List();

		POVMS_List& operator=(const POVMS_List& source);

		void Append(POVMS_Attribute& item);
		void Append(POVMS_List& item);
		void Append(POVMS_Object& item);
		void AppendN(int cnt, POVMS_Attribute& item);
		void AppendN(int cnt, POVMS_List& item);
		void AppendN(int cnt, POVMS_Object& item);
		void GetNth(int index, POVMS_Attribute& item);
		void GetNth(int index, POVMS_List& item);
		void GetNth(int index, POVMS_Object& item);
		void SetNth(int index, POVMS_Attribute& item);
		void SetNth(int index, POVMS_List& item);
		void SetNth(int index, POVMS_Object& item);
		void RemoveNth(int index);
		void Clear();

		int GetListSize();
};

class POVMS_Object : public POVMS_Container
{
		friend class POVMS_Message;
		friend class POVMS_MessageReceiver;

		class InputStream
		{
			public:
				InputStream() { }
				virtual ~InputStream() { }
				virtual bool read(void *, int) = 0;
		};

		class OutputStream
		{
			public:
				OutputStream() { }
				virtual ~OutputStream() { }
				virtual bool write(void *, int) = 0;
		};

		template<class T> class InputStreamT : public InputStream
		{
			public:
				InputStreamT(T& s) : stream(s) { }
				virtual ~InputStreamT() { }
				virtual bool read(void *ptr, int cnt) { return !(!stream.read(ptr, (size_t)cnt)); }
			private:
				T& stream;
		};

		template<class T> class OutputStreamT : public OutputStream
		{
			public:
				OutputStreamT(T& s) : stream(s) { }
				virtual ~OutputStreamT() { }
				virtual bool write(void *ptr, int cnt) { return !(!stream.write(ptr, (size_t)cnt)); }
			private:
				T& stream;
		};
	public:
		POVMS_Object();
		POVMS_Object(POVMSType objclass);
		POVMS_Object(POVMSObject& convert);
		POVMS_Object(POVMSObjectPtr convert);
		POVMS_Object(const POVMS_Object& source);
		~POVMS_Object();

		POVMS_Object& operator=(const POVMS_Object& source);

		void Get(POVMSType key, POVMS_Attribute& attr);
		void Get(POVMSType key, POVMS_List& attr);
		void Get(POVMSType key, POVMS_Object& attr);
		void Set(POVMSType key, POVMS_Attribute& attr);
		void Set(POVMSType key, POVMS_List& attr);
		void Set(POVMSType key, POVMS_Object& attr);
		void Remove(POVMSType key);
		bool Exist(POVMSType key);
		void Merge(POVMS_Object& source);

		const POVMSObject& operator*() const;
		const POVMSObject* operator->() const;
		POVMSObject operator()();

		void SetString(POVMSType key, const char *str); // Note: Strings may not contain \0 characters codes!
		void SetUCS2String(POVMSType key, const POVMSUCS2 *str); // Note: Strings may not contain \0 characters codes!
		void SetInt(POVMSType key, POVMSInt value);
		void SetLong(POVMSType key, POVMSLong value);
		void SetFloat(POVMSType key, POVMSFloat value);
		void SetBool(POVMSType key, POVMSBool value);
		void SetType(POVMSType key, POVMSType value);

		void SetIntVector(POVMSType key, std::vector<POVMSInt>& value);
		void SetLongVector(POVMSType key, std::vector<POVMSLong>& value);
		void SetFloatVector(POVMSType key, std::vector<POVMSFloat>& value);
		void SetTypeVector(POVMSType key, std::vector<POVMSType>& value);

		int GetStringLength(POVMSType key); // Note: Includes trailing \0 character code!
		int GetString(POVMSType key, char *str, int maxlen);
		std::string GetString(POVMSType key);
		int GetUCS2StringLength(POVMSType key); // Note: Includes trailing \0 character code!
		int GetUCS2String(POVMSType key, POVMSUCS2 *str, int maxlen);
		POVMSUCS2String GetUCS2String(POVMSType key);
		POVMSInt GetInt(POVMSType key);
		POVMSLong GetLong(POVMSType key);
		POVMSFloat GetFloat(POVMSType key);
		POVMSBool GetBool(POVMSType key);
		POVMSType GetType(POVMSType key);

		std::vector<POVMSInt> GetIntVector(POVMSType key);
		std::vector<POVMSLong> GetLongVector(POVMSType key);
		std::vector<POVMSFloat> GetFloatVector(POVMSType key);
		std::vector<POVMSType> GetTypeVector(POVMSType key);

		std::string TryGetString(POVMSType key, const char *alt);
		std::string TryGetString(POVMSType key, const std::string& alt);
		POVMSUCS2String TryGetUCS2String(POVMSType key, const char *alt);
		POVMSUCS2String TryGetUCS2String(POVMSType key, const POVMSUCS2String& alt);
		POVMSInt TryGetInt(POVMSType key, POVMSInt alt);
		POVMSLong TryGetLong(POVMSType key, POVMSLong alt);
		POVMSFloat TryGetFloat(POVMSType key, POVMSFloat alt);
		POVMSBool TryGetBool(POVMSType key, POVMSBool alt);
		POVMSType TryGetType(POVMSType key, POVMSType alt);

		template<class T> void Read(T& stream)
		{
			InputStreamT<T> s(stream);
			Read(s, false, false);
		}

		template<class T> void Write(T& stream)
		{
			OutputStreamT<T> s(stream);
			Write(s, false, true);
		}
	private:
		void Read(InputStream& stream, bool continued, bool headeronly);
		void Write(OutputStream& stream, bool append, bool compress);
};

class POVMS_Message : public POVMS_Object
{
	public:
		POVMS_Message();
		POVMS_Message(POVMSType objclass, POVMSType msgclass = kPOVMSType_WildCard, POVMSType msgid = kPOVMSType_WildCard);
		POVMS_Message(POVMS_Object& convert, POVMSType msgclass = kPOVMSType_WildCard, POVMSType msgid = kPOVMSType_WildCard);
		POVMS_Message(POVMSObject& convert);
		POVMS_Message(POVMSObjectPtr convert);
		POVMS_Message(const POVMS_Message& source);

		POVMS_Message& operator=(const POVMS_Message& source);

		POVMSType GetClass();
		POVMSType GetIdentifier();

		POVMSAddress GetSourceAddress();
		POVMSAddress GetDestinationAddress();
		void SetSourceAddress(POVMSAddress);
		void SetDestinationAddress(POVMSAddress);
};

class POVMS_MessageReceiver
{
	private:
		class HandlerOO
		{
			public:
				virtual void Call(POVMS_Message&, POVMS_Message&, int) = 0;
		};
		class Handler
		{
			public:
				virtual void Call(POVMSObjectPtr, POVMSObjectPtr, int) = 0;
		};
	protected:
		template<class T> class MemberHandlerOO : public HandlerOO
		{
			public:
				typedef void (T::*MemberHandlerPtr)(POVMS_Message&, POVMS_Message&, int);

				MemberHandlerOO()
				{
					classptr = NULL;
					handlerptr = NULL;
				}

				MemberHandlerOO(T *cptr, MemberHandlerPtr hptr)
				{
					classptr = cptr;
					handlerptr = hptr;
				}

				void Call(POVMS_Message& msg, POVMS_Message& result, int mode)
				{
					if((classptr != NULL) && (handlerptr != NULL))
						(classptr->*handlerptr)(msg, result, mode);
					else
						throw POV_EXCEPTION_CODE(pov_base::kNullPointerErr);
				}
			private:
				MemberHandlerPtr handlerptr;
				T *classptr;
		};

		template<class T> class MemberHandler : public Handler
		{
			public:
				typedef void (T::*MemberHandlerPtr)(POVMSObjectPtr, POVMSObjectPtr, int);

				MemberHandler()
				{
					classptr = NULL;
					handlerptr = NULL;
				}

				MemberHandler(T *cptr, MemberHandlerPtr hptr)
				{
					classptr = cptr;
					handlerptr = hptr;
				}

				void Call(POVMSObjectPtr msg, POVMSObjectPtr result, int mode)
				{
					if((classptr != NULL) && (handlerptr != NULL))
						(classptr->*handlerptr)(msg, result, mode);
					else
						throw POV_EXCEPTION_CODE(pov_base::kNullPointerErr);
				}
			private:
				MemberHandlerPtr handlerptr;
				T *classptr;
		};

		class FunctionHandlerOO : public HandlerOO
		{
			public:
				typedef void (*FunctionHandlerPtr)(POVMS_Message&, POVMS_Message&, int, void *);

				FunctionHandlerOO()
				{
					handlerptr = NULL;
					privatedata = NULL;
				}

				FunctionHandlerOO(FunctionHandlerPtr hptr, void *pptr)
				{
					handlerptr = hptr;
					privatedata = pptr;
				}

				void Call(POVMS_Message& msg, POVMS_Message& result, int mode)
				{
					if(handlerptr != NULL)
						handlerptr(msg, result, mode, privatedata);
					else
						throw POV_EXCEPTION_CODE(pov_base::kNullPointerErr);
				}
			private:
				FunctionHandlerPtr handlerptr;
				void *privatedata;
		};

		class FunctionHandler : public Handler
		{
			public:
				typedef void (*FunctionHandlerPtr)(POVMSObjectPtr, POVMSObjectPtr, int, void *);

				FunctionHandler()
				{
					handlerptr = NULL;
					privatedata = NULL;
				}

				FunctionHandler(FunctionHandlerPtr hptr, void *pptr)
				{
					handlerptr = hptr;
					privatedata = pptr;
				}

				void Call(POVMSObjectPtr msg, POVMSObjectPtr result, int mode)
				{
					if(handlerptr != NULL)
						handlerptr(msg, result, mode, privatedata);
					else
						throw POV_EXCEPTION_CODE(pov_base::kNullPointerErr);
				}
			private:
				FunctionHandlerPtr handlerptr;
				void *privatedata;
		};

		POVMS_MessageReceiver(POVMSContext contextref);
		virtual ~POVMS_MessageReceiver();

		template<class T> void InstallFront(POVMSType hclass, POVMSType hid, T *cptr, typename MemberHandlerOO<T>::MemberHandlerPtr hptr)
		{
			AddNodeFront(hclass, hid, new MemberHandlerOO<T>(cptr, hptr), NULL);
		}

		template<class T> void InstallFront(POVMSType hclass, POVMSType hid, T *cptr, typename MemberHandler<T>::MemberHandlerPtr hptr)
		{
			AddNodeFront(hclass, hid, NULL, new MemberHandler<T>(cptr, hptr));
		}

		void InstallFront(POVMSType hclass, POVMSType hid, FunctionHandlerOO::FunctionHandlerPtr hptr, void *pptr)
		{
			AddNodeFront(hclass, hid, new FunctionHandlerOO(hptr, pptr), NULL);
		}

		void InstallFront(POVMSType hclass, POVMSType hid, FunctionHandler::FunctionHandlerPtr hptr, void *pptr)
		{
			AddNodeFront(hclass, hid, NULL, new FunctionHandler(hptr, pptr));
		}

		template<class T> void InstallBack(POVMSType hclass, POVMSType hid, T *cptr, typename MemberHandlerOO<T>::MemberHandlerPtr hptr)
		{
			AddNodeBack(hclass, hid, new MemberHandlerOO<T>(cptr, hptr), NULL);
		}

		template<class T> void InstallBack(POVMSType hclass, POVMSType hid, T *cptr, typename MemberHandler<T>::MemberHandlerPtr hptr)
		{
			AddNodeBack(hclass, hid, NULL, new MemberHandler<T>(cptr, hptr));
		}

		void InstallBack(POVMSType hclass, POVMSType hid, FunctionHandlerOO::FunctionHandlerPtr hptr, void *pptr)
		{
			AddNodeBack(hclass, hid, new FunctionHandlerOO(hptr, pptr), NULL);
		}

		void InstallBack(POVMSType hclass, POVMSType hid, FunctionHandler::FunctionHandlerPtr hptr, void *pptr)
		{
			AddNodeBack(hclass, hid, NULL, new FunctionHandler(hptr, pptr));
		}

		void Remove(POVMSType hclass, POVMSType hid);
	private:
		struct HandlerNode
		{
			struct HandlerNode *last;
			struct HandlerNode *next;
			POVMSType hclass;
			POVMSType hid;
			HandlerOO *handleroo;
			Handler *handler;
		};

		POVMSContext context;
		HandlerNode *receivers;

		POVMS_MessageReceiver(); // default constructor not allowed
		POVMS_MessageReceiver(const POVMS_MessageReceiver&); // no copies allowed
		POVMS_MessageReceiver& operator=(const POVMS_MessageReceiver&); // no copy assignments allowed

		static int ReceiveHandler(POVMSObjectPtr msg, POVMSObjectPtr result, int mode, void *privatedataptr);

		void AddNodeFront(POVMSType hclass, POVMSType hid, HandlerOO *hooptr, Handler *hptr);
		void AddNodeBack(POVMSType hclass, POVMSType hid, HandlerOO *hooptr, Handler *hptr);
		void RemoveNode(HandlerNode *nodeptr);
};

void POVMS_SendMessage(POVMS_Message& msg);
void POVMS_SendMessage(POVMSContext contextref, POVMS_Message& msg, POVMS_Message *result, int mode);

#endif
