// file: crates/ksp-app-backfill-desk/tests/config_composition.rs
// version: 2

//! Config composite and Transport-readiness contracts for Backfill Desk through pre.004.

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

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),
    };
}

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 pre_003_default_composite_selects_trace_devnet_logging_transport_and_store() {
    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_BACKFILL_DESK);
    assert!(file_id.is_ok(), "Backfill Desk composite file_id should be valid: {file_id:?}");
    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 Backfill 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_component(&composite, "transport", ksp_config_lib::FILE_ID_STD_TRANSPORT, "devnet_public");
        assert_component(&composite, "store", ksp_config_lib::FILE_ID_STD_STORE, "devnet");
        let logging = composite.component("logging");
        assert!(logging.is_some(), "Backfill Desk composite should expose Logging");
        if let std::option::Option::Some(logging) = logging {
            assert_eq!(logging.resolved().profile().get("default_filter").and_then(serde_json::Value::as_str), std::option::Option::Some("trace"));
        }
    }
}

#[test]
fn pre_003_named_profiles_keep_transport_and_store_network_selection_paired() {
    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_BACKFILL_DESK);
    let file_id = match file_id {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    for (profile_id, logging_profile, transport_profile, store_profile) in
        [("mainnet", "console_info", "mainnet_public", "mainnet"), ("testnet", "console_info", "publicnode_testnet", "testnet")]
    {
        let composite = engine.load_resolved_composite(&file_id, std::option::Option::Some(profile_id));
        assert!(composite.is_ok(), "Backfill Desk composite profile {profile_id} should resolve: {composite:?}");
        if let std::result::Result::Ok(composite) = composite {
            assert_eq!(composite.profile_id(), profile_id);
            assert_component(&composite, "logging", ksp_config_lib::FILE_ID_STD_LOGGING, logging_profile);
            assert_component(&composite, "transport", ksp_config_lib::FILE_ID_STD_TRANSPORT, transport_profile);
            assert_component(&composite, "store", ksp_config_lib::FILE_ID_STD_STORE, store_profile);
        }
    }
}

#[test]
fn pre_004_default_composite_builds_http_pool_for_both_backfill_rpc_methods() {
    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_BACKFILL_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);
    assert!(composite.is_ok(), "committed Backfill Desk composite should resolve: {composite:?}");
    let composite = match composite {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let transport = composite.component("transport");
    assert!(transport.is_some(), "Backfill Desk composite should expose Transport");
    let transport = match transport {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let environment = ksp_config_lib::ConfigEnvironment::load();
    assert!(environment.is_ok(), "Config environment should load for committed public devnet profile");
    let environment = match environment {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let resolved = engine.resolve_transport_config_profile(transport.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.profile_id(), "devnet_public");
    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(), "composite-selected Transport settings should construct an HTTP pool");
    let pool = match pool {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let snapshot = pool.snapshot();
    let mut clusters = snapshot
        .endpoints()
        .iter()
        .filter_map(|endpoint| {
            if endpoint.enabled() {
                return std::option::Option::Some(endpoint.cluster().to_owned());
            }
            return std::option::Option::None;
        })
        .collect::<std::vec::Vec<_>>();
    clusters.sort();
    clusters.dedup();
    assert_eq!(clusters, vec!["devnet".to_owned()]);
    let role = ksp_onchain_transport_lib::HttpRoleName::new("default");
    for method in ["getSignaturesForAddress", "getTransaction"] {
        let descriptor = ksp_onchain_transport_lib::find_http_rpc_method(method);
        assert!(descriptor.is_some(), "required Transport method {method} should exist");
        if let std::option::Option::Some(descriptor) = descriptor {
            let selection = pool.select_for_method(&role, descriptor);
            assert!(selection.is_ok(), "role default should route {method}: {selection:?}");
        }
    }
}