// file: crates/ksp-app-config-desk/unit_tests/environment.rs
// version: 4

#[test]
fn namespace_projection_distinguishes_ksp_and_kspb_sensitivity_families() {
    assert_eq!(super::namespace_label("KSP_LOGS_DIRECTORY"), "KSP");
    assert_eq!(super::namespace_label("KSP_PUBLIC_RPC_URL"), "KSP_PUBLIC");
    assert_eq!(super::namespace_label("KSP_SECRET_API_KEY"), "KSP_SECRET");
    assert_eq!(super::namespace_label("KSPB_WORKER_MODE"), "KSPB");
    assert_eq!(super::namespace_label("KSPB_PUBLIC_ENDPOINT"), "KSPB_PUBLIC");
    assert_eq!(super::namespace_label("KSPB_SECRET_TOKEN"), "KSPB_SECRET");
}

#[test]
fn environment_labels_cover_config_sources_and_sensitivities() {
    assert_eq!(super::environment_source_label(std::option::Option::Some(ksp_config_lib::ConfigEnvironmentSource::Process)), "process");
    assert_eq!(super::environment_source_label(std::option::Option::Some(ksp_config_lib::ConfigEnvironmentSource::DotEnv)), "dotenv");
    assert_eq!(super::environment_source_label(std::option::Option::Some(ksp_config_lib::ConfigEnvironmentSource::Fallback)), "fallback");
    assert_eq!(super::environment_source_label(std::option::Option::None), "none");
    assert_eq!(super::sensitivity_label(ksp_config_lib::ConfigSensitivity::Public), "public");
    assert_eq!(super::sensitivity_label(ksp_config_lib::ConfigSensitivity::Internal), "internal");
    assert_eq!(super::sensitivity_label(ksp_config_lib::ConfigSensitivity::Secret), "secret");
}

#[test]
fn mutation_sensitivity_is_owned_by_config_namespace_rules() {
    let public = super::mutation_sensitivity("KSP_PUBLIC_TEST_VALUE");
    assert!(public.is_ok());
    if let std::result::Result::Ok(value) = public {
        assert_eq!(value, ksp_config_lib::ConfigSensitivity::Public);
    }
    let secret = super::mutation_sensitivity("KSP_SECRET_TEST_VALUE");
    assert!(secret.is_ok());
    if let std::result::Result::Ok(value) = secret {
        assert_eq!(value, ksp_config_lib::ConfigSensitivity::Secret);
    }
    let internal = super::mutation_sensitivity("KSPB_TEST_VALUE");
    assert!(internal.is_ok());
    if let std::result::Result::Ok(value) = internal {
        assert_eq!(value, ksp_config_lib::ConfigSensitivity::Internal);
    }
    assert!(super::mutation_sensitivity("EXTERNAL_TEST_VALUE").is_err());
}

#[test]
fn mutation_operation_labels_are_stable() {
    assert_eq!(super::EnvironmentMutationOperation::Set.label(), "set");
    assert_eq!(super::EnvironmentMutationOperation::Remove.label(), "remove");
}

#[test]
fn committed_environment_report_is_safe_and_deterministic_when_present() {
    let management = committed_management();
    assert!(management.is_ok(), "committed management should construct: {management:?}");
    if let std::result::Result::Ok(management) = management {
        let report = super::report_from_management(&management);
        assert!(report.is_ok(), "environment report should project safely: {report:?}");
        if let std::result::Result::Ok(report) = report {
            let mut previous = std::option::Option::<&str>::None;
            for entry in &report {
                if let std::option::Option::Some(previous) = previous {
                    assert!(previous <= entry.variable_name.as_str());
                }
                if entry.sensitivity == "secret" {
                    if let std::option::Option::Some(value) = entry.desired_safe_value.as_deref() {
                        assert_eq!(value, ksp_config_lib::REDACTED_CONFIG_VALUE);
                    }
                    if let std::option::Option::Some(value) = entry.effective_safe_value.as_deref() {
                        assert_eq!(value, ksp_config_lib::REDACTED_CONFIG_VALUE);
                    }
                }
                previous = std::option::Option::Some(entry.variable_name.as_str());
            }
        }
    }
}

fn committed_management() -> ksp_core_lib::Result<ksp_config_lib::ConfigManagement> {
    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();
    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)));
}