// file: crates/ksp-app-raw-transaction-ingest-desk/unit_tests/route_inventory.rs
// version: 2

#[test]
fn pre_006_route_requirement_projection_is_fail_closed_and_ordered() {
    let route = super::route_with_requirements(
        crate::RawIngestRouteId::StandardLogsHydrated,
        "devnet",
        &[
            (false, crate::RawIngestRouteUnavailableReason::MissingWsLogsCapability),
            (false, crate::RawIngestRouteUnavailableReason::MissingHttpGetTransaction),
        ],
    );
    assert!(!route.selectable);
    assert_eq!(route.state, crate::RawIngestRouteState::Unavailable);
    assert_eq!(route.reason, std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingWsLogsCapability));
    assert_eq!(route.network.as_deref(), std::option::Option::Some("devnet"));
    let configured = super::route_with_requirements(
        crate::RawIngestRouteId::HttpBlockPolling,
        "mainnet",
        &[(true, crate::RawIngestRouteUnavailableReason::MissingHttpBlockScan)],
    );
    assert!(configured.selectable);
    assert_eq!(configured.state, crate::RawIngestRouteState::Configured);
    assert_eq!(configured.reason, std::option::Option::None);
}

#[test]
fn pre_006_unavailable_profile_projects_all_five_routes_without_physical_material() {
    let profile =
        super::unavailable_profile("mainnet", false, std::option::Option::Some("mainnet"), crate::RawIngestRouteUnavailableReason::MissingRequiredSecret);
    assert_eq!(profile.routes.len(), 5);
    assert_eq!(profile.network.as_deref(), std::option::Option::Some("mainnet"));
    for route in profile.routes {
        assert!(!route.selectable);
        assert_eq!(route.reason, std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingRequiredSecret));
    }
}

#[test]
fn pre_006_fix_001_network_profiles_aggregate_same_network_transport_capabilities() {
    let management = committed_management();
    assert!(management.is_ok());
    let management = match management {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let environment = all_optional_source_secrets();
    let inventory = super::build_route_inventory_with_environment(&management, &environment, 7);
    assert!(inventory.is_ok());
    let inventory = match inventory {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    assert_eq!(inventory.generation, 7);
    assert_eq!(inventory.default_profile, "devnet");
    assert_eq!(
        inventory.profiles.iter().map(|profile| return profile.profile_id.as_str()).collect::<std::vec::Vec<_>>(),
        vec!["devnet", "mainnet", "testnet"]
    );
    let devnet = profile(&inventory, "devnet");
    assert!(devnet.is_some());
    if let std::option::Option::Some(devnet) = devnet {
        assert!(devnet.is_default);
        assert_eq!(devnet.network.as_deref(), std::option::Option::Some("devnet"));
        assert_route(devnet, crate::RawIngestRouteId::YellowstoneHydrated, true, std::option::Option::None);
        assert_route(devnet, crate::RawIngestRouteId::StandardLogsHydrated, true, std::option::Option::None);
        assert_route(
            devnet,
            crate::RawIngestRouteId::StandardBlockDirect,
            false,
            std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingWsBlockCapability),
        );
        assert_route(devnet, crate::RawIngestRouteId::HeliusTransactionHydrated, true, std::option::Option::None);
        assert_route(devnet, crate::RawIngestRouteId::HttpBlockPolling, true, std::option::Option::None);
    }
    let mainnet = profile(&inventory, "mainnet");
    assert!(mainnet.is_some());
    if let std::option::Option::Some(mainnet) = mainnet {
        assert_eq!(mainnet.network.as_deref(), std::option::Option::Some("mainnet"));
        assert_route(mainnet, crate::RawIngestRouteId::YellowstoneHydrated, true, std::option::Option::None);
        assert_route(mainnet, crate::RawIngestRouteId::StandardLogsHydrated, true, std::option::Option::None);
        assert_route(mainnet, crate::RawIngestRouteId::HeliusTransactionHydrated, true, std::option::Option::None);
        assert_route(mainnet, crate::RawIngestRouteId::HttpBlockPolling, true, std::option::Option::None);
    }
    let testnet = profile(&inventory, "testnet");
    assert!(testnet.is_some());
    if let std::option::Option::Some(testnet) = testnet {
        assert_eq!(testnet.network.as_deref(), std::option::Option::Some("testnet"));
        assert_route(testnet, crate::RawIngestRouteId::YellowstoneHydrated, true, std::option::Option::None);
        assert_route(testnet, crate::RawIngestRouteId::StandardLogsHydrated, true, std::option::Option::None);
        assert_route(
            testnet,
            crate::RawIngestRouteId::HeliusTransactionHydrated,
            false,
            std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingHeliusTransactionCapability),
        );
        assert_route(testnet, crate::RawIngestRouteId::HttpBlockPolling, true, std::option::Option::None);
    }
    let serialized = serde_json::to_string(&inventory);
    assert!(serialized.is_ok());
    if let std::result::Result::Ok(serialized) = serialized {
        for forbidden in [
            "http://",
            "https://",
            "ws://",
            "wss://",
            "api-key",
            "x-token",
            "connection_uri",
            "source_key",
            "endpoint_name",
            "publicnode_mainnet",
            "helius_mainnet",
        ] {
            assert!(!serialized.contains(forbidden), "safe network inventory leaked forbidden source marker {forbidden}");
        }
    }
}

#[test]
fn pre_006_fix_001_missing_optional_source_secret_does_not_disable_base_network_routes() {
    let management = committed_management();
    assert!(management.is_ok());
    let management = match management {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let environment = ksp_config_lib::ConfigEnvironment::from_maps(std::collections::BTreeMap::new(), std::collections::BTreeMap::new());
    let inventory = super::build_route_inventory_with_environment(&management, &environment, 11);
    assert!(inventory.is_ok());
    let inventory = match inventory {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    let mainnet = profile(&inventory, "mainnet");
    assert!(mainnet.is_some());
    if let std::option::Option::Some(mainnet) = mainnet {
        assert_route(mainnet, crate::RawIngestRouteId::StandardLogsHydrated, true, std::option::Option::None);
        assert_route(mainnet, crate::RawIngestRouteId::HttpBlockPolling, true, std::option::Option::None);
        assert_route(
            mainnet,
            crate::RawIngestRouteId::YellowstoneHydrated,
            false,
            std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingRequiredSecret),
        );
        assert_route(
            mainnet,
            crate::RawIngestRouteId::HeliusTransactionHydrated,
            false,
            std::option::Option::Some(crate::RawIngestRouteUnavailableReason::MissingRequiredSecret),
        );
    }
}

fn committed_management() -> ksp_core_lib::Result<ksp_config_lib::ConfigManagement> {
    let manifest = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    let crates_root = manifest.parent();
    let crates_root = match crates_root {
        std::option::Option::Some(value) => value,
        std::option::Option::None => {
            return std::result::Result::Err(ksp_core_lib::Error::new(crate::ERROR_CODE_ROUTE_INVENTORY_INVALID, "test manifest has no crates parent"));
        },
    };
    let workspace = crates_root.parent();
    let workspace = match workspace {
        std::option::Option::Some(value) => value,
        std::option::Option::None => {
            return std::result::Result::Err(ksp_core_lib::Error::new(crate::ERROR_CODE_ROUTE_INVENTORY_INVALID, "test crates root has no workspace parent"));
        },
    };
    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();
    let registry = match registry {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(error) => return std::result::Result::Err(error),
    };
    return std::result::Result::Ok(ksp_config_lib::ConfigManagement::new(ksp_config_lib::ConfigDocumentEngine::new(bootstrap, registry)));
}

fn all_optional_source_secrets() -> ksp_config_lib::ConfigEnvironment {
    let mut process = std::collections::BTreeMap::<String, String>::new();
    process.insert("KSP_SECRET_HELIUS_API_KEY".to_owned(), "helius-route-inventory-canary".to_owned());
    process.insert("KSP_SECRET_ORBITFLARE_DEVNET_GRPC_X_TOKEN".to_owned(), "orbitflare-route-inventory-canary".to_owned());
    process.insert("KSP_SECRET_PUBLICNODE_MAINNET_GRPC_X_TOKEN".to_owned(), "publicnode-mainnet-route-inventory-canary".to_owned());
    process.insert("KSP_SECRET_PUBLICNODE_TESTNET_GRPC_X_TOKEN".to_owned(), "publicnode-testnet-route-inventory-canary".to_owned());
    return ksp_config_lib::ConfigEnvironment::from_maps(process, std::collections::BTreeMap::new());
}

fn profile<'a>(inventory: &'a crate::RawIngestRouteInventoryDto, profile_id: &str) -> std::option::Option<&'a crate::RawIngestProfileInventoryDto> {
    return inventory.profiles.iter().find(|profile| return profile.profile_id == profile_id);
}

fn assert_route(
    profile: &crate::RawIngestProfileInventoryDto,
    route_id: crate::RawIngestRouteId,
    selectable: bool,
    reason: std::option::Option<crate::RawIngestRouteUnavailableReason>,
) {
    let route = profile.routes.iter().find(|route| return route.route_id == route_id);
    assert!(route.is_some());
    if let std::option::Option::Some(route) = route {
        assert_eq!(route.selectable, selectable);
        assert_eq!(route.reason, reason);
        assert_eq!(route.state, if selectable { crate::RawIngestRouteState::Configured } else { crate::RawIngestRouteState::Unavailable });
    }
}