//
//  ModelSerializersTests.cpp
//  tests/model-serializers/src
//
//  Created by Dale Glass on 20/11/2022.
//  Copyright 2022 Overte e.V.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html


// This test checks a large amount of files. To debug more comfortably and avoid going through
// a lot of uninteresting data, QTest allows us to narrow down what gets run with command line
// arguments, like this:
//
//     ./model-serializers-ModelSerializersTests loadGLTF:gltf2.0-RecursiveSkeletons.glb
//
// This will run only the loadGLTF test, and only on the gltf2.0-RecursiveSkeletons.glb file.

#include "ModelSerializersTests.h"
#include "GLTFSerializer.h"
#include "FBXSerializer.h"
#include "OBJSerializer.h"

#include "Gzip.h"
#include "model-networking/ModelLoader.h"
#include <hfm/ModelFormatRegistry.h>
#include "DependencyManager.h"
#include "ResourceManager.h"
#include "AssetClient.h"
#include "LimitedNodeList.h"
#include "NodeList.h"
#include "ResourceRequestObserver.h"
#include "StatTracker.h"

#include <QUrl>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QByteArray>
#include <QDebug>
#include <QDirIterator>

QTEST_MAIN(ModelSerializersTests)

void ModelSerializersTests::initTestCase() {
    qRegisterMetaType<QNetworkReply*>("QNetworkReply*");

    DependencyManager::registerInheritance<LimitedNodeList, NodeList>();
    DependencyManager::set<NodeList>(NodeType::Agent, INVALID_PORT);

    DependencyManager::set<ModelFormatRegistry>(); // ModelFormatRegistry must be defined before ModelCache. See the ModelCache constructor.
    DependencyManager::set<ResourceManager>();
    DependencyManager::set<AssetClient>();
    DependencyManager::set<ResourceRequestObserver>();
    DependencyManager::set<StatTracker>();




    auto modelFormatRegistry = DependencyManager::get<ModelFormatRegistry>();
    modelFormatRegistry->addFormat(FBXSerializer());
    modelFormatRegistry->addFormat(OBJSerializer());
    modelFormatRegistry->addFormat(GLTFSerializer());
}

void ModelSerializersTests::loadGLTF_data() {
    // We feed a large amount of files into the test. Some we expect to fail, some we expect to load with issues. The
    // added columns below indicate our expectations for each file.


    QTest::addColumn<QString>("filename");
    QTest::addColumn<bool>("expectParseFail");
    QTest::addColumn<bool>("expectWarnings");
    QTest::addColumn<bool>("expectErrors");

    QTest::newRow("ready-player-me-good1")   << "models/src/DragonAvatar1.glb.gz"              << false << false << false;
    QTest::newRow("ready-player-me-good2")   << "models/src/UkraineFranny.glb.gz"              << false << false << false;
    QTest::newRow("ready-player-me-good3")   << "models/src/Franny.glb.gz"                     << false << false << false;
    QTest::newRow("ready-player-me-good4")   << "models/src/womanInTShirt.glb.gz"              << false << false << false;
    QTest::newRow("ready-player-me-good5")   << "models/src/female-avatar-with-swords.glb.gz"  << false << false << false;
    QTest::newRow("ready-player-me-broken1") << "models/src/broken-2022-11-27.glb.gz"          << false << false << false;


    // We can't parse GLTF 1.0 at present, and probably not ever. We're expecting all these to fail.
    /*QDirIterator it("models/src/gltf_samples/1.0", QStringList() << "*.glb", QDir::Files, QDirIterator::Subdirectories);
    while(it.hasNext()) {
        QString filename = it.next();
        QFileInfo fi(filename);
        QString testname = "gltf1.0-" + fi.fileName();
        QTest::newRow(testname.toUtf8().data()) << filename << true << false << false;
    }*/

    QDirIterator it2("models/src/gltf_samples/2.0", QStringList() << "*.glb", QDir::Files, QDirIterator::Subdirectories);
    while(it2.hasNext()) {
        QString filename = it2.next();
        QFileInfo fi(filename);
        QString testname = "gltf2.0-" + fi.fileName();
        QTest::newRow(testname.toUtf8().data()) << filename << false << false << false;
    }

    QDirIterator it3("models/src/kenney_building_kit/Models/GLB format", QStringList() << "*.glb", QDir::Files, QDirIterator::Subdirectories);
    while(it3.hasNext()) {
        QString filename = it3.next();
        QFileInfo fi(filename);
        QString testname = "kenney-" + fi.fileName();
        QTest::newRow(testname.toUtf8().data()) << filename << false << false << false;
    }
}

void ModelSerializersTests::loadGLTF() {
    QFETCH(QString, filename);
    QFETCH(bool, expectParseFail);
    QFETCH(bool, expectWarnings);
    QFETCH(bool, expectErrors);


    QFile gltf_file(filename);
    QVERIFY(gltf_file.open(QIODevice::ReadOnly));

    QByteArray data = gltf_file.readAll();
    QByteArray uncompressedData;
    QUrl url("file:" + QCoreApplication::applicationDirPath());

    qInfo() << "URL: " << url;

    if (filename.toLower().endsWith(".gz")) {
        url.setPath(QCoreApplication::applicationDirPath() + "/" + filename.chopped(3));

        if (gunzip(data, uncompressedData)) {
            qInfo() << "Uncompressed into" << uncompressedData.length();
        } else {
            qCritical() << "Failed to uncompress";
        }
    } else {
        url.setPath(QCoreApplication::applicationDirPath() + "/" + filename);
        uncompressedData = data;
    }


    ModelLoader loader;
    QMultiHash<QString, QVariant> serializerMapping;
    std::string webMediaType;

    serializerMapping.insert("combineParts", true);
    serializerMapping.insert("deduplicateIndices", true);

    qInfo() << "Loading model from" << uncompressedData.length() << "bytes data, url" << url;

    // Check that we can find a serializer for this
    auto serializer = DependencyManager::get<ModelFormatRegistry>()->getSerializerForMediaType(uncompressedData, url, webMediaType);
    QVERIFY(serializer);



    hfm::Model::Pointer model = loader.load(uncompressedData, serializerMapping, url, webMediaType);
    QVERIFY(expectParseFail == !model);

    if (!model) {
        // We expected this parse to fail, so nothing more to do here.
        return;
    }

    QVERIFY(!model->meshes.empty());
    QVERIFY(!model->joints.empty());

    qInfo() << "Model was loaded with" << model->meshes.count() << "meshes and" << model->joints.count() << "joints. Found" << model->loadWarningCount << "warnings and" << model->loadErrorCount << "errors";

    // Some models we test are expected to be broken. We're testing that we can load the model without blowing up,
    // so loading it with errors is still a successful test.
    QVERIFY(expectWarnings == (model->loadWarningCount>0));
    QVERIFY(expectErrors == (model->loadErrorCount>0));
}