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

#include "node.hpp"


namespace ZShell::settings {

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

Node::Node(Node* fallback, QObject* parent, bool globalOnly)
	: QObject(parent)
	, m_globalOnly(globalOnly || (parentNode() && parentNode()->m_globalOnly))
	, m_rootNode(parentNode() ? parentNode()->rootNode() : this)
	, m_fallbackNode(fallback)
	, m_writeOrigin(WriteOrigin::Qml)
	, m_internalRead(false)
	, m_batcher(m_rootNode == this ? new ChangeBatcher(this) : nullptr) {
	if (fallback && !m_globalOnly)
		QObject::connect(
			fallback, &Node::optionChanged, this, &Node::onFallbackNotify);
}

QString Node::key() const {
	return parentNode() ? parentNode()->keyOf(this) : QString();
}

QString Node::path() const {
	return parentNode() ? parentNode()->pathFor(key()) : key();
}

QString Node::pathFor(const QString& key) const {
	const auto p = path();
	return p.isEmpty() ? key : p + u'.' + key;
}

QString Node::elementPath(const QString& path, const QString& index) {
	return path + u'[' + index + u']';
}

Node* Node::parentNode() const {
	return qobject_cast<Node*>(parent());
}

Node* Node::rootNode() const {
	return m_rootNode;
}

Node* Node::fallbackNode() const {
	return m_fallbackNode;
}

void Node::detachFallback() {
	if (m_fallbackNode) {
		QObject::disconnect(m_fallbackNode, nullptr, this, nullptr);
		m_fallbackNode = nullptr;
	}

	const auto childNodes = findChildren<Node*>(Qt::FindDirectChildrenOnly);
	for (auto* const child : childNodes)
		child->detachFallback();
}

bool Node::isGlobalOnly() const {
	return m_globalOnly;
}

bool Node::isOverride(const QString& key) const {
	return m_overrides.contains(key);
}

const QSet<QString>& Node::overrides() const {
	return m_overrides;
}

bool Node::hasContent() const {
	return !m_overrides.isEmpty() || m_quarantine ||
		   std::ranges::any_of(
			   findChildren<Node*>(Qt::FindDirectChildrenOnly),
			   &Node::hasContent);
}

QVariant Node::value(const QString& key) const {
	const auto* desc = schema().get(key);
	if (!desc) {
		qCCritical(
			lcSettings,
			"Attempted to read an unknown key %s, something is wrong.",
			qUtf8Printable(pathFor(key)));
		return {};
	}

	// Generated getters warn on global reads, this silences them as the warning is only for QML reads
	const InternalRead guard(m_rootNode);
	return metaObject()->property(desc->metaIndex).read(this);
}

bool Node::setValue(const QString& key, const QVariant& value) {
	const auto* desc = schema().get(key);
	if (!desc) {
		qCCritical(
			lcSettings,
			"Attempted to set an unknown key %s, something is wrong.",
			qUtf8Printable(pathFor(key)));
		return false;
	}

	if (desc->isNode) {
		qCCritical(
			lcSettings,
			"Attempted to set node %s directly, something is wrong.",
			qUtf8Printable(pathFor(key)));
		return false;
	}

	// Type mismatch, conversion should happen before this function is called
	if (rejectInvalidWrite(key, value)) return false;

	return metaObject()->property(desc->metaIndex).write(this, value);
}

void Node::resetToDefaults() {
	// Don't reset global only nodes on overlays, the whole subtree belongs to the global layer
	if (m_globalOnly && m_fallbackNode) return;

	m_quarantine.reset(); // Reset quarantine as well

	// No write scope, callers should create the scope
	for (const auto& desc : schema().descriptors()) {
		if (desc.isNode)
			value(desc.key).value<Node*>()->resetToDefaults();
		else if (
			!desc.globalOnly() ||
			!m_fallbackNode) // Skip resetting global options on overlays
			setValue(
				desc.key,
				m_fallbackNode ? m_fallbackNode->value(desc.key)
							   : desc.defaultValue());
	}
}

const Quarantine* Node::quarantine() const {
	return m_quarantine.get();
}

bool Node::rejectInvalidWrite(const QString& key, const QVariant& value) const {
	const auto* desc = schema().get(key);
	if (!desc || desc->accepts(value.metaType())) return false;

	qCWarning(
		lcSettings,
		"Type mismatch for %s, expected %s got %s",
		qUtf8Printable(pathFor(key)),
		qUtf8Printable(desc->typeString()),
		value.metaType().name());
	return true;
}

void Node::warnGlobalRead(const QString& key) const {
	if (!m_fallbackNode || m_rootNode->m_internalRead) return;

	qCWarning(
		lcSettings,
		"Global option %s was read from an overlay layer. "
		"This should not be used, read global options from the global layer "
		"instead.",
		qUtf8Printable(pathFor(key)));
}

bool Node::rejectGlobalWrite(const QString& key) {
	const auto* desc = schema().get(key);
	if (!desc) {
		qCCritical(
			lcSettings,
			"Attempted to check a write for an unknown key %s, something is "
			"seriously wrong...",
			qUtf8Printable(pathFor(key)));
		return false;
	}

	const auto origin = m_rootNode->m_writeOrigin;
	const auto fromUser = origin == WriteOrigin::Qml ||
						  origin == WriteOrigin::QmlReset;

	if ((!m_globalOnly && !desc->globalOnly()) || !fromUser || !m_fallbackNode)
		return false;

	if (origin == WriteOrigin::QmlReset)
		qCWarning(
			lcSettings,
			"Attempted to reset global option %s from an overlay layer, "
			"ignoring. "
			"This should not be used, reset global options from the global "
			"layer instead.",
			qUtf8Printable(pathFor(key)));
	else
		qCWarning(
			lcSettings,
			"Attempted to write global option %s from an overlay layer, "
			"ignoring. "
			"This should not be used, write global options from the global "
			"layer instead.",
			qUtf8Printable(pathFor(key)));

	return true;
}

void Node::warnGlobalSync(QList<Diagnostic>& diagnostics, const QString& path) {
	qCWarning(
		lcSettings,
		"Global option definition %s found in overlay file, ignoring.",
		qUtf8Printable(path));
	diagnostics << Diagnostic{
		.type = DiagnosticType::GlobalOption,
		.option = path,
		.message = QStringLiteral(
			"Global options should not be defined in overlay files"),
	};
}

bool Node::rejectGlobalSync(QList<Diagnostic>& diagnostics) const {
	if (!m_globalOnly || !m_fallbackNode) return false;

	warnGlobalSync(diagnostics, path());
	return true;
}

bool Node::recordWrite(const QString& key, bool changed) {
	const auto* desc = schema().get(key);
	if (!desc) {
		qCCritical(
			lcSettings,
			"Attempted to record a write for an unknown key %s, something is "
			"seriously wrong...",
			qUtf8Printable(pathFor(key)));
		return false;
	}

	const auto origin = m_rootNode->m_writeOrigin;
	const auto fromUser = origin == WriteOrigin::Qml ||
						  origin == WriteOrigin::QmlReset;

	bool dirty = changed;
	switch (origin) {
	// Init does not notify or write to file
	case WriteOrigin::Init:
		return false;

	// File and qml both count as overrides
	case WriteOrigin::File:
	case WriteOrigin::Qml:
		dirty |= !m_overrides.contains(key);
		m_overrides << key;
		break;

	// Layer is not an override, it is a sync with the fallback value
	case WriteOrigin::Layer:
		break;

	// Both resets clear the override
	case WriteOrigin::FileReset:
	case WriteOrigin::QmlReset:
		dirty |= m_overrides.remove(key);
		break;
	}

	// User writes/reset override quarantine
	if (fromUser) dirty |= removeQuarantined(key);

	// Both qml and reset write to the file (only write if dirty)
	if (fromUser && dirty) m_rootNode->m_batcher->dirty();

	if (changed) emit optionChanged(key);

	return changed;
}

bool Node::removeQuarantined(const QString& key) {
	if (!m_quarantine) return false;

	const auto removed = m_quarantine->remove(key);
	if (m_quarantine->isEmpty()) m_quarantine.reset();

	return removed;
}

ChangeBatcher* Node::batcher() const {
	return m_rootNode->m_batcher;
}

QString Node::keyOf(const Node* child) const {
	for (const auto& desc : schema().descriptors()) {
		if (desc.isNode && child == value(desc.key).value<Node*>())
			return desc.key;
	}

	return {};
}

void Node::onFallbackNotify(const QString& key) {
	if (m_overrides.contains(key)) return;

	// Don't mirror global options onto overlays
	const auto* desc = schema().get(key);
	if (desc && desc->globalOnly()) return;

	const WriteScope scope(this, WriteOrigin::Layer);
	setValue(key, m_fallbackNode->value(key));
}

} // namespace ZShell::settings