// file: crates/ksp-onchain-transport-lib/unit_tests/rpc_economics.rs
// version: 2

#[test]
fn inflation_reward_config_preserves_epoch_commitment_and_min_context_slot() {
    let config = crate::SolanaInflationRewardConfig::new(
        std::option::Option::Some(811),
        std::option::Option::Some(crate::SolanaCommitment::Finalized),
        std::option::Option::Some(429_000_000),
    );
    assert_eq!(config.epoch(), std::option::Option::Some(811));
    assert_eq!(config.commitment(), std::option::Option::Some(crate::SolanaCommitment::Finalized));
    assert_eq!(config.min_context_slot(), std::option::Option::Some(429_000_000));
    assert_eq!(config.to_json_value(), serde_json::json!({"epoch":811,"commitment":"finalized","minContextSlot":429000000}));
    assert!(crate::SolanaInflationRewardConfig::default().is_empty());
}

#[test]
fn supply_config_distinguishes_omitted_from_explicit_false() {
    let omitted = crate::SolanaSupplyConfig::default();
    let explicit_false = crate::SolanaSupplyConfig::new(std::option::Option::Some(crate::SolanaCommitment::Confirmed), std::option::Option::Some(false));
    assert!(omitted.is_empty());
    assert_eq!(omitted.to_json_value(), serde_json::json!({}));
    assert_eq!(explicit_false.exclude_non_circulating_accounts_list(), std::option::Option::Some(false));
    assert_eq!(explicit_false.to_json_value(), serde_json::json!({"commitment":"confirmed","excludeNonCirculatingAccountsList":false}));
}

#[test]
fn inflation_governor_and_rate_fixtures_preserve_runtime_values() {
    let governor_value = serde_json::from_str::<serde_json::Value>(include_str!("../fixtures/http/inflation_governor.v4_2_1.json"))
        .expect("inflation governor fixture must decode");
    let rate_value =
        serde_json::from_str::<serde_json::Value>(include_str!("../fixtures/http/inflation_rate.v4_2_1.json")).expect("inflation rate fixture must decode");
    let governor = crate::SolanaInflationGovernor::decode_wire("getInflationGovernor", governor_value).expect("inflation governor must decode");
    let rate = crate::SolanaInflationRate::decode_wire("getInflationRate", rate_value).expect("inflation rate must decode");
    assert_eq!(governor.initial(), 0.08);
    assert_eq!(governor.terminal(), 0.015);
    assert_eq!(governor.taper(), 0.15);
    assert_eq!(governor.foundation(), 0.05);
    assert_eq!(governor.foundation_term(), 7.0);
    assert_eq!(rate.total(), 0.042);
    assert_eq!(rate.validator(), 0.041);
    assert_eq!(rate.foundation(), 0.001);
    assert_eq!(rate.epoch(), 812);
}

#[test]
fn inflation_reward_fixture_preserves_position_null_and_commission_bps_states() {
    let values = serde_json::from_str::<std::vec::Vec<serde_json::Value>>(include_str!("../fixtures/http/inflation_reward.variants.json"))
        .expect("inflation reward fixtures must decode");
    let first = crate::SolanaInflationReward::decode_wire("getInflationReward", values[0].clone()).expect("first reward must decode");
    let third = crate::SolanaInflationReward::decode_wire("getInflationReward", values[2].clone()).expect("third reward must decode");
    assert_eq!(values.len(), 3);
    assert!(values[1].is_null());
    assert_eq!(first.epoch(), 811);
    assert_eq!(first.effective_slot(), 429_900_000);
    assert_eq!(first.amount(), 2_500_000);
    assert_eq!(first.post_balance(), 1_002_500_000);
    assert_eq!(first.commission(), std::option::Option::Some(7));
    assert_eq!(first.commission_bps().value(), std::option::Option::Some(&725));
    assert_eq!(third.commission(), std::option::Option::None);
    assert!(third.commission_bps().is_omitted());
}

#[test]
fn supply_fixture_types_non_circulating_accounts_and_preserves_order() {
    let value = serde_json::from_str::<serde_json::Value>(include_str!("../fixtures/http/supply.v4_2_1.json")).expect("supply fixture must decode");
    let supply = crate::SolanaSupply::decode_wire("getSupply", value).expect("supply must decode");
    assert_eq!(supply.total(), 600_000_000_000_000_000);
    assert_eq!(supply.circulating(), 500_000_000_000_000_000);
    assert_eq!(supply.non_circulating(), 100_000_000_000_000_000);
    assert_eq!(supply.non_circulating_accounts().len(), 2);
    assert_eq!(supply.non_circulating_accounts()[0].to_string(), "11111111111111111111111111111111");
    assert_eq!(supply.non_circulating_accounts()[1].to_string(), "Vote111111111111111111111111111111111111111");
}

#[test]
fn supply_rejects_invalid_non_circulating_pubkey_without_echoing_value() {
    let result = crate::SolanaSupply::decode_wire(
        "getSupply",
        serde_json::json!({"total":3,"circulating":2,"nonCirculating":1,"nonCirculatingAccounts":["invalid-pubkey"]}),
    );
    let error = result.expect_err("invalid supply pubkey must fail closed");
    assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RESPONSE);
    assert!(!error.to_string().contains("invalid-pubkey"));
}

fn pool_for_url(url: &str) -> crate::HttpTransportPool {
    let role = crate::HttpEndpointRoleSettings::new(
        crate::HttpRoleName::new("default"),
        true,
        std::vec![crate::HttpRequestKind::wildcard()],
        10,
        crate::HttpRoleLimits::new(std::option::Option::None, std::option::Option::None, std::option::Option::None, std::option::Option::None),
    );
    let endpoint = crate::HttpEndpointSettings::new(
        "fixture",
        true,
        crate::HttpProviderName::new("fixture"),
        crate::HttpClusterName::new("local"),
        crate::HttpEndpointUrl::parse(url).expect("fixture URL must parse"),
        std::time::Duration::from_secs(1),
        std::time::Duration::from_secs(1),
        std::option::Option::Some(1),
        std::vec![role],
    );
    let settings = crate::HttpTransportSettings::new(
        std::vec![endpoint],
        crate::HttpRetrySettings::new(0, std::time::Duration::from_millis(1), std::time::Duration::from_millis(1)),
    );
    return crate::HttpTransportPool::new(settings).expect("fixture pool must build");
}

fn serve_once(body: &'static str) -> (std::string::String, std::thread::JoinHandle<std::string::String>) {
    let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("fixture listener must bind");
    let address = listener.local_addr().expect("fixture listener address must resolve");
    let handle = std::thread::spawn(move || {
        let (mut stream, _) = listener.accept().expect("fixture server must accept one request");
        let request = read_request(&mut stream);
        let response = format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", body.len(), body);
        std::io::Write::write_all(&mut stream, response.as_bytes()).expect("fixture response must write");
        return request;
    });
    return (format!("http://{address}"), handle);
}

fn read_request(stream: &mut std::net::TcpStream) -> std::string::String {
    let mut bytes = std::vec::Vec::new();
    let mut buffer = [0_u8; 1024];
    loop {
        let count = std::io::Read::read(stream, &mut buffer).expect("fixture request must read");
        if count == 0 {
            break;
        }
        bytes.extend_from_slice(&buffer[..count]);
        if request_complete(bytes.as_slice()) {
            break;
        }
    }
    return std::string::String::from_utf8(bytes).expect("fixture request must be UTF-8");
}

fn request_complete(bytes: &[u8]) -> bool {
    let text = match std::str::from_utf8(bytes) {
        std::result::Result::Ok(text) => text,
        std::result::Result::Err(_) => return false,
    };
    let header_end = match text.find("\r\n\r\n") {
        std::option::Option::Some(value) => value,
        std::option::Option::None => return false,
    };
    let mut content_length = 0_usize;
    for line in text[..header_end].lines() {
        let (name, value) = match line.split_once(':') {
            std::option::Option::Some(parts) => parts,
            std::option::Option::None => continue,
        };
        if name.eq_ignore_ascii_case("content-length") {
            content_length = value.trim().parse::<usize>().expect("content length must parse");
        }
    }
    return bytes.len() >= header_end.saturating_add(4).saturating_add(content_length);
}

fn request_body(request: &str) -> serde_json::Value {
    let body = request.split("\r\n\r\n").nth(1).expect("fixture request body must exist");
    return serde_json::from_str(body).expect("fixture request body must be JSON");
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_inflation_governor_serializes_processed_commitment_and_preserves_runtime_values() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_governor.success.json"));
    let pool = pool_for_url(url.as_str());
    let config = crate::SolanaCommitmentConfig::new(std::option::Option::Some(crate::SolanaCommitment::Processed));
    let governor = pool
        .get_inflation_governor(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config))
        .await
        .expect("inflation governor fixture must succeed");
    assert_eq!(governor.initial(), 0.07123456789);
    assert_eq!(governor.terminal(), 0.0123456789);
    assert_eq!(governor.taper(), 0.2718281828);
    assert_eq!(governor.foundation(), 0.0042);
    assert_eq!(governor.foundation_term(), 6.25);
    let request = handle.join().expect("fixture server must join");
    let body = request_body(request.as_str());
    assert_eq!(body["method"], serde_json::json!("getInflationGovernor"));
    assert_eq!(body["params"], serde_json::json!([{"commitment":"processed"}]));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_inflation_governor_omits_absent_and_empty_config() {
    let role = crate::HttpRoleName::new("default");
    let empty = crate::SolanaCommitmentConfig::default();
    for config in [std::option::Option::None, std::option::Option::Some(&empty)] {
        let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_governor.success.json"));
        let pool = pool_for_url(url.as_str());
        pool.get_inflation_governor(&role, config).await.expect("inflation governor fixture must succeed");
        let request = handle.join().expect("fixture server must join");
        assert_eq!(request_body(request.as_str())["params"], serde_json::json!([]));
    }
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_inflation_rate_has_no_params_and_preserves_runtime_values() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_rate.success.json"));
    let pool = pool_for_url(url.as_str());
    let rate = pool.get_inflation_rate(&crate::HttpRoleName::new("default")).await.expect("inflation rate fixture must succeed");
    assert_eq!(rate.total(), 0.0387654321);
    assert_eq!(rate.validator(), 0.037654321);
    assert_eq!(rate.foundation(), 0.0011111111);
    assert_eq!(rate.epoch(), 913);
    let request = handle.join().expect("fixture server must join");
    let body = request_body(request.as_str());
    assert_eq!(body["method"], serde_json::json!("getInflationRate"));
    assert_eq!(body["params"], serde_json::json!([]));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_stake_minimum_delegation_preserves_context_and_runtime_value_without_local_minimum() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_stake_minimum_delegation.success.json"));
    let pool = pool_for_url(url.as_str());
    let config = crate::SolanaContextConfig::new(std::option::Option::Some(crate::SolanaCommitment::Processed), std::option::Option::Some(431_000_000));
    let result = pool
        .get_stake_minimum_delegation(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config))
        .await
        .expect("stake minimum delegation fixture must succeed");
    assert_eq!(*result.value(), 42_424_242);
    assert_eq!(result.context().slot(), 431_000_123);
    assert_eq!(result.context().api_version(), std::option::Option::Some("4.2.1"));
    let request = handle.join().expect("fixture server must join");
    assert_eq!(request_body(request.as_str())["params"], serde_json::json!([{"commitment":"processed","minContextSlot":431000000}]));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_stake_minimum_delegation_omits_absent_and_empty_config() {
    let role = crate::HttpRoleName::new("default");
    let empty = crate::SolanaContextConfig::default();
    for config in [std::option::Option::None, std::option::Option::Some(&empty)] {
        let (url, handle) = serve_once(include_str!("../fixtures/http/get_stake_minimum_delegation.success.json"));
        let pool = pool_for_url(url.as_str());
        pool.get_stake_minimum_delegation(&role, config).await.expect("stake minimum delegation fixture must succeed");
        let request = handle.join().expect("fixture server must join");
        assert_eq!(request_body(request.as_str())["params"], serde_json::json!([]));
    }
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_supply_preserves_explicit_false_full_account_list_and_context() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_supply.success.json"));
    let pool = pool_for_url(url.as_str());
    let config = crate::SolanaSupplyConfig::new(std::option::Option::Some(crate::SolanaCommitment::Processed), std::option::Option::Some(false));
    let result = pool.get_supply(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config)).await.expect("supply fixture must succeed");
    assert_eq!(result.context().slot(), 431_000_124);
    assert_eq!(result.value().total(), 610_000_000_000_000_000);
    assert_eq!(result.value().circulating(), 510_000_000_000_000_000);
    assert_eq!(result.value().non_circulating(), 100_000_000_000_000_000);
    assert_eq!(result.value().non_circulating_accounts().len(), 2);
    let request = handle.join().expect("fixture server must join");
    assert_eq!(request_body(request.as_str())["params"], serde_json::json!([{"commitment":"processed","excludeNonCirculatingAccountsList":false}]));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_supply_preserves_explicit_true_as_empty_runtime_account_list() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_supply.excluded.success.json"));
    let pool = pool_for_url(url.as_str());
    let config = crate::SolanaSupplyConfig::new(std::option::Option::None, std::option::Option::Some(true));
    let result = pool
        .get_supply(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config))
        .await
        .expect("excluded supply fixture must succeed");
    assert_eq!(result.value().non_circulating_accounts(), &[]);
    assert_eq!(result.value().non_circulating(), 100_000_000_000_000_000);
    let request = handle.join().expect("fixture server must join");
    assert_eq!(request_body(request.as_str())["params"], serde_json::json!([{"excludeNonCirculatingAccountsList":true}]));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_supply_omits_absent_and_empty_config() {
    let role = crate::HttpRoleName::new("default");
    let empty = crate::SolanaSupplyConfig::default();
    for config in [std::option::Option::None, std::option::Option::Some(&empty)] {
        let (url, handle) = serve_once(include_str!("../fixtures/http/get_supply.success.json"));
        let pool = pool_for_url(url.as_str());
        pool.get_supply(&role, config).await.expect("supply fixture must succeed");
        let request = handle.join().expect("fixture server must join");
        assert_eq!(request_body(request.as_str())["params"], serde_json::json!([]));
    }
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_stake_minimum_delegation_preserves_min_context_slot_rpc_error() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_stake_minimum_delegation.error_min_context.json"));
    let pool = pool_for_url(url.as_str());
    let config = crate::SolanaContextConfig::new(std::option::Option::None, std::option::Option::Some(431_000_000));
    let result = pool.get_stake_minimum_delegation(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config)).await;
    let error = result.expect_err("min-context-slot RPC error must propagate");
    assert_eq!(error.code(), crate::ERROR_CODE_RPC_APPLICATION_ERROR);
    handle.join().expect("fixture server must join");
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_supply_preserves_scan_rpc_error() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_supply.error_scan.json"));
    let pool = pool_for_url(url.as_str());
    let result = pool.get_supply(&crate::HttpRoleName::new("default"), std::option::Option::None).await;
    let error = result.expect_err("supply scan RPC error must propagate");
    assert_eq!(error.code(), crate::ERROR_CODE_RPC_APPLICATION_ERROR);
    handle.join().expect("fixture server must join");
}