/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "VariablesViewStateHistory.h"

#include <new>

#include "FunctionID.h"
#include "VariablesViewState.h"


// #pragma mark - Key


struct VariablesViewStateHistory::Key {
	thread_id	threadID;
	FunctionID*	functionID;

	Key(thread_id threadID, FunctionID* functionID)
		:
		threadID(threadID),
		functionID(functionID)
	{
	}

	uint32 HashValue() const
	{
		return functionID->HashValue() ^ threadID;
	}

	bool operator==(const Key& other) const
	{
		return threadID == other.threadID && *functionID == *other.functionID;
	}
};


// #pragma mark - StateEntry


struct VariablesViewStateHistory::StateEntry : Key, VariablesViewNodeInfo {
	StateEntry*			next;
	VariablesViewState*	state;

	StateEntry(thread_id threadID, FunctionID* functionID)
		:
		Key(threadID, functionID),
		state(NULL)
	{
		functionID->AcquireReference();
	}

	~StateEntry()
	{
		functionID->ReleaseReference();
		if (state != NULL)
			state->ReleaseReference();
	}

	void SetState(VariablesViewState* state)
	{
		if (state == this->state)
			return;

		if (state != NULL)
			state->AcquireReference();

		if (this->state != NULL)
			this->state->ReleaseReference();

		this->state = state;
	}
};


struct VariablesViewStateHistory::StateEntryHashDefinition {
	typedef Key			KeyType;
	typedef	StateEntry	ValueType;

	size_t HashKey(const Key& key) const
	{
		return key.HashValue();
	}

	size_t Hash(const StateEntry* value) const
	{
		return HashKey(*value);
	}

	bool Compare(const Key& key, const StateEntry* value) const
	{
		return key == *value;
	}

	StateEntry*& GetLink(StateEntry* value) const
	{
		return value->next;
	}
};


VariablesViewStateHistory::VariablesViewStateHistory()
	:
	fStates(NULL)
{
}


VariablesViewStateHistory::~VariablesViewStateHistory()
{
	if (fStates != NULL) {
		StateEntry* entry = fStates->Clear(true);

		while (entry != NULL) {
			StateEntry* next = entry->next;
			delete entry;
			entry = next;
		}

		delete fStates;
	}
}


status_t
VariablesViewStateHistory::Init()
{
	fStates = new(std::nothrow) StateTable;
	if (fStates == NULL)
		return B_NO_MEMORY;

	return fStates->Init();
}


VariablesViewState*
VariablesViewStateHistory::GetState(thread_id threadID, FunctionID* functionID)
	const
{
	// first try an exact match with the thread ID
	if (threadID >= 0) {
		StateEntry* stateEntry = fStates->Lookup(Key(threadID, functionID));
		if (stateEntry != NULL)
			return stateEntry->state;
	}

	// just match the function ID
	StateEntry* stateEntry = fStates->Lookup(Key(-1, functionID));
	return stateEntry != NULL ? stateEntry->state : NULL;
}


VariablesViewState*
VariablesViewStateHistory::GetState(FunctionID* functionID) const
{
	StateEntry* stateEntry = fStates->Lookup(Key(-1, functionID));
	return stateEntry != NULL ? stateEntry->state : NULL;
}


status_t
VariablesViewStateHistory::SetState(thread_id threadID, FunctionID* functionID,
	VariablesViewState* state)
{
	// Make sure the default entry for the function exists.
	StateEntry* defaultEntry = fStates->Lookup(Key(-1, functionID));
	bool newDefaultEntry = false;

	if (defaultEntry == NULL) {
		defaultEntry = new(std::nothrow) StateEntry(-1, functionID);
		if (defaultEntry == NULL)
			return B_NO_MEMORY;
		fStates->Insert(defaultEntry);
		newDefaultEntry = true;
	}

	// If we have a valid thread ID, make sure the respective entry for the
	// function exists.
	StateEntry* threadEntry = NULL;
	if (threadID >= 0) {
		threadEntry = fStates->Lookup(Key(threadID, functionID));

		if (threadEntry == NULL) {
			threadEntry = new(std::nothrow) StateEntry(threadID, functionID);
			if (threadEntry == NULL) {
				if (newDefaultEntry) {
					fStates->Remove(defaultEntry);
					delete defaultEntry;
				}
				return B_NO_MEMORY;
			}
			fStates->Insert(threadEntry);
		}
	}

	defaultEntry->SetState(state);
	if (threadEntry != NULL)
		threadEntry->SetState(state);

	return B_OK;
}