// file: crates/ksp-app-backfill-desk/unit_tests/transport_runtime.rs
// version: 2

fn endpoint(
    name: &str,
    cluster: &str,
    role_name: &str,
    request_kinds: std::vec::Vec<ksp_onchain_transport_lib::HttpRequestKind>,
) -> ksp_core_lib::Result<ksp_onchain_transport_lib::HttpEndpointSettings> {
    let url = ksp_onchain_transport_lib::HttpEndpointUrl::parse(format!("https://{name}.example.invalid"));
    let url = match url {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    let role = ksp_onchain_transport_lib::HttpEndpointRoleSettings::new(
        ksp_onchain_transport_lib::HttpRoleName::new(role_name),
        true,
        request_kinds,
        0,
        ksp_onchain_transport_lib::HttpRoleLimits::new(
            std::option::Option::None,
            std::option::Option::None,
            std::option::Option::None,
            std::option::Option::None,
        ),
    );
    return std::result::Result::Ok(ksp_onchain_transport_lib::HttpEndpointSettings::new(
        name,
        true,
        ksp_onchain_transport_lib::HttpProviderName::new("fixture"),
        ksp_onchain_transport_lib::HttpClusterName::new(cluster),
        url,
        std::time::Duration::from_secs(1),
        std::time::Duration::from_secs(2),
        std::option::Option::Some(1),
        vec![role],
    ));
}

fn pool(endpoints: std::vec::Vec<ksp_onchain_transport_lib::HttpEndpointSettings>) -> ksp_core_lib::Result<ksp_onchain_transport_lib::HttpTransportPool> {
    let settings = ksp_onchain_transport_lib::HttpTransportSettings::new(
        endpoints,
        ksp_onchain_transport_lib::HttpRetrySettings::new(0, std::time::Duration::from_millis(10), std::time::Duration::from_millis(10)),
    );
    return ksp_onchain_transport_lib::HttpTransportPool::new(settings);
}

#[test]
fn http_routes_require_both_backfill_rpc_methods() {
    let signatures = ksp_onchain_transport_lib::find_http_rpc_method("getSignaturesForAddress");
    let transaction = ksp_onchain_transport_lib::find_http_rpc_method("getTransaction");
    assert!(signatures.is_some());
    assert!(transaction.is_some());
    let signatures = match signatures {
        std::option::Option::Some(value) => ksp_onchain_transport_lib::HttpRequestKind::new(value.request_kind()),
        std::option::Option::None => return,
    };
    let transaction = match transaction {
        std::option::Option::Some(value) => ksp_onchain_transport_lib::HttpRequestKind::new(value.request_kind()),
        std::option::Option::None => return,
    };
    let complete = endpoint("complete", "devnet", "complete", vec![signatures.clone(), transaction]);
    let complete = match complete {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let partial = endpoint("partial", "devnet", "partial", vec![signatures]);
    let partial = match partial {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let runtime_pool = pool(vec![complete, partial]);
    assert!(runtime_pool.is_ok());
    let runtime_pool = match runtime_pool {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let snapshot = runtime_pool.snapshot();
    let roles = super::compatible_backfill_http_routes(&runtime_pool, &snapshot);
    assert!(roles.is_ok());
    if let std::result::Result::Ok(roles) = roles {
        assert_eq!(roles.len(), 1);
        if let std::option::Option::Some(route) = roles.first() {
            assert_eq!(route.role, "complete");
            assert_eq!(route.providers, vec!["fixture".to_owned()]);
            assert!(!route.pooled);
        }
    }
}

#[test]
fn configured_networks_are_safe_sorted_and_deduplicated() {
    let one = endpoint("one", "testnet", "default", vec![ksp_onchain_transport_lib::HttpRequestKind::wildcard()]);
    let two = endpoint("two", "devnet", "default", vec![ksp_onchain_transport_lib::HttpRequestKind::wildcard()]);
    let three = endpoint("three", "devnet", "default", vec![ksp_onchain_transport_lib::HttpRequestKind::wildcard()]);
    let (one, two, three) = match (one, two, three) {
        (std::result::Result::Ok(one), std::result::Result::Ok(two), std::result::Result::Ok(three)) => (one, two, three),
        _ => return,
    };
    let runtime_pool = pool(vec![one, two, three]);
    assert!(runtime_pool.is_ok());
    if let std::result::Result::Ok(runtime_pool) = runtime_pool {
        let values = super::configured_networks(&runtime_pool.snapshot());
        assert_eq!(values, vec!["devnet".to_owned(), "testnet".to_owned()]);
    }
}

#[test]
fn coherent_network_requires_exactly_one_enabled_http_cluster() {
    let one = endpoint("one", "devnet", "default", vec![ksp_onchain_transport_lib::HttpRequestKind::wildcard()]);
    let one = match one {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let one_pool = pool(vec![one]);
    assert!(one_pool.is_ok());
    if let std::result::Result::Ok(one_pool) = one_pool {
        let runtime = crate::TransportRuntime { pool: one_pool, profile_id: "fixture".to_owned() };
        assert_eq!(runtime.coherent_network(), std::option::Option::Some("devnet".to_owned()));
    }
    let two = endpoint("two", "devnet", "default", vec![ksp_onchain_transport_lib::HttpRequestKind::wildcard()]);
    let three = endpoint("three", "testnet", "default", vec![ksp_onchain_transport_lib::HttpRequestKind::wildcard()]);
    let (two, three) = match (two, three) {
        (std::result::Result::Ok(two), std::result::Result::Ok(three)) => (two, three),
        _ => return,
    };
    let multi_pool = pool(vec![two, three]);
    assert!(multi_pool.is_ok());
    if let std::result::Result::Ok(multi_pool) = multi_pool {
        let runtime = crate::TransportRuntime { pool: multi_pool, profile_id: "fixture".to_owned() };
        assert_eq!(runtime.coherent_network(), std::option::Option::None);
    }
}