// file: crates/ksp-worker-raw-transaction-ingest-lib/unit_tests/settings.rs
// version: 2

fn identities() -> std::option::Option<(ksp_store_lib::RawNetworkId, ksp_worker_api::WorkerId)> {
    let network_result = ksp_store_lib::RawNetworkId::new("mainnet");
    assert!(network_result.is_ok());
    let network = match network_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    let worker_id_result = ksp_worker_api::WorkerId::new("raw-ingest-mainnet-001");
    assert!(worker_id_result.is_ok());
    let worker_id = match worker_id_result {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return std::option::Option::None,
    };
    return std::option::Option::Some((network, worker_id));
}

#[test]
fn pre_003_defaults_are_exact_and_preserve_typed_identity() {
    let (network, worker_id) = match identities() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let settings = crate::RawTransactionIngestSettings::with_defaults(network.clone(), worker_id.clone());
    assert_eq!(settings.network(), &network);
    assert_eq!(settings.worker_id(), &worker_id);
    assert_eq!(settings.admission_queue_capacity(), 256);
    assert_eq!(settings.persistence_concurrency(), 8);
    assert_eq!(settings.shutdown_drain_timeout(), std::time::Duration::from_secs(5));
    assert_eq!(crate::DEFAULT_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY, 256);
    assert_eq!(crate::DEFAULT_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY, 8);
    assert_eq!(crate::DEFAULT_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT, std::time::Duration::from_secs(5));
    return;
}

#[test]
fn pre_003_inclusive_bounds_accept_exact_minimum_and_maximum() {
    for (queue, concurrency, drain) in [
        (
            crate::MIN_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY,
            crate::MIN_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY,
            crate::MIN_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT,
        ),
        (
            crate::MAX_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY,
            crate::MAX_RAW_TRANSACTION_INGEST_PERSISTENCE_CONCURRENCY,
            crate::MAX_RAW_TRANSACTION_INGEST_SHUTDOWN_DRAIN_TIMEOUT,
        ),
    ] {
        let (network, worker_id) = match identities() {
            std::option::Option::Some(value) => value,
            std::option::Option::None => return,
        };
        let settings = crate::RawTransactionIngestSettings::new(network, worker_id, queue, concurrency, drain);
        assert!(settings.is_ok());
    }
    return;
}

#[test]
fn pre_003_invalid_runtime_bounds_return_stable_field_scoped_error() {
    let invalid = [
        (0, 8, std::time::Duration::from_secs(5), "admission_queue_capacity"),
        (65_537, 8, std::time::Duration::from_secs(5), "admission_queue_capacity"),
        (256, 0, std::time::Duration::from_secs(5), "persistence_concurrency"),
        (256, 65, std::time::Duration::from_secs(5), "persistence_concurrency"),
        (256, 8, std::time::Duration::from_millis(99), "shutdown_drain_timeout"),
        (256, 8, std::time::Duration::from_millis(30_001), "shutdown_drain_timeout"),
    ];
    for (queue, concurrency, drain, field) in invalid {
        let (network, worker_id) = match identities() {
            std::option::Option::Some(value) => value,
            std::option::Option::None => return,
        };
        let result = crate::RawTransactionIngestSettings::new(network, worker_id, queue, concurrency, drain);
        assert!(result.is_err());
        let error = match result {
            std::result::Result::Ok(_) => continue,
            std::result::Result::Err(value) => value,
        };
        assert_eq!(error.code(), crate::ERROR_CODE_RAW_TRANSACTION_INGEST_SETTINGS_INVALID);
        assert_eq!(error.code().domain(), "worker_raw_transaction_ingest");
        assert_eq!(error.code().code(), "settings_invalid");
        assert_eq!(error.context().len(), 1);
        assert_eq!(error.context()[0].key(), "field");
        assert_eq!(error.context()[0].value(), field);
    }
    return;
}

#[test]
fn pre_003_debug_keeps_worker_identity_redacted() {
    let (network, worker_id) = match identities() {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return,
    };
    let settings = crate::RawTransactionIngestSettings::with_defaults(network, worker_id);
    let rendered = std::format!("{settings:?}");
    assert!(rendered.contains("mainnet"));
    assert!(rendered.contains("WorkerId(..)"));
    assert!(!rendered.contains("raw-ingest-mainnet-001"));
    return;
}