#ifndef ASEBA_MSG
#define ASEBA_MSG

#include "../common/types.h"
#include "../common/consts.h"
#include <cstring>
#include <valarray>

namespace Aseba
{
	
	class Message
	{
	public:
		uint16 type;
		
	public:
		Message();
		virtual ~Message();
		
		void serialize(int fd);
		static Message *receive(int fd);
		void dump(std::ostream &stream);
		
	protected:
		virtual void serializeSpecific() = 0;
		virtual void deserializeSpecific() = 0;
		virtual void dumpSpecific(std::ostream &stream) = 0;
		virtual operator const char * () const { return "message super class"; }
	
	protected:
		template<typename T> void add(const T& val);
		template<typename T> T get();
		
	protected:
		std::valarray<uint8> data;
		size_t readPos;
	};
	
	
	class UserMessage : public Message
	{
	protected:
		virtual void serializeSpecific() {}
		virtual void deserializeSpecific() {}
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "user message"; }
	};
	
	class BootloaderDataRead : public Message
	{
	public:
		uint8 data[6];
		
	public:
		BootloaderDataRead() { type = ASEBA_MESSAGE_BOOTLOADER_PAGE_DATA_READ; }
	
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "bootloader page data read"; }
	};
	
	class BootloaderAck : public Message
	{
	public:
		uint16 errorCode;
		uint16 errorAddress;
		
	public:
		BootloaderAck() { type = ASEBA_MESSAGE_BOOTLOADER_ACK; }
	
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "bootloader ack"; }
	};
	
	class Presence : public Message
	{
	public:
		Presence() { type = ASEBA_MESSAGE_PRESENCE; }
		
	protected:
		virtual void serializeSpecific() {}
		virtual void deserializeSpecific() {}
		virtual void dumpSpecific(std::ostream &stream) {}
		virtual operator const char * () const { return "presence message"; }
	};
	
	class Description : public Message
	{
	public:
		uint16 bytecodeSize;
		uint16 stackSize;
		uint16 variablesSize;
		std::string nodeName;
		std::valarray<std::string> variablesNames;
		std::valarray<uint16> variablesSizes;
		
	public:
		Description() { type = ASEBA_MESSAGE_DESCRIPTION; }
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "description"; }
	};
	
	class Variables : public Message
	{
	public:
		uint16 start;
		std::valarray<sint16> variables;
		
	public:
		Variables() { type = ASEBA_MESSAGE_VARIABLES; }
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "variables"; }
	};
	
	class ExecutionState : public Message
	{
	public:
		uint16 pc;
		uint16 flags;
		
	public:
		ExecutionState() { type = ASEBA_MESSAGE_EXECUTION_STATE; }
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "execution state"; }
	};
	
	class ArrayAccessOutOfBounds : public Message
	{
	public:
		uint16 pc;
		uint16 index;
		
	public:
		ArrayAccessOutOfBounds() { type = ASEBA_MESSAGE_ARRAY_ACCESS_OUT_OF_BOUND; }
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "array access out of bounds"; }
	};
	
	class DivisionByZero : public Message
	{
	public:
		uint16 pc;
		
	public:
		DivisionByZero() { type = ASEBA_MESSAGE_DIVISION_BY_ZERO; }
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "division by zero"; }
	};
	
	
	//! Cammands messages talk to a specific node
	class CmdMessage : public Message
	{
	public:
		uint8 dest;
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "cammand message super class"; }
	};
	
	class BootloaderReset : public CmdMessage
	{
	public:
		BootloaderReset() { type = ASEBA_MESSAGE_BOOTLOADER_RESET; }
	
	protected:
		virtual operator const char * () const { return "bootloader reset"; }
	};
	
	class BootloaderReadPage : public CmdMessage
	{
	public:
		uint16 pageNumber;
		
	public:
		BootloaderReadPage() { type = ASEBA_MESSAGE_BOOTLOADER_READ_PAGE; }
	
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "bootloader read page"; }
	};
	
	class BootloaderWritePage : public CmdMessage
	{
	public:
		uint16 pageNumber;
		
	public:
		BootloaderWritePage() { type = ASEBA_MESSAGE_BOOTLOADER_WRITE_PAGE; }
	
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "bootloader write page"; }
	};
	
	class BootloaderPageDataWrite : public CmdMessage
	{
	public:
		uint8 data[4];
		
	public:
		BootloaderPageDataWrite() { type = ASEBA_MESSAGE_BOOTLOADER_PAGE_DATA_WRITE; }
	
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "bootloader page data write"; }
	};
	
	
	class AttachDebugger : public CmdMessage
	{
	public:
		AttachDebugger() { type = ASEBA_MESSAGE_ATTACH_DEBUGGER; }
		
	protected:
		virtual operator const char * () const { return "attach debugger"; }
	};
	
	class DetachDebugger : public CmdMessage
	{
	public:
		DetachDebugger() { type = ASEBA_MESSAGE_DETACH_DEBUGGER; }
		
	protected:
		virtual operator const char * () const { return "detach debugger"; }
	};
	
	class SetBytecode : public CmdMessage
	{
	public:
		std::valarray<uint16> bytecode;
		
	public:
		SetBytecode() { type = ASEBA_MESSAGE_SET_BYTECODE; }
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "set bytecode"; }
	};
	
	class SetupEvent : public CmdMessage
	{
	public:
		uint16 eventId;
		std::valarray<uint16> arguments;
		
	public:
		SetupEvent() { type = ASEBA_MESSAGE_SETUP_EVENT; }
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "setup event"; }
	};
	
	class BackgroundRun : public CmdMessage
	{
	public:
		BackgroundRun() { type = ASEBA_MESSAGE_BACKGROUND_RUN; }
		
	protected:
		virtual operator const char * () const { return "background run"; }
	};
	
	class Stop : public CmdMessage
	{
	public:
		Stop() { type = ASEBA_MESSAGE_STOP; }
		
	protected:
		virtual operator const char * () const { return "stop"; }
	};
	
	class Step : public CmdMessage
	{
	public:
		Step() { type = ASEBA_MESSAGE_STEP; }
		
	protected:
		virtual operator const char * () const { return "step"; }
	};
	
	class BreakpointSet : public CmdMessage
	{
	public:
		uint16 pc;
		
	public:
		BreakpointSet() { type = ASEBA_MESSAGE_BREAKPOINT_SET; }
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "breakpoint set"; }
	};
	
	class BreakpointClear : public CmdMessage
	{
	public:
		uint16 pc;
		
	public:
		BreakpointClear() { type = ASEBA_MESSAGE_BREAKPOINT_CLEAR; }
		
	protected:
		virtual void serializeSpecific();
		virtual void deserializeSpecific();
		virtual void dumpSpecific(std::ostream &stream);
		virtual operator const char * () const { return "breakpoint clear"; }
	};
	
	class BreakpointClearAll : public CmdMessage
	{
	public:
		BreakpointClearAll() { type = ASEBA_MESSAGE_BREAKPOINT_CLEAR_ALL; }
		
	protected:
		virtual operator const char * () const { return "breakpoint clear all"; }
	};
	
	class GetVariables : public CmdMessage
	{
	public:
		GetVariables() { type = ASEBA_MESSAGE_GET_VARIABLES; }
		
	protected:
		virtual operator const char * () const { return "get variables"; }
	};
}

#endif