/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
 
 
#include <DebugLooper.h>
 
#include <new>
 
#include <AutoLocker.h>
#include <DebugMessageHandler.h>
#include <TeamDebugger.h>
#include <util/DoublyLinkedList.h>
 
 
struct BDebugLooper::Debugger {
	BTeamDebugger*			debugger;
	BDebugMessageHandler*	handler;
 
	Debugger(BTeamDebugger* debugger, BDebugMessageHandler* handler)
		:
		debugger(debugger),
		handler(handler)
	{
	}
};
 
 
struct BDebugLooper::Job : DoublyLinkedListLinkImpl<Job> {
	Job()
		:
		fDoneSemaphore(-1)
	{
	}
 
	virtual ~Job()
	{
	}
 
	status_t Wait(BLocker& lock)
	{
		fDoneSemaphore = create_sem(0, "debug looper job");
 
		lock.Unlock();
 
		while (acquire_sem(fDoneSemaphore) == B_INTERRUPTED) {
		}
 
		lock.Lock();
 
		delete_sem(fDoneSemaphore);
		fDoneSemaphore = -1;
 
		return fResult;
	}
 
	void Done(status_t result)
	{
		fResult = result;
		release_sem(fDoneSemaphore);
	}
 
	virtual status_t Do(BDebugLooper* looper) = 0;
 
protected:
	sem_id			fDoneSemaphore;
	status_t		fResult;
};
 
 
struct BDebugLooper::JobList : DoublyLinkedList<Job> {
};
 
 
struct BDebugLooper::AddDebuggerJob : Job {
	AddDebuggerJob(BTeamDebugger* debugger,
		BDebugMessageHandler* handler)
		:
		fDebugger(debugger),
		fHandler(handler)
	{
	}
 
	virtual status_t Do(BDebugLooper* looper)
	{
		Debugger* debugger = new(std::nothrow) Debugger(fDebugger, fHandler);
		if (debugger == NULL || !looper->fDebuggers.AddItem(debugger)) {
			delete debugger;
			return B_NO_MEMORY;
		}
 
		return B_OK;
	}
 
private:
	BTeamDebugger*			fDebugger;
	BDebugMessageHandler*	fHandler;
};
 
 
struct BDebugLooper::RemoveDebuggerJob : Job {
	RemoveDebuggerJob(team_id team)
		:
		fTeam(team)
	{
	}
 
	virtual status_t Do(BDebugLooper* looper)
	{
		for (int32 i = 0; Debugger* debugger = looper->fDebuggers.ItemAt(i);
				i++) {
			if (debugger->debugger->Team() == fTeam) {
				delete looper->fDebuggers.RemoveItemAt(i);
				return B_OK;
			}
		}
 
		return B_ENTRY_NOT_FOUND;
	}
 
private:
	team_id	fTeam;
};
 
 
// #pragma mark -
 
 
BDebugLooper::BDebugLooper()
	:
	fLock("debug looper"),
	fThread(-1),
	fOwnsThread(false),
	fTerminating(false),
	fNotified(false),
	fJobs(NULL),
	fEventSemaphore(-1)
{
}
 
 
BDebugLooper::~BDebugLooper()
{
}
 
 
status_t
BDebugLooper::Init()
{
	status_t error = fLock.InitCheck();
	if (error != B_OK)
		return error;
 
	AutoLocker<BLocker> locker(fLock);
 
	if (fThread >= 0)
		return B_BAD_VALUE;
 
	if (fJobs == NULL) {
		fJobs = new(std::nothrow) JobList;
		if (fJobs == NULL)
			return B_NO_MEMORY;
	}
 
	if (fEventSemaphore < 0) {
		fEventSemaphore = create_sem(0, "debug looper event");
		if (fEventSemaphore < 0)
			return fEventSemaphore;
	}
 
	return B_OK;
}
 
 
thread_id
BDebugLooper::Run(bool spawnThread)
{
	AutoLocker<BLocker> locker(fLock);
 
	if (fThread >= 0)
		return B_BAD_VALUE;
 
	fNotified = false;
 
	if (spawnThread) {
		fThread = spawn_thread(&_MessageLoopEntry, "debug looper",
			B_NORMAL_PRIORITY, this);
		if (fThread < 0)
			return fThread;
 
		fOwnsThread = true;
 
		resume_thread(fThread);
		return B_OK;
	}
 
	fThread = find_thread(NULL);
	fOwnsThread = false;
 
	_MessageLoop();
	return B_OK;
}
 
 
void
BDebugLooper::Quit()
{
	AutoLocker<BLocker> locker(fLock);
 
	fTerminating = true;
	_Notify();
}
 
 
status_t
BDebugLooper::AddTeamDebugger(BTeamDebugger* debugger,
	BDebugMessageHandler* handler)
{
	if (debugger == NULL || handler == NULL)
		return B_BAD_VALUE;
 
	AddDebuggerJob job(debugger, handler);
	return _DoJob(&job);
}
 
 
bool
BDebugLooper::RemoveTeamDebugger(BTeamDebugger* debugger)
{
	if (debugger == NULL)
		return false;
 
	RemoveDebuggerJob job(debugger->Team());
	return _DoJob(&job) == B_OK;
}
 
 
bool
BDebugLooper::RemoveTeamDebugger(team_id team)
{
	if (team < 0)
		return false;
 
	RemoveDebuggerJob job(team);
	return _DoJob(&job) == B_OK;
}
 
 
/*static*/ status_t
BDebugLooper::_MessageLoopEntry(void* data)
{
	return ((BDebugLooper*)data)->_MessageLoop();
}
 
 
status_t
BDebugLooper::_MessageLoop()
{
	while (true) {
		// prepare the wait info array
		int32 debuggerCount = fDebuggers.CountItems();
		object_wait_info waitInfos[debuggerCount + 1];
 
		for (int32 i = 0; i < debuggerCount; i++) {
			waitInfos[i].object
				= fDebuggers.ItemAt(i)->debugger->DebuggerPort();
			waitInfos[i].type = B_OBJECT_TYPE_PORT;
			waitInfos[i].events = B_EVENT_READ;
		}
 
		waitInfos[debuggerCount].object = fEventSemaphore;
		waitInfos[debuggerCount].type = B_OBJECT_TYPE_SEMAPHORE;
		waitInfos[debuggerCount].events = B_EVENT_ACQUIRE_SEMAPHORE;
 
		// wait for the next event
		wait_for_objects(waitInfos, debuggerCount + 1);
 
		AutoLocker<BLocker> locker(fLock);
 
		// handle all pending jobs
		bool handledJobs = fJobs->Head() != NULL;
		while (Job* job = fJobs->RemoveHead())
			job->Done(job->Do(this));
 
		// acquire notification semaphore and mark unnotified
		if ((waitInfos[debuggerCount].events & B_EVENT_ACQUIRE_SEMAPHORE) != 0)
			acquire_sem(fEventSemaphore);
		fNotified = false;
 
		if (fTerminating)
			return B_OK;
 
		// Always loop when jobs were executed, since that might add/remove
		// debuggers.
		if (handledJobs)
			continue;
 
		// read a pending port message
		for (int32 i = 0; i < debuggerCount; i++) {
			if ((waitInfos[i].events & B_EVENT_READ) != 0) {
				Debugger* debugger = fDebuggers.ItemAt(i);
 
				// read the message
				debug_debugger_message_data message;
				int32 code;
				ssize_t messageSize = read_port(
					debugger->debugger->DebuggerPort(), &code, &message,
					sizeof(message));
				if (messageSize < 0)
					continue;
 
				// handle the message
				bool continueThread = debugger->handler->HandleDebugMessage(
					code, message);
 
				// If requested, tell the thread to continue (only when there
				// is a thread and the message was synchronous).
				if (continueThread && message.origin.thread >= 0
						&& message.origin.nub_port >= 0) {
					debugger->debugger->ContinueThread(message.origin.thread);
				}
 
				// Handle only one message -- the hook might have added/removed
				// debuggers which makes further iteration problematic.
				break;
			}
		}
	}
}
 
 
status_t
BDebugLooper::_DoJob(Job* job)
{
	AutoLocker<BLocker> locker(fLock);
 
	// execute directly, if in looper thread or not running yet
	if (fThread < 0 || fThread == find_thread(NULL))
		return job->Do(this);
 
	// execute in the looper thread
	fJobs->Add(job);
	_Notify();
 
	return job->Wait(fLock);
}
 
 
void
BDebugLooper::_Notify()
{
	if (fNotified)
		return;
 
	fNotified = true;
	release_sem(fEventSemaphore);
}