/****************************************************************************
**
** Copyright (C) 2020 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt Quick 3D.
**
** $QT_BEGIN_LICENSE:GPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 or (at your option) any later version
** approved by the KDE Free Qt Foundation. The licenses are as published by
** the Free Software Foundation and appearing in the file LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "parser.h"

#include <QtCore/qdir.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qstringview.h>

#include <QtQml/qqmllist.h>

// Parsing
#include <QtQml/private/qqmljsengine_p.h>
#include <QtQml/private/qqmljslexer_p.h>
#include <QtQml/private/qqmljsparser_p.h>

#include <QtQuick3D/private/qquick3dobject_p.h>
#include <QtQuick3D/private/qquick3dviewport_p.h>
// Scene
#include <QtQuick3D/private/qquick3dsceneenvironment_p.h>
// Material(s)
#include <QtQuick3D/private/qquick3dprincipledmaterial_p.h>
#include <QtQuick3D/private/qquick3ddefaultmaterial_p.h>
#include <QtQuick3D/private/qquick3dcustommaterial_p.h>
// Lights
#include <QtQuick3D/private/qquick3dspotlight_p.h>
#include <QtQuick3D/private/qquick3dpointlight_p.h>
#include <QtQuick3D/private/qquick3ddirectionallight_p.h>

// Instancing
#include <QtQuick3D/private/qquick3dinstancing_p.h>

#include <QtQuick3D/private/qquick3dshaderutils_p.h>

#include <QtQuick3DUtils/private/qssginvasivelinkedlist_p.h>

QT_BEGIN_NAMESPACE

template<typename T, T *T::*N = &T::next>
struct InvasiveListView : protected QSSGInvasiveSingleLinkedList<T, N>
{
    using QSSGInvasiveSingleLinkedList<T, N>::begin;
    using QSSGInvasiveSingleLinkedList<T, N>::end;
    using QSSGInvasiveSingleLinkedList<T, N>::m_head;

    explicit InvasiveListView(const T &obj) { m_head = &const_cast<T &>(obj); }
};

template <typename T> struct TypeInfo
{
    static constexpr const char *qmlTypeName() { return "Unknown"; }
    static constexpr int typeId() { return QMetaType::UnknownType; }
};

#define DECLARE_QQ3D_TYPE(CLASS, TYPE_NAME) \
template<> struct TypeInfo<CLASS> \
{ \
    static constexpr const char *qmlTypeName() { return #TYPE_NAME; } \
    inline static constexpr int typeId() { return qMetaTypeId<CLASS>(); } \
    inline static constexpr int qmlListTypeId() { return qMetaTypeId<QQmlListProperty<CLASS>>(); } \
}

DECLARE_QQ3D_TYPE(QQuick3DViewport, View3D);
DECLARE_QQ3D_TYPE(QQuick3DSceneEnvironment, SceneEnvironment);
DECLARE_QQ3D_TYPE(QQuick3DMaterial, Material);
DECLARE_QQ3D_TYPE(QQuick3DPrincipledMaterial, PrincipledMaterial);
DECLARE_QQ3D_TYPE(QQuick3DDefaultMaterial, DefaultMaterial);
DECLARE_QQ3D_TYPE(QQuick3DCustomMaterial, CustomMaterial);
DECLARE_QQ3D_TYPE(QQuick3DDirectionalLight, DirectionalLight);
DECLARE_QQ3D_TYPE(QQuick3DPointLight, PointLight);
DECLARE_QQ3D_TYPE(QQuick3DSpotLight, SpotLight);
DECLARE_QQ3D_TYPE(QQuick3DTexture, Texture);
DECLARE_QQ3D_TYPE(QQuick3DShaderUtilsTextureInput, TextureInput);
DECLARE_QQ3D_TYPE(QQuick3DModel, Model);
DECLARE_QQ3D_TYPE(QQuick3DEffect, Effect);
DECLARE_QQ3D_TYPE(QQuick3DShaderUtilsRenderPass, Pass);
DECLARE_QQ3D_TYPE(QQuick3DShaderUtilsShader, Shader);
DECLARE_QQ3D_TYPE(QQuick3DInstanceList, InstanceList);
DECLARE_QQ3D_TYPE(QQuick3DInstanceListEntry, InstanceListEntry);

using QmlTypeNames = QHash<QString, int>;

#define QQ3D_TYPE_ENTRY(TYPE) { TypeInfo<TYPE>::qmlTypeName(), TypeInfo<TYPE>::typeId() }

QmlTypeNames baseTypeMap()
{
    return { QQ3D_TYPE_ENTRY(QQuick3DViewport),
             QQ3D_TYPE_ENTRY(QQuick3DSceneEnvironment),
             QQ3D_TYPE_ENTRY(QQuick3DPrincipledMaterial),
             QQ3D_TYPE_ENTRY(QQuick3DDefaultMaterial),
             QQ3D_TYPE_ENTRY(QQuick3DCustomMaterial),
             QQ3D_TYPE_ENTRY(QQuick3DDirectionalLight),
             QQ3D_TYPE_ENTRY(QQuick3DPointLight),
             QQ3D_TYPE_ENTRY(QQuick3DSpotLight),
             QQ3D_TYPE_ENTRY(QQuick3DTexture),
             QQ3D_TYPE_ENTRY(QQuick3DShaderUtilsTextureInput),
             QQ3D_TYPE_ENTRY(QQuick3DModel),
             QQ3D_TYPE_ENTRY(QQuick3DEffect),
             QQ3D_TYPE_ENTRY(QQuick3DShaderUtilsRenderPass),
             QQ3D_TYPE_ENTRY(QQuick3DShaderUtilsShader),
             QQ3D_TYPE_ENTRY(QQuick3DInstanceList),
             QQ3D_TYPE_ENTRY(QQuick3DInstanceListEntry)
    };
}

Q_GLOBAL_STATIC(QmlTypeNames, s_typeMap)

struct Context
{
    enum class Type
    {
        Application,
        Component
    };

    struct Property {
        enum MemberState : quint8
        {
            Uninitialized,
            Initialized
        };

        QObject *target = nullptr;
        QStringView name;
        int targetType = QMetaType::UnknownType;
        QMetaType::Type type = QMetaType::UnknownType;
        MemberState memberState = Uninitialized;
    };

    template<typename T> using Vector = QVector<T>;
    using InterceptObjDefFunc = bool (*)(const QQmlJS::AST::UiObjectDefinition &, Context &, int &);
    using InterceptObjBinding = bool (*)(const QQmlJS::AST::UiObjectBinding &, Context &, int &);
    using InterceptPublicMember = bool (*)(const QQmlJS::AST::UiPublicMember &, Context &, int &);
    using InterceptCallExpression = bool (*)(const QQmlJS::AST::CallExpression &, Context &, int &);

    QQmlJS::Engine *engine = nullptr;
    QDir workingDir; // aka source directory
    QFileInfo currentFileInfo;

    MaterialParser::SceneData sceneData;
    Property property;

    struct Component
    {
        QObject *ptr = nullptr;
        int type = QMetaType::UnknownType;
    };

    QHash<QStringView, QObject *> identifierMap;
    QHash<QString, Component> components;
    InterceptObjDefFunc interceptODFunc = nullptr;
    InterceptObjBinding interceptOBFunc = nullptr;
    InterceptPublicMember interceptPMFunc = nullptr;
    InterceptCallExpression interceptCallExpr = nullptr;
    Type type = Type::Application;
    bool dbgprint = false;
};

Q_DECLARE_TYPEINFO(Context::Component, Q_PRIMITIVE_TYPE);

namespace BuiltinHelpers {

using ArgumentListView = InvasiveListView<QQmlJS::AST::ArgumentList>;

template <typename T> Q_REQUIRED_RESULT constexpr quint8 componentCount() { Q_STATIC_ASSERT(true); return 0; }
template <> Q_REQUIRED_RESULT constexpr quint8 componentCount<QVector2D>() { return 2; }
template <> Q_REQUIRED_RESULT constexpr quint8 componentCount<QVector3D>() { return 3; }
template <> Q_REQUIRED_RESULT constexpr quint8 componentCount<QVector4D>() { return 4; }

static double expressionValue(const QQmlJS::AST::ExpressionNode &expr) {
    using namespace QQmlJS::AST;

    if (expr.kind == Node::Kind_NumericLiteral) {
        return static_cast<const NumericLiteral &>(expr).value;
    } else if (expr.kind == Node::Kind_UnaryMinusExpression) {
        const auto &minusExpr = static_cast<const UnaryMinusExpression &>(expr);
        if (minusExpr.expression && minusExpr.expression->kind == Node::Kind_NumericLiteral)
            return static_cast<const NumericLiteral &>(*minusExpr.expression).value * -1.0;
    } else if (expr.kind == Node::Kind_UnaryPlusExpression) {
        const auto &plusExpr = static_cast<const UnaryPlusExpression &>(expr);
        if (plusExpr.expression && plusExpr.expression->kind == Node::Kind_NumericLiteral)
            return static_cast<const NumericLiteral &>(*plusExpr.expression).value;
    } else {
        printf("Expression type \'%d\' unhandled!\n", expr.kind);
    }

    return 0.0;
}

template <typename T>
static inline bool setProperty(const Context::Property &property, const T &v)
{
    return property.target->setProperty(property.name.toLatin1(), QVariant::fromValue(v));
}

template<typename Vec>
static Vec toVec(const ArgumentListView &list, bool *ok = nullptr)
{
    using namespace QQmlJS::AST;
    int i = 0;
    const int e = componentCount<Vec>();
    Vec vec;
    for (const auto &listItem : list) {
        if (listItem.expression && i != e)
            vec[i] = expressionValue(*listItem.expression);
        ++i;
    }

    if (ok)
        *ok = (i == e);

    return vec;
}

static QPointF toPoint(const ArgumentListView &list, bool *ok = nullptr)
{
    using namespace QQmlJS::AST;
    int i = 0;
    const int e = 2;
    qreal args[e];
    for (const auto &listItem : list) {
        if (listItem.expression && i != e)
            args[i] = expressionValue(*listItem.expression);
        ++i;
    }

    if (ok)
        *ok = (i == e);

    return QPointF(args[0], args[1]);
}

static QSizeF toSize(const ArgumentListView &list, bool *ok = nullptr)
{
    using namespace QQmlJS::AST;
    int i = 0;
    const int e = 2;
    qreal args[e];
    for (const auto &listItem : list) {
        if (listItem.expression && listItem.expression->kind == Node::Kind_NumericLiteral && i != e)
            args[i] = expressionValue(*listItem.expression);
        ++i;
    }

    if (ok)
        *ok = (i == e);

    return QSizeF(args[0], args[1]);
}

static QRectF toRect(const ArgumentListView &list, bool *ok = nullptr)
{
    using namespace QQmlJS::AST;
    int i = 0;
    const int e = 4;
    qreal args[e];
    for (const auto &listItem : list) {
        if (listItem.expression && i != e)
            args[i] = expressionValue(*listItem.expression);
        ++i;
    }

    if (ok)
        *ok = (i == e);

    return QRectF(args[0], args[1], args[2], args[3]);
}

static QMatrix4x4 toMat44(const ArgumentListView &list, bool *ok = nullptr)
{
    using namespace QQmlJS::AST;
    int i = 0;
    const int e = 16;
    float args[e];
    for (const auto &listItem : list) {
        if (listItem.expression && i != e)
            args[i] = float(expressionValue(*listItem.expression));
        ++i;
    }

    if (ok)
        *ok = (i == e);

    return QMatrix4x4(args);
}

static QQuaternion toQuaternion(const ArgumentListView &list, bool *ok = nullptr)
{
    using namespace QQmlJS::AST;
    int i = 0;
    const int e = 4;
    float args[e];
    for (const auto &listItem : list) {
        if (listItem.expression && listItem.expression->kind == Node::Kind_NumericLiteral && i != e)
            args[i] = float(expressionValue(*listItem.expression));
        ++i;
    }

    if (ok)
        *ok = (i == e);

    return QQuaternion(args[0], args[1], args[2], args[3]);
}

// String variants
// Note: Unlike the call variants we assume arguments are correct (can be converted),
// as they should have failed earlier, during parsing, if they were not.
template <typename Vec>
static Vec toVec(const QStringView &ref)
{
    const auto args = ref.split(u',');
    Vec vec;
    bool ok = false;
    if (args.size() == componentCount<Vec>()) {
        for (int i = 0; i != componentCount<Vec>(); ++i) {
            vec[i] = args.at(i).toDouble(&ok);
            Q_ASSERT(ok);
        }
    }

    return vec;
}

static QPointF toPoint(const QStringView &ref)
{
    const auto args = ref.split(u",");
    if (args.size() == 2) {
        bool ok = false;
        const auto arg0 = args.at(0).toDouble(&ok);
        Q_ASSERT(ok);
        const auto arg1 = args.at(1).toDouble(&ok);
        Q_ASSERT(ok);
        return QPointF(arg0, arg1);
    }
    return QPointF();
}

static QSizeF toSize(const QStringView &ref)
{
    const auto args = ref.split(u'x');
    if (args.size() == 2) {
        bool ok = false;
        const auto arg0 = args.at(0).toDouble(&ok);
        Q_ASSERT(ok);
        const auto arg1 = args.at(1).toDouble(&ok);
        Q_ASSERT(ok);
        return QSizeF(arg0, arg1);
    }
    return QSizeF();
}

static QRectF toRect(const QStringView &ref)
{
    auto args = ref.split(u",");
    if (args.size() == 3) {
        bool ok = false;
        const auto arg0 = args.at(0).toDouble(&ok);
        Q_ASSERT(ok);
        const auto arg1 = args.at(1).toDouble(&ok);
        Q_ASSERT(ok);
        args = args.at(2).split(u'x');
        if (args.size() == 2) {
            const auto arg2 = args.at(0).toDouble(&ok);
            Q_ASSERT(ok);
            const auto arg3 = args.at(1).toDouble(&ok);
            Q_ASSERT(ok);
            return QRectF(arg0, arg1, arg2, arg3);
        }
    }
    return QRectF();
}

static QQuaternion toQuaternion(const QStringView &ref)
{
    const auto args = ref.split(u',');
    if (args.size() == 4) {
        bool ok = false;
        const auto arg0 = args.at(0).toDouble(&ok);
        Q_ASSERT(ok);
        const auto arg1 = args.at(1).toDouble(&ok);
        Q_ASSERT(ok);
        const auto arg2 = args.at(2).toDouble(&ok);
        Q_ASSERT(ok);
        const auto arg3 = args.at(3).toDouble(&ok);
        Q_ASSERT(ok);
        return QQuaternion(arg0, arg1, arg2, arg3);
    }
    return QQuaternion();
}

} // BuiltinHelpers

template <typename T>
static void cloneQmlList(const QObject &so, QMetaProperty &sp, QObject &to, QMetaProperty &tp) {
    Q_ASSERT(sp.typeId() == tp.typeId());
    const auto tv = tp.read(&to);
    const auto sv = sp.read(&so);
    if (sv.isValid() && tv.isValid()) {
        auto tl = tv.value<QQmlListProperty<T>>();
        auto sl = sv.value<QQmlListProperty<T>>();
        const auto count = sl.count(&sl);
        for (int i = 0; count != i; ++i) {
            const auto &item = sl.at(&sl, i);
            tl.append(&tl, item);
        }
    }
}

static void cloneProperties(QObject &target, const QObject &source)
{
    Q_ASSERT(target.metaObject() == source.metaObject());
    const auto smo = source.metaObject();
    auto tmo = target.metaObject();
    const int propCount = smo->propertyCount();
    for (int i = 0; i != propCount; ++i) {
        auto sp = smo->property(i);
        auto tp = tmo->property(i);
        if (sp.typeId() == tp.typeId()) {
            if (sp.typeId() == TypeInfo<QQuick3DMaterial>::qmlListTypeId())
                cloneQmlList<QQuick3DMaterial>(source, sp, target, tp);
            else if (sp.typeId() == TypeInfo<QQuick3DEffect>::qmlListTypeId())
                cloneQmlList<QQuick3DEffect>(source, sp, target, tp);
            else if (sp.typeId() == TypeInfo<QQuick3DShaderUtilsRenderPass>::qmlListTypeId())
                cloneQmlList<QQuick3DShaderUtilsRenderPass>(source, sp, target, tp);
            else if (sp.typeId() == TypeInfo<QQuick3DShaderUtilsShader>::qmlListTypeId())
                cloneQmlList<QQuick3DShaderUtilsShader>(source, sp, target, tp);
            else
                tmo->property(i).write(&target, smo->property(i).read(&source));
        }
    }

    // Clone the dynamic properties as well
    for (const auto &prop : source.dynamicPropertyNames())
        target.setProperty(prop.constData(), source.property(prop.constData()));
}

template <typename T>
inline QVariant fromStringEnumHelper(const QStringView &ref, const QMetaProperty &property)
{
    bool ok = false;
    const int v = property.enumerator().keyToValue(ref.toLatin1(), &ok);
    return ok ? QVariant::fromValue(T(v)) : QVariant();
}

static QVariant fromString(const QStringView &ref, const Context &ctx)
{
    const auto &p = ctx.property;
    if (!p.target)
        return QVariant();

    static const auto toBuiltinType = [](int type, const QStringView &ref, const QDir &workingDir) {
        using namespace BuiltinHelpers;
        bool ok = false;
        switch (type) {
        case QMetaType::Int:
        {
            const auto v = ref.toInt(&ok);
            return (ok ? QVariant::fromValue(v) : QVariant());
        }
            break;
        case QMetaType::Bool:
        {
            const auto v = ref.toInt(&ok);
            return (ok ? QVariant::fromValue(bool(v)) : QVariant());
        }
        case QMetaType::Double:
        {
            const auto v = ref.toDouble(&ok);
            return (ok ? QVariant::fromValue(qreal(v)) : QVariant());
        }
            break;
        case QMetaType::QString:
            return QVariant::fromValue(ref);
        case QMetaType::QUrl:
        {
            if (ref.startsWith(u':') || ref.startsWith(QDir::separator()))
                return QVariant::fromValue(QUrl::fromLocalFile(ref.toString()));
            else if (ref.startsWith(u'#'))
                return QVariant::fromValue(QUrl(ref.toString()));
            else
                return QVariant::fromValue(QUrl::fromUserInput(ref.toString(), workingDir.canonicalPath()));
        }
        case QMetaType::QColor:
            return QVariant::fromValue(QColor(ref));
        case QMetaType::QTime:
            return QVariant::fromValue(QTime::fromString(ref.toString()));
        case QMetaType::QDate:
            return QVariant::fromValue(QDate::fromString(ref.toString()));
        case QMetaType::QDateTime:
            return QVariant::fromValue(QDateTime::fromString(ref.toString()));
        case QMetaType::QRectF:
            return QVariant::fromValue(toRect(ref));
        case QMetaType::QPointF:
            return QVariant::fromValue(toPoint(ref));
        case QMetaType::QSizeF:
            return QVariant::fromValue(toSize(ref));
        case QMetaType::QVector2D:
            return QVariant::fromValue(toVec<QVector2D>(ref));
        case QMetaType::QVector3D:
            return QVariant::fromValue(toVec<QVector3D>(ref));
        case QMetaType::QVector4D:
            return QVariant::fromValue(toVec<QVector4D>(ref));
        case QMetaType::QQuaternion:
            return QVariant::fromValue(toQuaternion(ref));
        }

        return QVariant();
    };

    if (p.type != QMetaType::UnknownType) // Built in Qt types int, vector3d etc
        return toBuiltinType(p.type, ref, ctx.workingDir);

    // hard mode, detect the property type
    // We only care about the types that are relevant for us
    if (p.targetType != QMetaType::UnknownType) {
        Q_ASSERT(p.target);
        Q_ASSERT(!p.name.isEmpty());
        const int idx = p.target->metaObject()->indexOfProperty(p.name.toLatin1().constData());
        const auto property = p.target->metaObject()->property(idx);
        if (property.metaType().id() >= QMetaType::User) {
            const QMetaType metaType = property.metaType();
            if (p.targetType == TypeInfo<QQuick3DDefaultMaterial>::typeId() || p.targetType == TypeInfo<QQuick3DPrincipledMaterial>::typeId()) {
                // Common for both materials
                if (metaType.id() == qMetaTypeId<QQuick3DMaterial::CullMode>())
                    return fromStringEnumHelper<QQuick3DMaterial::CullMode>(ref, property);
                if (metaType.id() == qMetaTypeId<QQuick3DMaterial::TextureChannelMapping>())
                    return fromStringEnumHelper<QQuick3DMaterial::TextureChannelMapping>(ref, property);

                if (p.targetType == TypeInfo<QQuick3DPrincipledMaterial>::typeId()) {
                    if (metaType.id() == qMetaTypeId<QQuick3DPrincipledMaterial::Lighting>())
                        return fromStringEnumHelper<QQuick3DPrincipledMaterial::Lighting>(ref, property);
                    if (metaType.id() == qMetaTypeId<QQuick3DPrincipledMaterial::BlendMode>())
                        return fromStringEnumHelper<QQuick3DPrincipledMaterial::BlendMode>(ref, property);
                    if (metaType.id() == qMetaTypeId<QQuick3DPrincipledMaterial::AlphaMode>())
                        return fromStringEnumHelper<QQuick3DPrincipledMaterial::AlphaMode>(ref, property);
                } else if (p.targetType == TypeInfo<QQuick3DDefaultMaterial>::typeId()) {
                    if (metaType.id() == qMetaTypeId<QQuick3DDefaultMaterial::Lighting>())
                        return fromStringEnumHelper<QQuick3DDefaultMaterial::Lighting>(ref, property);
                    if (metaType.id() == qMetaTypeId<QQuick3DDefaultMaterial::BlendMode>())
                        return fromStringEnumHelper<QQuick3DDefaultMaterial::BlendMode>(ref, property);
                    if (metaType.id() == qMetaTypeId<QQuick3DDefaultMaterial::SpecularModel>())
                        return fromStringEnumHelper<QQuick3DDefaultMaterial::SpecularModel>(ref, property);
                }
            } else if (p.targetType == TypeInfo<QQuick3DCustomMaterial>::typeId()) {
                if (metaType.id() == qMetaTypeId<QQuick3DCustomMaterial::ShadingMode>())
                    return fromStringEnumHelper<QQuick3DCustomMaterial::ShadingMode>(ref, property);
                if (metaType.id() == qMetaTypeId<QQuick3DCustomMaterial::BlendMode>())
                    return fromStringEnumHelper<QQuick3DCustomMaterial::BlendMode>(ref, property);
            } else if (p.targetType == TypeInfo<QQuick3DSpotLight>::typeId() || p.targetType == TypeInfo<QQuick3DPointLight>::typeId()) {
                if (metaType.id() == qMetaTypeId<QQuick3DAbstractLight::QSSGShadowMapQuality>())
                    return fromStringEnumHelper<QQuick3DAbstractLight::QSSGShadowMapQuality>(ref, property);
            } else if (p.targetType == TypeInfo<QQuick3DSceneEnvironment>::typeId()) {
                if (metaType.id() == qMetaTypeId<QQuick3DSceneEnvironment::QQuick3DEnvironmentBackgroundTypes>())
                    return fromStringEnumHelper<QQuick3DSceneEnvironment::QQuick3DEnvironmentBackgroundTypes>(ref, property);
                if (metaType.id() == qMetaTypeId<QQuick3DSceneEnvironment::QQuick3DEnvironmentAAModeValues>())
                    return fromStringEnumHelper<QQuick3DSceneEnvironment::QQuick3DEnvironmentAAModeValues>(ref, property);
                if (metaType.id() == qMetaTypeId<QQuick3DSceneEnvironment::QQuick3DEnvironmentAAQualityValues>())
                    return fromStringEnumHelper<QQuick3DSceneEnvironment::QQuick3DEnvironmentAAQualityValues>(ref, property);
                if (metaType.id() == qMetaTypeId<QQuick3DSceneEnvironment::QQuick3DEnvironmentTonemapModes>())
                    return fromStringEnumHelper<QQuick3DSceneEnvironment::QQuick3DEnvironmentTonemapModes>(ref, property);
            } else if (p.targetType == TypeInfo<QQuick3DShaderUtilsShader>::typeId()) {
                if (metaType.id() == qMetaTypeId<QQuick3DShaderUtilsShader::Stage>())
                    return fromStringEnumHelper<QQuick3DShaderUtilsShader::Stage>(ref, property);
            }
        } else { // Qt type
            return toBuiltinType(property.metaType().id(), ref, ctx.workingDir);
        }
    }

    if (ctx.dbgprint)
        printf("Unhandled type for property %s\n", ref.toLatin1().constData());

    return QVariant();
}

static QString getQmlFileExtension() { return QStringLiteral("qml"); }

struct Visitors
{
    static void visit(const QQmlJS::AST::UiProgram &program, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;
        const bool readHeaders = false;
        if (readHeaders && program.headers) { // No real need for us to look at the includes
            using HeaderItem = UiHeaderItemList;
            using Headers = InvasiveListView<HeaderItem>;

            Headers headers(*program.headers);
            for (const auto &header : headers)
                printf("Type: %d\n", header.kind);
        }
        if (program.members)
            visit(*program.members, ctx, ret);
    }
    static void visit(const QQmlJS::AST::UiObjectInitializer &objInitializer, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;
        if (objInitializer.members)
            visit(*objInitializer.members, ctx, ret);
    }

    static void visit(const QQmlJS::AST::UiObjectDefinition &def, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;
        if (ctx.dbgprint)
            printf("Object definition -> %s\n", def.qualifiedTypeNameId->name.toLocal8Bit().constData());
        if (!(ctx.interceptODFunc && ctx.interceptODFunc(def, ctx, ret))) {
            if (def.initializer)
                visit(*static_cast<UiObjectInitializer *>(def.initializer), ctx, ret);
        }
    }

    static void visit(const QQmlJS::AST::UiArrayMemberList &memberList, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;
        using ArrayMemberItem = UiArrayMemberList;
        using ArrayMembers = InvasiveListView<ArrayMemberItem>;

        ArrayMembers arrayMembers(memberList);
        for (auto &object : arrayMembers) {
            if (object.member->kind == Node::Kind_UiObjectDefinition) {
                const auto &def = *static_cast<UiObjectDefinition *>(object.member);
                visit(def, ctx, ret);
            }
        }
    }

    static void visit(const QQmlJS::AST::UiScriptBinding &binding, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;
        if (ctx.dbgprint)
            printf("Script binding -> %s ", binding.qualifiedId->name.toLocal8Bit().constData());

        const auto oldName = ctx.property.name; // reentrancy
        ctx.property.name = binding.qualifiedId->name;

        if (binding.statement) {
            if (binding.statement->kind == Node::Kind_ExpressionStatement) {
                const auto &expressionStatement = static_cast<const ExpressionStatement &>(*binding.statement);
                visit(expressionStatement, ctx, ret);
            }
        }
        ctx.property.name = oldName;
    }

    static void visit(const QQmlJS::AST::UiArrayBinding &arrayBinding, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;
        if (ctx.dbgprint)
            printf("Array binding(s) -> %s: [\n", arrayBinding.qualifiedId->name.toLocal8Bit().constData());

        const auto oldName = ctx.property.name; // reentrancy
        ctx.property.name = arrayBinding.qualifiedId->name;

        if (arrayBinding.members)
            visit(*arrayBinding.members, ctx, ret);

        if (ctx.dbgprint)
            printf("]\n");

        ctx.property.name = oldName;
    }

    static void visit(const QQmlJS::AST::UiObjectBinding &objectBinding, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;

        if (ctx.dbgprint)
            printf("Object binding -> %s: %s {\n", objectBinding.qualifiedId->name.toLocal8Bit().constData(), objectBinding.qualifiedTypeNameId->name.toLocal8Bit().constData());

        if (objectBinding.initializer) {
            if (!(ctx.interceptOBFunc && ctx.interceptOBFunc(objectBinding, ctx, ret)))
                visit(*objectBinding.initializer, ctx, ret);
        }

        if (ctx.dbgprint)
            printf("}\n");
    }

    static void visit(const QQmlJS::AST::UiPublicMember &member, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;

        if (ctx.dbgprint)
            printf("%s member -> %s ", (member.type == UiPublicMember::Signal ? "Signal" : "Property"), member.name.toLocal8Bit().constData());

        auto name = ctx.property.name;
        ctx.property.name = member.name;
        const auto typeCpy = ctx.property.type;

        if (!(ctx.interceptPMFunc && ctx.interceptPMFunc(member, ctx, ret))) {
            if (member.statement) {
                const auto &statement = member.statement;
                if (statement->kind == Node::Kind_ExpressionStatement)
                    visit(static_cast<const ExpressionStatement &>(*statement), ctx, ret);
                else if (ctx.dbgprint)
                    printf("Unhandled statement (%d)\n", statement->kind);
            } else if (member.binding) {
                const auto &binding = member.binding;
                if (binding->kind == Node::Kind_UiObjectBinding)
                    visit(static_cast<const UiObjectBinding &>(*binding), ctx, ret);
                else if (ctx.dbgprint)
                    printf("Unhandled binding (%d)\n", binding->kind);
            }
        }

        qSwap(ctx.property.name, name);
        ctx.property.type = typeCpy;
    }

    static void visit(const QQmlJS::AST::ExpressionStatement &exprStatement, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;
        if (exprStatement.expression) {
            if (exprStatement.expression->kind == Node::Kind_IdentifierExpression) {
                const auto &identExpression = static_cast<const IdentifierExpression &>(*exprStatement.expression);
                visit(identExpression, ctx, ret);
            } else if (exprStatement.expression->kind == Node::Kind_StringLiteral) {
                const auto &stringLiteral = static_cast<const StringLiteral &>(*exprStatement.expression);
                visit(stringLiteral, ctx, ret);
            } else if (exprStatement.expression->kind == Node::Kind_NumericLiteral) {
                const auto &numericLiteral = static_cast<const NumericLiteral &>(*exprStatement.expression);
                visit(numericLiteral, ctx, ret);
            } else if (exprStatement.expression->kind == Node::Kind_FieldMemberExpression) {
                const auto &fieldMemberExpression = static_cast<const FieldMemberExpression &>(*exprStatement.expression);
                visit(fieldMemberExpression, ctx, ret);
            } else if (exprStatement.expression->kind == Node::Kind_TrueLiteral || exprStatement.expression->kind == Node::Kind_FalseLiteral) {
                const bool v = (exprStatement.expression->kind == Node::Kind_TrueLiteral);
                if (ctx.dbgprint)
                    printf("-> TrueLiteral: %s\n", v ? "true" : "false");
                if (ctx.property.target) {
                    auto target = ctx.property.target;
                    const auto &name = ctx.property.name;
                    target->setProperty(name.toLatin1(), QVariant::fromValue(v));
                }
            } else if (exprStatement.expression->kind == Node::Kind_ArrayPattern) {
                const auto &arrayPattern = static_cast<const ArrayPattern &>(*exprStatement.expression);
                visit(arrayPattern, ctx, ret);
            } else if (exprStatement.expression->kind == Node::Kind_CallExpression) {
                const auto &callExpression = static_cast<const CallExpression &>(*exprStatement.expression);
                visit(callExpression, ctx, ret);
            } else if (exprStatement.expression->kind == Node::Kind_UnaryMinusExpression) {
                const auto &unaryMinusExpr = static_cast<const UnaryMinusExpression &>(*exprStatement.expression);
                if (unaryMinusExpr.expression && unaryMinusExpr.expression->kind == Node::Kind_NumericLiteral) {
                    auto &numericLiteral = static_cast<NumericLiteral &>(*unaryMinusExpr.expression);
                    const auto value = numericLiteral.value;
                    numericLiteral.value *= -1;
                    visit(numericLiteral, ctx, ret);
                    numericLiteral.value = value;
                }
            } else if (exprStatement.expression->kind == Node::Kind_UnaryPlusExpression) {
                const auto &unaryPlusExpr = static_cast<const UnaryPlusExpression &>(*exprStatement.expression);
                if (unaryPlusExpr.expression)
                    visit(static_cast<const NumericLiteral &>(*unaryPlusExpr.expression), ctx, ret);
            } else {
                if (ctx.dbgprint)
                    printf("<expression: %d>\n", exprStatement.expression->kind);
            }
        }
    }

    static void visit(const QQmlJS::AST::IdentifierExpression &idExpr, Context &ctx, int &ret)
    {
        Q_UNUSED(ret);
        if (ctx.dbgprint)
            printf("-> Identifier: %s\n", idExpr.name.toLocal8Bit().constData());

        if (ctx.property.target && ctx.type != Context::Type::Component) {
            const auto foundIt = ctx.identifierMap.constFind(idExpr.name);
            const auto end = ctx.identifierMap.constEnd();
            if (foundIt != end) { // If an item was found it means this is a reference
                if (ctx.property.targetType == TypeInfo<QQuick3DModel>::typeId()) {
                    if (QQuick3DMaterial *mat = qobject_cast<QQuick3DMaterial *>(*foundIt)) {
                        auto materials = qobject_cast<QQuick3DModel *>(ctx.property.target)->materials();
                        // Since we are initializing this for the first time, make sure we clean out any inherited data!
                        if (ctx.property.memberState == Context::Property::Uninitialized) {
                            if (ctx.dbgprint)
                                printf("Clearing inherited materials\n");
                            materials.clear(&materials);
                            ctx.property.memberState = Context::Property::Initialized;
                        }
                        materials.append(&materials, mat);
                        if (ctx.dbgprint)
                            printf("Appending material to %s\n", ctx.property.name.toLatin1().constData());
                    } else if (QQuick3DInstanceList *instancingList = qobject_cast<QQuick3DInstanceList *>(*foundIt)) {
                        qobject_cast<QQuick3DModel *>(ctx.property.target)->setInstancing(instancingList);
                        if (ctx.dbgprint)
                            printf("Setting instance list on model\n");
                    }
                } else if (ctx.property.targetType == TypeInfo<QQuick3DSceneEnvironment>::typeId()) {
                    if (QQuick3DEffect *effect = qobject_cast<QQuick3DEffect *>(*foundIt)) {
                        auto effects = qobject_cast<QQuick3DSceneEnvironment *>(ctx.property.target)->effects();
                        // Since we are initializing this for the first time, make sure we clean out any inherited data!
                        if (ctx.property.memberState == Context::Property::Uninitialized) {
                            if (ctx.dbgprint)
                                printf("Clearing inherited effects\n");
                            effects.clear(&effects);
                            ctx.property.memberState = Context::Property::Initialized;
                        }
                        effects.append(&effects, effect);
                        if (ctx.dbgprint)
                            printf("Appending effect to \'%s\'\n", ctx.property.name.toLatin1().constData());
                    }
                } else if (ctx.property.targetType == TypeInfo<QQuick3DShaderUtilsRenderPass>::typeId()) {
                    if (QQuick3DShaderUtilsShader *shader = qobject_cast<QQuick3DShaderUtilsShader *>(*foundIt)) {
                        auto shaders = qobject_cast<QQuick3DShaderUtilsRenderPass *>(ctx.property.target)->shaders();
                        // Since we are initializing this for the first time, make sure we clean out any inherited data!
                        if (ctx.property.memberState == Context::Property::Uninitialized) {
                            if (ctx.dbgprint)
                                printf("Clearing inherited shaders\n");
                            shaders.clear(&shaders);
                            ctx.property.memberState = Context::Property::Initialized;
                        }
                        shaders.append(&shaders, shader);
                        if (ctx.dbgprint)
                            printf("Appending shader to \'%s\'\n", ctx.property.name.toLatin1().constData());
                    }
                } else if (ctx.property.targetType == TypeInfo<QQuick3DInstanceList>::typeId()) {
                    if (QQuick3DInstanceListEntry *listEntry = qobject_cast<QQuick3DInstanceListEntry *>(*foundIt)) {
                        auto instances = qobject_cast<QQuick3DInstanceList *>(ctx.property.target)->instances();
                        // Since we are initializing this for the first time, make sure we clean out any inherited data!
                        if (ctx.property.memberState == Context::Property::Uninitialized) {
                            if (ctx.dbgprint)
                                printf("Clearing inherited instances\n");
                            instances.clear(&instances);
                            ctx.property.memberState = Context::Property::Initialized;
                        }
                        instances.append(&instances, listEntry);
                        if (ctx.dbgprint)
                            printf("Appending instance entry to %s\n", ctx.property.name.toLatin1().constData());
                    } else if (QQuick3DInstanceList *instancingList = qobject_cast<QQuick3DInstanceList *>(*foundIt)) {
                        qobject_cast<QQuick3DModel *>(ctx.property.target)->setInstancing(instancingList);
                        if (ctx.dbgprint)
                            printf("Setting instance list on model\n");
                    }
                } else if (ctx.dbgprint) {
                    printf("Unhandled binding: %s\n", idExpr.name.toLatin1().constData());
                }
            } else {
                // If no item with 'this' id was found, then that id is for 'this' object (if this not the case, then something is broken, e.g., a ref to an unknown item).
                // NOTE: This can be a problem in the future and we might need to add some more guards, but for now it just won't generate the correct shader(s).
                ctx.identifierMap.insert(idExpr.name, ctx.property.target);
            }
        }
    }

    static void visit(const QQmlJS::AST::StringLiteral &stringLiteral, Context &ctx, int &ret)
    {
        Q_UNUSED(ret);
        if (ctx.dbgprint)
            printf("-> StringLiteral: \"%s\"\n", stringLiteral.value.toLocal8Bit().constData());

        if (ctx.property.target) {
            const auto &name = ctx.property.name;
            const auto v = fromString(stringLiteral.value, ctx);
            if (v.isValid()) {
                const bool b = ctx.property.target->setProperty(name.toLatin1(), v);
                if (b && ctx.dbgprint)
                    printf("Property %s updated!\n", name.toLatin1().constData());
            }
        }
    }

    static void visit(const QQmlJS::AST::NumericLiteral &numericLiteral, Context &ctx, int &ret)
    {
        Q_UNUSED(ret);
        if (ctx.dbgprint)
            printf("-> NumericLiteral: %f\n", numericLiteral.value);

        if (ctx.property.target) {
            auto target = ctx.property.target;
            const auto &name = ctx.property.name;
            target->setProperty(name.toLatin1(), QVariant::fromValue(numericLiteral.value));
        }
    }

    static void visit(const QQmlJS::AST::FieldMemberExpression &fieldMemberExpression, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;

        Q_UNUSED(ret);
        if (ctx.dbgprint)
            printf("-> FieldMemberExpression: %s\n", fieldMemberExpression.name.toLocal8Bit().constData());

        if (ctx.property.target) {
            const auto &name = ctx.property.name;
            const auto v = fromString(fieldMemberExpression.name, ctx);
            if (v.isValid())
                ctx.property.target->setProperty(name.toLatin1(), v);
        }
    }

    static void visit(const QQmlJS::AST::ArrayPattern &arrayPattern, Context &ctx, int &ret)
    {
        Q_UNUSED(ret);
        if (ctx.dbgprint)
            printf("-> [ ");

        using namespace QQmlJS::AST;
        using PatternElementItem = PatternElementList;
        using PatternElementListView = InvasiveListView<PatternElementItem>;

        PatternElementListView elements(*arrayPattern.elements);
        for (auto &element : elements) {
            auto patternElement = element.element;
            if (patternElement->type == PatternElement::Literal) {
                if (patternElement->initializer && patternElement->initializer->kind == Node::Kind_IdentifierExpression) {
                    const auto &identExpression = static_cast<const IdentifierExpression &>(*patternElement->initializer);
                    visit(identExpression, ctx, ret);
                }
            } else if (ctx.dbgprint) {
                printf("Unahandled(%d), ", patternElement->type);
            }
        }

        if (ctx.dbgprint)
            printf(" ]\n");

    }

    static void visit(const QQmlJS::AST::CallExpression &callExpression, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;

        Q_UNUSED(ret);
        Q_UNUSED(callExpression);
        if (ctx.dbgprint)
            printf("-> Call(%d)\n", callExpression.base->kind);

        (ctx.interceptCallExpr && ctx.interceptCallExpr(callExpression, ctx, ret));
    }

    static void visit(const QQmlJS::AST::UiObjectMember &member, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;

        if (member.kind == Node::Kind_UiObjectBinding)
            visit(static_cast<const UiObjectBinding &>(member), ctx, ret);
        else if (ctx.dbgprint)
            printf("Unhandled member (%d)\n", member.kind);
    }

    static void visit(const QQmlJS::AST::UiObjectMemberList &memberList, Context &ctx, int &ret)
    {
        using namespace QQmlJS::AST;
        using ObjectMemberItem = UiObjectMemberList;
        using ObjectMembers = InvasiveListView<ObjectMemberItem>;

        const auto oldEvalType = ctx.property.memberState;

        ObjectMembers objectMembers(memberList);
        for (const auto &member : objectMembers) {
            if (member.member) {
                if (member.member->kind == Node::Kind_UiScriptBinding) {
                    ctx.property.memberState = Context::Property::MemberState::Uninitialized;
                    const auto &scriptBinding = static_cast<const UiScriptBinding &>(*member.member);
                    visit(scriptBinding, ctx, ret);
                } else if (member.member->kind == Node::Kind_UiArrayBinding) {
                    ctx.property.memberState = Context::Property::MemberState::Uninitialized;
                    const auto &arrayBinding = static_cast<const UiArrayBinding &>(*member.member);
                    visit(arrayBinding, ctx, ret);
                } else if (member.member->kind == Node::Kind_UiObjectDefinition) {
                    const auto &objectDef = static_cast<const UiObjectDefinition &>(*member.member);
                    visit(objectDef, ctx, ret);
                } else if (member.member->kind == Node::Kind_UiObjectBinding) {
                    ctx.property.memberState = Context::Property::MemberState::Uninitialized;
                    const auto &objBinding = static_cast<const UiObjectBinding &>(*member.member);
                    visit(objBinding, ctx, ret);
                } else if (member.member->kind == Node::Kind_UiPublicMember) {
                    ctx.property.memberState = Context::Property::MemberState::Uninitialized;
                    const auto &pubMember = static_cast<const UiPublicMember &>(*member.member);
                    visit(pubMember, ctx, ret);
                } else {
                    if (ctx.dbgprint)
                        printf("<member %d>\n", member.member->kind);
                }
            }
        }

        ctx.property.memberState = oldEvalType;
    }

private:
    Visitors() = delete;
    Q_DISABLE_COPY(Visitors);
};

template <typename O, typename T>
T *buildType(const O &obj, Context &ctx, int &ret, const T *base = nullptr)
{
    // swap -> reentrancy
    Context::Property property;
    qSwap(property, ctx.property);
    Q_ASSERT(ctx.property.target == nullptr);

    T *instance = nullptr;

    if (ctx.dbgprint)
        printf("Building %s!\n", TypeInfo<T>::qmlTypeName());

    if (obj.initializer) {
        instance = new T;
        if (base)
            cloneProperties(*instance, *base);

        if (obj.initializer) {
            ctx.property.target = instance;
            ctx.property.targetType = TypeInfo<T>::typeId();
            Visitors::visit(*obj.initializer, ctx, ret);
        }
    }

    // swap back
    qSwap(property, ctx.property);

    return instance;
}

static QQuick3DAbstractLight *buildLight(const QQmlJS::AST::UiObjectDefinition &def,
                                         Context &ctx,
                                         int &ret,
                                         int lightType,
                                         const QQuick3DAbstractLight *base = nullptr)
{
    if (lightType == TypeInfo<QQuick3DDirectionalLight>::typeId())
        return buildType(def, ctx, ret, qobject_cast<const QQuick3DDirectionalLight *>(base));
    if (lightType == TypeInfo<QQuick3DPointLight>::typeId())
        return buildType(def, ctx, ret, qobject_cast<const QQuick3DPointLight *>(base));
    if (lightType == TypeInfo<QQuick3DSpotLight>::typeId())
        return buildType(def, ctx, ret, qobject_cast<const QQuick3DSpotLight *>(base));
    return nullptr;
}


template <typename T>
static void updateProperty(Context &ctx, T type, QStringView propName)
{
    if (ctx.property.target) {
        if (ctx.dbgprint)
            printf("Updating property %s\n", propName.toLatin1().constData());
        const auto &target = ctx.property.target;
        if (ctx.property.memberState == Context::Property::Uninitialized) {
            target->setProperty(propName.toLatin1().constData(), QVariant::fromValue(type));
            ctx.property.memberState = Context::Property::Initialized;
        } else {
            const int idx = target->metaObject()->indexOfProperty(propName.toLatin1().constData());
            if (idx != -1) {
                auto prop = target->metaObject()->property(idx);
                prop.write(target, QVariant::fromValue(type));
            }
        }
    }
}

static bool interceptObjectBinding(const QQmlJS::AST::UiObjectBinding &objectBinding, Context &ctx, int &ret)
{
    if (ctx.dbgprint)
        printf("Intercepted object binding!\n");

    bool handled = false;

    const auto &typeName = objectBinding.qualifiedTypeNameId->name.toString();
    const auto &propName = objectBinding.qualifiedId->name;

    int type = -1;

    // Base type?
    const auto typeIt = s_typeMap->constFind(typeName);
    if (typeIt != s_typeMap->cend())
        type = *typeIt;

    // Component?
    auto &components = ctx.components;
    const auto compIt = (type == -1) ? components.constFind(typeName) : components.cend();
    QObject *base = nullptr;
    if (compIt != components.cend()) {
        type = compIt->type;
        base = compIt->ptr;
    }

    if (type != -1) {
        if (ctx.dbgprint)
            printf("Resolving: \'%s\'\n", qPrintable(typeName));

        if (type == TypeInfo<QQuick3DSceneEnvironment>::typeId()) {
            if (ctx.property.targetType == TypeInfo<QQuick3DViewport>::typeId()) {
                if (auto environment = buildType(objectBinding, ctx, ret, qobject_cast<QQuick3DSceneEnvironment *>(base))) {
                    auto viewport = qobject_cast<QQuick3DViewport *>(ctx.property.target);
                    Q_ASSERT(viewport);
                    viewport->setEnvironment(environment);
                    handled = true;
                }
            }
        } else if (type == TypeInfo<QQuick3DTexture>::typeId()) {
            if (auto tex = buildType(objectBinding, ctx, ret, qobject_cast<QQuick3DTexture *>(base))) {
                updateProperty(ctx, tex, propName);
                ctx.sceneData.textures.append(tex);
            }
            handled = true;
        } else if (type == TypeInfo<QQuick3DShaderUtilsTextureInput>::typeId()) {
            auto texInput = buildType(objectBinding, ctx, ret, qobject_cast<QQuick3DShaderUtilsTextureInput *>(base));
            if (texInput && texInput->texture()) {
                updateProperty(ctx, texInput, propName);
                ctx.sceneData.textures.append(texInput->texture());
            }
            handled = true;
        } else if (type == TypeInfo<QQuick3DEffect>::typeId()) {
            if (ctx.property.targetType == TypeInfo<QQuick3DSceneEnvironment>::typeId()) {
                if (auto effect = buildType(objectBinding, ctx, ret, qobject_cast<QQuick3DEffect *>(base))) {
                    auto sceneEnvironment = qobject_cast<QQuick3DSceneEnvironment *>(ctx.property.target);
                    Q_ASSERT(sceneEnvironment);
                    auto effects = sceneEnvironment->effects();
                    effects.append(&effects, effect);
                    handled = true;
                }
            }
        } else if (type == TypeInfo<QQuick3DShaderUtilsRenderPass>::typeId()) {
            if (ctx.property.targetType == TypeInfo<QQuick3DEffect>::typeId()) {
                if (auto pass = buildType(objectBinding, ctx, ret, qobject_cast<QQuick3DShaderUtilsRenderPass *>(base))) {
                    auto effect = qobject_cast<QQuick3DEffect *>(ctx.property.target);
                    Q_ASSERT(effect);
                    auto passes = effect->passes();
                    passes.append(&passes, pass);
                    handled = true;
                }
            }
        } else if (type == TypeInfo<QQuick3DShaderUtilsShader>::typeId()) {
            if (ctx.property.targetType == TypeInfo<QQuick3DShaderUtilsRenderPass>::typeId()) {
                if (auto shader = buildType(objectBinding, ctx, ret, qobject_cast<QQuick3DShaderUtilsShader *>(base))) {
                    auto pass = qobject_cast<QQuick3DShaderUtilsRenderPass *>(ctx.property.target);
                    Q_ASSERT(pass);
                    auto shaders = pass->shaders();
                    shaders.append(&shaders, shader);
                    handled = true;
                }
            }
        } else if (type == TypeInfo<QQuick3DDefaultMaterial>::typeId()) {
            if (ctx.property.targetType == TypeInfo<QQuick3DModel>::typeId()) {
                if (auto mat = buildType(objectBinding, ctx, ret, qobject_cast<QQuick3DDefaultMaterial *>(base))) {
                    auto model = qobject_cast<QQuick3DModel *>(ctx.property.target);
                    Q_ASSERT(model);
                    auto materials = model->materials();
                    materials.append(&materials, mat);
                    handled = true;
                    if (ctx.dbgprint)
                        printf("Appending material to %s\n", ctx.property.name.toLatin1().constData());
                }
            }
        } else if (type == TypeInfo<QQuick3DPrincipledMaterial>::typeId()) {
            if (ctx.property.targetType == TypeInfo<QQuick3DModel>::typeId()) {
                if (auto mat = buildType(objectBinding, ctx, ret, qobject_cast<QQuick3DPrincipledMaterial *>(base))) {
                    auto model = qobject_cast<QQuick3DModel *>(ctx.property.target);
                    Q_ASSERT(model);
                    auto materials = model->materials();
                    materials.append(&materials, mat);
                    handled = true;
                }
            }
        } else if (type == TypeInfo<QQuick3DCustomMaterial>::typeId()) {
            if (ctx.property.targetType == TypeInfo<QQuick3DModel>::typeId()) {
                if (auto mat = buildType(objectBinding, ctx, ret, qobject_cast<QQuick3DCustomMaterial *>(base))) {
                    auto model = qobject_cast<QQuick3DModel *>(ctx.property.target);
                    Q_ASSERT(model);
                    auto materials = model->materials();
                    materials.append(&materials, mat);
                    handled = true;
                }
            }
        } else if (ctx.dbgprint) {
            printf("Unhandled type\n");
        }
    }

    return handled;
}

static bool interceptObjectDef(const QQmlJS::AST::UiObjectDefinition &def, Context &ctx, int &ret)
{
    const auto &typeName = def.qualifiedTypeNameId->name.toString();

    if (ctx.dbgprint)
        printf("Intercepted object definition (\'%s\')!\n", typeName.toLatin1().constData());

    QString componentName;
    int type = -1;
    bool doRegisterComponent = false;

    // Base type?
    const auto typeIt = s_typeMap->constFind(typeName);
    if (typeIt != s_typeMap->cend())
        type = *typeIt;

    // Component?
    auto &components = ctx.components;
    const auto compIt = (type == -1) ? components.constFind(typeName) : components.cend();
    if (compIt != components.cend())
        type = compIt->type;

    // If this is a new component register it
    if (ctx.type == Context::Type::Component && ctx.property.target == nullptr && type != -1) {
        const auto &fileName = ctx.currentFileInfo.fileName();
        componentName = fileName.left(fileName.length() - 4);
        doRegisterComponent = !componentName.isEmpty();
    }

    const auto registerComponent = [&ctx, &components, &componentName](Context::Component component) {
        if (ctx.dbgprint)
            printf("Registering component \'%s\'\n", qPrintable(componentName));
        components.insert(componentName, component);
    };

    if (type == TypeInfo<QQuick3DViewport>::typeId()) {
        const QQuick3DViewport *base = (compIt != components.cend()) ? qobject_cast<QQuick3DViewport *>(compIt->ptr) : nullptr;
        if (QQuick3DViewport *viewport = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ viewport, type });
            // Only one viewport supported atm (see SceneEnvironment case as well).
            if (!ctx.sceneData.viewport)
                ctx.sceneData.viewport = viewport;
        }
    } else if (type == TypeInfo<QQuick3DSceneEnvironment>::typeId()) {
        const QQuick3DSceneEnvironment *base = (compIt != components.cend()) ? qobject_cast<QQuick3DSceneEnvironment *>(compIt->ptr) : nullptr;
        if (QQuick3DSceneEnvironment *sceneEnv = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ sceneEnv, type });

            if (ctx.sceneData.viewport)
                ctx.sceneData.viewport->setEnvironment(sceneEnv);
        }
    } else if (type == TypeInfo<QQuick3DPrincipledMaterial>::typeId()) {
        const QQuick3DPrincipledMaterial *base = (compIt != components.cend()) ? qobject_cast<QQuick3DPrincipledMaterial *>(compIt->ptr) : nullptr;
        if (QQuick3DPrincipledMaterial *mat = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ mat, type });

            if (ctx.property.target) {
                if (ctx.property.targetType == TypeInfo<QQuick3DModel>::typeId()) {
                    auto materials = qobject_cast<QQuick3DModel *>(ctx.property.target)->materials();
                    if (ctx.property.memberState == Context::Property::Uninitialized) {
                        if (ctx.dbgprint)
                            printf("Clearing inherited materials\n");
                        materials.clear(&materials);
                        ctx.property.memberState = Context::Property::Initialized;
                    }
                    materials.append(&materials, mat);
                    if (ctx.dbgprint)
                        printf("Appending material to %s\n", ctx.property.name.toLatin1().constData());
                }
            }

            // At this point we don't know if this material is going to be referenced somewhere else, so keep it in the list
            ctx.sceneData.materials.push_back(mat);
        }
    } else if (type == TypeInfo<QQuick3DDefaultMaterial>::typeId()) {
        const QQuick3DDefaultMaterial *base = (compIt != components.cend()) ? qobject_cast<QQuick3DDefaultMaterial *>(compIt->ptr) : nullptr;
        if (QQuick3DDefaultMaterial *mat = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ mat, type });

            if (ctx.property.target) {
                if (ctx.property.targetType == TypeInfo<QQuick3DModel>::typeId()) {
                    auto materials = qobject_cast<QQuick3DModel *>(ctx.property.target)->materials();
                    if (ctx.property.memberState == Context::Property::Uninitialized) {
                        if (ctx.dbgprint)
                            printf("Clearing inherited materials\n");
                        materials.clear(&materials);
                        ctx.property.memberState = Context::Property::Initialized;
                    }
                    materials.append(&materials, mat);
                    if (ctx.dbgprint)
                        printf("Appending material to %s\n", ctx.property.name.toLatin1().constData());
                }
            }

            // At this point we don't know if this material is going to be referenced somewhere else, so keep it in the list
            ctx.sceneData.materials.push_back(mat);
        }
    } else if (type == TypeInfo<QQuick3DCustomMaterial>::typeId()) {
        const QQuick3DCustomMaterial *base = (compIt != components.cend()) ? qobject_cast<QQuick3DCustomMaterial *>(compIt->ptr) : nullptr;
        if (QQuick3DCustomMaterial *mat = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ mat, type });

            if (ctx.property.target) {
                if (ctx.property.targetType == TypeInfo<QQuick3DModel>::typeId()) {
                    auto materials = qobject_cast<QQuick3DModel *>(ctx.property.target)->materials();
                    if (ctx.property.memberState == Context::Property::Uninitialized) {
                        if (ctx.dbgprint)
                            printf("Clearing inherited materials\n");
                        materials.clear(&materials);
                        ctx.property.memberState = Context::Property::Initialized;
                    }
                    materials.append(&materials, mat);
                    if (ctx.dbgprint)
                        printf("Appending material to %s\n", ctx.property.name.toLatin1().constData());
                }
            }

            // At this point we don't know if this material is going to be referenced somewhere else, so keep it in the list
            ctx.sceneData.materials.push_back(mat);
        }
    } else if (type == TypeInfo<QQuick3DEffect>::typeId()) {
        const QQuick3DEffect *base = (compIt != components.cend()) ? qobject_cast<QQuick3DEffect *>(compIt->ptr) : nullptr;
        if (QQuick3DEffect *effect = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ effect, type });

            if (ctx.property.target) {
                if (ctx.property.targetType == TypeInfo<QQuick3DSceneEnvironment>::typeId()) {
                    auto effects = qobject_cast<QQuick3DSceneEnvironment *>(ctx.property.target)->effects();
                    if (ctx.property.memberState == Context::Property::Uninitialized) {
                        if (ctx.dbgprint)
                            printf("Clearing inherited effects\n");
                        effects.clear(&effects);
                        ctx.property.memberState = Context::Property::Initialized;
                    }
                    effects.append(&effects, effect);
                    if (ctx.dbgprint)
                        printf("Appending effect to %s\n", ctx.property.name.toLatin1().constData());
                }
            }

            // At this point we don't know if this effect is going to be referenced somewhere else, so keep it in the list
            ctx.sceneData.effects.push_back(effect);
        }
    } else if (type == TypeInfo<QQuick3DDirectionalLight>::typeId() || type == TypeInfo<QQuick3DPointLight>::typeId() || type == TypeInfo<QQuick3DSpotLight>::typeId())  {
        const QQuick3DAbstractLight *base = (compIt != components.cend()) ? qobject_cast<QQuick3DAbstractLight *>(compIt->ptr) : nullptr;
        if (QQuick3DAbstractLight *light = buildLight(def, ctx, ret, type, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ light, type });

            ctx.sceneData.lights.push_back(light);
        }
    } else if (type == TypeInfo<QQuick3DTexture>::typeId()) {
        const QQuick3DTexture *base = (compIt != components.cend()) ? qobject_cast<QQuick3DTexture *>(compIt->ptr) : nullptr;
        if (QQuick3DTexture *tex = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ tex, type });

            ctx.sceneData.textures.push_back(tex);
        }
    } else if (type == TypeInfo<QQuick3DModel>::typeId()) {
        const auto *base = (compIt != components.cend()) ? qobject_cast<QQuick3DModel *>(compIt->ptr) : nullptr;
        if (auto *model = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ model, type });

            ctx.sceneData.models.push_back(model);
        }
    } else if (type == TypeInfo<QQuick3DShaderUtilsShader>::typeId()) {
        const auto *base = (compIt != components.cend()) ? qobject_cast<QQuick3DShaderUtilsShader *>(compIt->ptr) : nullptr;
        if (auto *shader = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ shader, type });
            if (ctx.property.target) {
                if (ctx.property.targetType == TypeInfo<QQuick3DShaderUtilsRenderPass>::typeId()) {
                    auto shaders = qobject_cast<QQuick3DShaderUtilsRenderPass *>(ctx.property.target)->shaders();
                    if (ctx.property.memberState == Context::Property::Uninitialized) {
                        if (ctx.dbgprint)
                            printf("Clearing inherited shaders\n");
                        shaders.clear(&shaders);
                        ctx.property.memberState = Context::Property::Initialized;
                    }
                    shaders.append(&shaders, shader);
                    if (ctx.dbgprint)
                        printf("Appending shader to %s\n", ctx.property.name.toLatin1().constData());
                }
            }

            ctx.sceneData.shaders.push_back(shader);
        }
    } else if (type == TypeInfo<QQuick3DShaderUtilsRenderPass>::typeId()) {
        const auto *base = (compIt != components.cend()) ? qobject_cast<QQuick3DShaderUtilsRenderPass *>(compIt->ptr) : nullptr;
        if (auto *pass = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ pass, type });
            if (ctx.property.target) {
                if (ctx.property.targetType == TypeInfo<QQuick3DEffect>::typeId()) {
                    auto passes = qobject_cast<QQuick3DEffect *>(ctx.property.target)->passes();
                    if (ctx.property.memberState == Context::Property::Uninitialized) {
                        if (ctx.dbgprint)
                            printf("Clearing inherited passes\n");
                        passes.clear(&passes);
                        ctx.property.memberState = Context::Property::Initialized;
                    }
                    passes.append(&passes, pass);
                    if (ctx.dbgprint)
                        printf("Appending pass to %s\n", ctx.property.name.toLatin1().constData());
                }
            }
        }
    } else if (type == TypeInfo<QQuick3DInstanceList>::typeId()) {
        const auto *base = (compIt != components.cend()) ? qobject_cast<QQuick3DInstanceList *>(compIt->ptr) : nullptr;
        if (auto *instanceList = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ instanceList, type });
            if (ctx.property.target) {
                if (ctx.property.targetType == TypeInfo<QQuick3DModel>::typeId()) {
                    qobject_cast<QQuick3DModel *>(ctx.property.target)->setInstancing(instanceList);
                    if (ctx.dbgprint)
                        printf("Setting instance list on %s\n", ctx.property.name.toLatin1().constData());
                }
            }
        }
    } else if (type == TypeInfo<QQuick3DInstanceListEntry>::typeId()) {
        const auto *base = (compIt != components.cend()) ? qobject_cast<QQuick3DInstanceListEntry *>(compIt->ptr) : nullptr;
        if (auto *instanceListEntry = buildType(def, ctx, ret, base)) {
            // If this is a component we'll store it for lookups later.
            if (doRegisterComponent)
                registerComponent({ instanceListEntry, type });
            if (ctx.property.target) {
                if (ctx.property.targetType == TypeInfo<QQuick3DInstanceList>::typeId()) {
                    auto instances = qobject_cast<QQuick3DInstanceList *>(ctx.property.target)->instances();
                    instances.append(&instances, instanceListEntry);
                    if (ctx.dbgprint)
                        printf("Appending instance list entry to %s\n", ctx.property.name.toLatin1().constData());
                }
            }
        }
    } else {
        if (ctx.dbgprint)
            printf("Object def for \'%s\' was not handled\n", ctx.property.name.toLatin1().constData());
        return false;
    }

    return true;
}

static bool interceptPublicMember(const QQmlJS::AST::UiPublicMember &member, Context &ctx, int &ret)
{
    Q_UNUSED(ret);
    using namespace QQmlJS::AST;

    if (ctx.dbgprint)
        printf("Intercepted public member!\n");

    if (member.statement && member.statement->kind == Node::Kind_ExpressionStatement) {
        if ((ctx.property.targetType == TypeInfo<QQuick3DCustomMaterial>::typeId() || ctx.property.targetType == TypeInfo<QQuick3DEffect>::typeId()) && member.memberType) {
            // For custom materials we have properties that are user provided, so we'll
            // need to add these to the objects properties (we add these here to be able
            // to piggyback on the existing type matching code)
            if (member.memberType->name == u"real") {
                ctx.property.type = QMetaType::Double;
            } else if (member.memberType->name == u"bool") {
                ctx.property.type = QMetaType::Bool;
            } else if (member.memberType->name == u"int") {
                ctx.property.type = QMetaType::Int;
            } else if (member.memberType->name == u"size") {
                ctx.property.type = QMetaType::QSizeF;
            } else if (member.memberType->name == u"rect") {
                ctx.property.type = QMetaType::QRectF;
            } else if (member.memberType->name == u"point") {
                ctx.property.type = QMetaType::QPointF;
            } else if (member.memberType->name == u"color") {
                ctx.property.type = QMetaType::QColor;
            } else if (member.memberType->name.startsWith(u"vector")) {
                if (member.memberType->name.endsWith(u"2d")) {
                    ctx.property.type = QMetaType::QVector2D;
                } else if (member.memberType->name.endsWith(u"3d")) {
                    ctx.property.type = QMetaType::QVector3D;
                } else if (member.memberType->name.endsWith(u"4d")) {
                    ctx.property.type = QMetaType::QVector4D;
                }
            } else if (member.memberType->name == u"matrix4x4") {
                ctx.property.type = QMetaType::QMatrix4x4;;
            } else if (member.memberType->name == u"quaternion") {
                ctx.property.type = QMetaType::QQuaternion;
            } else if (member.memberType->name == u"var") {
                ctx.property.type = QMetaType::QVariant;
            }
        }
    }

    return false;
}

static bool interceptCallExpression(const QQmlJS::AST::CallExpression &callExpression, Context &ctx, int &ret)
{
    Q_UNUSED(ret);
    using namespace QQmlJS::AST;
    using namespace BuiltinHelpers;

    if (ctx.dbgprint)
        printf("Intercepted call expression!\n");

    const bool ok = (ctx.property.target && !ctx.property.name.isEmpty());
    if (callExpression.base && ok) {
        if (callExpression.base->kind == Node::Kind_FieldMemberExpression) {
            const auto &fieldMemberExpression = static_cast<const FieldMemberExpression &>(*callExpression.base);
            if (fieldMemberExpression.base) {
                if (fieldMemberExpression.base->kind == Node::Kind_IdentifierExpression) {
                    const auto &identExpr = static_cast<const IdentifierExpression &>(*fieldMemberExpression.base);
                    if (identExpr.name == u"Qt") {
                        bool ok = false;
                        QVariant v;
                        if (fieldMemberExpression.name == u"point") {
                            const auto point = toPoint(ArgumentListView(*callExpression.arguments), &ok);
                            if (ctx.dbgprint)
                                printf("Qt.point(%f, %f)\n", point.x(), point.y());
                            setProperty(ctx.property, point);
                        } else if (fieldMemberExpression.name == u"size") {
                            const auto size = toSize(ArgumentListView(*callExpression.arguments), &ok);
                            if (ctx.dbgprint)
                                printf("Qt.size(%f, %f)\n", size.width(), size.height());
                            setProperty(ctx.property, size);
                        } else if (fieldMemberExpression.name == u"rect") {
                            const auto rect = toRect(ArgumentListView(*callExpression.arguments), &ok);
                            if (ctx.dbgprint)
                                printf("Qt.rect(%f, %f, %f, %f)\n", rect.x(), rect.y(), rect.width(), rect.height());
                            setProperty(ctx.property, rect);
                        } else if (fieldMemberExpression.name.startsWith(u"vector")) {
                            if (fieldMemberExpression.name.endsWith(u"2d")) {
                                const auto vec2 = toVec<QVector2D>(ArgumentListView(*callExpression.arguments), &ok);
                                if (ctx.dbgprint)
                                    printf("Qt.vector2d(%f, %f)\n", vec2.x(), vec2.y());
                                setProperty(ctx.property, vec2);
                            } else if (fieldMemberExpression.name.endsWith(u"3d")) {
                                const auto vec3 = toVec<QVector3D>(ArgumentListView(*callExpression.arguments), &ok);
                                if (ctx.dbgprint)
                                    printf("Qt.vector3d(%f, %f, %f)\n", vec3.x(), vec3.y(), vec3.z());
                                setProperty(ctx.property, vec3);
                            } else if (fieldMemberExpression.name.endsWith(u"4d")) {
                                const auto vec4 = toVec<QVector4D>(ArgumentListView(*callExpression.arguments), &ok);
                                if (ctx.dbgprint)
                                    printf("Qt.vector4d(%f, %f, %f, %f)\n", vec4.x(), vec4.y(), vec4.z(), vec4.w());
                                setProperty(ctx.property, vec4);
                            }
                        } else if (fieldMemberExpression.name == u"matrix4x4") {
                            const auto mat44 = toMat44(ArgumentListView(*callExpression.arguments), &ok);
                            if (ctx.dbgprint)
                                printf("Qt.matrix4x4(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n",
                                       mat44(0, 0), mat44(0, 1), mat44(0, 2), mat44(0, 3),
                                       mat44(1, 0), mat44(1, 1), mat44(1, 2), mat44(1, 3),
                                       mat44(2, 0), mat44(2, 1), mat44(2, 2), mat44(2, 3),
                                       mat44(3, 0), mat44(3, 1), mat44(3, 2), mat44(3, 3));
                            setProperty(ctx.property, mat44);
                        } else if (fieldMemberExpression.name == u"quaternion") {
                            const auto quat = toQuaternion(ArgumentListView(*callExpression.arguments), &ok);
                            if (ctx.dbgprint)
                                printf("Qt.quaternion(%f, %f, %f, %f)\n", quat.scalar(), quat.x(), quat.y(), quat.z());
                            setProperty(ctx.property, quat);
                        } else if (fieldMemberExpression.name == u"rgba") {
                            const auto vec4 = toVec<QVector4D>(ArgumentListView(*callExpression.arguments), &ok);
                            if (ok) {
                                QColor color = QColor::fromRgbF(vec4.x(), vec4.y(), vec4.z(), vec4.w());
                                if (ctx.dbgprint)
                                    printf("Qt.rgba(%f, %f, %f, %f)\n", color.redF(), color.greenF(), color.blueF(), color.alphaF());
                                setProperty(ctx.property, color);
                            }
                        }
                        if (ok && v.isValid() && ctx.property.target)
                            ctx.property.target->setProperty(ctx.property.name.toLatin1().constData(), v);
                    }
                }
            }
        }
    }

    return false;
}

static int parseQmlData(const QByteArray &code, Context &ctx)
{
    Q_ASSERT(ctx.engine && ctx.engine->lexer());
    ctx.identifierMap.clear(); // not visible outside the scope of this "code"
    if (ctx.dbgprint)
        printf("Parsing %s\n", qPrintable(ctx.currentFileInfo.filePath()));
    int ret = 0;
    ctx.engine->lexer()->setCode(QString::fromUtf8(code), 1, true);
    QQmlJS::Parser parser(ctx.engine);
    const bool ok = parser.parse();
    if (ok) {
        const auto program = parser.ast();
        if (program)
            Visitors::visit(*program, ctx, ret);
    } else {
        ret = -1;
        qWarning("Parsing failed due to %s in %s:%d%d", qPrintable(parser.errorMessage()), qPrintable(ctx.currentFileInfo.fileName()), parser.errorLineNumber(), parser.errorColumnNumber());
    }

    return ret;
}

int MaterialParser::parseQmlData(const QByteArray &code, const QString &fileName, MaterialParser::SceneData &sceneData)
{
    // set initial type map
    *s_typeMap = baseTypeMap();

    QQmlJS::Engine engine;
    QQmlJS::Lexer lexer(&engine);

    Context ctx;
    ctx.engine = &engine;
    ctx.interceptODFunc = &interceptObjectDef;
    ctx.interceptOBFunc = &interceptObjectBinding;
    ctx.interceptPMFunc = &interceptPublicMember;
    ctx.interceptCallExpr = &interceptCallExpression;
    ctx.currentFileInfo = QFileInfo(fileName);
    ctx.type = Context::Type::Component;

    const int ret = ::parseQmlData(code, ctx);
    sceneData = std::move(ctx.sceneData);

    return ret;
}

int MaterialParser::parseQmlFiles(const QVector<QString> &filePaths, const QDir &sourceDir, SceneData &sceneData, bool verboseOutput)
{
    // set initial type map
    *s_typeMap = baseTypeMap();

    int ret = 0;

    if (filePaths.isEmpty()) {
        qWarning("No input files");
        return ret;
    }

    QQmlJS::Engine engine;
    QQmlJS::Lexer lexer(&engine);

    Context ctx;
    ctx.dbgprint = verboseOutput;
    ctx.engine = &engine;
    ctx.interceptODFunc = &interceptObjectDef;
    ctx.interceptOBFunc = &interceptObjectBinding;
    ctx.interceptPMFunc = &interceptPublicMember;
    ctx.interceptCallExpr = &interceptCallExpression;
    ctx.workingDir = sourceDir;

    QVector<QString> deferredOther;
    QVector<QString> deferredComponets;

    const QString sourcePath = sourceDir.canonicalPath() + QDir::separator();

    const bool isMultifile = filePaths.size() != 1;

    // Go through and find the material components first
    for (const auto &v : filePaths) {
        QFileInfo &currentFileInfo = ctx.currentFileInfo;
        if (!QFileInfo(v).isAbsolute())
            currentFileInfo.setFile(sourcePath + v);
        else
            currentFileInfo.setFile(v);
        const bool maybeComponent = currentFileInfo.fileName().at(0).isUpper();
        if (currentFileInfo.isFile() && currentFileInfo.suffix() == getQmlFileExtension()) {
            const QString filePath = currentFileInfo.canonicalFilePath();
            if (isMultifile && maybeComponent) {
                QFile f(filePath);
                if (!f.open(QFile::ReadOnly)) {
                    qWarning("Could not open file %s for reading!", qPrintable(filePath));
                    return -1;
                }

                const QByteArray code = f.readAll();
                int idx = code.indexOf('{');
                if (idx != -1) {
                    const QByteArray section = code.mid(0, idx);
                    QVarLengthArray<const char *, 3> componentTypes { TypeInfo<QQuick3DPrincipledMaterial>::qmlTypeName(),
                                                                           TypeInfo<QQuick3DCustomMaterial>::qmlTypeName(),
                                                                           TypeInfo<QQuick3DDefaultMaterial>::qmlTypeName()};
                    for (const auto compType : qAsConst(componentTypes)) {
                        if ((idx = section.indexOf(compType)) != -1)
                            break;
                    }
                    if (idx != -1) {
                        ctx.type = Context::Type::Component;
                        ret = parseQmlData(code, ctx);
                        if (ret != 0)
                            break;
                    } else {
                        deferredComponets.push_back(filePath);
                    }
                } else {
                    qWarning("No items found in %s\n", qPrintable(filePath));
                }
            } else {
                deferredOther.push_back(filePath);
            }
        } else {
            qWarning("The file %s is either not a file or has the wrong extension!", qPrintable(v));
        }
    }

    const auto parsePaths = [&ctx, &ret](const QVector<QString> &paths, Context::Type type) {
        ctx.type = type;
        for (const auto &path : paths) {
            QFileInfo &currentFileInfo = ctx.currentFileInfo;
            currentFileInfo.setFile(path);
            if (currentFileInfo.isFile() && currentFileInfo.suffix() == getQmlFileExtension()) {
                const QString filePath = currentFileInfo.canonicalFilePath();
                QFile f(filePath);
                if (!f.open(QFile::ReadOnly)) {
                    qWarning("Could not open file %s for reading!", qPrintable(filePath));
                    ret =  -1;
                    return;
                }

                const QByteArray code = f.readAll();
                ret = parseQmlData(code, ctx);
                if (ret != 0)
                    break;
            }
        }
    };

    // Other components
    parsePaths(deferredComponets, Context::Type::Component);

    // Now parse the rest
    parsePaths(deferredOther, Context::Type::Application);

    sceneData = std::move(ctx.sceneData);

    return ret;
}

QT_END_NAMESPACE
