// file: crates/ksp-app-store-desk/tests/dependency_boundary.rs
// version: 7

//! Dependency-boundary tests for the Store Desk application.

#[test]
fn pre_006_manifest_uses_store_facade_without_physical_or_transport_dependencies() {
    let manifest = include_str!("../Cargo.toml");
    for forbidden in [
        "ksp-store-api",
        "ksp-store-postgres-lib",
        "ksp-onchain-transport-lib",
        "ksp-offchain-transport-lib",
        "ksp-job-api",
        "ksp-job-backfill-lib",
        "reqwest",
        "tokio-postgres",
        "deadpool-postgres",
    ] {
        assert!(!manifest.contains(forbidden), "forbidden Store Desk dependency present: {forbidden}");
    }
    for required in ["ksp-config-lib", "ksp-core-lib", "ksp-logging-lib", "ksp-store-lib", "tauri-plugin-tracing"] {
        assert!(manifest.contains(required), "required Store Desk dependency missing: {required}");
    }
}

#[test]
fn pre_006_store_open_is_owned_by_store_runtime_and_never_escapes_to_physical_sql() {
    let bootstrap = include_str!("../src/bootstrap.rs");
    let store_runtime = include_str!("../src/store_runtime.rs");
    let app_state = include_str!("../src/app_state.rs");
    let tauri = include_str!("../src/tauri.rs");
    assert!(!bootstrap.contains("Store::open"));
    assert!(store_runtime.contains("ksp_store_lib::Store::open"));
    assert!(store_runtime.contains("store.runtime_snapshot()"));
    assert!(store_runtime.contains("store.health().await"));
    assert!(store_runtime.contains("store.close().await"));
    let sources = [bootstrap, store_runtime, app_state, tauri].join("\n");
    for forbidden in ["tokio_postgres", "deadpool_postgres", "SELECT ", "INSERT ", "UPDATE ", "DELETE ", "ksp_store_api", "ksp_store_postgres"] {
        assert!(!sources.contains(forbidden), "Store Desk leaked forbidden physical Store surface: {forbidden}");
    }
}

#[test]
fn pre_006_fix_001_shared_visible_items_use_the_crate_root_facade_inside_owner_modules() {
    let lib = include_str!("../src/lib.rs");
    let dto_common = include_str!("../src/dto_common.rs");
    let frontend_logging = include_str!("../src/frontend_logging.rs");
    let splash = include_str!("../src/splash.rs");
    let store_runtime = include_str!("../src/store_runtime.rs");
    let tw_main = include_str!("../src/tw_main.rs");
    let tw_splash = include_str!("../src/tw_splash.rs");
    for expected in [
        "pub(crate) use self::dto_common::CommandErrorDto;",
        "pub(crate) use self::frontend_logging::FrontendLogPayloadDto;",
        "pub(crate) use self::splash::SplashOrderDto;",
        "pub(crate) use self::splash::SplashSettings;",
        "pub(crate) use self::store_runtime::StoreRuntime;",
        "pub(crate) use self::store_runtime::StoreStartup;",
    ] {
        assert!(lib.contains(expected), "missing Store Desk crate-root re-export: {expected}");
    }
    assert!(dto_common.contains("std::option::Option<crate::CommandErrorDto>"));
    assert!(frontend_logging.contains("payload: crate::FrontendLogPayloadDto"));
    assert!(splash.contains("impl crate::SplashSettings"));
    assert!(splash.contains("impl crate::SplashOrderDto"));
    assert!(store_runtime.contains("std::option::Option<crate::StoreRuntime>"));
    assert!(store_runtime.contains("impl crate::StoreRuntime"));
    assert!(store_runtime.contains("impl crate::StoreStartup"));
    assert!(store_runtime.contains("-> crate::StoreStartup"));
    assert!(store_runtime.contains("crate::StoreStartup {"));
    assert!(store_runtime.contains("std::option::Option::Some(crate::StoreRuntime {"));
    assert!(tw_main.contains("const WINDOW_LABEL_MAIN: &str = \"main\";"));
    assert!(!tw_main.contains("pub(crate) const WINDOW_LABEL_MAIN"));
    assert!(tw_splash.contains("const WINDOW_LABEL_SPLASH: &str = \"splash\";"));
    assert!(!tw_splash.contains("pub(crate) const WINDOW_LABEL_SPLASH"));
}

#[test]
fn pre_007_transaction_inspection_uses_store_facade_and_new_visible_items_use_crate_root_exports() {
    let lib = include_str!("../src/lib.rs");
    let runtime = include_str!("../src/store_runtime.rs");
    let app_state = include_str!("../src/app_state.rs");
    let tauri = include_str!("../src/tauri.rs");
    for expected in [
        "pub(crate) use self::dto_transaction::StoreTransactionDetailRequestDto;",
        "pub(crate) use self::dto_transaction::StoreTransactionDetailDto;",
        "pub(crate) use self::dto_transaction::StoreTransactionQueryRequestDto;",
        "pub(crate) use self::dto_transaction::StoreTransactionQueryResponseDto;",
        "pub(crate) use self::dto_transaction::StoreTransactionRowDto;",
    ] {
        assert!(lib.contains(expected), "missing pre.007 crate-root DTO re-export: {expected}");
    }
    assert!(runtime.contains("ksp_store_lib::RawTransactionInspectionRead::inspect_raw_transactions"));
    assert!(runtime.contains("ksp_store_lib::RawTransactionRead::get_raw_transaction"));
    assert!(runtime.contains("ksp_store_lib::RawTransactionRetentionRead::get_raw_transaction_retention_state"));
    assert!(runtime.contains("ksp_store_lib::RawTransactionRetentionRead::get_raw_transaction_tombstone"));
    assert!(app_state.contains("request: crate::StoreTransactionQueryRequestDto"));
    assert!(app_state.contains("request: crate::StoreTransactionDetailRequestDto"));
    assert!(tauri.contains("request: crate::StoreTransactionQueryRequestDto"));
    assert!(tauri.contains("request: crate::StoreTransactionDetailRequestDto"));
    let sources = [runtime, app_state, tauri].join("\n");
    for forbidden in ["ksp_store_api", "ksp_store_postgres", "tokio_postgres", "deadpool_postgres", "SELECT ", "OFFSET "] {
        assert!(!sources.contains(forbidden), "Store Desk transaction inspection crossed physical/backend-neutral boundary: {forbidden}");
    }
}

#[test]
fn pre_008_account_inspection_uses_store_facade_and_new_visible_items_use_crate_root_exports() {
    let lib = include_str!("../src/lib.rs");
    let runtime = include_str!("../src/store_runtime.rs");
    let app_state = include_str!("../src/app_state.rs");
    let tauri = include_str!("../src/tauri.rs");
    for expected in [
        "pub(crate) use self::dto_account::StoreAccountDetailRequestDto;",
        "pub(crate) use self::dto_account::StoreAccountDetailDto;",
        "pub(crate) use self::dto_account::StoreAccountQueryRequestDto;",
        "pub(crate) use self::dto_account::StoreAccountQueryResponseDto;",
        "pub(crate) use self::dto_account::StoreAccountRowDto;",
    ] {
        assert!(lib.contains(expected), "missing pre.008 crate-root DTO re-export: {expected}");
    }
    assert!(runtime.contains("ksp_store_lib::RawAccountStateInspectionRead::inspect_raw_account_states"));
    assert!(runtime.contains("ksp_store_lib::RawAccountStateRead::get_raw_account_state"));
    assert!(app_state.contains("request: crate::StoreAccountQueryRequestDto"));
    assert!(app_state.contains("request: crate::StoreAccountDetailRequestDto"));
    assert!(tauri.contains("request: crate::StoreAccountQueryRequestDto"));
    assert!(tauri.contains("request: crate::StoreAccountDetailRequestDto"));
    let sources = [runtime, app_state, tauri].join("\n");
    for forbidden in ["ksp_store_api", "ksp_store_postgres", "tokio_postgres", "deadpool_postgres", "SELECT ", "OFFSET "] {
        assert!(!sources.contains(forbidden), "Store Desk account inspection crossed physical/backend-neutral boundary: {forbidden}");
    }
}

#[test]
fn pre_010_observation_ui_uses_store_facade_and_new_visible_items_use_crate_root_exports() {
    let lib = include_str!("../src/lib.rs");
    let dto = include_str!("../src/dto_observation.rs");
    let runtime = include_str!("../src/store_runtime.rs");
    let app_state = include_str!("../src/app_state.rs");
    let tauri = include_str!("../src/tauri.rs");
    for expected in [
        "pub(crate) use self::dto_observation::StoreAccountObservationQueryRequestDto;",
        "pub(crate) use self::dto_observation::StoreAccountObservationQueryResponseDto;",
        "pub(crate) use self::dto_observation::StoreAccountObservationRowDto;",
        "pub(crate) use self::dto_observation::StoreObservationProvenanceDto;",
        "pub(crate) use self::dto_observation::StoreTransactionObservationQueryRequestDto;",
        "pub(crate) use self::dto_observation::StoreTransactionObservationQueryResponseDto;",
        "pub(crate) use self::dto_observation::StoreTransactionObservationRowDto;",
    ] {
        assert!(lib.contains(expected), "missing pre.010 crate-root observation DTO re-export: {expected}");
    }
    assert!(dto.contains("crate::StoreObservationProvenanceDto"));
    assert!(runtime.contains("ksp_store_lib::RawTransactionObservationInspectionRead::inspect_raw_transaction_observations"));
    assert!(runtime.contains("ksp_store_lib::RawAccountObservationInspectionRead::inspect_raw_account_observations"));
    assert!(app_state.contains("request: crate::StoreTransactionObservationQueryRequestDto"));
    assert!(app_state.contains("request: crate::StoreAccountObservationQueryRequestDto"));
    assert!(tauri.contains("request: crate::StoreTransactionObservationQueryRequestDto"));
    assert!(tauri.contains("request: crate::StoreAccountObservationQueryRequestDto"));
    let sources = [runtime, app_state, tauri].join("\n");
    for forbidden in ["ksp_store_api", "ksp_store_postgres", "tokio_postgres", "deadpool_postgres", "SELECT ", "OFFSET "] {
        assert!(!sources.contains(forbidden), "Store Desk observation UI crossed physical/backend-neutral boundary: {forbidden}");
    }
}