/*
 * Copyright 2014, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "ExpressionInfo.h"

#include "Type.h"
#include "Value.h"
#include "ValueNode.h"


// #pragma mark - ExpressionResult


ExpressionResult::ExpressionResult()
	:
	fResultKind(EXPRESSION_RESULT_KIND_UNKNOWN),
	fPrimitiveValue(NULL),
	fValueNodeValue(NULL),
	fTypeResult(NULL)
{
}


ExpressionResult::~ExpressionResult()
{
	if (fPrimitiveValue != NULL)
		fPrimitiveValue->ReleaseReference();

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

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


void
ExpressionResult::SetToPrimitive(Value* value)
{
	_Unset();

	fPrimitiveValue = value;
	if (fPrimitiveValue != NULL) {
		fPrimitiveValue->AcquireReference();
		fResultKind = EXPRESSION_RESULT_KIND_PRIMITIVE;
	}
}


void
ExpressionResult::SetToValueNode(ValueNodeChild* child)
{
	_Unset();

	fValueNodeValue = child;
	if (fValueNodeValue != NULL) {
		fValueNodeValue->AcquireReference();
		fResultKind = EXPRESSION_RESULT_KIND_VALUE_NODE;
	}

	// if the child has a node with a resolved value, store
	// it as a primitive, so the consumer of the expression
	// can use it as-is if desired.

	ValueNode* node = child->Node();
	if (node == NULL)
		return;

	fPrimitiveValue = node->GetValue();
	if (fPrimitiveValue != NULL)
		fPrimitiveValue->AcquireReference();
}


void
ExpressionResult::SetToType(Type* type)
{
	_Unset();

	fTypeResult = type;
	if (fTypeResult != NULL) {
		fTypeResult->AcquireReference();
		fResultKind = EXPRESSION_RESULT_KIND_TYPE;
	}
}


void
ExpressionResult::_Unset()
{
	if (fPrimitiveValue != NULL) {
		fPrimitiveValue->ReleaseReference();
		fPrimitiveValue = NULL;
	}

	if (fValueNodeValue != NULL) {
		fValueNodeValue->ReleaseReference();
		fValueNodeValue = NULL;
	}

	if (fTypeResult != NULL) {
		fTypeResult->ReleaseReference();
		fTypeResult = NULL;
	}

	fResultKind = EXPRESSION_RESULT_KIND_UNKNOWN;
}


// #pragma mark - ExpressionInfo


ExpressionInfo::ExpressionInfo()
	:
	fExpression()
{
}


ExpressionInfo::ExpressionInfo(const ExpressionInfo& other)
	:
	fExpression(other.fExpression)
{
}


ExpressionInfo::~ExpressionInfo()
{
}


ExpressionInfo::ExpressionInfo(const BString& expression)
	:
	fExpression(expression)
{
}


void
ExpressionInfo::SetTo(const BString& expression)
{
	fExpression = expression;
}


void
ExpressionInfo::AddListener(Listener* listener)
{
	fListeners.Add(listener);
}


void
ExpressionInfo::RemoveListener(Listener* listener)
{
	fListeners.Remove(listener);
}


void
ExpressionInfo::NotifyExpressionEvaluated(status_t result,
	ExpressionResult* value)
{
	for (ListenerList::Iterator it = fListeners.GetIterator();
			Listener* listener = it.Next();) {
		listener->ExpressionEvaluated(this, result, value);
	}
}


// #pragma mark - ExpressionInfo::Listener


ExpressionInfo::Listener::~Listener()
{
}