// file: crates/ksp-app-raw-transaction-ingest-desk/tests/release_completeness.rs
// version: 12

//! Release-completeness canaries for Raw Transaction Ingest Desk Start-resource reconstruction.

#![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_010_production_module_inventory_adds_only_route_monitoring_to_pre_009_surface() {
    let lib = read_text(app_root().join("src/lib.rs").as_path());
    let expected = [
        "mod app_state;",
        "mod bootstrap;",
        "mod constants;",
        "mod dto_common;",
        "mod dto_route;",
        "mod errors;",
        "mod frontend_logging;",
        "mod logging_runtime;",
        "mod route_inventory;",
        "mod route_monitoring;",
        "mod route_runtime;",
        "mod route_start;",
        "mod splash;",
        "mod tauri;",
        "mod tw_main;",
        "mod tw_splash;",
    ];
    assert_eq!(lib.matches("mod ").count(), expected.len());
    for module in expected {
        assert!(lib.contains(module));
    }
}

#[test]
fn pre_008_public_surface_still_exposes_only_application_run_entry_point() {
    let lib = read_text(app_root().join("src/lib.rs").as_path());
    let public_reexports = lib.lines().filter(|line| return line.starts_with("pub use ")).collect::<std::vec::Vec<_>>();
    assert_eq!(public_reexports, vec!["pub use self::tauri::run;"]);
}

#[test]
fn pre_008_keeps_five_exact_source_reconstructions_separate_from_store_worker_lifecycle() {
    let route_start = read_text(app_root().join("src/route_start.rs").as_path());
    for required in [
        "RawTransactionIngestYellowstoneSource::new",
        "RawTransactionIngestStandardLogsSource::new",
        "RawTransactionIngestStandardBlockSource::new",
        "RawTransactionIngestHeliusTransactionSource::new",
        "RawTransactionIngestHttpBlockPollingSource::new",
        "RawTransactionIngestRuntimeResources",
    ] {
        assert!(route_start.contains(required), "missing pre.008 exact Worker resource marker {required}");
    }
    for forbidden in ["Store::open", "start_with_runtime_resources", "request_stop", "wait_terminal"] {
        assert!(!route_start.contains(forbidden), "route preparation owns runtime lifecycle marker {forbidden}");
    }
    let runtime = read_text(app_root().join("src/route_runtime.rs").as_path());
    for required in ["Store::open", "start_with_runtime_resources", "request_stop", "wait_terminal", "StoreHealthState::Ready", "close_store_arc"] {
        assert!(runtime.contains(required), "missing pre.008 lifecycle marker {required}");
    }
}

#[test]
fn pre_007_start_revalidation_reuses_inventory_and_requires_profile_network_identity() {
    let route_start = read_text(app_root().join("src/route_start.rs").as_path());
    for required in [
        "current_generation == 0",
        "request.inventory_generation != current_generation",
        "build_route_inventory_with_environment",
        "request.profile_id",
        "resolve_store_config_profile",
        "store.settings().network().as_str() != network",
        "transport_matches_network",
    ] {
        assert!(route_start.contains(required), "missing pre.007 revalidation marker {required}");
    }
}

#[test]
fn pre_009_multi_route_runtime_keeps_independent_workers_on_one_same_network_store() {
    let runtime = read_text(app_root().join("src/route_runtime.rs").as_path());
    for required in [
        "routes: std::vec::Vec<RouteRuntimeSlot>",
        "store: std::option::Option<std::sync::Arc<ksp_store_lib::Store>>",
        "ERROR_CODE_ROUTE_RUNTIME_NETWORK_MISMATCH",
        "already owns one Worker for the selected logical route",
        "shared_store(prepared.network.as_str())",
        "self.runtime_state.finish(self.token, terminal, monitoring)",
        "Arc::try_unwrap",
    ] {
        assert!(runtime.contains(required), "missing pre.009 shared-Store marker {required}");
    }
    assert!(!runtime.contains("RouteRuntimeSlot::Idle"));
}

#[test]
fn pre_009_targeted_stop_is_route_scoped_and_late_terminal_safe() {
    let dto = read_text(app_root().join("src/dto_route.rs").as_path());
    assert!(dto.contains("RawIngestRouteStopRequestDto"));
    let runtime = read_text(app_root().join("src/route_runtime.rs").as_path());
    assert!(runtime.contains("stop_and_wait(&self, request: &crate::RawIngestRouteStopRequestDto)"));
    assert!(runtime.contains("terminal.profile_id == request.profile_id && terminal.route_id == request.route_id"));
    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
    assert!(tauri.contains("request: crate::RawIngestRouteStopRequestDto"));
}

#[test]
fn pre_009_yellowstone_uses_block_subscription_and_one_get_block_path_instead_of_per_transaction_hydration() {
    let route_start = read_text(app_root().join("src/route_start.rs").as_path());
    let start = route_start.find("fn prepare_yellowstone(");
    let end = route_start.find("fn prepare_http_polling(");
    assert!(start.is_some());
    assert!(end.is_some());
    let yellowstone = match (start, end) {
        (std::option::Option::Some(start), std::option::Option::Some(end)) if start < end => &route_start[start..end],
        _ => "",
    };
    assert!(yellowstone.contains("insert_block_filter"));
    assert!(yellowstone.contains("set_include_transactions(std::option::Option::Some(false))"));
    assert!(yellowstone.contains("single_http_role(transport.http_settings(), network, &[\"getBlock\"])"));
    assert!(!yellowstone.contains("insert_transaction_filter"));
    let workspace = read_text(app_root().join("../ksp-worker-raw-transaction-ingest-lib/src/runtime_resources.rs").as_path());
    assert!(workspace.contains("RawTransactionIngestYellowstoneMode::BlockHydration"));
    assert!(workspace.contains("fetch_yellowstone_block_ingresses"));
    assert!(workspace.contains("get_block_observed"));
    assert!(workspace.contains("RAW_TRANSACTION_INGEST_YELLOWSTONE_BLOCK_RECONCILIATION_ATTEMPTS"));
    assert!(workspace.contains("stop_receiver.changed()"));
}

#[test]
fn pre_010_latest_value_monitoring_reuses_worker_snapshot_source_and_tauri_event_bridge() {
    let monitoring = read_text(app_root().join("src/route_monitoring.rs").as_path());
    for required in [
        "RawIngestRouteMonitoringDto",
        "RawIngestRouteGapDto",
        "project_route_monitoring",
        "continuity_frontier_slot",
        "future_target_coverage",
        "source_reconnect_total",
        "source_replay_attempt_total",
        "repaired_gap_total",
        "backpressure_wait_total",
    ] {
        assert!(monitoring.contains(required), "missing pre.010 monitoring marker {required}");
    }
    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
    for required in ["get_route_monitoring", "RAW_INGEST_ROUTE_STATUS_EVENT_NAME", "monitor_route_status", "source.wait_for_change(observed).await"] {
        assert!(tauri.contains(required), "missing pre.010 event/resync marker {required}");
    }
    let runtime = read_text(app_root().join("src/route_runtime.rs").as_path());
    assert!(runtime.contains("monitoring_statuses"));
    assert!(runtime.contains("last_monitoring"));
}

#[test]
fn pre_011_frontend_supervision_closes_planned_ui_without_backend_module_growth() {
    let lib = read_text(app_root().join("src/lib.rs").as_path());
    assert_eq!(lib.matches("mod ").count(), 16);
    let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
    for required in [
        "RawIngestRouteMonitoringDto",
        "bindRouteMonitoring",
        "renderMonitoringDetail",
        "syncRouteMonitoring(\"startup\")",
        "syncRouteMonitoring(\"start\")",
        "syncRouteMonitoring(\"stop\")",
    ] {
        assert!(main.contains(required), "missing pre.011 frontend completeness marker {required}");
    }
    let html = read_text(app_root().join("frontend/main.html").as_path());
    for required in ["Supervision route", "Pipeline / persistence", "Sources / continuité / repair", "Gaps courants / récents"] {
        assert!(html.contains(required), "missing pre.011 operator supervision surface {required}");
    }
}

#[test]
fn pre_011_fix_001_preserves_latest_value_contract_without_backend_module_growth() {
    let lib = read_text(app_root().join("src/lib.rs").as_path());
    assert_eq!(lib.matches("mod ").count(), 16);
    let tauri = read_text(app_root().join("src/tauri.rs").as_path());
    assert!(tauri.contains("source.wait_for_change(observed).await"));
    assert!(tauri.contains("ROUTE_MONITORING_MIN_EMIT_INTERVAL_MS: u64 = 500"));
    let main = read_text(app_root().join("frontend/ts/main.ts").as_path());
    assert!(main.contains("renderRouteMonitoringCard"));
    assert!(main.contains("renderSelectedProfile"));
}

#[test]
fn pre_012_race_shutdown_and_ipc_hardening_adds_no_production_module_or_lower_layer_growth() {
    let lib = read_text(app_root().join("src/lib.rs").as_path());
    assert_eq!(lib.matches("mod ").count(), 16);
    for required in [
        "ERROR_CODE_FRONTEND_LOG_PAYLOAD_INVALID",
        "ERROR_CODE_ROUTE_REQUEST_INVALID",
        "ERROR_CODE_ROUTE_RUNTIME_SHUTTING_DOWN",
        "ERROR_CODE_ROUTE_RUNTIME_SHUTDOWN_FAILED",
    ] {
        assert!(lib.contains(required), "missing pre.012 crate-root error export {required}");
    }
    let runtime = read_text(app_root().join("src/route_runtime.rs").as_path());
    assert!(runtime.contains("stop_requested: bool"));
    assert!(runtime.contains("RouteStopTarget::Starting"));
    assert!(runtime.contains("cancelled_start_terminal"));
    assert!(runtime.contains("inner.routes.is_empty()"));
    let route_start = read_text(app_root().join("src/route_start.rs").as_path());
    assert!(route_start.contains("build_route_inventory_with_environment"));
    assert!(route_start.contains("request.validate_logical_identity()"));
    let worker_manifest = read_text(app_root().join("../ksp-worker-raw-transaction-ingest-lib/Cargo.toml").as_path());
    assert!(!worker_manifest.contains("ksp-app-raw-transaction-ingest-desk"));
}