/*
 * Copyright 2013-2018, Rene Gollent, rene@gollent.com.
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "VariablesViewState.h"

#include <new>

#include "ExpressionValues.h"
#include "FunctionID.h"
#include "StackFrameValues.h"
#include "Type.h"
#include "TypeComponentPath.h"
#include "TypeHandler.h"


// #pragma mark - VariablesViewNodeInfo


VariablesViewNodeInfo::VariablesViewNodeInfo()
	:
	fNodeExpanded(false),
	fCastedType(NULL),
	fTypeHandler(NULL),
	fRendererSettings()
{
}


VariablesViewNodeInfo::VariablesViewNodeInfo(const VariablesViewNodeInfo& other)
	:
	fNodeExpanded(other.fNodeExpanded),
	fCastedType(other.fCastedType),
	fTypeHandler(other.fTypeHandler),
	fRendererSettings(other.fRendererSettings)
{
	if (fCastedType != NULL)
		fCastedType->AcquireReference();
}


VariablesViewNodeInfo::~VariablesViewNodeInfo()
{
	if (fCastedType != NULL)
		fCastedType->ReleaseReference();

	if (fTypeHandler != NULL)
		fTypeHandler->ReleaseReference();
}


VariablesViewNodeInfo&
VariablesViewNodeInfo::operator=(const VariablesViewNodeInfo& other)
{
	fNodeExpanded = other.fNodeExpanded;
	SetCastedType(other.fCastedType);
	SetTypeHandler(other.fTypeHandler);
	fRendererSettings = other.fRendererSettings;

	return *this;
}


void
VariablesViewNodeInfo::SetNodeExpanded(bool expanded)
{
	fNodeExpanded = expanded;
}


void
VariablesViewNodeInfo::SetCastedType(Type* type)
{
	if (fCastedType != NULL)
		fCastedType->ReleaseReference();

	fCastedType = type;
	if (fCastedType != NULL)
		fCastedType->AcquireReference();
}


void
VariablesViewNodeInfo::SetTypeHandler(TypeHandler* handler)
{
	if (fTypeHandler != NULL)
		fTypeHandler->ReleaseReference();

	fTypeHandler = handler;
	if (fTypeHandler != NULL)
		fTypeHandler->AcquireReference();
}


void
VariablesViewNodeInfo::SetRendererSettings(const BMessage& settings)
{
	fRendererSettings = settings;
}


// #pragma mark - Key


struct VariablesViewState::Key {
	ObjectID*			variable;
	TypeComponentPath*	path;

	Key(ObjectID* variable, TypeComponentPath* path)
		:
		variable(variable),
		path(path)
	{
	}

	uint32 HashValue() const
	{
		return variable->HashValue() ^ path->HashValue();
	}

	bool operator==(const Key& other) const
	{
		return *variable == *other.variable && *path == *other.path;
	}
};


// #pragma mark - InfoEntry


struct VariablesViewState::InfoEntry : Key, VariablesViewNodeInfo {
	InfoEntry*	next;

	InfoEntry(ObjectID* variable, TypeComponentPath* path)
		:
		Key(variable, path)
	{
		variable->AcquireReference();
		path->AcquireReference();
	}

	~InfoEntry()
	{
		variable->ReleaseReference();
		path->ReleaseReference();
	}

	void SetInfo(const VariablesViewNodeInfo& info)
	{
		VariablesViewNodeInfo::operator=(info);
	}
};


struct VariablesViewState::InfoEntryHashDefinition {
	typedef Key			KeyType;
	typedef	InfoEntry	ValueType;

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

	size_t Hash(const InfoEntry* value) const
	{
		return value->HashValue();
	}

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

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


VariablesViewState::VariablesViewState()
	:
	fNodeInfos(NULL),
	fValues(NULL),
	fExpressionValues(NULL)
{
}


VariablesViewState::~VariablesViewState()
{
	_Cleanup();
}


status_t
VariablesViewState::Init()
{
	fNodeInfos = new(std::nothrow) NodeInfoTable;
	if (fNodeInfos == NULL)
		return B_NO_MEMORY;

	return fNodeInfos->Init();
}

void
VariablesViewState::SetValues(StackFrameValues* values)
{
	if (fValues == values)
		return;

	if (fValues != NULL)
		fValues->ReleaseReference();

	fValues = values;

	if (fValues != NULL)
		fValues->AcquireReference();
}


void
VariablesViewState::SetExpressionValues(ExpressionValues* values)
{
	if (fExpressionValues == values)
		return;

	if (fExpressionValues != NULL)
		fExpressionValues->ReleaseReference();

	fExpressionValues = values;

	if (fExpressionValues != NULL)
		fExpressionValues->AcquireReference();
}


const VariablesViewNodeInfo*
VariablesViewState::GetNodeInfo(ObjectID* variable,
	const TypeComponentPath* path) const
{
	return fNodeInfos->Lookup(Key(variable, (TypeComponentPath*)path));
}


status_t
VariablesViewState::SetNodeInfo(ObjectID* variable, TypeComponentPath* path,
	const VariablesViewNodeInfo& info)
{
	InfoEntry* entry = fNodeInfos->Lookup(Key(variable, path));
	if (entry == NULL) {
		entry = new(std::nothrow) InfoEntry(variable, path);
		if (entry == NULL)
			return B_NO_MEMORY;
		fNodeInfos->Insert(entry);
	}

	entry->SetInfo(info);
	return B_OK;
}


void
VariablesViewState::_Cleanup()
{
	if (fNodeInfos != NULL) {
		InfoEntry* entry = fNodeInfos->Clear(true);

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

		delete fNodeInfos;
		fNodeInfos = NULL;
	}

	SetValues(NULL);
	SetExpressionValues(NULL);
}