/*
 * Copyright 2011, Oliver Tappe <zooey@hirschkaefer.de>
 * Distributed under the terms of the MIT License.
 */


#include <package/PackageResolvableExpression.h>

#include <package/hpkg/PackageInfoAttributeValue.h>
#include <package/PackageInfo.h>
#include <package/PackageResolvable.h>


namespace BPackageKit {


const char*
BPackageResolvableExpression
::kOperatorNames[B_PACKAGE_RESOLVABLE_OP_ENUM_COUNT] = {
	"<",
	"<=",
	"==",
	"!=",
	">=",
	">",
};


BPackageResolvableExpression::BPackageResolvableExpression()
	:
	fOperator(B_PACKAGE_RESOLVABLE_OP_ENUM_COUNT)
{
}


BPackageResolvableExpression::BPackageResolvableExpression(
	const BPackageResolvableExpressionData& data)
	:
	fName(data.name),
	fOperator(data.op),
	fVersion(data.version)
{
	fName.ToLower();
}


BPackageResolvableExpression::BPackageResolvableExpression(const BString& name,
	BPackageResolvableOperator _operator, const BPackageVersion& version)
	:
	fName(name),
	fOperator(_operator),
	fVersion(version)
{
	fName.ToLower();
}


BPackageResolvableExpression::BPackageResolvableExpression(
	const BString& expressionString)
	:
	fName(),
	fOperator(B_PACKAGE_RESOLVABLE_OP_ENUM_COUNT),
	fVersion()
{
	SetTo(expressionString);
}


status_t
BPackageResolvableExpression::InitCheck() const
{
	if (fName.Length() == 0)
		return B_NO_INIT;

	// either both or none of operator and version must be set
	if ((fOperator >= 0 && fOperator < B_PACKAGE_RESOLVABLE_OP_ENUM_COUNT)
		!= (fVersion.InitCheck() == B_OK))
		return B_NO_INIT;

	return B_OK;
}


const BString&
BPackageResolvableExpression::Name() const
{
	return fName;
}


BPackageResolvableOperator
BPackageResolvableExpression::Operator() const
{
	return fOperator;
}


const BPackageVersion&
BPackageResolvableExpression::Version() const
{
	return fVersion;
}


BString
BPackageResolvableExpression::ToString() const
{
	BString string = fName;

	if (fVersion.InitCheck() == B_OK)
		string << kOperatorNames[fOperator] << fVersion.ToString();

	return string;
}


status_t
BPackageResolvableExpression::SetTo(const BString& expressionString)
{
	fName.Truncate(0);
	fOperator = B_PACKAGE_RESOLVABLE_OP_ENUM_COUNT;
	fVersion.Clear();

	return BPackageInfo::ParseResolvableExpressionString(expressionString,
		*this);
}


void
BPackageResolvableExpression::SetTo(const BString& name,
	BPackageResolvableOperator _operator, const BPackageVersion& version)
{
	fName = name;
	fOperator = _operator;
	fVersion = version;

	fName.ToLower();
}


void
BPackageResolvableExpression::Clear()
{
	fName.Truncate(0);
	fOperator = B_PACKAGE_RESOLVABLE_OP_ENUM_COUNT;
	fVersion.Clear();
}


bool
BPackageResolvableExpression::Matches(const BPackageVersion& version,
	const BPackageVersion& compatibleVersion) const
{
	// If no particular version is required, we always match.
	if (fVersion.InitCheck() != B_OK)
		return true;

	if (version.InitCheck() != B_OK)
		return false;

	int compare = version.Compare(fVersion);
	bool matches = false;
	switch (fOperator) {
		case B_PACKAGE_RESOLVABLE_OP_LESS:
			matches = compare < 0;
			break;
		case B_PACKAGE_RESOLVABLE_OP_LESS_EQUAL:
			matches = compare <= 0;
			break;
		case B_PACKAGE_RESOLVABLE_OP_EQUAL:
			matches = compare == 0;
			break;
		case B_PACKAGE_RESOLVABLE_OP_NOT_EQUAL:
			matches = compare != 0;
			break;
		case B_PACKAGE_RESOLVABLE_OP_GREATER_EQUAL:
			matches = compare >= 0;
			break;
		case B_PACKAGE_RESOLVABLE_OP_GREATER:
			matches = compare > 0;
			break;
		default:
			break;
	}
	if (!matches)
		return false;

	// Check compatible version. If not specified, the match must be exact.
	// Otherwise fVersion must be >= compatibleVersion.
	if (compatibleVersion.InitCheck() != B_OK)
		return compare == 0;

	// Since compatibleVersion <= version, we can save the comparison, if
	// version <= fVersion.
	return compare <= 0 || compatibleVersion.Compare(fVersion) <= 0;
}


bool
BPackageResolvableExpression::Matches(const BPackageResolvable& provides) const
{
	if (provides.Name() != fName)
		return false;

	return Matches(provides.Version(), provides.CompatibleVersion());
}


}	// namespace BPackageKit