#include <XCEngine/Core/Asset/AssetDatabase.h>
#include <XCEngine/Core/Asset/ArtifactContainer.h>
#include <XCEngine/Core/Asset/ArtifactFormats.h>
#include <XCEngine/Core/Asset/ResourceTypes.h>
#include <XCEngine/Core/Containers/Array.h>
#include <XCEngine/Core/Containers/String.h>
#include <XCEngine/Rendering/Internal/ShaderVariantUtils.h>
#include <XCEngine/RHI/D3D12/D3D12Shader.h>
#include <XCEngine/Resources/Shader/ShaderLoader.h>

#include <d3dcompiler.h>

#include <cstring>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <memory>
#include <string>
#include <system_error>
#include <vector>

namespace {

class ScopedCurrentPath {
public:
    explicit ScopedCurrentPath(const std::filesystem::path& path)
        : m_previousPath(std::filesystem::current_path()) {
        std::filesystem::current_path(path);
    }

    ScopedCurrentPath(const ScopedCurrentPath&) = delete;
    ScopedCurrentPath& operator=(const ScopedCurrentPath&) = delete;

    ~ScopedCurrentPath() {
        std::error_code ec;
        std::filesystem::current_path(m_previousPath, ec);
    }

private:
    std::filesystem::path m_previousPath;
};

bool ContainsPathSuffix(
    const XCEngine::Containers::Array<XCEngine::Containers::String>& paths,
    const char* suffix) {
    for (size_t index = 0; index < paths.Size(); ++index) {
        const std::string path = paths[index].CStr();
        if (path.ends_with(suffix)) {
            return true;
        }
    }

    return false;
}

bool WriteTextFile(const std::filesystem::path& path, const char* text) {
    std::filesystem::create_directories(path.parent_path());
    std::ofstream stream(path, std::ios::binary);
    if (!stream) {
        return false;
    }

    stream << text;
    return true;
}

std::vector<std::string> SplitTabFields(const std::string& line) {
    std::vector<std::string> fields;
    size_t fieldStart = 0;
    while (fieldStart <= line.size()) {
        const size_t tabPos = line.find('\t', fieldStart);
        if (tabPos == std::string::npos) {
            fields.push_back(line.substr(fieldStart));
            break;
        }

        fields.push_back(line.substr(fieldStart, tabPos - fieldStart));
        fieldStart = tabPos + 1;
    }

    return fields;
}

bool LoadSourceDbShaderRecord(
    const std::filesystem::path& projectRoot,
    const char* relativePath,
    std::vector<std::string>& outFields) {
    std::ifstream input(projectRoot / "Library/assets.db");
    if (!input.is_open()) {
        std::cerr << "failed to open source asset db\n";
        return false;
    }

    std::string line;
    while (std::getline(input, line)) {
        if (line.empty() || line[0] == '#') {
            continue;
        }

        std::vector<std::string> fields = SplitTabFields(line);
        if (fields.size() >= 10 && fields[1] == relativePath) {
            outFields = std::move(fields);
            return true;
        }
    }

    std::cerr << "source asset db did not contain record: " << relativePath << "\n";
    return false;
}

XCEngine::Core::uint64 GetFileSizeValue(const std::filesystem::path& path) {
    std::error_code ec;
    const auto size = std::filesystem::file_size(path, ec);
    return ec ? 0 : static_cast<XCEngine::Core::uint64>(size);
}

XCEngine::Core::uint64 GetFileWriteTimeValue(const std::filesystem::path& path) {
    std::error_code ec;
    const auto writeTime = std::filesystem::last_write_time(path, ec);
    if (ec) {
        return 0;
    }

    return static_cast<XCEngine::Core::uint64>(writeTime.time_since_epoch().count());
}

bool WriteMinimalCurrentShaderArtifact(const std::filesystem::path& artifactPath) {
    XCEngine::Resources::ShaderArtifactFileHeader fileHeader = {};
    XCEngine::Resources::ShaderArtifactHeader shaderHeader = {};

    XCEngine::Containers::Array<XCEngine::Core::uint8> payload;
    payload.Resize(sizeof(fileHeader) + sizeof(shaderHeader));
    std::memcpy(payload.Data(), &fileHeader, sizeof(fileHeader));
    std::memcpy(
        payload.Data() + sizeof(fileHeader),
        &shaderHeader,
        sizeof(shaderHeader));

    XCEngine::Resources::ArtifactContainerEntry entry = {};
    entry.name = "main";
    entry.resourceType = XCEngine::Resources::ResourceType::Shader;
    entry.localID = XCEngine::Resources::kMainAssetLocalID;
    entry.payload = std::move(payload);

    XCEngine::Resources::ArtifactContainerWriter writer;
    writer.AddEntry(std::move(entry));
    XCEngine::Containers::String error;
    if (!writer.WriteToFile(artifactPath.generic_string().c_str(), &error)) {
        std::cerr << "failed to write minimal shader artifact: "
                  << error.CStr() << "\n";
        return false;
    }

    return true;
}

bool WriteShaderArtifactDbRecord(
    const std::filesystem::path& projectRoot,
    const std::vector<std::string>& sourceFields,
    const std::filesystem::path& dependencyPath,
    XCEngine::Core::uint64 dependencyFileSize,
    XCEngine::Core::uint64 dependencyWriteTime,
    const std::string& artifactKey,
    const std::string& mainArtifactPath) {
    if (sourceFields.size() < 10) {
        return false;
    }

    const std::filesystem::path artifactDbPath = projectRoot / "Library/artifacts.db";
    std::filesystem::create_directories(artifactDbPath.parent_path());
    std::ofstream output(artifactDbPath, std::ios::out | std::ios::trunc);
    if (!output.is_open()) {
        std::cerr << "failed to write artifact db: " << artifactDbPath << "\n";
        return false;
    }

    output << "# schema=2\n";
    output << "# artifactKey\tassetGuid\timporter\tversion\ttype\tartifactDir\tmainArtifact\tsourceHash\tmetaHash\tsize\twriteTime\tmainLocalID\tstorageKind\tmainEntryName\t(depPath\tdepHash\tdepSize\tdepWriteTime)...\n";
    output << artifactKey << '\t'
           << sourceFields[0] << '\t'
           << "ShaderImporter" << '\t'
           << "8" << '\t'
           << static_cast<XCEngine::Core::uint32>(XCEngine::Resources::ResourceType::Shader) << '\t'
           << std::filesystem::path(mainArtifactPath).parent_path().generic_string() << '\t'
           << mainArtifactPath << '\t'
           << sourceFields[7] << '\t'
           << sourceFields[6] << '\t'
           << sourceFields[8] << '\t'
           << sourceFields[9] << '\t'
           << XCEngine::Resources::kMainAssetLocalID << '\t'
           << static_cast<XCEngine::Core::uint32>(
                  XCEngine::Resources::ArtifactStorageKind::SingleFileContainer) << '\t'
           << "main" << '\t'
           << dependencyPath.lexically_normal().generic_string() << '\t'
           << "dependency-hash-not-used-by-currentness-check" << '\t'
           << dependencyFileSize << '\t'
           << dependencyWriteTime << '\n';

    return static_cast<bool>(output);
}

bool CollectDependencies(
    const std::filesystem::path& shaderPath,
    XCEngine::Containers::Array<XCEngine::Containers::String>& dependencies) {
    XCEngine::Resources::ShaderLoader loader;
    return loader.CollectSourceDependencies(shaderPath.generic_string().c_str(), dependencies);
}

bool CollectDependencies(
    const std::filesystem::path& shaderPath,
    XCEngine::Containers::Array<XCEngine::Containers::String>& dependencies,
    XCEngine::Containers::String& error) {
    XCEngine::Resources::ShaderLoader loader;
    return loader.CollectSourceDependencies(shaderPath.generic_string().c_str(), dependencies, &error);
}

std::string NarrowWideString(const std::wstring& value) {
    std::string result;
    result.reserve(value.size());
    for (wchar_t ch : value) {
        result.push_back(static_cast<char>(ch));
    }

    return result;
}

bool RequireDependencySuffixes(
    const XCEngine::Containers::Array<XCEngine::Containers::String>& dependencies,
    const std::vector<const char*>& suffixes) {
    for (const char* suffix : suffixes) {
        if (ContainsPathSuffix(dependencies, suffix)) {
            continue;
        }

        std::cerr << "missing dependency suffix: " << suffix << "\n";
        for (const auto& dependency : dependencies) {
            std::cerr << "dependency: " << dependency.CStr() << "\n";
        }
        return false;
    }

    return true;
}

bool RequireNoDependencyPrefix(
    const XCEngine::Containers::Array<XCEngine::Containers::String>& dependencies,
    const std::filesystem::path& prefixPath) {
    const std::string prefix = prefixPath.lexically_normal().generic_string();
    for (const auto& dependency : dependencies) {
        const std::string path = std::filesystem::path(dependency.CStr())
            .lexically_normal()
            .generic_string();
        if (path.rfind(prefix, 0) == 0) {
            std::cerr << "dependency unexpectedly resolved under shadow package root: "
                      << path << "\n";
            return false;
        }
    }

    return true;
}

bool RequireDependencySuffixUnderPrefix(
    const XCEngine::Containers::Array<XCEngine::Containers::String>& dependencies,
    const char* suffix,
    const std::filesystem::path& prefixPath) {
    const std::string prefix = prefixPath.lexically_normal().generic_string();
    bool sawSuffix = false;
    for (const auto& dependency : dependencies) {
        const std::string path = std::filesystem::path(dependency.CStr())
            .lexically_normal()
            .generic_string();
        if (!path.ends_with(suffix)) {
            continue;
        }

        sawSuffix = true;
        if (path.rfind(prefix, 0) == 0) {
            return true;
        }

        std::cerr << "dependency suffix resolved outside expected prefix: "
                  << path << " prefix=" << prefix << "\n";
    }

    if (!sawSuffix) {
        std::cerr << "missing dependency suffix under prefix: " << suffix << "\n";
    }

    for (const auto& dependency : dependencies) {
        std::cerr << "dependency: " << dependency.CStr() << "\n";
    }
    return false;
}

bool CompileD3D12ShaderVariant(
    const std::filesystem::path& shaderPath,
    const XCEngine::Resources::ShaderPass& pass,
    const XCEngine::Resources::ShaderStageVariant& variant) {
    XCEngine::RHI::ShaderCompileDesc compileDesc = {};
    XCEngine::Rendering::Internal::ApplyShaderStageVariant(
        shaderPath.generic_string().c_str(),
        pass,
        XCEngine::Resources::ShaderBackend::D3D12,
        variant,
        compileDesc);

    std::vector<std::string> macroNames;
    std::vector<std::string> macroDefinitions;
    std::vector<D3D_SHADER_MACRO> macros;
    macroNames.reserve(compileDesc.macros.size());
    macroDefinitions.reserve(compileDesc.macros.size());
    macros.reserve(compileDesc.macros.size() + 1u);
    for (const XCEngine::RHI::ShaderCompileMacro& macro : compileDesc.macros) {
        macroNames.push_back(NarrowWideString(macro.name));
        macroDefinitions.push_back(NarrowWideString(macro.definition));
    }
    for (size_t macroIndex = 0; macroIndex < macroNames.size(); ++macroIndex) {
        D3D_SHADER_MACRO d3dMacro = {};
        d3dMacro.Name = macroNames[macroIndex].c_str();
        d3dMacro.Definition =
            macroDefinitions[macroIndex].empty() ? "1" : macroDefinitions[macroIndex].c_str();
        macros.push_back(d3dMacro);
    }
    macros.push_back({ nullptr, nullptr });

    const std::string entryPoint = NarrowWideString(compileDesc.entryPoint);
    const std::string profile = NarrowWideString(compileDesc.profile);

    XCEngine::RHI::D3D12Shader compiledShader;
    if (!compiledShader.Compile(
            compileDesc.source.data(),
            compileDesc.source.size(),
            compileDesc.fileName.empty() ? nullptr : compileDesc.fileName.c_str(),
            macros.data(),
            entryPoint.empty() ? nullptr : entryPoint.c_str(),
            profile.empty() ? nullptr : profile.c_str())) {
        std::cerr << "D3D12 compile failed for entry=" << entryPoint << " profile=" << profile << "\n";
        return false;
    }

    if (compiledShader.GetBytecodeSize() == 0) {
        std::cerr << "D3D12 compile produced empty bytecode for entry=" << entryPoint << "\n";
        return false;
    }

    return true;
}

bool RequirePackageShaderLoadAndD3D12Compile(const std::filesystem::path& shaderPath) {
    XCEngine::Resources::ShaderLoader loader;
    XCEngine::Resources::LoadResult result =
        loader.Load(shaderPath.generic_string().c_str());
    if (!result || result.resource == nullptr) {
        std::cerr << "failed to load package compile shader: "
                  << result.errorMessage.CStr() << "\n";
        return false;
    }

    std::unique_ptr<XCEngine::Resources::Shader> shader(
        static_cast<XCEngine::Resources::Shader*>(result.resource));
    const XCEngine::Resources::ShaderPass* pass = shader->FindPass("PackageCompile");
    if (pass == nullptr) {
        std::cerr << "loaded package compile shader is missing PackageCompile pass\n";
        return false;
    }

    const XCEngine::Resources::ShaderStageVariant* vertexVariant =
        shader->FindVariant(
            "PackageCompile",
            XCEngine::Resources::ShaderType::Vertex,
            XCEngine::Resources::ShaderBackend::Generic);
    const XCEngine::Resources::ShaderStageVariant* fragmentVariant =
        shader->FindVariant(
            "PackageCompile",
            XCEngine::Resources::ShaderType::Fragment,
            XCEngine::Resources::ShaderBackend::Generic);
    if (vertexVariant == nullptr || fragmentVariant == nullptr) {
        std::cerr << "loaded package compile shader is missing graphics variants\n";
        return false;
    }

    const std::string vertexSource = vertexVariant->sourceCode.CStr();
    if (vertexSource.find("Packages/") != std::string::npos ||
        vertexSource.find("TransformObjectToHClip") == std::string::npos ||
        vertexSource.find("XC_UNIVERSAL_CORE_INCLUDED") == std::string::npos) {
        std::cerr << "package include was not expanded into compile-ready source\n";
        return false;
    }

    return CompileD3D12ShaderVariant(shaderPath, *pass, *vertexVariant) &&
           CompileD3D12ShaderVariant(shaderPath, *pass, *fragmentVariant);
}

bool RequirePackageDependencyCurrentPathFallback(
    const std::filesystem::path& projectRoot) {
    std::error_code cleanupError;
    std::filesystem::remove_all(projectRoot, cleanupError);

    const char* includePath =
        "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/CurrentPathFallbackOnly_20260425.hlsl";
    const char* resolvedSuffix =
        "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/CurrentPathFallbackOnly_20260425.hlsl";
    const std::filesystem::path shaderPath =
        projectRoot / "current_path_fallback.shader";
    const std::filesystem::path dependencyPath =
        projectRoot / resolvedSuffix;

    const std::string shaderSource =
        std::string("Shader \"Tests/CurrentPathFallback\"\n") +
        "{\n"
        "    HLSLINCLUDE\n"
        "    #include \"" + includePath + "\"\n"
        "    ENDHLSL\n"
        "    SubShader\n"
        "    {\n"
        "    }\n"
        "}\n";

    if (!WriteTextFile(shaderPath, shaderSource.c_str()) ||
        !WriteTextFile(dependencyPath, "float4 CurrentPathFallbackOnlyValue() { return 1.0f.xxxx; }\n")) {
        std::cerr << "failed to prepare current-path package fallback fixtures\n";
        return false;
    }

    XCEngine::Containers::Array<XCEngine::Containers::String> dependencies;
    XCEngine::Containers::String dependencyError;
    {
        ScopedCurrentPath scopedCurrentPath(projectRoot);
        if (!CollectDependencies(shaderPath, dependencies, dependencyError)) {
            std::cerr << "current-path package fallback dependency collection failed: "
                      << dependencyError.CStr() << "\n";
            return false;
        }
    }

    return RequireDependencySuffixUnderPrefix(
        dependencies,
        resolvedSuffix,
        projectRoot);
}

bool RequireShaderArtifactLoads(
    const std::filesystem::path& projectRoot,
    const XCEngine::Containers::String& artifactMainPath,
    const char* label) {
    if (artifactMainPath.Empty()) {
        std::cerr << label << " artifact path is empty\n";
        return false;
    }

    const std::filesystem::path absoluteArtifactPath =
        projectRoot / artifactMainPath.CStr();
    if (!std::filesystem::exists(absoluteArtifactPath)) {
        std::cerr << label << " artifact file does not exist: "
                  << absoluteArtifactPath << "\n";
        return false;
    }

    XCEngine::Resources::ShaderLoader loader;
    XCEngine::Resources::LoadResult result =
        loader.Load(absoluteArtifactPath.generic_string().c_str());
    if (!result || result.resource == nullptr) {
        std::cerr << label << " artifact failed to load: "
                  << result.errorMessage.CStr() << "\n";
        return false;
    }

    delete static_cast<XCEngine::Resources::Shader*>(result.resource);
    return true;
}

bool RequireAssetDatabaseImportFailureDiagnostic(const std::filesystem::path& projectRoot) {
    const std::filesystem::path shaderPath =
        projectRoot / "Assets/MissingPackageInclude.shader";
    const char* shaderSource = R"(Shader "Tests/AssetDatabaseMissingPackageInclude"
{
    SubShader
    {
        Pass
        {
            Name "AssetDatabaseMissingPackageInclude"
            HLSLPROGRAM
            #pragma vertex MainVS
            #pragma fragment MainPS
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/MissingAssetDatabaseFile.hlsl"
            float4 MainVS(float3 positionOS : POSITION) : SV_POSITION
            {
                return float4(positionOS, 1.0f);
            }
            float4 MainPS() : SV_TARGET
            {
                return 1.0f.xxxx;
            }
            ENDHLSL
        }
    }
}
)";

    if (!WriteTextFile(shaderPath, shaderSource)) {
        std::cerr << "failed to write AssetDatabase missing include shader fixture: "
                  << shaderPath << "\n";
        return false;
    }

    XCEngine::Resources::AssetDatabase assetDatabase;
    assetDatabase.Initialize(projectRoot.generic_string().c_str());

    XCEngine::Resources::AssetDatabase::ResolvedAsset resolvedAsset;
    XCEngine::Resources::AssetDatabase::MaintenanceStats stats;
    const bool imported = assetDatabase.ReimportAsset(
        "Assets/MissingPackageInclude.shader",
        resolvedAsset,
        &stats);
    const std::string errorText = assetDatabase.GetLastErrorMessage().CStr();
    assetDatabase.Shutdown();

    if (imported) {
        std::cerr << "AssetDatabase unexpectedly imported shader with missing package include\n";
        return false;
    }

    if (errorText.find(
            "requested=Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/MissingAssetDatabaseFile.hlsl") ==
            std::string::npos ||
        errorText.find(
            "normalized=Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/MissingAssetDatabaseFile.hlsl") ==
            std::string::npos ||
        errorText.find("source=") == std::string::npos ||
        errorText.find("normalizedCandidate=") == std::string::npos ||
        errorText.find("searchedAnchors=[sourceRoot=") == std::string::npos ||
        errorText.find("includeChain=") == std::string::npos ||
        errorText.find("builtinPackageRoot=engine/assets/builtin/shaders/Packages") ==
            std::string::npos) {
        std::cerr << "AssetDatabase missing package include diagnostic is not actionable: "
                  << errorText << "\n";
        return false;
    }

    return true;
}

bool RequirePackageEditProducesNewShaderArtifact(
    const std::filesystem::path& projectRoot) {
    std::error_code cleanupError;
    std::filesystem::remove_all(projectRoot, cleanupError);
    std::filesystem::create_directories(projectRoot / "Assets");

    ScopedCurrentPath scopedCurrentPath(projectRoot);

    const char* relativeShaderPath = "Assets/PackageArtifactEdit.shader";
    const std::filesystem::path shaderPath = projectRoot / relativeShaderPath;
    const std::filesystem::path dependencyPath =
        projectRoot /
        "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/ArtifactEditTest.hlsl";

    const char* shaderSource = R"(Shader "Tests/PackageArtifactEdit"
{
    HLSLINCLUDE
    #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/ArtifactEditTest.hlsl"
    ENDHLSL

    SubShader
    {
    }
}
)";

    if (!WriteTextFile(shaderPath, shaderSource) ||
        !WriteTextFile(dependencyPath, "float4 PackageArtifactEditValue() { return 1.0f.xxxx; }\n")) {
        std::cerr << "failed to prepare package edit artifact fixtures\n";
        return false;
    }

    XCEngine::Resources::AssetDatabase assetDatabase;
    assetDatabase.Initialize(projectRoot.generic_string().c_str());

    XCEngine::Resources::AssetDatabase::ResolvedAsset firstArtifact;
    if (!assetDatabase.EnsureArtifact(
            relativeShaderPath,
            XCEngine::Resources::ResourceType::Shader,
            firstArtifact)) {
        std::cerr << "initial package-edit shader import failed: "
                  << assetDatabase.GetLastErrorMessage().CStr() << "\n";
        assetDatabase.Shutdown();
        return false;
    }

    if (!firstArtifact.imported ||
        !RequireShaderArtifactLoads(projectRoot, firstArtifact.artifactMainPath, "initial package-edit shader")) {
        std::cerr << "initial package-edit shader did not produce a valid new artifact\n";
        assetDatabase.Shutdown();
        return false;
    }

    const std::string firstArtifactPath = firstArtifact.artifactMainPath.CStr();
    if (!WriteTextFile(
            dependencyPath,
            "float4 PackageArtifactEditValue() { return float4(0.25f, 0.5f, 0.75f, 1.0f); }\n"
            "float4 PackageArtifactEditValueAfterEdit() { return 2.0f.xxxx; }\n")) {
        std::cerr << "failed to edit package dependency fixture\n";
        assetDatabase.Shutdown();
        return false;
    }

    XCEngine::Resources::AssetDatabase::ResolvedAsset secondArtifact;
    if (!assetDatabase.EnsureArtifact(
            relativeShaderPath,
            XCEngine::Resources::ResourceType::Shader,
            secondArtifact)) {
        std::cerr << "package-edit shader reimport failed after dependency edit: "
                  << assetDatabase.GetLastErrorMessage().CStr() << "\n";
        assetDatabase.Shutdown();
        return false;
    }

    const std::string secondArtifactPath = secondArtifact.artifactMainPath.CStr();
    if (!secondArtifact.imported ||
        secondArtifactPath.empty() ||
        secondArtifactPath == firstArtifactPath ||
        !RequireShaderArtifactLoads(projectRoot, secondArtifact.artifactMainPath, "edited package shader")) {
        std::cerr << "package edit did not produce a distinct valid shader artifact; first="
                  << firstArtifactPath << " second=" << secondArtifactPath << "\n";
        assetDatabase.Shutdown();
        return false;
    }

    XCEngine::Resources::AssetDatabase::ResolvedAsset thirdArtifact;
    if (!assetDatabase.EnsureArtifact(
            relativeShaderPath,
            XCEngine::Resources::ResourceType::Shader,
            thirdArtifact)) {
        std::cerr << "package-edit shader unchanged ensure failed: "
                  << assetDatabase.GetLastErrorMessage().CStr() << "\n";
        assetDatabase.Shutdown();
        return false;
    }

    const std::string thirdArtifactPath = thirdArtifact.artifactMainPath.CStr();
    if (thirdArtifact.imported || thirdArtifactPath != secondArtifactPath) {
        std::cerr << "unchanged package dependency did not reuse current shader artifact; second="
                  << secondArtifactPath << " third=" << thirdArtifactPath << "\n";
        assetDatabase.Shutdown();
        return false;
    }

    assetDatabase.Shutdown();
    return true;
}

bool RequirePackageDependencyStaleRecordTriggersShaderReimport(
    const std::filesystem::path& projectRoot) {
    std::error_code cleanupError;
    std::filesystem::remove_all(projectRoot, cleanupError);

    const char* relativeShaderPath = "Assets/StalePackageDependency.shader";
    const std::filesystem::path shaderPath = projectRoot / relativeShaderPath;
    const std::filesystem::path dependencyPath =
        projectRoot /
        "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/StaleArtifactDependency.hlsl";
    const std::string artifactKey = "0123456789abcdef0123456789abcdef";
    const std::string mainArtifactPath =
        "Library/Artifacts/01/" + artifactKey + ".xcshader";

    const char* shaderSource = R"(Shader "Tests/StalePackageDependency"
{
    SubShader
    {
        Pass
        {
            Name "StalePackageDependency"
            HLSLPROGRAM
            #pragma vertex MainVS
            #pragma fragment MainPS
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/MissingAfterInvalidation.hlsl"
            float4 MainVS(float3 positionOS : POSITION) : SV_POSITION
            {
                return float4(positionOS, 1.0f);
            }
            float4 MainPS() : SV_TARGET
            {
                return 1.0f.xxxx;
            }
            ENDHLSL
        }
    }
}
)";

    if (!WriteTextFile(shaderPath, shaderSource) ||
        !WriteTextFile(dependencyPath, "float4 StaleArtifactDependencyValue() { return 1.0f.xxxx; }\n")) {
        std::cerr << "failed to prepare stale package dependency fixtures\n";
        return false;
    }

    {
        XCEngine::Resources::AssetDatabase assetDatabase;
        assetDatabase.Initialize(projectRoot.generic_string().c_str());
        assetDatabase.Refresh();
        assetDatabase.Shutdown();
    }

    std::vector<std::string> sourceFields;
    if (!LoadSourceDbShaderRecord(projectRoot, relativeShaderPath, sourceFields)) {
        return false;
    }

    if (!WriteMinimalCurrentShaderArtifact(projectRoot / mainArtifactPath)) {
        std::cerr << "failed to write stale package dependency artifact fixture\n";
        return false;
    }

    const XCEngine::Core::uint64 currentDependencySize = GetFileSizeValue(dependencyPath);
    const XCEngine::Core::uint64 currentDependencyWriteTime = GetFileWriteTimeValue(dependencyPath);
    if (!WriteShaderArtifactDbRecord(
            projectRoot,
            sourceFields,
            dependencyPath,
            currentDependencySize,
            currentDependencyWriteTime,
            artifactKey,
            mainArtifactPath)) {
        return false;
    }

    {
        XCEngine::Resources::AssetDatabase assetDatabase;
        assetDatabase.Initialize(projectRoot.generic_string().c_str());

        XCEngine::Resources::AssetDatabase::ResolvedAsset resolvedAsset;
        if (!assetDatabase.EnsureArtifact(
                relativeShaderPath,
                XCEngine::Resources::ResourceType::Shader,
                resolvedAsset)) {
            std::cerr << "current package dependency record unexpectedly triggered import: "
                      << assetDatabase.GetLastErrorMessage().CStr() << "\n";
            assetDatabase.Shutdown();
            return false;
        }

        if (resolvedAsset.imported ||
            resolvedAsset.artifactMainPath.CStr()[0] == '\0') {
            std::cerr << "current package dependency record did not use existing artifact\n";
            assetDatabase.Shutdown();
            return false;
        }

        assetDatabase.Shutdown();
    }

    const XCEngine::Core::uint64 staleWriteTime =
        currentDependencyWriteTime == 1 ? 2 : 1;
    if (!WriteShaderArtifactDbRecord(
            projectRoot,
            sourceFields,
            dependencyPath,
            currentDependencySize,
            staleWriteTime,
            artifactKey,
            mainArtifactPath)) {
        return false;
    }

    {
        XCEngine::Resources::AssetDatabase assetDatabase;
        assetDatabase.Initialize(projectRoot.generic_string().c_str());

        XCEngine::Resources::AssetDatabase::ResolvedAsset resolvedAsset;
        const bool ensured = assetDatabase.EnsureArtifact(
            relativeShaderPath,
            XCEngine::Resources::ResourceType::Shader,
            resolvedAsset);
        const std::string errorText = assetDatabase.GetLastErrorMessage().CStr();
        assetDatabase.Shutdown();

        if (ensured) {
            std::cerr << "stale package dependency record did not trigger shader reimport\n";
            return false;
        }

        if (errorText.find(
                "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/MissingAfterInvalidation.hlsl") ==
            std::string::npos) {
            std::cerr << "stale package dependency reimport did not reach shader loader diagnostic: "
                      << errorText << "\n";
            return false;
        }
    }

    return true;
}

bool RequireIncludeFailureDiagnostic(
    const char* label,
    const XCEngine::Containers::String& error,
    const std::string& requestedPath) {
    const std::string errorText = error.CStr();
    if (errorText.find("requested=" + requestedPath) == std::string::npos ||
        errorText.find("normalized=") == std::string::npos ||
        errorText.find("source=") == std::string::npos ||
        errorText.find("normalizedCandidate=") == std::string::npos ||
        errorText.find("searchedAnchors=[sourceRoot=") == std::string::npos ||
        errorText.find("resourceRoot=") == std::string::npos ||
        errorText.find("currentPath=") == std::string::npos ||
        errorText.find("includeChain=") == std::string::npos ||
        errorText.find("builtinPackageRoot=engine/assets/builtin/shaders/Packages") == std::string::npos) {
        std::cerr << label << " diagnostic is not actionable: " << errorText << "\n";
        return false;
    }

    return true;
}

} // namespace

int main() {
    const std::filesystem::path tempRoot =
        std::filesystem::temp_directory_path() /
        "xcengine_shader_dependency_tests";
    const std::filesystem::path shaderPath = tempRoot / "package_include.shader";

    const char* shaderSource = R"(Shader "Tests/PackageInclude"
{
    SubShader
    {
        Pass
        {
            Name "PackageInclude"
            HLSLPROGRAM
            #pragma vertex MainVS
            #pragma fragment MainPS
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            float4 MainVS(float3 positionOS : POSITION) : SV_POSITION
            {
                return TransformObjectToHClip(positionOS);
            }
            float4 MainPS() : SV_TARGET
            {
                return 1.0f.xxxx;
            }
            ENDHLSL
        }
    }
}
)";

    if (!WriteTextFile(shaderPath, shaderSource)) {
        std::cerr << "failed to write shader fixture: " << shaderPath << "\n";
        return 1;
    }

    XCEngine::Containers::Array<XCEngine::Containers::String> dependencies;
    if (!CollectDependencies(shaderPath, dependencies)) {
        std::cerr << "CollectSourceDependencies failed\n";
        return 1;
    }

    if (!RequireDependencySuffixes(
            dependencies,
            {
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/Core.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.core/ShaderLibrary/ShaderVariables.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl",
            })) {
        return 1;
    }

    const std::filesystem::path originalCurrentPath = std::filesystem::current_path();
    const std::filesystem::path shadowPackageRoot =
        tempRoot / "engine/assets/builtin/shaders/Packages";
    const std::filesystem::path shadowCorePath =
        shadowPackageRoot /
        "com.xcengine.render-pipelines.universal/ShaderLibrary/Core.hlsl";
    if (!WriteTextFile(shadowCorePath, "float4 ShadowRootSelected() { return 1.0f.xxxx; }\n")) {
        std::cerr << "failed to write shadow package include fixture: " << shadowCorePath << "\n";
        return 1;
    }

    std::filesystem::current_path(tempRoot);
    dependencies.Clear();
    if (!CollectDependencies(shaderPath, dependencies)) {
        std::filesystem::current_path(originalCurrentPath);
        std::cerr << "CollectSourceDependencies failed while current directory contained a shadow package root\n";
        return 1;
    }
    std::filesystem::current_path(originalCurrentPath);

    if (!RequireDependencySuffixes(
            dependencies,
            {
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/Core.hlsl",
            }) ||
        !RequireNoDependencyPrefix(dependencies, shadowPackageRoot)) {
        return 1;
    }

    const std::filesystem::path currentPathFallbackProjectRoot =
        tempRoot / "current_path_fallback_project";
    if (!RequirePackageDependencyCurrentPathFallback(currentPathFallbackProjectRoot)) {
        return 1;
    }

    const std::filesystem::path packageCompileShaderPath =
        tempRoot / "package_compile.shader";
    const char* packageCompileShaderSource = R"(Shader "Tests/PackageCompile"
{
    SubShader
    {
        Pass
        {
            Name "PackageCompile"
            HLSLPROGRAM
            #pragma vertex MainVS
            #pragma fragment MainPS
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            struct Attributes
            {
                float3 positionOS : POSITION;
            };
            struct Varyings
            {
                float4 positionCS : SV_POSITION;
            };
            Varyings MainVS(Attributes input)
            {
                Varyings output;
                output.positionCS = TransformObjectToHClip(input.positionOS);
                return output;
            }
            float4 MainPS(Varyings input) : SV_TARGET
            {
                return input.positionCS;
            }
            ENDHLSL
        }
    }
}
)";

    if (!WriteTextFile(packageCompileShaderPath, packageCompileShaderSource)) {
        std::cerr << "failed to write package compile shader fixture: " << packageCompileShaderPath << "\n";
        return 1;
    }

    if (!RequirePackageShaderLoadAndD3D12Compile(packageCompileShaderPath)) {
        return 1;
    }

    const std::filesystem::path backslashPackageIncludeShaderPath =
        tempRoot / "backslash_package_include.shader";
    const char* backslashPackageIncludeShaderSource = R"(Shader "Tests/BackslashPackageInclude"
{
    SubShader
    {
        Pass
        {
            Name "BackslashPackageInclude"
            HLSLPROGRAM
            #pragma vertex MainVS
            #pragma fragment MainPS
            #include "Packages\com.xcengine.render-pipelines.universal\ShaderLibrary\Core.hlsl"
            float4 MainVS(float3 positionOS : POSITION) : SV_POSITION
            {
                return TransformObjectToHClip(positionOS);
            }
            float4 MainPS() : SV_TARGET
            {
                return 1.0f.xxxx;
            }
            ENDHLSL
        }
    }
}
)";

    if (!WriteTextFile(backslashPackageIncludeShaderPath, backslashPackageIncludeShaderSource)) {
        std::cerr << "failed to write backslash package include shader fixture: " << backslashPackageIncludeShaderPath << "\n";
        return 1;
    }

    dependencies.Clear();
    if (!CollectDependencies(backslashPackageIncludeShaderPath, dependencies)) {
        std::cerr << "CollectSourceDependencies failed for backslash package include\n";
        return 1;
    }

    if (!RequireDependencySuffixes(
            dependencies,
            {
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/Core.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.core/ShaderLibrary/ShaderVariables.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl",
            })) {
        return 1;
    }

    const std::filesystem::path allPublicIncludesShaderPath =
        tempRoot / "all_public_package_includes.shader";
    const char* allPublicIncludesShaderSource = R"(Shader "Tests/AllPublicPackageIncludes"
{
    SubShader
    {
        Pass
        {
            Name "AllPublicPackageIncludes"
            HLSLPROGRAM
            #pragma vertex MainVS
            #pragma fragment MainPS
            #include "Packages/com.xcengine.render-pipelines.core/ShaderLibrary/ShaderVariables.hlsl"
            #include "Packages/com.xcengine.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl"
            #include "Packages/com.xcengine.render-pipelines.core/ShaderLibrary/TextureSampling.hlsl"
            #include "Packages/com.xcengine.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.xcengine.render-pipelines.core/ShaderLibrary/Packing.hlsl"
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/Input.hlsl"
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/SurfaceInput.hlsl"
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/ShaderPass.hlsl"
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl"
            float4 MainVS(float3 positionOS : POSITION) : SV_POSITION
            {
                return TransformObjectToHClip(positionOS);
            }
            float4 MainPS() : SV_TARGET
            {
                return XcLinearToSrgb(1.0f.xxx).xyzz;
            }
            ENDHLSL
        }
    }
}
)";

    if (!WriteTextFile(allPublicIncludesShaderPath, allPublicIncludesShaderSource)) {
        std::cerr << "failed to write all public package include shader fixture: " << allPublicIncludesShaderPath << "\n";
        return 1;
    }

    dependencies.Clear();
    if (!CollectDependencies(allPublicIncludesShaderPath, dependencies)) {
        std::cerr << "CollectSourceDependencies failed for all public package includes\n";
        return 1;
    }

    if (!RequireDependencySuffixes(
            dependencies,
            {
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.core/ShaderLibrary/ShaderVariables.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.core/ShaderLibrary/SpaceTransforms.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.core/ShaderLibrary/TextureSampling.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.core/ShaderLibrary/Color.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.core/ShaderLibrary/Packing.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/Core.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/Input.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/SurfaceInput.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/ShaderPass.hlsl",
                "engine/assets/builtin/shaders/Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl",
            })) {
        return 1;
    }

    const std::filesystem::path missingIncludeShaderPath =
        tempRoot / "missing_package_include.shader";
    const char* missingIncludeShaderSource = R"(Shader "Tests/MissingPackageInclude"
{
    SubShader
    {
        Pass
        {
            Name "MissingPackageInclude"
            HLSLPROGRAM
            #pragma vertex MainVS
            #pragma fragment MainPS
            #include "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/MissingFile.hlsl"
            float4 MainVS(float3 positionOS : POSITION) : SV_POSITION
            {
                return float4(positionOS, 1.0f);
            }
            float4 MainPS() : SV_TARGET
            {
                return 1.0f.xxxx;
            }
            ENDHLSL
        }
    }
}
)";

    if (!WriteTextFile(missingIncludeShaderPath, missingIncludeShaderSource)) {
        std::cerr << "failed to write missing include shader fixture: " << missingIncludeShaderPath << "\n";
        return 1;
    }

    dependencies.Clear();
    XCEngine::Containers::String dependencyError;
    if (CollectDependencies(missingIncludeShaderPath, dependencies, dependencyError)) {
        std::cerr << "CollectSourceDependencies unexpectedly accepted a missing package include\n";
        return 1;
    }
    if (!RequireIncludeFailureDiagnostic(
            "missing package include",
            dependencyError,
            "Packages/com.xcengine.render-pipelines.universal/ShaderLibrary/MissingFile.hlsl")) {
        return 1;
    }

    const std::filesystem::path escapedPackageShaderPath =
        tempRoot / "escaped_package_include.shader";
    const char* escapedPackageShaderSource = R"(Shader "Tests/EscapedPackageInclude"
{
    SubShader
    {
        Pass
        {
            Name "EscapedPackageInclude"
            HLSLPROGRAM
            #pragma vertex MainVS
            #pragma fragment MainPS
            #include "Packages/../forward-lit.shader"
            float4 MainVS(float3 positionOS : POSITION) : SV_POSITION
            {
                return float4(positionOS, 1.0f);
            }
            float4 MainPS() : SV_TARGET
            {
                return 1.0f.xxxx;
            }
            ENDHLSL
        }
    }
}
)";

    if (!WriteTextFile(escapedPackageShaderPath, escapedPackageShaderSource)) {
        std::cerr << "failed to write escaped package include shader fixture: " << escapedPackageShaderPath << "\n";
        return 1;
    }

    dependencies.Clear();
    dependencyError.Clear();
    if (CollectDependencies(escapedPackageShaderPath, dependencies, dependencyError)) {
        std::cerr << "CollectSourceDependencies unexpectedly accepted a package include outside Packages root\n";
        return 1;
    }
    if (!RequireIncludeFailureDiagnostic(
            "escaped package include",
            dependencyError,
            "Packages/../forward-lit.shader")) {
        return 1;
    }

    const std::filesystem::path absoluteIncludeTargetPath =
        tempRoot / "absolute_include_target.hlsl";
    if (!WriteTextFile(absoluteIncludeTargetPath, "float4 AbsoluteIncludeValue() { return 1.0f.xxxx; }\n")) {
        std::cerr << "failed to write absolute include target fixture: " << absoluteIncludeTargetPath << "\n";
        return 1;
    }

    const std::filesystem::path absoluteIncludeShaderPath =
        tempRoot / "absolute_include.shader";
    const std::string absoluteIncludePath = absoluteIncludeTargetPath.generic_string();
    const std::string absoluteIncludeShaderSource =
        "Shader \"Tests/AbsoluteInclude\"\n"
        "{\n"
        "    SubShader\n"
        "    {\n"
        "        Pass\n"
        "        {\n"
        "            Name \"AbsoluteInclude\"\n"
        "            HLSLPROGRAM\n"
        "            #pragma vertex MainVS\n"
        "            #pragma fragment MainPS\n"
        "            #include \"" + absoluteIncludePath + "\"\n" +
        "            float4 MainVS(float3 positionOS : POSITION) : SV_POSITION\n"
        "            {\n"
        "                return float4(positionOS, 1.0f);\n"
        "            }\n"
        "            float4 MainPS() : SV_TARGET\n"
        "            {\n"
        "                return AbsoluteIncludeValue();\n"
        "            }\n"
        "            ENDHLSL\n"
        "        }\n"
        "    }\n"
        "}\n";

    if (!WriteTextFile(absoluteIncludeShaderPath, absoluteIncludeShaderSource.c_str())) {
        std::cerr << "failed to write absolute include shader fixture: " << absoluteIncludeShaderPath << "\n";
        return 1;
    }

    dependencies.Clear();
    dependencyError.Clear();
    if (CollectDependencies(absoluteIncludeShaderPath, dependencies, dependencyError)) {
        std::cerr << "CollectSourceDependencies unexpectedly accepted an absolute include\n";
        return 1;
    }
    if (!RequireIncludeFailureDiagnostic(
            "absolute include",
            dependencyError,
            absoluteIncludePath)) {
        return 1;
    }

    const std::filesystem::path assetDatabaseProjectRoot =
        tempRoot / "asset_database_project";
    std::error_code cleanupError;
    std::filesystem::remove_all(assetDatabaseProjectRoot, cleanupError);
    if (!RequireAssetDatabaseImportFailureDiagnostic(assetDatabaseProjectRoot)) {
        return 1;
    }

    const std::filesystem::path artifactInvalidationProjectRoot =
        tempRoot / "artifact_invalidation_project";
    if (!RequirePackageDependencyStaleRecordTriggersShaderReimport(
            artifactInvalidationProjectRoot)) {
        return 1;
    }

    const std::filesystem::path packageEditProjectRoot =
        tempRoot / "package_edit_artifact_project";
    if (!RequirePackageEditProducesNewShaderArtifact(packageEditProjectRoot)) {
        return 1;
    }

    return 0;
}