/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "common/arguments.h"
#include "common/configuration.h"

#include <filamentapp/Config.h>
#include <filamentapp/FilamentApp.h>
#include <filamentapp/IBL.h>

#include <filament/Camera.h>
#include <filament/ColorGrading.h>
#include <filament/Engine.h>
#include <filament/IndexBuffer.h>
#include <filament/RenderableManager.h>
#include <filament/Renderer.h>
#include <filament/Scene.h>
#include <filament/Skybox.h>
#include <filament/TransformManager.h>
#include <filament/VertexBuffer.h>
#include <filament/View.h>

#include <gltfio/AssetLoader.h>
#include <gltfio/FilamentAsset.h>
#include <gltfio/ResourceLoader.h>
#include <gltfio/TextureProvider.h>

#include <viewer/AutomationEngine.h>
#include <viewer/AutomationSpec.h>
#include <viewer/ViewerGui.h>

#include <camutils/Manipulator.h>

#include <private/filament/EngineEnums.h>

#include <getopt/getopt.h>

#include <utils/NameComponentManager.h>
#include <utils/Log.h>

#include <math/vec3.h>
#include <math/vec4.h>
#include <math/mat3.h>
#include <math/norm.h>

#include <imgui.h>
#include <filagui/ImGuiExtensions.h>

#include <cgltf.h>

#include <algorithm>
#include <array>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <set>
#include <sstream>
#include <string>

#include "generated/resources/gltf_demo.h"
#include "materials/uberarchive.h"

#if FILAMENT_DISABLE_MATOPT
#   define OPTIMIZE_MATERIALS false
#else
#   define OPTIMIZE_MATERIALS true
#endif

using namespace filament;
using namespace filament::math;
using namespace filament::viewer;

using namespace filament::gltfio;
using namespace utils;

enum MaterialSource {
    JITSHADER,
    UBERSHADER,
};

struct App {
    Engine* engine;
    ViewerGui* viewer;
    Config config;
    Camera* mainCamera;
    Entity rootTransformEntity;

    AssetLoader* assetLoader;
    FilamentAsset* asset = nullptr;
    FilamentInstance* instance = nullptr;
    NameComponentManager* names;

    MaterialProvider* materials;
    MaterialSource materialSource = JITSHADER;

    gltfio::ResourceLoader* resourceLoader = nullptr;
    gltfio::TextureProvider* stbDecoder = nullptr;
    gltfio::TextureProvider* ktxDecoder = nullptr;
    bool recomputeAabb = false;

    bool actualSize = false;
    bool originIsFarAway = false;
    float originDistance = 1.0f;

    struct Scene {
        Entity groundPlane;
        VertexBuffer* groundVertexBuffer;
        IndexBuffer* groundIndexBuffer;
        Material* groundMaterial;

        Material* overdrawMaterial;
        // use layer 7 because 0, 1 and 2 are used by FilamentApp
        static constexpr auto OVERDRAW_VISIBILITY_LAYER = 7u;   // overdraw renderables View layer
        static constexpr auto OVERDRAW_LAYERS = 4u;             // unique overdraw colors
        std::array<Entity, OVERDRAW_LAYERS> overdrawVisualizer;
        std::array<MaterialInstance*, OVERDRAW_LAYERS> overdrawMaterialInstances;
        VertexBuffer* fullScreenTriangleVertexBuffer;
        IndexBuffer* fullScreenTriangleIndexBuffer;
    } scene;

    ColorGradingSettings lastColorGradingOptions = { .enabled = false };

    ColorGrading* colorGrading = nullptr;

    std::string notificationText;
    std::string messageBoxText;
    std::string settingsFile;
    std::string batchFile;

    AutomationSpec* automationSpec = nullptr;
    AutomationEngine* automationEngine = nullptr;
    bool screenshot = false;
    uint8_t screenshotSeq = 0;
    bool screenshotAsPPM = false;
};

static const char* DEFAULT_IBL = "assets/ibl/lightroom_14b";

static void printUsage(char* name) {
    std::string const exec_name(Path(name).getName());
    std::string usage(
        "SHOWCASE renders the specified glTF file, or a built-in file if none is specified\n"
        "Usage:\n"
        "    SHOWCASE [options] <gltf path>\n"
        "Options:\n"
        "   --help, -h\n"
        "       Prints this message\n\n"
        "API_USAGE"
        "   --feature-level=<1|2|3>, -f <1|2|3>\n"
        "       Specify the feature level to use. The default is the highest supported feature level.\n\n"
        "   --batch=<path to JSON file or 'default'>, -b\n"
        "       Start automation using the given JSON spec, then quit the app\n\n"
        "   --headless, -e\n"
        "       Use a headless swapchain; ignored if --batch is not present\n\n"
        "   --ibl=<path>, -i <path>\n"
        "       Override the built-in IBL\n"
        "       path can either be a directory containing IBL data files generated by cmgen,\n"
        "       or, a .hdr equiretangular image file\n\n"
        "   --actual-size, -s\n"
        "       Do not scale the model to fit into a unit cube\n\n"
        "   --recompute-aabb, -r\n"
        "       Ignore the min/max attributes in the glTF file\n\n"
        "   --settings=<path to JSON file>, -t\n"
        "       Apply the settings in the given JSON file\n\n"
        "   --ubershader, -u\n"
        "       Enable ubershaders (improves load time, adds shader complexity)\n\n"
        "   --camera=<camera mode>, -c <camera mode>\n"
        "       Set the camera mode: orbit (default) or flight\n"
        "       Flight mode uses the following controls:\n"
        "           Click and drag the mouse to pan the camera\n"
        "           Use the scroll wheel to adjust movement speed\n"
        "           W / S: forward / backward\n"
        "           A / D: left / right\n"
        "           E / Q: up / down\n\n"
        "   --eyes=<stereoscopic eyes>, -y <stereoscopic eyes>\n"
        "       Sets the number of stereoscopic eyes (default: 2) when stereoscopic rendering is\n"
        "       enabled.\n\n"
        "   --split-view, -v\n"
        "       Splits the window into 4 views\n\n"
        "   --vulkan-gpu-hint=<hint>, -g\n"
        "       Vulkan backend allows user to choose their GPU.\n"
        "       You can provide the index of the GPU or\n"
        "       a substring to match against the device name\n\n"
        "   --screenshot-as-ppm, -d\n"
        "       export PPM as oppose to TIFF screenshots\n\n"
        "   --webgpu-backend=<backend>, -w\n"
        "       You can force WebGPU to select a backend of your choice. Provided that the platform\n"
        "       supports this backend. (See -a for argument options).\n\n"
    );
    const std::string from("SHOWCASE");
    for (size_t pos = usage.find(from); pos != std::string::npos; pos = usage.find(from, pos)) {
        usage.replace(pos, from.length(), exec_name);
    }
    const std::string apiUsage("API_USAGE");
    for (size_t pos = usage.find(apiUsage); pos != std::string::npos; pos = usage.find(apiUsage, pos)) {
        usage.replace(pos, apiUsage.length(), samples::getBackendAPIArgumentsUsage());
    }
    std::cout << usage;
}

static std::ifstream::pos_type getFileSize(const char* filename) {
    std::ifstream in(filename, std::ifstream::ate | std::ifstream::binary);
    return in.tellg();
}

static int handleCommandLineArguments(int argc, char* argv[], App* app) {
    static constexpr const char* OPTSTR = "ha:f:i:usc:rt:y:b:evg:dw:";
    static const struct option OPTIONS[] = {
        { "help",              no_argument,          nullptr, 'h' },
        { "api",               required_argument,    nullptr, 'a' },
        { "feature-level",     required_argument,    nullptr, 'f' },
        { "batch",             required_argument,    nullptr, 'b' },
        { "headless",          no_argument,          nullptr, 'e' },
        { "ibl",               required_argument,    nullptr, 'i' },
        { "ubershader",        no_argument,          nullptr, 'u' },
        { "actual-size",       no_argument,          nullptr, 's' },
        { "camera",            required_argument,    nullptr, 'c' },
        { "eyes",              required_argument,    nullptr, 'y' },
        { "recompute-aabb",    no_argument,          nullptr, 'r' },
        { "settings",          required_argument,    nullptr, 't' },
        { "split-view",        no_argument,          nullptr, 'v' },
        { "vulkan-gpu-hint",   required_argument,    nullptr, 'g' },
        { "screenshot-as-ppm", no_argument,          nullptr, 'd' },
        { "webgpu-backend",    required_argument,    nullptr, 'w' },
        { nullptr, 0, nullptr, 0 }
    };
    int opt;
    int option_index = 0;
    while ((opt = getopt_long(argc, argv, OPTSTR, OPTIONS, &option_index)) >= 0) {
        std::string const arg(optarg ? optarg : "");
        switch (opt) {
            default:
            case 'h':
                printUsage(argv[0]);
                exit(0);
            case 'a':
                app->config.backend = samples::parseArgumentsForBackend(arg);
                break;
            case 'f':
                if (arg == "1") {
                    app->config.featureLevel = backend::FeatureLevel::FEATURE_LEVEL_1;
                } else if (arg == "2") {
                    app->config.featureLevel = backend::FeatureLevel::FEATURE_LEVEL_2;
                } else if (arg == "3") {
                    app->config.featureLevel = backend::FeatureLevel::FEATURE_LEVEL_3;
                } else {
                    std::cerr << "Unrecognized feature level. Must be 1, 2 or 3.\n";
                }
                break;
            case 'c':
                if (arg == "flight") {
                    app->config.cameraMode = camutils::Mode::FREE_FLIGHT;
                } else if (arg == "orbit") {
                    app->config.cameraMode = camutils::Mode::ORBIT;
                } else {
                    std::cerr << "Unrecognized camera mode. Must be 'flight'|'orbit'.\n";
                }
                break;
            case 'y': {
                int eyeCount = 0;
                try {
                    eyeCount = std::stoi(arg);
                } catch (std::invalid_argument &e) { }
                if (eyeCount >= 1 && eyeCount <= CONFIG_MAX_STEREOSCOPIC_EYES) {
                    app->config.stereoscopicEyeCount = eyeCount;
                } else {
                    std::cerr << "Eye count must be between 1 and CONFIG_MAX_STEREOSCOPIC_EYES ("
                              << (int) CONFIG_MAX_STEREOSCOPIC_EYES << ") (inclusive).\n";
                }
                break;
            }
            case 'e':
                app->config.headless = true;
                break;
            case 'i':
                app->config.iblDirectory = arg;
                break;
            case 'u':
                app->materialSource = UBERSHADER;
                break;
            case 's':
                app->actualSize = true;
                break;
            case 'r':
                app->recomputeAabb = true;
                break;
            case 't':
                app->settingsFile = arg;
                break;
            case 'b': {
                app->batchFile = arg;
                break;
            }
            case 'v': {
                app->config.splitView = true;
                break;
            }
            case 'g': {
                app->config.vulkanGPUHint = arg;
                break;
            }
            case 'd': {
                app->screenshotAsPPM = true;
                break;
            }
            case 'w': {
                app->config.forcedWebGPUBackend = samples::parseArgumentsForBackend(arg);
                break;
            }
        }
    }
    if (app->config.headless && app->batchFile.empty()) {
        std::cerr << "--headless is allowed only when --batch is present." << std::endl;
        app->config.headless = false;
    }
    return optind;
}

static bool loadSettings(const char* filename, Settings* out) {
    auto contentSize = getFileSize(filename);
    if (contentSize <= 0) {
        return false;
    }
    std::ifstream in(filename, std::ifstream::binary | std::ifstream::in);
    std::vector<char> json(static_cast<unsigned long>(contentSize));
    if (!in.read(json.data(), contentSize)) {
        return false;
    }
    JsonSerializer serializer;
    return serializer.readJson(json.data(), contentSize, out);
}

static void createGroundPlane(Engine* engine, Scene* scene, App& app) {
    auto& em = EntityManager::get();
    Material* shadowMaterial = Material::Builder()
            .package(GLTF_DEMO_GROUNDSHADOW_DATA, GLTF_DEMO_GROUNDSHADOW_SIZE)
            .build(*engine);
    auto& viewerOptions = app.viewer->getSettings().viewer;
    shadowMaterial->setDefaultParameter("strength", viewerOptions.groundShadowStrength);

    const static uint32_t indices[] = {
            0, 1, 2, 2, 3, 0
    };

    Aabb aabb = app.asset->getBoundingBox();
    if (!app.actualSize) {
        mat4f const transform = fitIntoUnitCube(aabb, 4);
        aabb = aabb.transform(transform);
    }

    float3 planeExtent{10.0f * aabb.extent().x, 0.0f, 10.0f * aabb.extent().z};

    const static float3 vertices[] = {
            { -planeExtent.x, 0, -planeExtent.z },
            { -planeExtent.x, 0,  planeExtent.z },
            {  planeExtent.x, 0,  planeExtent.z },
            {  planeExtent.x, 0, -planeExtent.z },
    };

    short4 const tbn = packSnorm16(
            mat3f::packTangentFrame(
                    mat3f{
                            float3{ 1.0f, 0.0f, 0.0f },
                            float3{ 0.0f, 0.0f, 1.0f },
                            float3{ 0.0f, 1.0f, 0.0f }
                    }
            ).xyzw);

    const static short4 normals[] { tbn, tbn, tbn, tbn };

    VertexBuffer* vertexBuffer = VertexBuffer::Builder()
            .vertexCount(4)
            .bufferCount(2)
            .attribute(VertexAttribute::POSITION,
                    0, VertexBuffer::AttributeType::FLOAT3)
            .attribute(VertexAttribute::TANGENTS,
                    1, VertexBuffer::AttributeType::SHORT4)
            .normalized(VertexAttribute::TANGENTS)
            .build(*engine);

    vertexBuffer->setBufferAt(*engine, 0, VertexBuffer::BufferDescriptor(
            vertices, vertexBuffer->getVertexCount() * sizeof(vertices[0])));
    vertexBuffer->setBufferAt(*engine, 1, VertexBuffer::BufferDescriptor(
            normals, vertexBuffer->getVertexCount() * sizeof(normals[0])));

    IndexBuffer* indexBuffer = IndexBuffer::Builder()
            .indexCount(6)
            .build(*engine);

    indexBuffer->setBuffer(*engine, IndexBuffer::BufferDescriptor(
            indices, indexBuffer->getIndexCount() * sizeof(uint32_t)));

    Entity const groundPlane = em.create();
    RenderableManager::Builder(1)
            .boundingBox({
                    {}, { planeExtent.x, 1e-4f, planeExtent.z }
            })
            .material(0, shadowMaterial->getDefaultInstance())
            .geometry(0, RenderableManager::PrimitiveType::TRIANGLES,
                    vertexBuffer, indexBuffer, 0, 6)
            .culling(false)
            .receiveShadows(true)
            .castShadows(false)
            .build(*engine, groundPlane);

    scene->addEntity(groundPlane);

    auto& tcm = engine->getTransformManager();
    tcm.setTransform(tcm.getInstance(groundPlane),
            mat4f::translation(float3{ 0, aabb.min.y, -4 }));

    auto& rcm = engine->getRenderableManager();
    auto instance = rcm.getInstance(groundPlane);
    rcm.setLayerMask(instance, 0xff, 0x00);

    app.scene.groundPlane = groundPlane;
    app.scene.groundVertexBuffer = vertexBuffer;
    app.scene.groundIndexBuffer = indexBuffer;
    app.scene.groundMaterial = shadowMaterial;
}

static constexpr float4 sFullScreenTriangleVertices[3] = {
        { -1.0f, -1.0f, 1.0f, 1.0f },
        {  3.0f, -1.0f, 1.0f, 1.0f },
        { -1.0f,  3.0f, 1.0f, 1.0f }
};

static const uint16_t sFullScreenTriangleIndices[3] = { 0, 1, 2 };

static void createOverdrawVisualizerEntities(Engine* engine, Scene* scene, App& app) {
    Material* material = Material::Builder()
            .package(GLTF_DEMO_OVERDRAW_DATA, GLTF_DEMO_OVERDRAW_SIZE)
            .build(*engine);

    const float3 overdrawColors[App::Scene::OVERDRAW_LAYERS] = {
            {0.0f, 0.0f, 1.0f},     // blue         (overdrawn 1 time)
            {0.0f, 1.0f, 0.0f},     // green        (overdrawn 2 times)
            {1.0f, 0.0f, 1.0f},     // magenta      (overdrawn 3 times)
            {1.0f, 0.0f, 0.0f}      // red          (overdrawn 4+ times)
    };

    for (auto i = 0; i < App::Scene::OVERDRAW_LAYERS; i++) {
        MaterialInstance* matInstance = material->createInstance();
        // TODO: move this to the material definition.
        matInstance->setStencilCompareFunction(MaterialInstance::StencilCompareFunc::E);
        // The stencil value represents the number of times the fragment has been written to.
        // We want 0-1 writes to be the regular color. Overdraw visualization starts at 2+ writes,
        // which represents a fragment overdrawn 1 time.
        matInstance->setStencilReferenceValue(i + 2);
        matInstance->setParameter("color", overdrawColors[i]);
        app.scene.overdrawMaterialInstances[i] = matInstance;
    }
    auto& lastMi = app.scene.overdrawMaterialInstances[App::Scene::OVERDRAW_LAYERS - 1];
    // This seems backwards, but it isn't. The comparison function compares:
    // the reference value (left side) <= stored stencil value (right side)
    lastMi->setStencilCompareFunction(MaterialInstance::StencilCompareFunc::LE);

    VertexBuffer* vertexBuffer = VertexBuffer::Builder()
            .vertexCount(3)
            .bufferCount(1)
            .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT4, 0)
            .build(*engine);

    vertexBuffer->setBufferAt(
            *engine, 0, { sFullScreenTriangleVertices, sizeof(sFullScreenTriangleVertices) });

    IndexBuffer* indexBuffer = IndexBuffer::Builder()
            .indexCount(3)
            .bufferType(IndexBuffer::IndexType::USHORT)
            .build(*engine);

    indexBuffer->setBuffer(*engine,
            { sFullScreenTriangleIndices, sizeof(sFullScreenTriangleIndices) });

    auto& em = EntityManager::get();
    const auto& matInstances = app.scene.overdrawMaterialInstances;
    for (auto i = 0; i < App::Scene::OVERDRAW_LAYERS; i++) {
        Entity overdrawEntity = em.create();
        RenderableManager::Builder(1)
                .boundingBox({{}, {1.0f, 1.0f, 1.0f}})
                .material(0, matInstances[i])
                .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, vertexBuffer, indexBuffer, 0, 3)
                .culling(false)
                .priority(7u)   // ensure the overdraw primitives are drawn last
                .layerMask(0xFF, 1u << App::Scene::OVERDRAW_VISIBILITY_LAYER)
                .build(*engine, overdrawEntity);
        scene->addEntity(overdrawEntity);
        app.scene.overdrawVisualizer[i] = overdrawEntity;
    }

    app.scene.overdrawMaterial = material;
    app.scene.fullScreenTriangleVertexBuffer = vertexBuffer;
    app.scene.fullScreenTriangleIndexBuffer = indexBuffer;
}

static void onClick(App& app, View* view, ImVec2 pos) {
    view->pick(pos.x, pos.y, [&app](View::PickingQueryResult const& result){
        if (const char* name = app.asset->getName(result.renderable); name) {
            app.notificationText = name;
        } else {
            app.notificationText.clear();
        }
    });
}

static utils::Path getPathForIBLAsset(std::string_view string) {
    auto isIBL = [] (utils::Path file) -> bool {
        return file.getExtension() == "ktx" || file.getExtension() == "hdr" ||
            file.getExtension() == "exr";

    };

    utils::Path filename{ string };
    if (!filename.exists()) {
        std::cerr << "file " << filename << " not found!" << std::endl;
        return {};
    }

    if (filename.isDirectory()) {
        std::vector<Path> files = filename.listContents();
        if (std::none_of(files.cbegin(), files.cend(), isIBL)) {
            return {};
        }
    } else if (!isIBL(filename)) {
        return {};
    }

    return filename;
}

static utils::Path getPathForGLTFAsset(std::string_view string) {
    auto isGLTF = [] (utils::Path file) -> bool {
        return file.getExtension() == "gltf" || file.getExtension() == "glb";
    };

    utils::Path filename{ string };
    if (!filename.exists()) {
        std::cerr << "file " << filename << " not found!" << std::endl;
        return {};
    }

    if (filename.isDirectory()) {
        std::vector<Path> files = filename.listContents();
        auto it = std::find_if(files.cbegin(), files.cend(), isGLTF);
        if (it == files.end()) {
            return {};
        }
        filename = *it;
    } else if (!isGLTF(filename)) {
        return {};
    }

    return filename;
}

static bool checkGLTFAsset(const utils::Path& filename) {
    // Peek at the file size to allow pre-allocation.
    long const contentSize = static_cast<long>(getFileSize(filename.c_str()));
    if (contentSize <= 0) {
        std::cerr << "Unable to open " << filename << std::endl;
        return false;
    }

    // Consume the glTF file.
    std::ifstream in(filename.c_str(), std::ifstream::binary | std::ifstream::in);
    std::vector<uint8_t> buffer(static_cast<unsigned long>(contentSize));
    if (!in.read((char*) buffer.data(), contentSize)) {
        std::cerr << "Unable to read " << filename << std::endl;
        return false;
    }

    // Try parsing the glTF file to check the validity of the file format.
    cgltf_options options{};
    cgltf_data* sourceAsset = nullptr;
    cgltf_result result = cgltf_parse(&options, buffer.data(), contentSize, &sourceAsset);
    cgltf_free(sourceAsset);
    if (result != cgltf_result_success) {
        slog.e << "Unable to parse glTF file." << io::endl;
        return false;
    }
    return true;
};


int main(int argc, char** argv) {
    App app;

    app.config.title = "Filament";
    app.config.iblDirectory = FilamentApp::getRootAssetsPath() + DEFAULT_IBL;

    int const optionIndex = handleCommandLineArguments(argc, argv, &app);

    utils::Path filename;
    int const num_args = argc - optionIndex;
    if (num_args >= 1) {
        filename = getPathForGLTFAsset(argv[optionIndex]);
        if (filename.isEmpty()) {
            std::cerr << "no glTF file found in " << filename << std::endl;
            return 1;
        }
    }

    auto loadAsset = [&app](const utils::Path& filename) {
        // Peek at the file size to allow pre-allocation.
        long const contentSize = static_cast<long>(getFileSize(filename.c_str()));
        if (contentSize <= 0) {
            std::cerr << "Unable to open " << filename << std::endl;
            exit(1);
        }

        // Consume the glTF file.
        std::ifstream in(filename.c_str(), std::ifstream::binary | std::ifstream::in);
        std::vector<uint8_t> buffer(static_cast<unsigned long>(contentSize));
        if (!in.read((char*) buffer.data(), contentSize)) {
            std::cerr << "Unable to read " << filename << std::endl;
            exit(1);
        }

        // Parse the glTF file and create Filament entities.
        app.asset = app.assetLoader->createAsset(buffer.data(), buffer.size());
        if (!app.asset) {
            std::cerr << "Unable to parse " << filename << std::endl;
            exit(1);
        }

        // pre-compile all material variants
        std::set<Material*> materials;
        RenderableManager const& rcm = app.engine->getRenderableManager();
        Slice<const Entity> const renderables{
                app.asset->getRenderableEntities(), app.asset->getRenderableEntityCount() };
        for (Entity const e: renderables) {
            auto ri = rcm.getInstance(e);
            size_t const c = rcm.getPrimitiveCount(ri);
            for (size_t i = 0; i < c; i++) {
                MaterialInstance* const mi = rcm.getMaterialInstanceAt(ri, i);
                Material* ma = const_cast<Material *>(mi->getMaterial());
                materials.insert(ma);
            }
        }
        for (Material* ma : materials) {
            // Don't attempt to precompile shaders on WebGL.
            // Chrome already suffers from slow shader compilation:
            // https://github.com/google/filament/issues/6615
            // Precompiling shaders exacerbates the problem.
#if !defined(__EMSCRIPTEN__)
            // First compile high priority variants
            ma->compile(Material::CompilerPriorityQueue::HIGH,
                    UserVariantFilterBit::DIRECTIONAL_LIGHTING |
                    UserVariantFilterBit::DYNAMIC_LIGHTING |
                    UserVariantFilterBit::SHADOW_RECEIVER);

            // and then, everything else at low priority, except STE, which is very uncommon.
            ma->compile(Material::CompilerPriorityQueue::LOW,
                    UserVariantFilterBit::FOG |
                    UserVariantFilterBit::SKINNING |
                    UserVariantFilterBit::SSR |
                    UserVariantFilterBit::VSM);
#endif
        }

        app.instance = app.asset->getInstance();
        buffer.clear();
        buffer.shrink_to_fit();
    };

    auto setupIBL = [&app]() {
        auto ibl = FilamentApp::get().getIBL();
        if (ibl) {
            app.viewer->setIndirectLight(ibl->getIndirectLight(), ibl->getSphericalHarmonics());
            app.viewer->getSettings().view.fogSettings.fogColorTexture = ibl->getFogTexture();
        }
    };

    auto loadResources = [&app, &setupIBL] (const utils::Path& filename) {
        // Load external textures and buffers.
        std::string const gltfPath = filename.getAbsolutePath();
        ResourceConfiguration configuration = {};
        configuration.engine = app.engine;
        configuration.gltfPath = gltfPath.c_str();
        configuration.normalizeSkinningWeights = true;

        if (!app.resourceLoader) {
            app.resourceLoader = new gltfio::ResourceLoader(configuration);
            app.stbDecoder = createStbProvider(app.engine);
            app.ktxDecoder = createKtx2Provider(app.engine);
            app.resourceLoader->addTextureProvider("image/png", app.stbDecoder);
            app.resourceLoader->addTextureProvider("image/jpeg", app.stbDecoder);
            app.resourceLoader->addTextureProvider("image/ktx2", app.ktxDecoder);
        } else {
            app.resourceLoader->setConfiguration(configuration);
        }

        if (!app.resourceLoader->asyncBeginLoad(app.asset)) {
            std::cerr << "Unable to start loading resources for " << filename << std::endl;
            exit(1);
        }

        if (app.recomputeAabb) {
            app.asset->getInstance()->recomputeBoundingBoxes();
        }

        app.asset->releaseSourceData();

        // Enable stencil writes on all material instances.
        const size_t matInstanceCount = app.instance->getMaterialInstanceCount();
        MaterialInstance* const* const instances = app.instance->getMaterialInstances();
        for (int mi = 0; mi < matInstanceCount; mi++) {
            instances[mi]->setStencilWrite(true);
            instances[mi]->setStencilOpDepthStencilPass(MaterialInstance::StencilOperation::INCR);
        }
        setupIBL();
    };

    auto setup = [&](Engine* engine, View* view, Scene* scene) {
        app.engine = engine;
        app.names = new NameComponentManager(EntityManager::get());
        app.viewer = new ViewerGui(engine, scene, view, 410);
        app.viewer->getSettings().viewer.autoScaleEnabled = !app.actualSize;

        engine->enableAccurateTranslations();
        auto& tcm = engine->getTransformManager();
        app.rootTransformEntity = engine->getEntityManager().create();
        tcm.create(app.rootTransformEntity);
        tcm.create(view->getFogEntity());

        const bool batchMode = !app.batchFile.empty();

        // First check if a custom automation spec has been provided. If it fails to load, the app
        // must be closed since it could be invoked from a script.
        if (batchMode && app.batchFile != "default") {
            auto size = getFileSize(app.batchFile.c_str());
            if (size > 0) {
                std::ifstream in(app.batchFile, std::ifstream::binary | std::ifstream::in);
                std::vector<char> json(static_cast<unsigned long>(size));
                in.read(json.data(), size);
                app.automationSpec = AutomationSpec::generate(json.data(), size);
                if (!app.automationSpec) {
                    std::cerr << "Unable to parse automation spec: " << app.batchFile << std::endl;
                    exit(1);
                }
            } else {
                std::cerr << "Unable to load automation spec: " << app.batchFile << std::endl;
                exit(1);
            }
        }

        // If no custom spec has been provided, or if in interactive mode, load the default spec.
        if (!app.automationSpec) {
            app.automationSpec = AutomationSpec::generateDefaultTestCases();
        }

        app.automationEngine = new AutomationEngine(app.automationSpec, &app.viewer->getSettings());

        if (batchMode) {
            app.automationEngine->startBatchMode();
            auto options = app.automationEngine->getOptions();
            options.sleepDuration = 0.0;
            options.exportScreenshots = true;
            options.exportSettings = true;
            options.exportFormat = app.screenshotAsPPM
                                           ? AutomationEngine::Options::ExportFormat::PPM
                                           : AutomationEngine::Options::ExportFormat::TIFF;
            app.automationEngine->setOptions(options);
            app.viewer->stopAnimation();
        }

        if (!app.settingsFile.empty()) {
            bool const success = loadSettings(app.settingsFile.c_str(), &app.viewer->getSettings());
            if (success) {
                std::cout << "Loaded settings from " << app.settingsFile << std::endl;
            } else {
                std::cerr << "Failed to load settings from " << app.settingsFile << std::endl;
            }
        }

        app.materials = (app.materialSource == JITSHADER)
                                ? createJitShaderProvider(engine, OPTIMIZE_MATERIALS,
                                          samples::getJitMaterialVariantFilter(app.config.backend))
                                : createUbershaderProvider(engine, UBERARCHIVE_DEFAULT_DATA,
                                          UBERARCHIVE_DEFAULT_SIZE);

        app.assetLoader = AssetLoader::create({ engine, app.materials, app.names });
        app.mainCamera = &view->getCamera();
        if (filename.isEmpty()) {
            app.asset = app.assetLoader->createAsset(
                    GLTF_DEMO_DAMAGEDHELMET_DATA,
                    GLTF_DEMO_DAMAGEDHELMET_SIZE);
            app.instance = app.asset->getInstance();
        } else {
            loadAsset(filename);
        }

        loadResources(filename);
        app.viewer->setAsset(app.asset, app.instance);

        createGroundPlane(engine, scene, app);
        createOverdrawVisualizerEntities(engine, scene, app);

        app.viewer->setUiCallback([&app, scene, view, engine] () {
            auto& automation = *app.automationEngine;

            if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
                ImVec2 pos = ImGui::GetMousePos();
                pos.x -= app.viewer->getSidebarWidth();
                pos.x *= ImGui::GetIO().DisplayFramebufferScale.x;
                pos.y *= ImGui::GetIO().DisplayFramebufferScale.y;
                if (pos.x > 0) {
                    pos.y = view->getViewport().height - 1 - pos.y;
                    onClick(app, view, pos);
                }
            }

            const ImVec4 yellow(1.0f,1.0f,0.0f,1.0f);

            if (!app.notificationText.empty()) {
                ImGui::TextColored(yellow, "Picked %s", app.notificationText.c_str());
                ImGui::Spacing();
            }

            float const progress = app.resourceLoader->asyncGetLoadProgress();
            if (progress < 1.0) {
                ImGui::ProgressBar(progress);
            } else {
                // The model is now fully loaded, so let automation know.
                automation.signalBatchMode();
            }

            // The screenshots do not include the UI, but we auto-open the Automation UI group
            // when in batch mode. This is useful when a human is observing progress.
            const int flags = automation.isBatchModeEnabled() ? ImGuiTreeNodeFlags_DefaultOpen : 0;

            if (ImGui::CollapsingHeader("Automation", flags)) {
                ImGui::Indent();

                if (automation.isRunning()) {
                    ImGui::TextColored(yellow, "Test case %zu / %zu",
                            automation.currentTest(), automation.testCount());
                } else {
                    ImGui::TextColored(yellow, "%zu test cases", automation.testCount());
                }

                auto options = automation.getOptions();

                ImGui::PushItemWidth(150);
                ImGui::SliderFloat("Sleep (seconds)", &options.sleepDuration, 0.0, 5.0);
                ImGui::PopItemWidth();

                // Hide the tooltip during automation to avoid photobombing the screenshot.
                if (ImGui::IsItemHovered() && !automation.isRunning()) {
                    ImGui::SetTooltip("Specifies the amount of time to sleep between test cases.");
                }

                ImGui::Checkbox("Export screenshot for each test", &options.exportScreenshots);
                ImGui::Checkbox("Export settings JSON for each test", &options.exportSettings);

                automation.setOptions(options);

                if (automation.isRunning()) {
                    if (ImGui::Button("Stop batch test")) {
                        automation.stopRunning();
                    }
                } else if (ImGui::Button("Run batch test")) {
                    automation.startRunning();
                }

                if (ImGui::Button("Export view settings")) {
                    AutomationEngine::exportSettings(app.viewer->getSettings(), "settings.json");
                    app.messageBoxText = automation.getStatusMessage();
                    ImGui::OpenPopup("MessageBox");
                }
                ImGui::Unindent();
            }

            if (ImGui::CollapsingHeader("Stats")) {
                ImGui::Indent();
                ImGui::Text("%zu entities in the asset", app.asset->getEntityCount());
                ImGui::Text("%zu renderables (excluding UI)", scene->getRenderableCount());
                ImGui::Text("%zu skipped frames", FilamentApp::get().getSkippedFrameCount());
                ImGui::Unindent();
            }

            if (ImGui::CollapsingHeader("Debug")) {
                auto& debug = engine->getDebugRegistry();
                if (engine->getBackend() == Engine::Backend::METAL) {
                    if (ImGui::Button("Capture frame")) {
                        bool* captureFrame =
                                debug.getPropertyAddress<bool>("d.renderer.doFrameCapture");
                        *captureFrame = true;
                    }
                }
                if (ImGui::Button("Screenshot")) {
                    app.screenshot = true;
                }
                ImGui::Checkbox("Disable buffer padding",
                        debug.getPropertyAddress<bool>("d.renderer.disable_buffer_padding"));
                ImGui::Checkbox("Disable sub-passes",
                        debug.getPropertyAddress<bool>("d.renderer.disable_subpasses"));
                ImGui::Checkbox("Camera at origin",
                        debug.getPropertyAddress<bool>("d.view.camera_at_origin"));
                ImGui::Checkbox("Far Origin", &app.originIsFarAway);
                ImGui::SliderFloat("Origin", &app.originDistance, 0, 1);
                ImGui::Checkbox("Far uses shadow casters",
                        debug.getPropertyAddress<bool>("d.shadowmap.far_uses_shadowcasters"));
                ImGui::Checkbox("Focus shadow casters",
                        debug.getPropertyAddress<bool>("d.shadowmap.focus_shadowcasters"));
                ImGui::Checkbox("Disable light frustum alignment",
                        debug.getPropertyAddress<bool>("d.shadowmap.disable_light_frustum_align"));
                ImGui::Checkbox("Depth clamp",
                        debug.getPropertyAddress<bool>("d.shadowmap.depth_clamp"));

                bool debugDirectionalShadowmap;
                if (debug.getProperty("d.shadowmap.debug_directional_shadowmap",
                        &debugDirectionalShadowmap)) {
                    ImGui::Checkbox("Debug DIR shadowmap", &debugDirectionalShadowmap);
                    debug.setProperty("d.shadowmap.debug_directional_shadowmap",
                            debugDirectionalShadowmap);
                }

                ImGui::Checkbox("Display Shadow Texture",
                        debug.getPropertyAddress<bool>("d.shadowmap.display_shadow_texture"));
                if (*debug.getPropertyAddress<bool>("d.shadowmap.display_shadow_texture")) {
                    int layerCount;
                    int levelCount;
                    debug.getProperty("d.shadowmap.display_shadow_texture_layer_count", &layerCount);
                    debug.getProperty("d.shadowmap.display_shadow_texture_level_count", &levelCount);
                    ImGui::Indent();
                    ImGui::SliderFloat("scale", debug.getPropertyAddress<float>(
                                    "d.shadowmap.display_shadow_texture_scale"), 0.0f, 8.0f);
                    ImGui::SliderFloat("contrast", debug.getPropertyAddress<float>(
                                    "d.shadowmap.display_shadow_texture_power"), 0.0f, 2.0f);
                    ImGui::SliderInt("layer", debug.getPropertyAddress<int>(
                                    "d.shadowmap.display_shadow_texture_layer"), 0, layerCount - 1);
                    ImGui::SliderInt("level", debug.getPropertyAddress<int>(
                                    "d.shadowmap.display_shadow_texture_level"), 0, levelCount - 1);
                    ImGui::SliderInt("channel", debug.getPropertyAddress<int>(
                                    "d.shadowmap.display_shadow_texture_channel"), 0, 3);
                    ImGui::Unindent();
                }

                bool cameraFrustum = FilamentApp::get().isCameraFrustumEnabled();
                ImGui::Checkbox("Show Camera Frustum", &cameraFrustum);
                FilamentApp::get().setCameraFrustumEnabled(cameraFrustum);

                bool shadowFrustum = FilamentApp::get().isDirectionalShadowFrustumEnabled();
                ImGui::Checkbox("Show Shadow Frustum", &shadowFrustum);
                FilamentApp::get().setDirectionalShadowFrustumEnabled(shadowFrustum);

                bool debugFroxelVisualization;
                if (debug.getProperty("d.lighting.debug_froxel_visualization",
                        &debugFroxelVisualization)) {
                    ImGui::Checkbox("Froxel Visualization", &debugFroxelVisualization);
                    debug.setProperty("d.lighting.debug_froxel_visualization",
                            debugFroxelVisualization);
                    FilamentApp::get().setFroxelGridEnabled(debugFroxelVisualization);
                }

                auto dataSource = debug.getDataSource("d.view.frame_info");
                if (dataSource.data) {
                    ImGuiExt::PlotLinesSeries("FrameInfo", 6,
                            [](int series) {
                                const ImVec4 colors[] = {
                                        { 1,    0, 0, 1 }, // target
                                        { 0, 0.5f, 0, 1 }, // frame-time
                                        { 0,    1, 0, 1 }, // frame-time denoised
                                        { 1,    1, 0, 1 }, // i
                                        { 1,    0, 1, 1 }, // d
                                        { 0,    1, 1, 1 }, // e

                                };
                                ImGui::PushStyleColor(ImGuiCol_PlotLines, colors[series]);
                            },
                            [](int series, void* buffer, int i) -> float {
                                auto const* p = (DebugRegistry::FrameHistory const*)buffer + i;
                                switch (series) {
                                    case 0:     return 0.03f * p->target;
                                    case 1:     return 0.03f * p->frameTime;
                                    case 2:     return 0.03f * p->frameTimeDenoised;
                                    case 3:     return p->pid_i * 0.5f / 100.0f + 0.5f;
                                    case 4:     return p->pid_d * 0.5f / 0.100f + 0.5f;
                                    case 5:     return p->pid_e * 0.5f / 1.000f + 0.5f;
                                    default:    return 0.0f;
                                }
                            },
                            [](int series) {
                                if (series < 6) ImGui::PopStyleColor();
                            },
                            const_cast<void*>(dataSource.data), int(dataSource.count), 0,
                            nullptr, 0.0f, 1.0f, { 0, 100 });
                }
#ifndef NDEBUG
                ImGui::SliderFloat("Kp", debug.getPropertyAddress<float>("d.view.pid.kp"), 0, 2);
                ImGui::SliderFloat("Ki", debug.getPropertyAddress<float>("d.view.pid.ki"), 0, 10);
                ImGui::SliderFloat("Kd", debug.getPropertyAddress<float>("d.view.pid.kd"), 0, 10);
#endif
                const auto overdrawVisibilityBit = (1u << App::Scene::OVERDRAW_VISIBILITY_LAYER);
                bool visualizeOverdraw = view->getVisibleLayers() & overdrawVisibilityBit;
                // TODO: enable after stencil buffer supported is added for Vulkan.
                const bool overdrawDisabled = engine->getBackend() == backend::Backend::VULKAN;
                ImGui::BeginDisabled(overdrawDisabled);
                ImGui::Checkbox(!overdrawDisabled ? "Visualize overdraw"
                                                  : "Visualize overdraw (disabled for Vulkan)",
                        &visualizeOverdraw);
                ImGui::EndDisabled();
                view->setVisibleLayers(overdrawVisibilityBit,
                        (uint8_t)visualizeOverdraw << App::Scene::OVERDRAW_VISIBILITY_LAYER);
                view->setStencilBufferEnabled(visualizeOverdraw);
            }

            if (ImGui::BeginPopupModal("MessageBox", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
                ImGui::Text("%s", app.messageBoxText.c_str());
                if (ImGui::Button("OK", ImVec2(120, 0))) {
                    ImGui::CloseCurrentPopup();
                }
                ImGui::EndPopup();
            }
        });
    };

    auto cleanup = [&app](Engine* engine, View*, Scene*) {
        app.automationEngine->terminate();
        app.resourceLoader->asyncCancelLoad();
        app.assetLoader->destroyAsset(app.asset);
        app.materials->destroyMaterials();

        engine->destroy(app.scene.groundPlane);
        engine->destroy(app.scene.groundVertexBuffer);
        engine->destroy(app.scene.groundIndexBuffer);
        engine->destroy(app.scene.groundMaterial);
        engine->destroy(app.colorGrading);

        engine->destroy(app.scene.fullScreenTriangleVertexBuffer);
        engine->destroy(app.scene.fullScreenTriangleIndexBuffer);

        auto& em = EntityManager::get();
        for (auto e : app.scene.overdrawVisualizer) {
            engine->destroy(e);
            em.destroy(e);
        }

        for (auto mi : app.scene.overdrawMaterialInstances) {
            engine->destroy(mi);
        }
        engine->destroy(app.scene.overdrawMaterial);

        delete app.viewer;
        delete app.materials;
        delete app.names;
        delete app.resourceLoader;
        delete app.stbDecoder;
        delete app.ktxDecoder;
        delete app.automationSpec;
        delete app.automationEngine;

        AssetLoader::destroy(&app.assetLoader);
    };

    auto animate = [&app](Engine*, View*, double now) {
        app.resourceLoader->asyncUpdateLoad();

        // Optionally fit the model into a unit cube at the origin.
        app.viewer->updateRootTransform();

        // Gradually add renderables to the scene as their textures become ready.
        app.viewer->populateScene();

        app.viewer->applyAnimation(now);
    };

    auto resize = [&app](Engine*, View* view) {
        Camera& camera = view->getCamera();
        if (&camera == app.mainCamera) {
            // Don't adjust the aspect ratio of the main camera, this is done inside of
            // FilamentApp.cpp
            return;
        }
        const Viewport& vp = view->getViewport();
        double const aspectRatio = (double) vp.width / vp.height;
        camera.setScaling({1.0 / aspectRatio, 1.0 });
    };

    auto gui = [&app](Engine*, View*) {
        app.viewer->updateUserInterface();

        FilamentApp::get().setSidebarWidth(app.viewer->getSidebarWidth());
    };

    auto preRender = [&app](Engine* engine, View* view, Scene* scene, Renderer* renderer) {
        auto& rcm = engine->getRenderableManager();
        auto instance = rcm.getInstance(app.scene.groundPlane);
        const auto viewerOptions = app.automationEngine->getViewerOptions();
        rcm.setLayerMask(instance,
                0xff, viewerOptions.groundPlaneEnabled ? 0xff : 0x00);

        engine->setAutomaticInstancingEnabled(viewerOptions.autoInstancingEnabled);

        // Note that this focal length might be different from the slider value because the
        // automation engine applies Camera::computeEffectiveFocalLength when DoF is enabled.
        FilamentApp::get().setCameraFocalLength(viewerOptions.cameraFocalLength);
        FilamentApp::get().setCameraNearFar(viewerOptions.cameraNear, viewerOptions.cameraFar);

        const size_t cameraCount = app.asset->getCameraEntityCount();
        view->setCamera(app.mainCamera);

        const int currentCamera = app.viewer->getCurrentCamera();
        if (currentCamera > 0 && currentCamera <= cameraCount) {
            const utils::Entity* cameras = app.asset->getCameraEntities();
            Camera* camera = engine->getCameraComponent(cameras[currentCamera - 1]);
            assert_invariant(camera);
            view->setCamera(camera);

            // Override the aspect ratio in the glTF file and adjust the aspect ratio of this
            // camera to the viewport.
            const Viewport& vp = view->getViewport();
            double const aspectRatio = (double) vp.width / vp.height;
            camera->setScaling({1.0 / aspectRatio, 1.0});
        }

        static bool stereoscopicEnabled = false;
        if (stereoscopicEnabled != view->getStereoscopicOptions().enabled) {
            // Stereo was turned on/off.
            FilamentApp::get().reconfigureCameras();
            stereoscopicEnabled = view->getStereoscopicOptions().enabled;
        }

        app.scene.groundMaterial->setDefaultParameter(
                "strength", viewerOptions.groundShadowStrength);

        // This applies clear options, the skybox mask, and some camera settings.
        Camera& camera = view->getCamera();
        Skybox* skybox = scene->getSkybox();
        applySettings(engine, app.viewer->getSettings().viewer, &camera, skybox, renderer);

        // FIMXE: This applySettings() is done here instead of in AutomationEngine.cpp because
        // we need access to the Renderer, which AutomationEngine does not provide.
        applySettings(engine, app.viewer->getSettings().debug, renderer);

        // technically we don't need to do this each frame
        auto& tcm = engine->getTransformManager();
        TransformManager::Instance const& root = tcm.getInstance(app.rootTransformEntity);
        tcm.setParent(tcm.getInstance(camera.getEntity()), root);
        tcm.setParent(tcm.getInstance(app.asset->getRoot()), root);
        tcm.setParent(tcm.getInstance(view->getFogEntity()), root);

        // these values represent a point somewhere on Earth's surface
        float const d = app.originIsFarAway ? app.originDistance : 0.0f;
//        tcm.setTransform(root, mat4::translation(double3{ 67.0, -6366759.0, -21552.0 } * d));
        tcm.setTransform(root, mat4::translation(
                double3{ 2304097.1410110965, -4688442.9915525438, -3639452.5611694567 } * d));

        // Check if color grading has changed.
        ColorGradingSettings const& options = app.viewer->getSettings().view.colorGrading;
        if (options.enabled) {
            if (options != app.lastColorGradingOptions) {
                ColorGrading *colorGrading = createColorGrading(options, engine);
                engine->destroy(app.colorGrading);
                app.colorGrading = colorGrading;
                app.lastColorGradingOptions = options;
            }
            view->setColorGrading(app.colorGrading);
        } else {
            view->setColorGrading(nullptr);
        }
    };

    auto postRender = [&app](Engine* engine, View* view, Scene*, Renderer* renderer) {
        if (app.screenshot) {
            std::ostringstream stringStream;
            stringStream << "screenshot" << std::setfill('0') << std::setw(2) << +app.screenshotSeq;
            std::string const ext = app.screenshotAsPPM ? ".ppm" : ".tif";
            AutomationEngine::exportScreenshot(
                    view, renderer, stringStream.str() + ext, false, app.automationEngine);
            ++app.screenshotSeq;
            app.screenshot = false;
        }
        if (app.automationEngine->shouldClose()) {
            FilamentApp::get().close();
            return;
        }
        AutomationEngine::ViewerContent const content = {
            .view = view,
            .renderer = renderer,
            .materials = app.instance->getMaterialInstances(),
            .materialCount = app.instance->getMaterialInstanceCount(),
        };
        app.automationEngine->tick(engine, content, ImGui::GetIO().DeltaTime);
    };

    FilamentApp& filamentApp = FilamentApp::get();
    filamentApp.animate(animate);
    filamentApp.resize(resize);

    filamentApp.setDropHandler([&](std::string_view path) {
        utils::Path filename = getPathForGLTFAsset(path);
        if (!filename.isEmpty()) {
            if (checkGLTFAsset(filename)) {
                app.resourceLoader->asyncCancelLoad();
                app.resourceLoader->evictResourceData();
                app.viewer->removeAsset();
                app.assetLoader->destroyAsset(app.asset);
                loadAsset(filename);
                loadResources(filename);
                app.viewer->setAsset(app.asset, app.instance);
            }
            return;
        }

        filename = getPathForIBLAsset(path);
        if (!filename.isEmpty()) {
            FilamentApp::get().loadIBL(path);
            setupIBL();
        }
    });

    filamentApp.run(app.config, setup, cleanup, gui, preRender, postRender);

    return 0;
}