#include "assets_image_fixtures.hpp"
#include <bit>
#include <chrono>
#include <faset/assets/asset_pipeline.hpp>
#include <faset/core/hash.hpp>
#include <fstream>
#include <iostream>
#include <stdexcept>
using namespace faset::assets;
namespace fs = std::filesystem;
namespace {
void require(bool value, const std::string& message) {
    if (!value)
        throw std::runtime_error(message);
}
void u32(std::vector<unsigned char>& data, std::uint32_t value) {
    for (int i = 0; i < 4; ++i)
        data.push_back(static_cast<unsigned char>(value >> (8 * i)));
}
void save(const fs::path& file, const std::vector<unsigned char>& data) {
    std::ofstream out(file, std::ios::binary);
    out.write(reinterpret_cast<const char*>(data.data()),
              static_cast<std::streamsize>(data.size()));
}
void save(const fs::path& file, const std::string& text) {
    std::ofstream(file, std::ios::binary) << text;
}
std::vector<unsigned char> geometry(float x) {
    std::vector<unsigned char> bin;
    for (float f : {x, 0.f, 0.f, 1.f, 0.f, 0.f, 0.f, 1.f, 0.f})
        u32(bin, std::bit_cast<std::uint32_t>(f));
    for (unsigned char c : {0, 0, 1, 0, 2, 0})
        bin.push_back(c);
    return bin;
}
Json document(const std::string& name, bool stable, bool second, float x = 0) {
    Json node{{"name", name}, {"mesh", 0}};
    if (stable)
        node["extras"] = {{"faset_id", "node-door"}};
    Json j = {
        {"asset", {{"version", "2.0"}}},
        {"scene", 0},
        {"scenes", Json::array({{{"nodes", Json::array({0})}}})},
        {"nodes", Json::array({node})},
        {"buffers", Json::array({{{"byteLength", 42}}})},
        {"bufferViews",
         Json::array({{{"buffer", 0}, {"byteOffset", 0}, {"byteLength", 36}, {"target", 34962}},
                      {{"buffer", 0}, {"byteOffset", 36}, {"byteLength", 6}, {"target", 34963}}})},
        {"accessors",
         Json::array(
             {{{"bufferView", 0},
               {"componentType", 5126},
               {"count", 3},
               {"type", "VEC3"},
               {"min", {std::min(0.f, x), 0, 0}},
               {"max", {std::max(1.f, x), 1, 0}}},
              {{"bufferView", 1}, {"componentType", 5123}, {"count", 3}, {"type", "SCALAR"}}})},
        {"meshes", Json::array({{{"name", "Triangle"},
                                 {"extras", {{"faset_id", "mesh-triangle"}}},
                                 {"primitives", Json::array({{{"attributes", {{"POSITION", 0}}},
                                                              {"indices", 1},
                                                              {"material", 0}}})}}})},
        {"materials", Json::array({{{"name", "Red"},
                                    {"pbrMetallicRoughness",
                                     {{"baseColorFactor", {1.0, 0.2, 0.1, 1.0}},
                                      {"metallicFactor", 0.2},
                                      {"roughnessFactor", 0.6}}}}})}};
    if (second) {
        j["nodes"].push_back(
            {{"name", "Handle"}, {"mesh", 0}, {"extras", {{"faset_id", "node-handle"}}}});
        j["scenes"][0]["nodes"].push_back(1);
    }
    return j;
}
void glb(const fs::path& path, const std::string& name = "Door", bool stable = true,
         bool second = false, float x = 0) {
    auto json = document(name, stable, second, x).dump();
    while (json.size() % 4)
        json += ' ';
    auto binary = geometry(x);
    while (binary.size() % 4)
        binary.push_back(0);
    std::vector<unsigned char> result;
    u32(result, 0x46546c67);
    u32(result, 2);
    u32(result, static_cast<std::uint32_t>(12 + 8 + json.size() + 8 + binary.size()));
    u32(result, static_cast<std::uint32_t>(json.size()));
    u32(result, 0x4e4f534a);
    result.insert(result.end(), json.begin(), json.end());
    u32(result, static_cast<std::uint32_t>(binary.size()));
    u32(result, 0x004e4942);
    result.insert(result.end(), binary.begin(), binary.end());
    save(path, result);
}
void success(const ImportResult& result) {
    if (!result.ok()) {
        std::string text = "Import failed: ";
        for (const auto& d : result.diagnostics)
            text += d + "; ";
        throw std::runtime_error(text);
    }
}
} // namespace
int main() {
    const auto root = fs::temp_directory_path() /
                      ("faset-assets-test-" +
                       std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
    fs::create_directories(root);
    try {
        AssetPipeline pipeline(root / "cache");
        const auto source = root / "door.glb";
        glb(source);
        auto first = pipeline.import_asset({source});
        success(first);
        require(first.manifest.at("input_key").at("target_profile") == "desktop-static-pbr-v1" &&
                    first.manifest.at("input_key")
                            .at("toolchain")
                            .at("cgltf")
                            .get<std::string>()
                            .size() == 40,
                "cache recipe omits the desktop profile or pinned importer toolchain");
        require(first.manifest.at("materials").at(0).at("format") == "faset.material" &&
                    first.manifest.at("materials").at(0).at("version") == 1,
                "material data is not explicitly versioned");
        require(!first.asset_id.empty(), "persistent identity missing");
        auto asset = pipeline.load_asset(first.asset_id);
        require(asset.meshes.size() == 1 && asset.nodes.size() == 1, "mesh/node extraction");
        require(asset.meshes[0].primitives[0].indices == std::vector<std::uint32_t>({0, 1, 2}),
                "index extraction");
        require(asset.meshes[0].primitives[0].vertices[0].normal[2] == 1, "generated normal");
        require(asset.materials[0].base_color[1] > .19f && asset.materials[0].metallic == .2f,
                "PBR extraction");
        const auto node_id = asset.nodes[0].id;
        const Json custom{{node_id,
                           {{"gameplay", {{"locked", true}}},
                            {"physics", {{"mass", 12}}},
                            {"material", "custom-brass"}}}};
        pipeline.set_overrides(first.asset_id, custom);
        AssetPipeline rebuilt_cache(root / "rebuilt-cache");
        const auto recovered = rebuilt_cache.import_asset({source});
        success(recovered);
        require(recovered.asset_id == first.asset_id && recovered.generation == first.generation &&
                    rebuilt_cache.load_asset(first.asset_id).nodes[0].id == node_id &&
                    rebuilt_cache.overrides(first.asset_id) == custom,
                "fresh cache changed source identity, outputs, or authoring overrides");
        auto unchanged = pipeline.import_asset({source});
        success(unchanged);
        require(unchanged.cache_hit && unchanged.generation == first.generation,
                "content cache hit");
        glb(source, "Renamed panel", true, false, .25f);
        auto modified = pipeline.import_asset({source});
        success(modified);
        require(modified.asset_id == first.asset_id && modified.generation != first.generation,
                "stable asset identity and changed generation");
        asset = pipeline.load_asset(first.asset_id);
        require(asset.nodes[0].id == node_id && asset.nodes[0].name == "Renamed panel",
                "faset_id survives rename");
        require(asset.meshes[0].primitives[0].vertices[0].position[0] == .25f,
                "new binary geometry loaded");
        require(pipeline.overrides(first.asset_id) == custom,
                "reimport erased authoring overrides");
        glb(source, "Renamed panel", true, true, .25f);
        auto added = pipeline.import_asset({source});
        success(added);
        glb(source, "Renamed panel", true, false, .25f);
        auto removed = pipeline.import_asset({source});
        require(removed.status == ImportStatus::conflict && !removed.removed_output_ids.empty(),
                "deletion must conflict");
        require(pipeline.load_asset(first.asset_id).generation == added.generation,
                "conflict replaced active generation");
        require(pipeline.overrides(first.asset_id) == custom, "conflict erased overrides");
        ImportRequest resolve{source};
        resolve.allow_removed_outputs = true;
        auto resolved = pipeline.import_asset(resolve);
        success(resolved);
        require(pipeline.load_asset(first.asset_id).nodes.size() == 1,
                "explicit deletion resolution");
        const auto active = resolved.generation;
        save(source, std::string("not a GLB"));
        auto failed = pipeline.import_asset({source});
        require(failed.status == ImportStatus::failed, "invalid source accepted");
        require(pipeline.load_asset(first.asset_id).generation == active,
                "failed import replaced active");
        glb(source, "Renamed panel", true, false, .5f);
        ImportJob* job_ptr = nullptr;
        ImportJob job([&](const ImportProgress& p) {
            if (p.fraction >= .9f)
                job_ptr->cancel();
        });
        job_ptr = &job;
        auto cancelled = pipeline.import_asset({source}, job);
        require(cancelled.status == ImportStatus::cancelled, "cancel before commit failed");
        require(pipeline.load_asset(first.asset_id).generation == active, "cancel replaced active");
        ImportRequest changed_settings{source};
        changed_settings.settings = {{"target", "test-profile"}};
        auto settings = pipeline.import_asset(changed_settings);
        success(settings);
        require(settings.generation != active, "recipe omitted from cache key");
        const auto plain = root / "ordinary.glb";
        glb(plain, "Ordinary", false);
        auto standard = pipeline.import_asset({plain});
        success(standard);
        require(!pipeline.load_asset(standard.asset_id).nodes[0].stable_source_id,
                "ordinary GLB wrongly marked stable source");
        glb(plain, "Renamed without ID", false);
        require(pipeline.import_asset({plain}).status == ImportStatus::conflict,
                "ambiguous rename silently matched");
        auto duplicate = document("Duplicate", true, true);
        duplicate["nodes"][1]["extras"]["faset_id"] = "node-door";
        duplicate["buffers"][0]["uri"] = "mesh.bin";
        save(root / "mesh.bin", geometry(0));
        save(root / "duplicate.gltf", duplicate.dump());
        require(pipeline.import_asset({root / "duplicate.gltf"}).status == ImportStatus::failed,
                "duplicate source ID accepted");
        auto external = document("External", true, false);
        external["buffers"][0]["uri"] = "mesh.bin";
        external["images"] = Json::array({{{"uri", "pixel.png"}, {"mimeType", "image/png"}}});
        external["textures"] = Json::array({{{"source", 0}}});
        external["materials"][0]["pbrMetallicRoughness"]["baseColorTexture"] = {{"index", 0}};
        // Real 1x1 PNG payload, transparent pixel; importer owns encoded bytes.
        const std::vector<unsigned char> png = {
            137, 80,  78,  71, 13, 10, 26, 10,  0,   0,  0,  13, 73, 72,  68,  82,  0,
            0,   0,   1,   0,  0,  0,  1,  8,   6,   0,  0,  0,  31, 21,  196, 137, 0,
            0,   0,   11,  73, 68, 65, 84, 120, 156, 99, 96, 0,  2,  0,   0,   5,   0,
            1,   165, 246, 69, 64, 0,  0,  0,   0,   73, 69, 78, 68, 174, 66,  96,  130};
        save(root / "pixel.png", png);
        save(root / "external.gltf", external.dump());
        auto ext = pipeline.import_asset({root / "external.gltf"});
        success(ext);
        auto ext_asset = pipeline.load_asset(ext.asset_id);
        require(ext_asset.textures.size() == 1 && ext_asset.textures[0].bytes.size() == png.size(),
                "external image not extracted");
        require(ext_asset.materials[0].base_color_texture == 0, "material texture reference lost");
        save(root / "mesh.bin", geometry(.3f));
        auto dependent = pipeline.import_asset({root / "external.gltf"});
        success(dependent);
        require(dependent.generation != ext.generation, "buffer dependency not invalidated");
        // A Blender bundle keeps its logical source stable while immutable payload paths change.
        const auto bundle_dir = root / "bundle";
        fs::create_directories(bundle_dir / "payload");
        glb(bundle_dir / "payload" / "first.glb", "Bundle", true, false);
        Json bundle{{"schema_version", 1},
                    {"asset_id", "bundle-asset"},
                    {"files", Json::array({{{"path", "payload/first.glb"},
                                            {"sha256", faset::sha256_file(bundle_dir / "payload" /
                                                                          "first.glb")}}})}};
        save(bundle_dir / "manifest.json", bundle.dump());
        auto bundle_first = pipeline.import_asset({bundle_dir / "manifest.json"});
        success(bundle_first);
        require(bundle_first.asset_id == "bundle-asset", "bundle identity lost");
        glb(bundle_dir / "payload" / "second.glb", "Bundle renamed", true, false, .4f);
        bundle["files"][0] = {
            {"path", "payload/second.glb"},
            {"sha256", faset::sha256_file(bundle_dir / "payload" / "second.glb")}};
        save(bundle_dir / "manifest.json", bundle.dump());
        auto bundle_second = pipeline.import_asset({bundle_dir / "manifest.json"});
        success(bundle_second);
        require(bundle_second.asset_id == bundle_first.asset_id &&
                    bundle_second.generation != bundle_first.generation,
                "bundle reimport identity/generation");
        bundle["files"][0]["sha256"] = std::string(64, '0');
        save(bundle_dir / "manifest.json", bundle.dump());
        require(pipeline.import_asset({bundle_dir / "manifest.json"}).status ==
                    ImportStatus::failed,
                "bundle checksum ignored");
        require(pipeline.load_asset("bundle-asset").generation == bundle_second.generation,
                "bad bundle replaced active");
        // Changing a dependency after it was snapshotted cannot publish mixed content.
        const auto dependency_active = pipeline.load_asset(ext.asset_id).generation;
        ImportJob mutate([&](const ImportProgress& progress) {
            if (progress.fraction == .5f)
                save(root / "mesh.bin", geometry(.7f));
        });
        require(pipeline.import_asset({root / "external.gltf"}, mutate).status ==
                    ImportStatus::failed,
                "concurrent dependency edit accepted");
        require(pipeline.load_asset(ext.asset_id).generation == dependency_active,
                "concurrent edit changed active");
        // Standalone images share the same identity, generation and failure guarantees.
        const auto picture = root / "sprite.PNG";
        save(picture, faset::test_images::png_red_green);
        ImportRequest image_request{picture};
        image_request.settings = {{"pixels_per_unit", 20.0}};
        auto image_first = pipeline.import_asset(image_request);
        success(image_first);
        auto image_asset = pipeline.load_asset(image_first.asset_id);
        require(image_asset.meshes.empty() && image_asset.textures.size() == 1,
                "Standalone PNG should produce one owned texture");
        require(image_asset.textures[0].mime_type == "image/png" &&
                    image_first.manifest["kind"] == "image",
                "PNG kind/MIME");
        require(image_first.manifest["image"]["width"] == 2 &&
                    image_first.manifest["image"]["height"] == 1 &&
                    image_first.manifest["image"]["pixels_per_unit"] == 20.0,
                "PNG dimensions and sprite scale recipe");
        const auto texture_id = image_asset.textures[0].id;
        pipeline.set_overrides(image_first.asset_id, {{texture_id, {{"gameplay", "preserved"}}}});
        auto image_cache = pipeline.import_asset({picture});
        success(image_cache);
        require(image_cache.cache_hit && image_cache.generation == image_first.generation,
                "PNG cache/recipe persistence");
        save(picture, faset::test_images::png_blue_white);
        auto image_changed = pipeline.import_asset({picture});
        success(image_changed);
        require(image_changed.asset_id == image_first.asset_id &&
                    image_changed.generation != image_first.generation,
                "PNG reimport content invalidation");
        require(pipeline.load_asset(image_first.asset_id).textures[0].id == texture_id,
                "Image subasset ID changed after content edit");
        image_request.settings = {{"pixels_per_unit", 40.0}};
        auto image_recipe = pipeline.import_asset(image_request);
        success(image_recipe);
        require(image_recipe.generation != image_changed.generation,
                "Image settings omitted from recipe hash");
        save(picture, std::string("broken PNG"));
        require(pipeline.import_asset({picture}).status == ImportStatus::failed,
                "Broken PNG published");
        require(pipeline.load_asset(image_first.asset_id).generation == image_recipe.generation,
                "Broken PNG replaced successful generation");
        save(picture, faset::test_images::jpeg_red_green);
        require(pipeline.import_asset({picture}).status == ImportStatus::failed,
                "Mismatched JPEG content accepted as PNG");
        auto oversized = faset::test_images::png_red_green;
        oversized[16] = 0;
        oversized[17] = 1;
        oversized[18] = 0;
        oversized[19] = 0;
        save(picture, oversized);
        require(pipeline.import_asset({picture}).status == ImportStatus::failed,
                "Oversized image accepted");
        save(picture, faset::test_images::png_red_green);
        ImportJob* image_job_pointer = nullptr;
        ImportJob image_job([&](const ImportProgress& progress) {
            if (progress.fraction >= .5f)
                image_job_pointer->cancel();
        });
        image_job_pointer = &image_job;
        require(pipeline.import_asset({picture}, image_job).status == ImportStatus::cancelled,
                "PNG cancellation ignored");
        require(pipeline.load_asset(image_first.asset_id).generation == image_recipe.generation,
                "Cancelled PNG replaced active generation");
        image_request.settings = {{"pixels_per_unit", 0}};
        require(pipeline.import_asset(image_request).status == ImportStatus::failed,
                "Zero pixels_per_unit accepted");
        save(picture, faset::test_images::png_blue_white);
        const auto renamed = root / "renamed.PNG";
        fs::rename(picture, renamed);
        fs::rename(picture.string() + ".faset-import.json",
                   renamed.string() + ".faset-import.json");
        fs::rename(picture.string() + ".faset-overrides.json",
                   renamed.string() + ".faset-overrides.json");
        auto image_rename = pipeline.import_asset({renamed});
        success(image_rename);
        require(image_rename.cache_hit && image_rename.asset_id == image_first.asset_id,
                "Image source rename with sidecar lost identity/cache");
        require(pipeline.current_manifest(image_first.asset_id)["source"] == renamed.string(),
                "Image rename retained old source pointer");
        require(pipeline.overrides(image_first.asset_id).contains(texture_id),
                "Image rename/reimport lost overrides");
        const auto jpeg = root / "sprite.JPEG";
        save(jpeg, faset::test_images::jpeg_red_green);
        auto jpeg_import = pipeline.import_asset({jpeg});
        success(jpeg_import);
        require(jpeg_import.manifest["image"]["width"] == 2 &&
                    pipeline.load_asset(jpeg_import.asset_id).textures[0].mime_type == "image/jpeg",
                "JPEG decoding/dimensions");
        save(root / "same.png", faset::test_images::png_blue_white);
        auto other_image = pipeline.import_asset({root / "same.png"});
        success(other_image);
        require(other_image.asset_id != image_first.asset_id,
                "Independent same-content source must have independent AssetId");
        fs::remove_all(root / "cache");
        auto restored = pipeline.import_asset({source});
        success(restored);
        require(restored.asset_id == first.asset_id, "cleared cache changed AssetId");
        require(restored.manifest["settings"] == changed_settings.settings,
                "persisted recipe lost");
        require(pipeline.overrides(first.asset_id) == custom,
                "cleared cache lost authoring overrides");
        fs::remove_all(root);
        std::cout << "assets: geometry/PBR/texture, GLB/glTF, cache, rename, deletion, overrides, "
                     "failure, cancellation, standalone PNG/JPEG OK\n";
        return 0;
    } catch (const std::exception& e) {
        std::cerr << e.what() << "\nFixtures retained: " << root << '\n';
        return 1;
    }
}