// file: crates/ksp-app-raw-transaction-ingest-desk/tests/desktop_contract.rs
// version: 11

//! Desktop scaffold contract canaries for Raw Transaction Ingest Desk.

#![forbid(unsafe_code)]
#![deny(unreachable_pub)]
#![warn(missing_docs)]

fn app_root() -> std::path::PathBuf {
    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
}

fn read_text(path: &std::path::Path) -> String {
    let source = std::fs::read_to_string(path);
    assert!(source.is_ok(), "unable to read {}", path.display());
    return match source {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => String::new(),
    };
}

#[test]
fn pre_005_vite_and_tauri_identity_use_reserved_ports_and_crate_local_hooks() {
    let config = std::fs::read_to_string(app_root().join("tauri.conf.json"));
    assert!(config.is_ok());
    let config = match config {
        std::result::Result::Ok(value) => serde_json::from_str::<serde_json::Value>(value.as_str()),
        std::result::Result::Err(_) => return,
    };
    assert!(config.is_ok());
    if let std::result::Result::Ok(config) = config {
        assert_eq!(config["productName"], "KSP Raw Transaction Ingest Desk");
        assert_eq!(config["identifier"], "com.sasedev.ksp-app-raw-transaction-ingest-desk");
        assert_eq!(config["build"]["devUrl"], "http://localhost:1440");
    }
    let vite = read_text(app_root().join("vite.config.ts").as_path());
    assert!(vite.contains("port: 1440"));
    assert!(vite.contains("strictPort: true"));
    assert!(vite.contains("port: 1441"));
}

#[test]
fn pre_005_rust_package_is_mixed_lib_bin_and_workspace_member() {
    let manifest = read_text(app_root().join("Cargo.toml").as_path());
    assert!(manifest.contains("name = \"ksp-app-raw-transaction-ingest-desk\""));
    assert!(manifest.contains("name = \"ksp_app_raw_transaction_ingest_desk_lib\""));
    assert!(manifest.contains("crate-type = [\"staticlib\", \"cdylib\", \"rlib\"]"));
    let workspace = read_text(app_root().join("../../Cargo.toml").as_path());
    assert!(workspace.contains("crates/ksp-app-raw-transaction-ingest-desk"));
}

#[test]
fn pre_005_package_dependencies_match_current_desk_baseline() {
    let package = std::fs::read_to_string(app_root().join("package.json"));
    assert!(package.is_ok());
    let package = match package {
        std::result::Result::Ok(value) => serde_json::from_str::<serde_json::Value>(value.as_str()),
        std::result::Result::Err(_) => return,
    };
    assert!(package.is_ok());
    if let std::result::Result::Ok(package) = package {
        let dependencies = &package["dependencies"];
        for dependency in
            ["@fltsci/tauri-plugin-tracing", "@fortawesome/fontawesome-free", "@tauri-apps/api", "bootstrap", "resize-observer-polyfill", "simplebar"]
        {
            assert!(dependencies.get(dependency).is_some(), "missing frontend dependency {dependency}");
        }
        assert!(dependencies.get("datatables.net-bs5").is_none());
        let development = &package["devDependencies"];
        for dependency in ["@tauri-apps/cli", "@types/bootstrap", "@types/node", "sass-embedded", "typescript", "vite"] {
            assert!(development.get(dependency).is_some(), "missing frontend development dependency {dependency}");
        }
    }
}

#[test]
fn pre_005_packaging_contains_current_sixteen_config_resources() {
    let config = std::fs::read_to_string(app_root().join("tauri.conf.json"));
    assert!(config.is_ok());
    let config = match config {
        std::result::Result::Ok(value) => serde_json::from_str::<serde_json::Value>(value.as_str()),
        std::result::Result::Err(_) => return,
    };
    assert!(config.is_ok());
    if let std::result::Result::Ok(config) = config {
        let resources = config["bundle"]["resources"].as_object();
        assert!(resources.is_some());
        if let std::option::Option::Some(resources) = resources {
            assert_eq!(resources.len(), 16);
            assert!(resources.contains_key("../../config/composite.ksp-app-raw-transaction-ingest-desk.json"));
        }
    }
}

#[test]
fn pre_005_splash_assets_match_existing_ksp_desk_template_byte_exact() {
    let reference = app_root().join("../ksp-app-backfill-desk");
    for relative in ["icons/favicon.ico", "icons/favicon.png", "frontend/fonts/DOS_Amazigh.ttf", "frontend/imgs/logo.png", "frontend/imgs/splash.png"] {
        let current = std::fs::read(app_root().join(relative));
        let expected = std::fs::read(reference.join(relative));
        assert!(current.is_ok());
        assert!(expected.is_ok());
        if let (std::result::Result::Ok(current), std::result::Result::Ok(expected)) = (current, expected) {
            assert_eq!(current, expected, "binary template asset differs: {relative}");
        }
    }
}

#[test]
fn pre_006_route_inventory_is_backend_owned_and_keeps_exact_five_ids_and_seven_states() {
    let dto = read_text(app_root().join("src/dto_route.rs").as_path());
    for route in ["YellowstoneHydrated", "StandardLogsHydrated", "StandardBlockDirect", "HeliusTransactionHydrated", "HttpBlockPolling"] {
        assert!(dto.contains(route));
    }
    for state in ["Unavailable", "Configured", "Starting", "Running", "Stopping", "Stopped", "Faulted"] {
        assert!(dto.contains(state));
    }
    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
    assert!(tauri.contains("get_route_foundation"));
    assert!(tauri.contains("get_route_inventory"));
    for forbidden in ["start_worker", "stop_worker", "RawTransactionIngestWorker", "Store::open"] {
        assert!(!tauri.contains(forbidden), "scaffold Tauri surface contains premature runtime marker {forbidden}");
    }
}

#[test]
fn pre_005_fix_002_shell_reuses_common_light_template_and_bounds_route_foundation() {
    let html = read_text(app_root().join("frontend/main.html").as_path());
    for required in [
        "<header class=\"app-header\">",
        "navbar h-100 py-0 bg-light text-dark",
        "col-auto app-sidebar border-end bg-body-tertiary",
        "col app-content app-scrollable h-100",
        "card app-shell-card mx-auto shadow-sm border-0",
        "id=\"routeFoundation\" class=\"row g-3 app-route-grid\"",
    ] {
        assert!(html.contains(required), "missing common shell marker: {required}");
    }
    for forbidden in ["app-header bg-dark", "app-sidebar bg-dark text-light", "app-content flex-grow-1"] {
        assert!(!html.contains(forbidden), "obsolete shell marker remains: {forbidden}");
    }
    let styles = read_text(app_root().join("frontend/sass/_app.scss").as_path());
    for required in [
        ".app-scrollable {",
        ".app-shell-card {",
        ".app-route-grid {",
        ".app-route-grid > * {",
        "min-width: 0;",
        "max-width: 100%;",
        "overflow: hidden;",
        "overflow-wrap: anywhere;",
    ] {
        assert!(styles.contains(required), "missing bounded layout marker: {required}");
    }
}

#[test]
fn pre_006_frontend_projects_profile_network_generation_and_safe_route_reasons() {
    let html = read_text(app_root().join("frontend/main.html").as_path());
    for required in ["id=\"routeProfile\"", "id=\"routeNetwork\"", "id=\"routeInventoryGeneration\"", "id=\"routeFoundation\""] {
        assert!(html.contains(required), "missing route inventory UI marker: {required}");
    }
    let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
    for required in ["get_route_inventory", "missing_ws_block_capability", "missing_required_secret", "Config route inventory"] {
        assert!(main.contains(required), "missing route inventory frontend marker: {required}");
    }
    for forbidden in ["endpointUrl", "connectionUri", "apiKey", "sourceKey", "x-token"] {
        assert!(!main.contains(forbidden), "frontend exposes forbidden physical marker: {forbidden}");
    }
}

#[test]
fn pre_007_start_preflight_is_backend_owned_generation_bound_and_does_not_launch_worker() {
    let dto = read_text(app_root().join("src/dto_route.rs").as_path());
    for required in
        ["RawIngestCommitment", "RawIngestRouteStartRequestDto", "inventory_generation", "profile_id", "route_id", "RawIngestRouteStartValidationDto"]
    {
        assert!(dto.contains(required), "missing pre.007 Start DTO marker: {required}");
    }
    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
    assert!(tauri.contains("validate_route_start"));
    for forbidden in ["start_worker", "stop_worker", "start_with_runtime_resources", "Store::open"] {
        assert!(!tauri.contains(forbidden), "pre.007 Tauri surface contains premature runtime marker {forbidden}");
    }
}

#[test]
fn pre_009_start_stop_controls_are_multi_route_targeted_and_backend_owned() {
    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
    for required in ["start_route", "stop_route", "RawIngestRouteStopRequestDto", "launch.monitor().await"] {
        assert!(tauri.contains(required), "missing pre.009 Tauri runtime marker {required}");
    }
    let html = read_text(app_root().join("frontend/main.html").as_path());
    for required in ["id=\"routeCommitment\"", "id=\"routeRuntimeState\"", "id=\"routeRuntimeIdentity\"", "Runtime multi-route / Store partagé"] {
        assert!(html.contains(required), "missing pre.009 frontend runtime marker {required}");
    }
    assert!(!html.contains("id=\"stopRoute\""));
    let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
    for required in ["activeRuntimes", "targeted route Stop requested", "start_route", "stop_route", "RawIngestRouteStopRequestDto"] {
        assert!(main.contains(required), "missing pre.009 frontend control marker {required}");
    }
}

#[test]
fn pre_010_runtime_monitoring_is_backend_owned_event_driven_and_resynchronizable() {
    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
    for required in [
        "get_route_monitoring",
        "monitor_route_status",
        "window.emit(crate::RAW_INGEST_ROUTE_STATUS_EVENT_NAME, status)",
        "source.wait_for_change(observed).await",
    ] {
        assert!(tauri.contains(required), "missing pre.010 monitoring bridge marker {required}");
    }
    let state = read_text(app_root().join("src/app_state.rs").as_path());
    assert!(state.contains("route_monitoring(&self)"));
    assert!(state.contains("pre.010-runtime-monitoring"));
}

#[test]
fn pre_011_frontend_consumes_latest_value_monitoring_and_renders_full_route_supervision() {
    let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
    for required in [
        "listen<RawIngestRouteMonitoringDto>",
        "ksp-raw-ingest-route-status",
        "get_route_monitoring",
        "routeMonitoring",
        "syncRouteMonitoring",
        "persistedTotal",
        "sourceActive",
        "openGapCount",
        "repairTransactionHydrationTotal",
        "route supervision selected",
        "route monitoring resynchronization requested",
    ] {
        assert!(main.contains(required), "missing pre.011 frontend monitoring marker {required}");
    }
    let html = read_text(app_root().join("frontend/main.html").as_path());
    for required in [
        "id=\"refreshRouteMonitoring\"",
        "id=\"routeMonitoringDetail\"",
        "id=\"monitorPersistedTotal\"",
        "id=\"monitorSourceCounts\"",
        "id=\"monitorContinuityFrontier\"",
        "id=\"monitorGapList\"",
        "id=\"headerStore\"",
    ] {
        assert!(html.contains(required), "missing pre.011 supervision UI marker {required}");
    }
    let styles = read_text(app_root().join("frontend/sass/_app.scss").as_path());
    for required in [".app-route-monitoring-summary {", ".app-monitoring-detail {", ".app-monitoring-list dd", ".app-monitoring-gaps"] {
        assert!(styles.contains(required), "missing pre.011 bounded supervision style {required}");
    }
}

#[test]
fn pre_011_fix_001_monitoring_bridge_is_bounded_and_steady_updates_preserve_route_controls() {
    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
    for required in [
        "ROUTE_MONITORING_MIN_EMIT_INTERVAL_MS: u64 = 500",
        "tokio::time::sleep(std::time::Duration::from_millis(ROUTE_MONITORING_MIN_EMIT_INTERVAL_MS)).await",
        "snapshot = source.current()",
    ] {
        assert!(tauri.contains(required), "missing pre.011-fix.001 bounded relay marker {required}");
    }
    let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
    for required in [
        "const routeCards = new Map<string, HTMLElement>()",
        "renderRouteMonitoringCard",
        "const lifecycleChanged = previous === null || previous.state !== status.state",
        "if (lifecycleChanged || !renderRouteMonitoringCard(status))",
    ] {
        assert!(main.contains(required), "missing pre.011-fix.001 stable-control marker {required}");
    }
}

#[test]
fn pre_012_window_shutdown_and_start_stop_races_are_bounded_backend_owned() {
    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
    for required in [
        "configure_window_events(builder)",
        "tauri::WindowEvent::CloseRequested",
        "api.prevent_close()",
        "state.begin_shutdown()",
        "state.shutdown_routes().await",
        "app_handle.exit(0)",
        "app_handle.exit(1)",
    ] {
        assert!(tauri.contains(required), "missing pre.012 bounded shutdown marker {required}");
    }
    let runtime = read_text(app_root().join("src/route_runtime.rs").as_path());
    for required in [
        "shutting_down: bool",
        "stop_requested: bool",
        "ROUTE_SHUTDOWN_TIMEOUT",
        "ensure_start_admission_open",
        "shutdown_and_wait",
        "RouteStopTarget::Starting",
        "*stop_requested = true",
        "handle.request_stop()",
    ] {
        assert!(runtime.contains(required), "missing pre.012 route-race marker {required}");
    }
    let app_state = read_text(app_root().join("src/app_state.rs").as_path());
    assert!(app_state.contains("let prepared = {"));
    assert!(app_state.contains("let generation = self.inventory_generation.lock()"));
    assert!(!app_state.contains("std::mem::drop(generation)"));
    assert!(app_state.contains("self.route_runtime.ensure_start_admission_open()"));
}