#include "MetaCoreDelivery/MetaCoreBuildPipeline.h"
#include "MetaCoreFoundation/MetaCoreAssetDependencyGraph.h"
#include "MetaCoreFoundation/MetaCoreHash.h"

#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>

namespace {

int Failures = 0;

void Expect(bool condition, const char* message) {
    if (!condition) {
        std::cerr << "FAILED: " << message << '\n';
        ++Failures;
    }
}

void WriteText(const std::filesystem::path& path, std::string_view value) {
    std::filesystem::create_directories(path.parent_path());
    std::ofstream output(path, std::ios::binary);
    output << value;
}

}  // namespace

int main() {
    const std::string abc = "abc";
    const auto* abcBytes = reinterpret_cast<const std::byte*>(abc.data());
    Expect(
        MetaCore::MetaCoreSha256Bytes(std::span(abcBytes, abc.size())) ==
            "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
        "SHA-256 known vector"
    );

    const auto temporary = std::filesystem::temp_directory_path() / "MetaCoreDeliveryTests";
    std::error_code error;
    std::filesystem::remove_all(temporary, error);
    WriteText(temporary / "unsafe.mcbuildprofile.json", R"({
      "format_version":1,"name":"unsafe","target_platform":"Linux-x86_64","configuration":"Development",
      "graphics_backend":"OpenGL","startup_scene":"../outside","output_directory":"Build","resource_policy":"ReferencedOnly"
    })");
    MetaCore::MetaCoreBuildIssue profileIssue;
    Expect(!MetaCore::MetaCoreReadBuildProfile(temporary / "unsafe.mcbuildprofile.json", &profileIssue), "unsafe profile rejected");
    Expect(profileIssue.Code == MetaCore::MetaCoreBuildErrorCode::UnsafePath, "unsafe profile error code");

    const auto package = temporary / "Package";
    WriteText(package / "payload.bin", "payload");
    MetaCore::MetaCoreRuntimeDeliveryDocument delivery;
    delivery.BuildId = "test-build";
    delivery.StartupScene = "payload.bin";
    delivery.ScriptModules.push_back("Project/Scripts/TestScripts.so");
    WriteText(package / delivery.ScriptModules.front(), "script");
    Expect(MetaCore::MetaCoreWriteRuntimeDeliveryDocument(package / "Project" / "MetaCore.runtimeproject", delivery), "write runtime delivery");
    MetaCore::MetaCoreReleaseManifestDocument manifest;
    manifest.BuildId = delivery.BuildId;
    const auto payloadHash = MetaCore::MetaCoreSha256File(package / "payload.bin");
    const auto deliveryHash = MetaCore::MetaCoreSha256File(package / "Project" / "MetaCore.runtimeproject");
    manifest.Files.push_back({"payload.bin", "asset", 7U, payloadHash.value_or(""), true});
    manifest.Files.push_back({"Project/MetaCore.runtimeproject", "runtime_project",
        std::filesystem::file_size(package / "Project" / "MetaCore.runtimeproject"), deliveryHash.value_or(""), true});
    const auto scriptHash = MetaCore::MetaCoreSha256File(package / delivery.ScriptModules.front());
    manifest.Files.push_back({delivery.ScriptModules.front(), "script_module", 6U, scriptHash.value_or(""), true});
    Expect(MetaCore::MetaCoreWriteReleaseManifest(package / "Manifest" / "MetaCore.release.json", manifest), "write release manifest");
    Expect(MetaCore::MetaCoreValidateReleasePackage(package).empty(), "valid package accepted");
    const auto readDelivery = MetaCore::MetaCoreReadRuntimeDeliveryDocument(package / "Project" / "MetaCore.runtimeproject");
    Expect(readDelivery.has_value() && readDelivery->ScriptModules == delivery.ScriptModules, "runtime delivery preserves script module paths");
    WriteText(package / "payload.bin", "tampered");
    const auto corruptIssues = MetaCore::MetaCoreValidateReleasePackage(package);
    Expect(!corruptIssues.empty(), "corrupt package rejected");
    Expect(corruptIssues.front().Code == MetaCore::MetaCoreBuildErrorCode::FileSizeMismatch ||
           corruptIssues.front().Code == MetaCore::MetaCoreBuildErrorCode::FileHashMismatch, "corrupt package error code");
    std::filesystem::remove(package / "payload.bin", error);
    const auto missingIssues = MetaCore::MetaCoreValidateReleasePackage(package);
    Expect(!missingIssues.empty() && missingIssues.front().Code == MetaCore::MetaCoreBuildErrorCode::RequiredFileMissing, "missing file reported");

    auto& graph = MetaCore::MetaCoreAssetDependencyGraph::Get();
    graph.Clear();
    const auto root = MetaCore::MetaCoreAssetGuid::Generate();
    const auto middle = MetaCore::MetaCoreAssetGuid::Generate();
    const auto leaf = MetaCore::MetaCoreAssetGuid::Generate();
    graph.SetDependencies(root, {middle});
    graph.SetDependencies(middle, {leaf});
    const auto closure = graph.GetDependencyClosure({root});
    Expect(closure.size() == 3U && closure.contains(root) && closure.contains(middle) && closure.contains(leaf), "transitive dependency closure");
    graph.Clear();

    std::filesystem::remove_all(temporary, error);
    if (Failures == 0) std::cout << "MetaCoreDeliveryTests passed\n";
    return Failures == 0 ? 0 : 1;
}