// Copyright (C) 2018 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default

#include "qlottiebase_p.h"

#include <QLoggingCategory>
#include <QRegularExpression>
#include <QRegularExpressionMatch>
#include <QString>

QT_BEGIN_NAMESPACE

using namespace Qt::Literals::StringLiterals;

Q_LOGGING_CATEGORY(lcLottieQtLottieParser, "qt.lottieqt.lottie.parser", QtWarningMsg);
Q_LOGGING_CATEGORY(lcLottieQtLottieUpdate, "qt.lottieqt.lottie.update");
Q_LOGGING_CATEGORY(lcLottieQtLottieRender, "qt.lottieqt.lottie.render");

QLottieBase::QLottieBase(const QLottieBase &other)
{
    m_definition = other.m_definition;
    m_type = other.m_type;
    m_hidden = other.m_hidden;
    m_name = other.m_name;
    for (QLottieBase *child : other.m_children) {
        QLottieBase *clone = child->clone();
        clone->setParent(this);
        appendChild(clone);
    }
}

QLottieBase::~QLottieBase()
{
    qDeleteAll(m_children);
}

QLottieBase *QLottieBase::clone() const
{
    return new QLottieBase(*this);
}

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

void QLottieBase::setName(const QString &name)
{
    m_name = name;
}

bool QLottieBase::setProperty(QLottieLiteral::PropertyType propertyName, QVariant value)
{
    for (QLottieBase *child : std::as_const(m_children)) {
        bool changed = child->setProperty(propertyName, value);
        if (changed)
            return true;
    }
    return false;
}

int QLottieBase::type() const
{
    return m_type;
}

void QLottieBase::setType(int type)
{
    m_type = type;
}

bool QLottieBase::isShapeElement() const
{
    return (m_type >= LOTTIE_SHAPE_ELLIPSE_IX && m_type <= LOTTIE_SHAPE_REPEATER_IX);
}

bool QLottieBase::isPathElement() const
{
    return (m_type == LOTTIE_SHAPE_ELLIPSE_IX || m_type == LOTTIE_SHAPE_RECT_IX
            || m_type == LOTTIE_SHAPE_SHAPE_IX || m_type == LOTTIE_SHAPE_STAR_IX);
}

void QLottieBase::prependChild(QLottieBase *child)
{
    m_children.push_front(child);
}

void QLottieBase::insertChildBeforeLast(QLottieBase *child)
{
    m_children.insert(qMax(m_children.size() - 1, 0), child);
}

void QLottieBase::appendChild(QLottieBase *child)
{
    m_children.push_back(child);
}

QLottieBase *QLottieBase::findChild(const QString &childName)
{
    if (name() == childName)
        return this;

    QLottieBase *found = nullptr;
    for (QLottieBase *child : std::as_const(m_children)) {
        found = child->findChild(childName);
        if (found)
            break;
    }
    return found;
}

void QLottieBase::updateProperties(int frame)
{
    if (m_hidden)
        return;

    for (QLottieBase *child : std::as_const(m_children))
        child->updateProperties(frame);
}

void QLottieBase::render(QLottieRenderer &renderer) const
{
    if (m_hidden)
        return;

    renderer.saveState();
    renderChildren(renderer);
    renderer.restoreState();
}

void QLottieBase::renderChildren(QLottieRenderer &renderer) const
{
    QList<QLottieBase *> pathElements;
    for (QLottieBase *child : std::as_const(m_children)) {
        if (child->isPathElement()) {
            if (!child->m_hidden)
                pathElements.prepend(child);
        } else {
            if (!pathElements.isEmpty()) {
                renderer.renderPathElements(pathElements);
                pathElements.clear();
            }
            if (!child->m_hidden)
                child->render(renderer);
        }
    }
    if (!pathElements.isEmpty())
        renderer.renderPathElements(pathElements);
}

bool QLottieBase::isStructureDumping() const
{
    if (m_structureDumping < 0) {
        QLottieBase *p = parent();
        m_structureDumping = p ? p->isStructureDumping() : 0;
    }
    return bool(m_structureDumping);
}

void QLottieBase::resolveTopRoot()
{
    if (!m_topRoot) {
        QLottieBase *p = this;
        while (p) {
            m_topRoot = p;
            p = p->parent();
        }
    }
    Q_ASSERT(m_topRoot);
}

QLottieBase *QLottieBase::topRoot() const
{
    if (!m_topRoot)
        const_cast<QLottieBase *>(this)->resolveTopRoot();
    return m_topRoot;
}

int QLottieBase::parse(const QJsonObject &definition)
{
    qCDebug(lcLottieQtLottieParser) << "QLottieBase::parse()";

    m_definition = definition;

    m_hidden = definition.value("hd"_L1).toBool(false);
    m_name = definition.value("nm"_L1).toString();
    m_matchName = definition.value("mn"_L1).toString();

    return 0;
}

const QJsonObject &QLottieBase::definition() const
{
    return m_definition;
}

bool QLottieBase::active(int frame) const
{
    Q_UNUSED(frame);
    return !m_hidden;
}

bool QLottieBase::hidden() const
{
    return m_hidden;
}

QSize QLottieBase::layerSize() const
{
    return m_parent ? m_parent->layerSize() : QSize();
}

void QLottieBase::setParent(QLottieBase *parent)
{
    m_parent = parent;
}

const QJsonObject QLottieBase::resolveExpression(const QJsonObject &definition)
{
    QString expr = definition.value("x"_L1).toString();

    // If there is no expression, return the original object definition
    if (expr.isEmpty())
        return definition;

    // Find out layer handle
    resolveTopRoot();

    QRegularExpression re(QStringLiteral("effect\\(\\'(.*?)\\'\\)\\(\\'(.*?)\\'\\)"));
    QRegularExpressionMatch match = re.match(expr);
    if (!match.hasMatch())
        return definition;

    QString effect = match.captured(1);
    QString elementName = match.captured(2);

    QJsonObject retVal = definition;

    if (QLottieBase *source = m_topRoot->findChild(effect)) {
        if (source->children().size())
            retVal = source->children().at(0)->definition().value("v"_L1).toObject();
        else
            retVal = source->definition().value("v"_L1).toObject();
        if (source->children().size() > 1)
            qCInfo(lcLottieQtLottieParser) << "Effect source points"
                                                "to a group that has"
                                                "many children. The"
                                                "first is be picked";
    } else {
        qCInfo(lcLottieQtLottieParser) << "Failed to find specified effect" << effect;
    }

    // Let users of the json know that it is originated from expression,
    // so they can adjust their behavior accordingly
    retVal.insert("fromExpression"_L1, true);

    return retVal;
}

bool QLottieBase::checkRequiredKeys(const QJsonObject &definition, const QLatin1StringView type,
                                    const QList<QLatin1StringView> &keys, const QString &name) const
{
    for (auto key : keys) {
        if (!definition.contains(key)) {
            qCWarning(lcLottieQtLottieParser) << type << name << "is missing required key \"" << key << "\"";
            return false;
        }
    }
    return true;
}

QT_END_NAMESPACE
