// file: crates/ksp-app-wallet-desk/tests/config_composition.rs
// version: 8

//! Config composition contracts introduced for Wallet Desk pre.003.

fn workspace_engine() -> ksp_core_lib::Result<ksp_config_lib::ConfigDocumentEngine> {
    let workspace = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
    let bootstrap = ksp_config_lib::ConfigBootstrapOptions::from_paths(workspace.join("config"), workspace.join("config/schemas"));
    let bootstrap = match bootstrap {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let registry = ksp_config_lib::ConfigFileRegistry::defaults();
    return match registry {
        std::result::Result::Ok(value) => std::result::Result::Ok(ksp_config_lib::ConfigDocumentEngine::new(bootstrap, value)),
        std::result::Result::Err(error) => std::result::Result::Err(error),
    };
}

#[test]
fn wallet_desk_composite_selects_logging_offchain_transport_transport_and_wallet_by_file_id() {
    let engine = workspace_engine();
    assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}");
    if let std::result::Result::Ok(engine) = engine {
        let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_WALLET_DESK);
        assert!(file_id.is_ok(), "Wallet Desk composite file_id should be valid: {file_id:?}");
        if let std::result::Result::Ok(file_id) = file_id {
            let composite = engine.load_resolved_composite(&file_id, std::option::Option::None);
            assert!(composite.is_ok(), "committed Wallet Desk composite should resolve: {composite:?}");
            if let std::result::Result::Ok(composite) = composite {
                assert_eq!(composite.profile_id(), "devnet");
                assert_component(&composite, "logging", ksp_config_lib::FILE_ID_STD_LOGGING, "supertrace");
                assert_wallet_desk_supertrace_profile(&composite);
                assert_component(&composite, "offchain_transport", ksp_config_lib::FILE_ID_STD_OFFCHAIN_TRANSPORT, "public_keyless");
                assert_component(&composite, "transport", ksp_config_lib::FILE_ID_STD_TRANSPORT, "devnet_public");
                assert_component(&composite, "wallet", ksp_config_lib::FILE_ID_STD_WALLET, "default");
            }
        }
    }
}

fn assert_wallet_desk_supertrace_profile(composite: &ksp_config_lib::ResolvedConfigComposite) {
    let component = composite.component("logging");
    assert!(component.is_some(), "missing logging component");
    if let std::option::Option::Some(component) = component {
        let profile = component.resolved().profile();
        assert_eq!(profile.get("default_filter").and_then(serde_json::Value::as_str), std::option::Option::Some("trace"));
        let console = profile.get("console").and_then(serde_json::Value::as_object);
        let console_filter = console
            .and_then(|value| {
                return value.get("filter");
            })
            .and_then(serde_json::Value::as_object);
        let console_level = console_filter
            .and_then(|value| {
                return value.get("level");
            })
            .and_then(serde_json::Value::as_str);
        assert_eq!(console_level, std::option::Option::Some("debug"));
        let console_targets = console_filter
            .and_then(|value| {
                return value.get("targets");
            })
            .and_then(serde_json::Value::as_array);
        assert_eq!(
            console_targets
                .and_then(|value| {
                    return value.first();
                })
                .and_then(serde_json::Value::as_str),
            std::option::Option::Some("*")
        );
        let files = profile.get("files").and_then(serde_json::Value::as_array);
        assert_eq!(files.map(std::vec::Vec::len), std::option::Option::Some(7));
        if let std::option::Option::Some(files) = files {
            for target in [
                "ksp-app-config-desk",
                "ksp-app-wallet-desk",
                "ksp-config-lib",
                "ksp-core-lib",
                "ksp-logging-lib",
                "ksp-onchain-transport-lib",
                "ksp-wallet-lib",
            ] {
                assert!(
                    files.iter().any(|file| -> bool {
                        let filter = file.get("filter");
                        let level = filter
                            .and_then(|value| {
                                return value.get("level");
                            })
                            .and_then(serde_json::Value::as_str);
                        let targets = filter
                            .and_then(|value| {
                                return value.get("targets");
                            })
                            .and_then(serde_json::Value::as_array);
                        return level == std::option::Option::Some("trace")
                            && targets.is_some_and(|targets| {
                                return targets.iter().any(|value| {
                                    return value.as_str() == std::option::Option::Some(target);
                                });
                            });
                    }),
                    "supertrace should contain one trace file sink for target {target}"
                );
            }
        }
        let target_filters = profile.get("target_filters").and_then(serde_json::Value::as_array);
        assert!(target_filters.is_some_and(std::vec::Vec::is_empty), "supertrace should rely on the global trace takeover instead of per-target overrides");
    }
}

fn assert_component(composite: &ksp_config_lib::ResolvedConfigComposite, component_id: &str, file_id: &str, profile_id: &str) {
    let component = composite.component(component_id);
    assert!(component.is_some(), "missing component {component_id}");
    if let std::option::Option::Some(component) = component {
        assert_eq!(component.resolved().file_id().as_str(), file_id);
        assert_eq!(component.resolved().profile_id(), profile_id);
        assert_eq!(component.resolved().selection_source(), ksp_config_lib::ConfigProfileSelectionSource::Composite);
    }
}

#[test]
fn wallet_desk_composite_transport_profile_builds_get_balance_pool() {
    let engine = workspace_engine();
    assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}");
    let engine = match engine {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_WALLET_DESK);
    assert!(file_id.is_ok());
    let file_id = match file_id {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let composite = engine.load_resolved_composite(&file_id, std::option::Option::None);
    assert!(composite.is_ok(), "committed Wallet Desk composite should resolve: {composite:?}");
    let composite = match composite {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let component = composite.component("transport");
    assert!(component.is_some());
    let component = match component {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let environment = ksp_config_lib::ConfigEnvironment::load();
    assert!(environment.is_ok(), "public Config environment snapshot should load");
    let environment = match environment {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let resolved = engine.resolve_transport_config_profile(component.resolved(), &environment);
    assert!(resolved.is_ok(), "composite-selected Transport should map: {resolved:?}");
    let resolved = match resolved {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(resolved.selection_source(), ksp_config_lib::ConfigProfileSelectionSource::Composite);
    let pool = ksp_onchain_transport_lib::HttpTransportPool::new(resolved.into_settings());
    assert!(pool.is_ok(), "mapped Transport settings should construct a pool");
    let pool = match pool {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let descriptor = ksp_onchain_transport_lib::find_http_rpc_method("getBalance");
    assert!(descriptor.is_some());
    if let std::option::Option::Some(descriptor) = descriptor {
        let selection = pool.select_for_method(&ksp_onchain_transport_lib::HttpRoleName::new("default"), descriptor);
        assert!(selection.is_ok(), "getBalance should route through the composite-selected Transport pool: {selection:?}");
    }
}

#[test]
fn wallet_desk_composite_offchain_profile_builds_provider_neutral_service() {
    let engine = workspace_engine();
    assert!(engine.is_ok(), "workspace Config engine should be constructible: {engine:?}");
    let engine = match engine {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let file_id = ksp_config_lib::ConfigFileId::new(ksp_config_lib::FILE_ID_COMPOSITE_KSP_APP_WALLET_DESK);
    let file_id = match file_id {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let composite = engine.load_resolved_composite(&file_id, std::option::Option::None);
    let composite = match composite {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let component = composite.component("offchain_transport");
    assert!(component.is_some(), "Wallet Desk composite should expose Off-chain Transport");
    let component = match component {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let environment = ksp_config_lib::ConfigEnvironment::load();
    assert!(environment.is_ok(), "public Config environment snapshot should load");
    let environment = match environment {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let resolved = engine.resolve_offchain_transport_config_profile(component.resolved(), &environment);
    assert!(resolved.is_ok(), "composite-selected Off-chain Transport should map");
    if let std::result::Result::Ok(resolved) = resolved {
        assert_eq!(resolved.profile_id(), "public_keyless");
        assert_eq!(resolved.selection_source(), ksp_config_lib::ConfigProfileSelectionSource::Composite);
        assert_eq!(resolved.service().registry().len(), 8);
    }
}