#include "NumericNodes.hpp"

#include "Model/Workflow/Evaluation.hpp"
#include "Model/Workflow/Values/Basic.hpp"
#include "Utils/Macros.hpp"
#include "Utils/RTTI.hpp"

#include <cassert>
#include <utility>

WorkflowNode::Kind NumericOperationNode::OperationTypeToNodeKind(OperationType type)
{
	switch (type) {
		case Addition: return KD_NumericAddition;
		case Subtraction: return KD_NumericSubtraction;
		case Multiplication: return KD_NumericMultiplication;
		case Division: return KD_NumericDivision;
		default: return InvalidKind;
	}
}

NumericOperationNode::OperationType NumericOperationNode::NodeKindToOperationType(Kind kind)
{
	switch (kind) {
		case KD_NumericAddition: return Addition;
		case KD_NumericSubtraction: return Subtraction;
		case KD_NumericMultiplication: return Multiplication;
		case KD_NumericDivision: return Division;
		default: return InvalidType;
	}
}

bool NumericOperationNode::IsInstance(const WorkflowNode* node)
{
	return node->GetKind() >= KD_NumericAddition && node->GetKind() <= KD_NumericDivision;
}

NumericOperationNode::NumericOperationNode(OperationType type)
	: WorkflowNode(OperationTypeToNodeKind(type), false)
	, mType{ type }
{
	mInputs.resize(2);
	mInputs[0].MatchingType = BaseValue::KD_Numeric;
	mInputs[1].MatchingType = BaseValue::KD_Numeric;

	mOutputs.resize(1);
	mOutputs[0].MatchingType = BaseValue::KD_Numeric;
}

void NumericOperationNode::Evaluate(WorkflowEvaluationContext& ctx)
{
	auto lhsVal = dyn_cast<NumericValue>(ctx.GetConnectionValue(mInputs[0]));
	if (!lhsVal) return;
	double lhs = lhsVal->GetValue();

	auto rhsVal = dyn_cast<NumericValue>(ctx.GetConnectionValue(mInputs[1]));
	if (!rhsVal) return;
	double rhs = rhsVal->GetValue();

	double res;
	switch (mType) {
		case Addition: res = lhs + rhs; break;
		case Subtraction: res = lhs - rhs; break;
		case Multiplication: res = lhs * rhs; break;
		case Division: {
			if (rhs == 0.0) {
				// TODO localize
				ctx.ReportError("Error: division by 0", *this);
				return;
			}
			res = lhs / rhs;
		} break;

		default: return;
	}

	auto value = std::make_unique<NumericValue>();
	value->SetValue(res);
	ctx.SetConnectionValue(mOutputs[0], std::move(value));
}

bool NumericExpressionNode::IsInstance(const WorkflowNode* node)
{
	return node->GetKind() == KD_NumericExpression;
}

NumericExpressionNode::NumericExpressionNode()
	: WorkflowNode(KD_NumericExpression, false)
{
}

void NumericExpressionNode::Evaluate(WorkflowEvaluationContext& ctx)
{
}