// file: crates/ksp-onchain-transport-lib/unit_tests/rpc_accounts.rs
// version: 4

#[test]
fn account_config_serializes_all_common_fields() {
    let config = crate::SolanaAccountInfoConfig::new(
        std::option::Option::Some(crate::SolanaAccountEncoding::Base64),
        std::option::Option::Some(crate::SolanaDataSliceConfig::new(8, 32)),
        std::option::Option::Some(crate::SolanaCommitment::Finalized),
        std::option::Option::Some(99),
    );
    assert_eq!(
        config.to_json_value(),
        serde_json::json!({"encoding":"base64","dataSlice":{"offset":8,"length":32},"commitment":"finalized","minContextSlot":99})
    );
}

#[test]
fn program_accounts_config_preserves_filter_variants_and_flags() {
    let filters = std::vec![
        crate::SolanaProgramAccountFilter::DataSize(165),
        crate::SolanaProgramAccountFilter::Memcmp(crate::SolanaMemcmpFilter::new(4, crate::SolanaMemcmpBytes::Base64("AQID".to_owned()))),
        crate::SolanaProgramAccountFilter::TokenAccountState,
    ];
    let config = crate::SolanaProgramAccountsConfig::new(
        crate::SolanaAccountInfoConfig::default(),
        filters,
        std::option::Option::Some(true),
        std::option::Option::Some(true),
    );
    assert_eq!(
        config.to_json_value(),
        serde_json::json!({
            "filters":[{"dataSize":165},{"memcmp":{"offset":4,"bytes":"AQID","encoding":"base64"}},"tokenAccountState"],
            "withContext":true,
            "sortResults":true
        })
    );
}

#[test]
fn account_wire_fixture_preserves_legacy_encoded_and_json_parsed_data() {
    let values: std::vec::Vec<serde_json::Value> =
        serde_json::from_str(include_str!("../fixtures/http/account_data.variants.json")).expect("fixture must decode");
    let legacy = crate::SolanaAccount::decode_wire("fixture", values[0].clone()).expect("legacy account must decode");
    assert!(matches!(legacy.data(), crate::SolanaAccountData::LegacyBinary(_)));
    assert_eq!(legacy.space(), std::option::Option::None);
    let encoded = crate::SolanaAccount::decode_wire("fixture", values[1].clone()).expect("encoded account must decode");
    assert!(matches!(encoded.data(), crate::SolanaAccountData::Encoded { encoding: crate::SolanaAccountEncoding::Base64Zstd, .. }));
    let parsed = crate::SolanaAccount::decode_wire("fixture", values[2].clone()).expect("parsed account must decode");
    assert!(matches!(parsed.data(), crate::SolanaAccountData::JsonParsed(_)), "jsonParsed fixture must retain parsed data");
    if let crate::SolanaAccountData::JsonParsed(value) = parsed.data() {
        assert_eq!(value.program(), "spl-token");
        assert_eq!(value.space(), 165);
        assert_eq!(value.parsed()["type"], serde_json::json!("account"));
    }
}

#[test]
fn staged_largest_and_keyed_account_helpers_match_wire_shapes() {
    let config = crate::SolanaLargestAccountsConfig::new(
        std::option::Option::Some(crate::SolanaCommitment::Finalized),
        std::option::Option::Some(crate::SolanaLargestAccountsFilter::NonCirculating),
        std::option::Option::Some(true),
    );
    assert_eq!(config.to_json_value(), serde_json::json!({"commitment":"finalized","filter":"nonCirculating","sortResults":true}));
    let keyed = crate::SolanaKeyedAccount::decode_wire(
        "fixture",
        serde_json::json!({
            "pubkey":"11111111111111111111111111111111",
            "account":{
                "lamports":42,
                "data":["", "base64"],
                "owner":"11111111111111111111111111111111",
                "executable":false,
                "rentEpoch":0,
                "space":0
            }
        }),
    )
    .expect("keyed account must decode");
    assert_eq!(keyed.pubkey().to_string(), "11111111111111111111111111111111");
    assert_eq!(keyed.account().lamports(), 42);
    let balance = crate::SolanaAccountBalance::decode_wire("fixture", serde_json::json!({"address":"11111111111111111111111111111111","lamports":99}))
        .expect("account balance must decode");
    assert_eq!(balance.address().to_string(), "11111111111111111111111111111111");
    assert_eq!(balance.lamports(), 99);
}

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");
}

fn fixture_pubkey(value: &str) -> ksp_core_lib::Pubkey {
    return value.parse::<ksp_core_lib::Pubkey>().expect("fixture pubkey must parse");
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_account_info_serializes_config_and_preserves_account_wire() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_account_info.success.json"));
    let pool = pool_for_url(url.as_str());
    let account = fixture_pubkey("11111111111111111111111111111111");
    let config = crate::SolanaAccountInfoConfig::new(
        std::option::Option::Some(crate::SolanaAccountEncoding::Base64),
        std::option::Option::Some(crate::SolanaDataSliceConfig::new(2, 4)),
        std::option::Option::Some(crate::SolanaCommitment::Finalized),
        std::option::Option::Some(400_000_000),
    );
    let response = pool
        .get_account_info(&crate::HttpRoleName::new("default"), &account, std::option::Option::Some(&config))
        .await
        .expect("getAccountInfo fixture must succeed");
    assert_eq!(response.context().slot(), 410_000_001);
    let returned = response.value().as_ref().expect("fixture account must be present");
    assert_eq!(returned.lamports(), 2_039_280);
    assert_eq!(returned.owner(), &account);
    assert_eq!(returned.space(), std::option::Option::Some(4));
    assert!(matches!(returned.data(), crate::SolanaAccountData::Encoded { encoding: crate::SolanaAccountEncoding::Base64, .. }));
    let request = handle.join().expect("fixture server must join");
    let body = request_body(request.as_str());
    assert_eq!(body["method"], serde_json::json!("getAccountInfo"));
    assert_eq!(body["params"][0], serde_json::json!(account.to_string()));
    assert_eq!(body["params"][1]["encoding"], serde_json::json!("base64"));
    assert_eq!(body["params"][1]["dataSlice"], serde_json::json!({"offset":2,"length":4}));
    assert_eq!(body["params"][1]["commitment"], serde_json::json!("finalized"));
    assert_eq!(body["params"][1]["minContextSlot"], serde_json::json!(400_000_000_u64));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_account_info_preserves_missing_account_as_none() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_account_info.null.json"));
    let pool = pool_for_url(url.as_str());
    let account = fixture_pubkey("11111111111111111111111111111111");
    let response = pool
        .get_account_info(&crate::HttpRoleName::new("default"), &account, std::option::Option::None)
        .await
        .expect("missing getAccountInfo fixture must succeed");
    assert_eq!(response.value(), &std::option::Option::None);
    let request = handle.join().expect("fixture server must join");
    assert_eq!(request_body(request.as_str())["params"].as_array().map(std::vec::Vec::len), std::option::Option::Some(1));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_account_info_rejects_invalid_owner_without_exposing_value() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_account_info.invalid_owner.json"));
    let pool = pool_for_url(url.as_str());
    let account = fixture_pubkey("11111111111111111111111111111111");
    let result = pool.get_account_info(&crate::HttpRoleName::new("default"), &account, std::option::Option::None).await;
    let error = result.expect_err("invalid account owner must fail typed decoding");
    assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RESPONSE);
    assert!(!format!("{error:?}").contains("not-a-pubkey"));
    handle.join().expect("fixture server must join");
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_largest_accounts_serializes_extended_config_and_decodes_order() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_largest_accounts.success.json"));
    let pool = pool_for_url(url.as_str());
    let config = crate::SolanaLargestAccountsConfig::new(
        std::option::Option::Some(crate::SolanaCommitment::Finalized),
        std::option::Option::Some(crate::SolanaLargestAccountsFilter::Circulating),
        std::option::Option::Some(true),
    );
    let response = pool
        .get_largest_accounts(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config))
        .await
        .expect("getLargestAccounts fixture must succeed");
    assert_eq!(response.value().len(), 2);
    assert_eq!(response.value()[0].lamports(), 999_999_999);
    assert_eq!(response.value()[1].lamports(), 888_888_888);
    let request = handle.join().expect("fixture server must join");
    let body = request_body(request.as_str());
    assert_eq!(body["method"], serde_json::json!("getLargestAccounts"));
    assert_eq!(body["params"][0], serde_json::json!({"commitment":"finalized","filter":"circulating","sortResults":true}));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_largest_accounts_rejects_invalid_address() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_largest_accounts.invalid_address.json"));
    let pool = pool_for_url(url.as_str());
    let result = pool.get_largest_accounts(&crate::HttpRoleName::new("default"), std::option::Option::None).await;
    let error = result.expect_err("invalid largest-account address must fail typed decoding");
    assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RESPONSE);
    assert!(!format!("{error:?}").contains("invalid-address"));
    handle.join().expect("fixture server must join");
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_minimum_balance_for_rent_exemption_serializes_length_and_commitment() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_minimum_balance_for_rent_exemption.success.json"));
    let pool = pool_for_url(url.as_str());
    let config = crate::SolanaCommitmentConfig::new(std::option::Option::Some(crate::SolanaCommitment::Processed));
    let result = pool
        .get_minimum_balance_for_rent_exemption(&crate::HttpRoleName::new("default"), 50, std::option::Option::Some(&config))
        .await
        .expect("rent-exemption fixture must succeed");
    assert_eq!(result, 890_880);
    let request = handle.join().expect("fixture server must join");
    let body = request_body(request.as_str());
    assert_eq!(body["method"], serde_json::json!("getMinimumBalanceForRentExemption"));
    assert_eq!(body["params"], serde_json::json!([50,{"commitment":"processed"}]));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_minimum_balance_for_rent_exemption_preserves_rpc_application_error() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_minimum_balance_for_rent_exemption.error.json"));
    let pool = pool_for_url(url.as_str());
    let result = pool.get_minimum_balance_for_rent_exemption(&crate::HttpRoleName::new("default"), usize::MAX, std::option::Option::None).await;
    let error = result.expect_err("remote invalid parameter must remain an RPC application error");
    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_multiple_accounts_preserves_order_nulls_and_config() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_multiple_accounts.success.json"));
    let pool = pool_for_url(url.as_str());
    let accounts = std::vec![
        fixture_pubkey("11111111111111111111111111111111"),
        fixture_pubkey("ComputeBudget111111111111111111111111111111"),
        fixture_pubkey("Stake11111111111111111111111111111111111111"),
    ];
    let config = crate::SolanaAccountInfoConfig::new(
        std::option::Option::Some(crate::SolanaAccountEncoding::JsonParsed),
        std::option::Option::None,
        std::option::Option::Some(crate::SolanaCommitment::Confirmed),
        std::option::Option::Some(400_000_001),
    );
    let response = pool
        .get_multiple_accounts(&crate::HttpRoleName::new("default"), accounts.as_slice(), std::option::Option::Some(&config))
        .await
        .expect("getMultipleAccounts fixture must succeed");
    assert_eq!(response.value().len(), 3);
    assert_eq!(response.value()[0].as_ref().map(crate::SolanaAccount::lamports), std::option::Option::Some(10));
    assert!(response.value()[1].is_none());
    assert_eq!(response.value()[2].as_ref().map(crate::SolanaAccount::lamports), std::option::Option::Some(20));
    assert!(matches!(response.value()[2].as_ref().map(crate::SolanaAccount::data), std::option::Option::Some(crate::SolanaAccountData::JsonParsed(_))));
    let request = handle.join().expect("fixture server must join");
    let body = request_body(request.as_str());
    assert_eq!(body["method"], serde_json::json!("getMultipleAccounts"));
    assert_eq!(body["params"][0], serde_json::json!(accounts.iter().map(std::string::ToString::to_string).collect::<std::vec::Vec<_>>()));
    assert_eq!(body["params"][1]["encoding"], serde_json::json!("jsonParsed"));
    assert_eq!(body["params"][1]["commitment"], serde_json::json!("confirmed"));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_multiple_accounts_rejects_more_than_100_before_io() {
    let pool = pool_for_url("http://127.0.0.1:9");
    let account = fixture_pubkey("11111111111111111111111111111111");
    let accounts = std::vec![account; 101];
    let result = pool.get_multiple_accounts(&crate::HttpRoleName::new("default"), accounts.as_slice(), std::option::Option::None).await;
    let error = result.expect_err("more than 100 accounts must be rejected locally");
    assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RPC_PARAMETERS);
    assert_eq!(error.context()[0].key(), "rpc_method");
    assert_eq!(error.context()[1].key(), "account_count");
    assert_eq!(error.context()[1].value(), "101");
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_program_accounts_serializes_filters_and_decodes_bare_result() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_program_accounts.bare.success.json"));
    let pool = pool_for_url(url.as_str());
    let program_id = fixture_pubkey("11111111111111111111111111111111");
    let filters = std::vec![
        crate::SolanaProgramAccountFilter::DataSize(3),
        crate::SolanaProgramAccountFilter::Memcmp(crate::SolanaMemcmpFilter::new(0, crate::SolanaMemcmpBytes::Base64("AQID".to_owned()))),
        crate::SolanaProgramAccountFilter::TokenAccountState,
    ];
    let account_config = crate::SolanaAccountInfoConfig::new(
        std::option::Option::Some(crate::SolanaAccountEncoding::Base64),
        std::option::Option::Some(crate::SolanaDataSliceConfig::new(0, 3)),
        std::option::Option::Some(crate::SolanaCommitment::Finalized),
        std::option::Option::Some(400_000_002),
    );
    let config = crate::SolanaProgramAccountsConfig::new(account_config, filters, std::option::Option::Some(false), std::option::Option::Some(true));
    let result = pool
        .get_program_accounts(&crate::HttpRoleName::new("default"), &program_id, std::option::Option::Some(&config))
        .await
        .expect("bare getProgramAccounts fixture must succeed");
    assert!(matches!(&result, crate::SolanaProgramAccountsResult::Accounts(_)), "bare fixture must preserve the bare account-list result");
    if let crate::SolanaProgramAccountsResult::Accounts(accounts) = result {
        assert_eq!(accounts.len(), 1);
        assert_eq!(accounts[0].account().lamports(), 42);
    }
    let request = handle.join().expect("fixture server must join");
    let body = request_body(request.as_str());
    assert_eq!(body["method"], serde_json::json!("getProgramAccounts"));
    assert_eq!(
        body["params"][1]["filters"],
        serde_json::json!([{"dataSize":3},{"memcmp":{"offset":0,"bytes":"AQID","encoding":"base64"}},"tokenAccountState"]),
    );
    assert_eq!(body["params"][1]["withContext"], serde_json::json!(false));
    assert_eq!(body["params"][1]["sortResults"], serde_json::json!(true));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_program_accounts_preserves_contextual_result() {
    let (url, handle) = serve_once(include_str!("../fixtures/http/get_program_accounts.context.success.json"));
    let pool = pool_for_url(url.as_str());
    let program_id = fixture_pubkey("11111111111111111111111111111111");
    let config = crate::SolanaProgramAccountsConfig::new(
        crate::SolanaAccountInfoConfig::default(),
        std::vec::Vec::new(),
        std::option::Option::Some(true),
        std::option::Option::None,
    );
    let result = pool
        .get_program_accounts(&crate::HttpRoleName::new("default"), &program_id, std::option::Option::Some(&config))
        .await
        .expect("contextual getProgramAccounts fixture must succeed");
    assert!(matches!(&result, crate::SolanaProgramAccountsResult::Context(_)), "contextual fixture must preserve RpcResponse wrapper");
    if let crate::SolanaProgramAccountsResult::Context(response) = result {
        assert_eq!(response.context().slot(), 410_000_007);
        assert_eq!(response.value().len(), 1);
    }
    let request = handle.join().expect("fixture server must join");
    assert_eq!(request_body(request.as_str())["params"][1]["withContext"], serde_json::json!(true));
}

#[tokio::test(flavor = "current_thread")]
async fn typed_get_program_accounts_rejects_filter_cardinality_and_oversized_raw_memcmp_before_io() {
    let pool = pool_for_url("http://127.0.0.1:9");
    let program_id = fixture_pubkey("11111111111111111111111111111111");
    let too_many = crate::SolanaProgramAccountsConfig::new(
        crate::SolanaAccountInfoConfig::default(),
        std::vec![
            crate::SolanaProgramAccountFilter::DataSize(1),
            crate::SolanaProgramAccountFilter::DataSize(2),
            crate::SolanaProgramAccountFilter::DataSize(3),
            crate::SolanaProgramAccountFilter::DataSize(4),
            crate::SolanaProgramAccountFilter::DataSize(5),
        ],
        std::option::Option::None,
        std::option::Option::None,
    );
    let result = pool.get_program_accounts(&crate::HttpRoleName::new("default"), &program_id, std::option::Option::Some(&too_many)).await;
    let error = result.expect_err("more than four program-account filters must be rejected locally");
    assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RPC_PARAMETERS);
    assert_eq!(error.context()[1].value(), "5");
    let oversized = crate::SolanaProgramAccountsConfig::new(
        crate::SolanaAccountInfoConfig::default(),
        std::vec![crate::SolanaProgramAccountFilter::Memcmp(crate::SolanaMemcmpFilter::new(0, crate::SolanaMemcmpBytes::Bytes(std::vec![0_u8; 129]),))],
        std::option::Option::None,
        std::option::Option::None,
    );
    let result = pool.get_program_accounts(&crate::HttpRoleName::new("default"), &program_id, std::option::Option::Some(&oversized)).await;
    let error = result.expect_err("raw memcmp data above 128 bytes must be rejected locally");
    assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RPC_PARAMETERS);
    assert_eq!(error.context()[1].value(), "129");
}

#[test]
fn typed_get_multiple_accounts_rejects_response_count_mismatch() {
    let value = serde_json::json!({
        "context":{"apiVersion":"4.2.1","slot":410000008},
        "value":[]
    });
    let result = super::decode_multiple_accounts_response("getMultipleAccounts", value, 1);
    let error = result.expect_err("response count mismatch must fail typed decoding");
    assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RESPONSE);
    assert_eq!(error.context()[1].key(), "expected_count");
    assert_eq!(error.context()[1].value(), "1");
    assert_eq!(error.context()[2].key(), "actual_count");
    assert_eq!(error.context()[2].value(), "0");
}