/*
 * Copyright 2016, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */
#ifndef REMOTE_DEBUG_REQUEST_H
#define REMOTE_DEBUG_REQUEST_H

#include <OS.h>

#include <Referenceable.h>

#include "Types.h"


enum remote_request_type {
	// debug requests
	REMOTE_REQUEST_TYPE_READ_MEMORY = 0,
	REMOTE_REQUEST_TYPE_WRITE_MEMORY,
	REMOTE_REQUEST_TYPE_SET_TEAM_FLAGS,
	REMOTE_REQUEST_TYPE_SET_THREAD_FLAGS,
	REMOTE_REQUEST_TYPE_CONTINUE_THREAD,
	REMOTE_REQUEST_TYPE_STOP_THREAD,
	REMOTE_REQUEST_TYPE_SINGLE_STEP_THREAD,
	REMOTE_REQUEST_TYPE_GET_CPU_STATE,
	REMOTE_REQUEST_TYPE_SET_CPU_STATE,
	REMOTE_REQUEST_TYPE_INSTALL_BREAKPOINT,
	REMOTE_REQUEST_TYPE_UNINSTALL_BREAKPOINT,
	REMOTE_REQUEST_TYPE_INSTALL_WATCHPOINT,
	REMOTE_REQUEST_TYPE_UNINSTALL_WATCHPOINT,
	REMOTE_REQUEST_TYPE_PREPARE_HANDOVER,
	REMOTE_REQUEST_TYPE_WRITE_CORE_FILE,

	// team information requests
	REMOTE_REQUEST_TYPE_GET_TEAM_INFO,
	REMOTE_REQUEST_TYPE_GET_THREAD_INFOS,
	REMOTE_REQUEST_TYPE_GET_IMAGE_INFOS,
	REMOTE_REQUEST_TYPE_GET_AREA_INFOS,
	REMOTE_REQUEST_TYPE_GET_SEM_INFOS,
	REMOTE_REQUEST_TYPE_GET_SYMBOL_INFOS,
	REMOTE_REQUEST_TYPE_GET_SYMBOL_INFO,
	REMOTE_REQUEST_TYPE_GET_THREAD_INFO,
	REMOTE_REQUEST_TYPE_GET_MEMORY_PROPERTIES
};


class Architecture;
class BMessage;
class CpuState;


class RemoteDebugRequest : public BReferenceable {
public:
								RemoteDebugRequest();
	virtual						~RemoteDebugRequest();

	virtual	remote_request_type	Type() const = 0;

			status_t			LoadFromMessage(const BMessage& data);
			status_t			SaveToMessage(BMessage& _output) const;

			Architecture*		GetArchitecture() const
									{ return fArchitecture; }
			void				SetArchitecture(Architecture* architecture);

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(
									const BMessage& data) = 0;
	virtual	status_t			SaveSpecificInfoToMessage(
									BMessage& _output) const = 0;

private:
			Architecture*		fArchitecture;
};


class RemoteDebugResponse : public BReferenceable {
public:
								RemoteDebugResponse();
	virtual						~RemoteDebugResponse();

			void				SetRequestInfo(RemoteDebugRequest* request,
									status_t result);

			RemoteDebugRequest*	Request() const 	{ return fRequest; }
			Architecture*		GetArchitecture() const
									{ return fRequest->GetArchitecture(); }

			status_t			LoadFromMessage(const BMessage& data);
			status_t			SaveToMessage(BMessage& _output) const;

			status_t			Result() const		{ return fResult; }
			bool				Succeeded() const	{ return fResult == B_OK; }

protected:
								// for requests that respond with additional
								// information beyond a simple success/failure,
								// a subclass must be implemented that provides
								// versions of the functions below to save/
								// and restore the corresponding additional
								// data. Requests that merely return a status
								// code can simply instantiate the basic
								// response class as is.
	virtual	status_t			LoadSpecificInfoFromMessage(const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(BMessage& _output) const;

private:
			RemoteDebugRequest*	fRequest;
			status_t			fResult;
};


// #pragma mark - Requests


class RemoteDebugReadMemoryRequest : public RemoteDebugRequest {
public:
								RemoteDebugReadMemoryRequest();
	virtual						~RemoteDebugReadMemoryRequest();

			void				SetTo(target_addr_t address,
									target_size_t size);

			target_addr_t		Address() const	{ return fAddress; }
			target_size_t 		Size() const { return fSize; }

	virtual	remote_request_type	Type() const;

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(
									const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(
									BMessage& _output) const;

private:
			target_addr_t		fAddress;
			target_size_t		fSize;
};


class RemoteDebugWriteMemoryRequest : public RemoteDebugRequest {
public:
								RemoteDebugWriteMemoryRequest();
	virtual						~RemoteDebugWriteMemoryRequest();

			status_t			SetTo(target_addr_t address,
									const void* data, target_size_t size);

			target_addr_t		Address() const	{ return fAddress; }
			const void*			Data() const	{ return fData; }
			target_size_t 		Size() const	{ return fSize; }

	virtual	remote_request_type	Type() const;

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(
									const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(
									BMessage& _output) const;

private:
			target_addr_t		fAddress;
			void*				fData;
			target_size_t		fSize;
};


class RemoteDebugSetTeamFlagsRequest : public RemoteDebugRequest {
public:
								RemoteDebugSetTeamFlagsRequest();
	virtual						~RemoteDebugSetTeamFlagsRequest();

			void				SetTo(int32 flags);

			int32				Flags() const	{ return fFlags; }

	virtual	remote_request_type	Type() const;

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(
									const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(
									BMessage& _output) const;

private:
			int32				fFlags;
};


class RemoteDebugSetThreadFlagsRequest : public RemoteDebugRequest {
public:
								RemoteDebugSetThreadFlagsRequest();
	virtual						~RemoteDebugSetThreadFlagsRequest();

			void				SetTo(thread_id thread, int32 flags);

			thread_id			Thread() const	{ return fThread; }
			int32				Flags() const	{ return fFlags; }

	virtual	remote_request_type	Type() const;

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(
									const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(
									BMessage& _output) const;

private:
			thread_id			fThread;
			int32				fFlags;
};


// abstract base for the various thread actions, as those all
// take a thread ID as a parameter and have no special response
// requirements, with only the action to be taken differing.
class RemoteDebugThreadActionRequest : public RemoteDebugRequest {
public:
								RemoteDebugThreadActionRequest();
	virtual						~RemoteDebugThreadActionRequest();

			void				SetTo(thread_id thread);

			thread_id			Thread() const	{ return fThread; }

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(
									const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(
									BMessage& _output) const;

private:
			thread_id			fThread;
};


class RemoteDebugContinueThreadRequest
	: public RemoteDebugThreadActionRequest {
public:
								RemoteDebugContinueThreadRequest();
	virtual						~RemoteDebugContinueThreadRequest();

	virtual	remote_request_type	Type() const;
};


class RemoteDebugStopThreadRequest
	: public RemoteDebugThreadActionRequest {
public:
								RemoteDebugStopThreadRequest();
	virtual						~RemoteDebugStopThreadRequest();

	virtual	remote_request_type	Type() const;
};


class RemoteDebugSingleStepThreadRequest
	: public RemoteDebugThreadActionRequest {
public:
								RemoteDebugSingleStepThreadRequest();
	virtual						~RemoteDebugSingleStepThreadRequest();

	virtual	remote_request_type	Type() const;
};


class RemoteDebugGetCpuStateRequest
	: public RemoteDebugThreadActionRequest {
public:
								RemoteDebugGetCpuStateRequest();
	virtual						~RemoteDebugGetCpuStateRequest();

	virtual	remote_request_type	Type() const;
};


class RemoteDebugSetCpuStateRequest : public RemoteDebugRequest {
public:
								RemoteDebugSetCpuStateRequest();
	virtual						~RemoteDebugSetCpuStateRequest();

			void				SetTo(thread_id thread, CpuState* state);

			thread_id			Thread() const	{ return fThread; }

	virtual	remote_request_type	Type() const;

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(
									const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(
									BMessage& _output) const;

private:
			thread_id			fThread;
			CpuState*			fCpuState;
};


// abstract base for the various actions that influence how the CPU
// reacts to a particular memory address, ergo break/watchpoints.
class RemoteDebugAddressActionRequest : public RemoteDebugRequest {
public:
								RemoteDebugAddressActionRequest();
	virtual						~RemoteDebugAddressActionRequest();

			void				SetTo(target_addr_t address);

			target_addr_t		Address() const	{ return fAddress; }

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(
									const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(
									BMessage& _output) const;

private:
			target_addr_t		fAddress;
};


class RemoteDebugInstallBreakpointRequest
	: public RemoteDebugAddressActionRequest {
public:
								RemoteDebugInstallBreakpointRequest();
	virtual						~RemoteDebugInstallBreakpointRequest();

	virtual	remote_request_type	Type() const;
};


class RemoteDebugUninstallBreakpointRequest
	: public RemoteDebugAddressActionRequest {
public:
								RemoteDebugUninstallBreakpointRequest();
	virtual						~RemoteDebugUninstallBreakpointRequest();

	virtual	remote_request_type	Type() const;
};


class RemoteDebugInstallWatchpointRequest : public RemoteDebugRequest {
public:
								RemoteDebugInstallWatchpointRequest();
	virtual						~RemoteDebugInstallWatchpointRequest();

			void				SetTo(target_addr_t address, uint32 type,
									int32 length);

			target_addr_t		Address() const		{ return fAddress; }
			uint32				WatchType() const	{ return fWatchType; }
			int32				Length() const		{ return fLength; }

	virtual	remote_request_type	Type() const;

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(
									const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(
									BMessage& _output) const;

private:
			target_addr_t		fAddress;
			uint32				fWatchType;
			int32				fLength;
};


class RemoteDebugUninstallWatchpointRequest
	: public RemoteDebugAddressActionRequest {
public:
								RemoteDebugUninstallWatchpointRequest();
	virtual						~RemoteDebugUninstallWatchpointRequest();

	virtual	remote_request_type	Type() const;
};


// #pragma mark - Responses


class RemoteDebugReadMemoryResponse : public RemoteDebugResponse {
public:
								RemoteDebugReadMemoryResponse();
	virtual						~RemoteDebugReadMemoryResponse();

			void				SetTo(void* data, target_size_t size);

			const void*			Data() const	{ return fData; }
			target_size_t		Size() const 	{ return fSize; }

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(BMessage& _output) const;

private:
			void*				fData;
			target_size_t		fSize;
};


class RemoteDebugGetCpuStateResponse : public RemoteDebugResponse {
public:
								RemoteDebugGetCpuStateResponse();
	virtual						~RemoteDebugGetCpuStateResponse();

			void				SetTo(CpuState* state);

			CpuState*			GetCpuState() const { return fCpuState; }

protected:
	virtual	status_t			LoadSpecificInfoFromMessage(const BMessage& data);
	virtual	status_t			SaveSpecificInfoToMessage(BMessage& _output) const;

private:
			CpuState*			fCpuState;
};


#endif	// REMOTE_DEBUG_REQUEST_H