z-bar-qt/Plugins/ZShell/Settings/codecs.cpp

#include "codecs.hpp"

#include <qjsonarray.h>
#include <qjsonobject.h>
#include <qmetaobject.h>

#include <cmath>

#include "util/metaenum.hpp"

namespace ZShell::settings {

using Qt::StringLiterals::operator""_s;

namespace {

// We don't know the option here so it isn't set, it should be set by the caller
DecodeResult error(DiagnosticType::Type type, const QString& message) {
	Diagnostic error;
	error.type = type;
	error.message = message;
	return {.value = QVariant(), .error = error, .indexPath = {}};
}

DecodeResult mismatch(ExpectedType expected, const QJsonValue& value) {
	return {
		.value = QVariant(),
		.error = Diagnostic::mismatch(expected, value),
		.indexPath = {}};
}

DecodeResult mismatch(
	const QList<ExpectedType>& expected, const QJsonValue& value) {
	return {
		.value = QVariant(),
		.error = Diagnostic::mismatch(expected, value),
		.indexPath = {}};
}

template <typename Container> ValueCodec* makeListCodec(const QMetaType& type) {
	const auto* elementCodec = ValueCodec::codecFor(
		QMetaType::fromType<typename Container::value_type>());
	return elementCodec ? new ListCodec<Container>(type, elementCodec)
						: nullptr;
}

// Unions are keyed by their alternatives in order, since order decides which one wins
QString unionKey(const QList<QMetaType>& types) {
	QStringList ids;
	ids.reserve(types.size());
	for (const auto& type : types)
		ids << QString::number(type.id());
	return ids.join(u","_s);
}

QList<ExpectedType> expectedTypesOf(
	const QList<const ValueCodec*>& alternatives) {
	QList<ExpectedType> types;
	types.reserve(alternatives.size());
	for (const auto* codec : alternatives)
		types << codec->expected();
	return types;
}

using ListFactory = ValueCodec* (*)(const QMetaType&);

const QHash<int, ListFactory>& listFactories() {
	static const QHash<int, ListFactory> k_factories{
		{QMetaType::fromType<QStringList>().id(), &makeListCodec<QStringList>},
		{QMetaType::fromType<QList<qreal>>().id(),
		 &makeListCodec<QList<qreal>>},
	};
	return k_factories;
}

} // namespace

ValueCodec::ValueCodec(const QMetaType& type, ExpectedType expected)
	: m_type(type), m_expected(expected) {}

QMetaType ValueCodec::type() const {
	return m_type;
}

ExpectedType ValueCodec::expected() const {
	return m_expected;
}

ValueCodec* ValueCodec::codecFor(const QMetaType& type) {
	// Cache for codecs, keyed by type id
	static QHash<int, ValueCodec*> s_registry;

	// Cached lookup
	if (const auto it = s_registry.constFind(type.id());
		it != s_registry.constEnd())
		return *it;

	ValueCodec* codec = nullptr;
	switch (type.id()) {
	case QMetaType::Bool:
		codec = new BoolCodec(type);
		break;
	case QMetaType::Int:
		codec = new IntCodec(type);
		break;
	case QMetaType::Double:
		codec = new RealCodec(type);
		break;
	case QMetaType::QString:
		codec = new StringCodec(type);
		break;
	case QMetaType::QVariantList:
		codec = new VariantListCodec(type);
		break;
	case QMetaType::QVariantMap:
		codec = new VariantMapCodec(type);
		break;
	default:
		if (const auto factory = listFactories().constFind(type.id());
			factory != listFactories().constEnd())
			codec = (*factory)(type);
		else if (util::isSupportedEnum(type))
			codec = new EnumCodec(type, util::metaEnumFor(type));
		break;
	}

	// Cache codec
	if (codec) s_registry.insert(type.id(), codec);

	return codec;
}

ValueCodec* ValueCodec::unionFor(const QList<QMetaType>& types) {
	// Cache for union codecs, keyed by their alternatives
	static QHash<QString, ValueCodec*> s_registry;

	if (types.size() < 2) {
		qCCritical(
			lcSettings,
			"A union needs at least two types, got %lld",
			types.size());
		return nullptr;
	}

	const auto key = unionKey(types);

	// Cached lookup
	if (const auto it = s_registry.constFind(key); it != s_registry.constEnd())
		return *it;

	QList<const ValueCodec*> alternatives;
	alternatives.reserve(types.size());

	for (const auto& type : types) {
		const auto* codec = codecFor(type);
		if (!codec) {
			qCCritical(
				lcSettings,
				"No codec found for type %s, cannot build union",
				type.name());
			return nullptr;
		}
		alternatives << codec;
	}

	auto* const codec = new UnionCodec(alternatives);
	s_registry.insert(key, codec);

	return codec;
}

QJsonValue BoolCodec::encode(const QVariant& value) const {
	return value.toBool();
}

DecodeResult BoolCodec::decode(const QJsonValue& value) const {
	// 1 and "true" are not booleans
	if (!value.isBool()) return mismatch(ExpectedType::Bool, value);

	return {.value = value.toBool(), .error = std::nullopt, .indexPath = {}};
}

QJsonValue IntCodec::encode(const QVariant& value) const {
	return value.toInt();
}

DecodeResult IntCodec::decode(const QJsonValue& value) const {
	if (!value.isDouble()) return mismatch(ExpectedType::Int, value);

	const auto num = value.toDouble();

	double integral;
	if (std::fpclassify(std::modf(num, &integral)) != FP_ZERO)
		return error(
			DiagnosticType::InvalidValue,
			QStringLiteral("Expected an integer, got the real %1")
				.arg(QString::number(num)));

	constexpr auto k_min = std::numeric_limits<int>::min();
	constexpr auto k_max = std::numeric_limits<int>::max();
	if (num < static_cast<double>(k_min) || num > static_cast<double>(k_max)) {
		const auto message =
			QStringLiteral(
				"Integer %1 is out of range, expected between %2 and %3")
				.arg(
					QString::number(num, 'f', 0),
					QString::number(k_min),
					QString::number(k_max));
		return error(DiagnosticType::InvalidValue, message);
	}

	return {
		.value = static_cast<int>(num), .error = std::nullopt, .indexPath = {}};
}

QJsonValue RealCodec::encode(const QVariant& value) const {
	return value.toDouble();
}

DecodeResult RealCodec::decode(const QJsonValue& value) const {
	if (!value.isDouble()) return mismatch(ExpectedType::Real, value);

	return {
		.value = QVariant::fromValue<qreal>(value.toDouble()),
		.error = std::nullopt,
		.indexPath = {}};
}

QJsonValue StringCodec::encode(const QVariant& value) const {
	return value.toString();
}

DecodeResult StringCodec::decode(const QJsonValue& value) const {
	if (!value.isString()) return mismatch(ExpectedType::String, value);

	return {.value = value.toString(), .error = std::nullopt, .indexPath = {}};
}

QJsonValue VariantListCodec::encode(const QVariant& value) const {
	return QJsonArray::fromVariantList(value.toList());
}

DecodeResult VariantListCodec::decode(const QJsonValue& value) const {
	if (!value.isArray()) return mismatch(ExpectedType::Array, value);

	return {
		.value = value.toArray().toVariantList(),
		.error = std::nullopt,
		.indexPath = {}};
}

QJsonValue VariantMapCodec::encode(const QVariant& value) const {
	return QJsonObject::fromVariantMap(value.toMap());
}

DecodeResult VariantMapCodec::decode(const QJsonValue& value) const {
	if (!value.isObject()) return mismatch(ExpectedType::Object, value);

	return {
		.value = value.toObject().toVariantMap(),
		.error = std::nullopt,
		.indexPath = {}};
}

EnumCodec::EnumCodec(const QMetaType& type, const QMetaEnum& metaEnum)
	: ValueCodec(type, ExpectedType::String), m_metaEnum(metaEnum) {}

QJsonValue EnumCodec::encode(const QVariant& value) const {
	const auto* key = util::enumKeyFor(m_metaEnum, value);
	if (!key) {
		qCWarning(
			lcSettings,
			"Cannot encode value %lld of enum %s, no such enumerator",
			value.toLongLong(),
			m_type.name());
		return {};
	}

	return QString::fromUtf8(key);
}

DecodeResult EnumCodec::decode(const QJsonValue& value) const {
	if (!value.isString()) return mismatch(ExpectedType::String, value);

	const auto key = value.toString();

	for (int i = 0; i < m_metaEnum.keyCount(); ++i) {
		if (QString::compare(
				QString::fromUtf8(m_metaEnum.key(i)),
				key,
				Qt::CaseInsensitive) != 0)
			continue;

		const auto raw = m_metaEnum.value(i);
		QVariant decoded(m_type);
		if (!QMetaType::convert(
				QMetaType::fromType<int>(), &raw, m_type, decoded.data())) {
			qCCritical(
				lcSettings,
				"Failed to convert value %d to enum %s",
				raw,
				m_type.name());
			return error(
				DiagnosticType::InvalidValue,
				QStringLiteral("Could not convert %1 to %2")
					.arg(key, QString::fromUtf8(m_type.name())));
		}

		return {.value = decoded, .error = std::nullopt, .indexPath = {}};
	}

	QStringList options;
	options.reserve(m_metaEnum.keyCount());
	for (int i = 0; i < m_metaEnum.keyCount(); ++i)
		options << QString::fromUtf8(m_metaEnum.key(i));

	return error(
		DiagnosticType::InvalidValue,
		QStringLiteral("Invalid enum value %1. Expected one of %2")
			.arg(key, options.join(u", "_s)));
}

template <typename Container>
ListCodec<Container>::ListCodec(
	const QMetaType& type, const ValueCodec* elementCodec)
	: ValueCodec(type, ExpectedType::Array), m_elementCodec(elementCodec) {}

template <typename Container>
QJsonValue ListCodec<Container>::encode(const QVariant& value) const {
	QJsonArray array;
	const auto list = value.value<Container>();
	for (const auto& element : list)
		array.append(m_elementCodec->encode(QVariant::fromValue(element)));
	return array;
}

template <typename Container>
DecodeResult ListCodec<Container>::decode(const QJsonValue& value) const {
	if (!value.isArray()) return mismatch(ExpectedType::Array, value);

	const auto array = value.toArray();
	Container list;
	list.reserve(array.size());

	for (qsizetype i = 0; i < array.size(); ++i) {
		auto result = m_elementCodec->decode(array.at(i));

		// Reject the entire list if any element is invalid
		if (result.error) {
			result.indexPath.prepend(i);
			return result;
		}

		list.append(result.value.value<Value>());
	}

	return {
		.value = QVariant::fromValue(list),
		.error = std::nullopt,
		.indexPath = {}};
}

UnionCodec::UnionCodec(const QList<const ValueCodec*>& alternatives)
	: ValueCodec(
		  QMetaType::fromType<QVariant>(), alternatives.first()->expected())
	, m_alternatives(alternatives)
	, m_expectedTypes(expectedTypesOf(alternatives)) {
	m_byType.reserve(alternatives.size());

	for (const auto* codec : alternatives)
		m_byType.insert(codec->type().id(), codec);
}

QJsonValue UnionCodec::encode(const QVariant& value) const {
	// An unset union is simply absent from the file
	if (!value.isValid()) return QJsonValue::Undefined;

	const auto* codec = m_byType.value(value.metaType().id());
	if (!codec) {
		qCWarning(
			lcSettings,
			"Cannot encode value of type %s, it is not one of the allowed "
			"types",
			value.typeName());
		return QJsonValue::Undefined;
	}

	return codec->encode(value);
}

DecodeResult UnionCodec::decode(const QJsonValue& value) const {
	std::optional<DecodeResult> best;

	for (const auto* codec : m_alternatives) {
		auto result = codec->decode(value);

		// The first alternative to accept the value wins
		if (!result.error) return result;

		// Non-nested type mismatch just means try another alternative
		if (result.indexPath.isEmpty() &&
			result.error->type == DiagnosticType::TypeMismatch)
			continue;

		// Report the deepest error that isn't a type mismatch
		if (!best || result.indexPath.size() > best->indexPath.size())
			best = std::move(result);
	}

	if (best) return *best;

	// Nothing matched the shape, so report every alternative
	return mismatch(m_expectedTypes, value);
}

// Instantiated for types as needed
template class ListCodec<QStringList>;
template class ListCodec<QList<qreal>>;

} // namespace ZShell::settings