Power Gauge Pro

#include "backend/formulas/Formula.h"
#include "backend/core/logging/LoggingCategories.h"
#include "backend/formulas/BaseOperation.h"

Formula::Formula(QObject *parent)
    : QObject{parent}
    , m_value{Value{QVariant{}}}
{}

void Formula::onExpressionValueChanged()
{
    // Get the cached value from expression
    Value newValue{m_expressionRoot ? m_expressionRoot->value() : Value{QVariant{}}};
    if (newValue != m_value) {
        m_value = newValue;
        emit valueChanged(name(), newValue);
    }
}

QString Formula::name() const
{
    return m_name;
}

void Formula::setName(const QString &newName)
{
    m_name = newName;
}

Value Formula::value()
{
    if (m_expressionRoot.isNull())
        return Value{QVariant{}};
    return m_expressionRoot->value();
}

void Formula::parseFormula(const QJsonObject &description)
{
    m_expressionRoot = BaseOperation::parseExpression(description, this);

    if (!m_expressionRoot) {
        QString errorMsg{"Failed to parse formula expression"};
        m_currentErrors.clear();
        m_currentErrors.append(FormulaError{errorMsg, FormulaError::Error});
        qCWarning(pgpFormulasFormula) << errorMsg;
        emit errorsChanged();
        return;
    }

    // Clear any previous errors
    if (!m_currentErrors.isEmpty()) {
        m_currentErrors.clear();
        emit errorsChanged();
    }

    // Connect error propagation from expression tree
    connect(
        m_expressionRoot.data(),
        &Expression::errorsChanged,
        this,
        &Formula::onExpressionErrorsChanged);

    // Connect value changes
    connect(
        m_expressionRoot.data(),
        &Expression::valueChanged,
        this,
        &Formula::onExpressionValueChanged);

    // Initialize value by evaluating the expression
    if (m_expressionRoot) {
        m_value = m_expressionRoot->evaluate();
        m_currentErrors = m_expressionRoot->currentErrors();
        if (!m_currentErrors.isEmpty()) {
            emit errorsChanged();
        }
    }
}