#![cfg(target_arch = "wasm32")]
use wasm_bindgen_test::*;
wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);

use evm_client::provider::{Transaction, parse_signature_rs_v, get_balance};
use ethers_core::types::{U256, Address, Bytes};
use hex;

#[wasm_bindgen_test]
fn test_rlp_encode_unsigned() {
    let tx = Transaction {
        nonce: U256::from(1),
        to: Address::zero(),
        value: U256::from(100),
        gas: U256::from(21000),
        gas_price: U256::from(1),
        data: Bytes::new(),
        chain_id: 1,
    };
    let rlp = tx.rlp_encode_unsigned();
    assert!(!rlp.is_empty());
}


#[wasm_bindgen_test(async)]
pub async fn test_get_balance_real_address_wasm_unique() {
    web_sys::console::log_1(&"WASM balance test running!".into());
    // Vitalik's address
    let address = "d8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
    let address = Address::from_slice(&hex::decode(address).unwrap());
    let url = "https://ethereum.blockpi.network/v1/rpc/public";
    let balance = get_balance(url, address).await.expect("Failed to get balance");
    web_sys::console::log_1(&format!("Balance: {balance:?}").into());
    assert!(balance > U256::zero(), "Vitalik's balance should be greater than zero");
}

#[wasm_bindgen_test(async)]
pub async fn test_vault_sessionmanager_balance_for_new_keypair_wasm() {
    use vault::{SessionManager, KeyType};
    use ethers_core::types::Address;
    use evm_client::provider::get_balance;
    use alloy_primitives::keccak256;
    web_sys::console::log_1(&"WASM vault-session balance test running!".into());
    let store = kvstore::wasm::WasmStore::open("test-db").await.expect("open");
    let mut vault = vault::Vault::new(store);
    let keyspace = "testspace-wasm";
    let password = b"testpass";
    // 1. Create keyspace
    vault.create_keyspace(keyspace, password, None).await.expect("create keyspace");
    // 2. Add secp256k1 keypair
    let key_id = vault.add_keypair(keyspace, password, Some(KeyType::Secp256k1), None).await.expect("add keypair");
    // 3. Create SessionManager and unlock keyspace
    let mut session = SessionManager::new(vault);
    session.unlock_keyspace(keyspace, password).await.expect("unlock keyspace");
    session.select_keyspace(keyspace).expect("select keyspace");
    session.select_keypair(&key_id).expect("select keypair");
    let kp = session.current_keypair().expect("current keypair");
    // 4. Derive Ethereum address from public key
    let pubkey = &kp.public_key;
    let pubkey = if pubkey.len() == 65 && pubkey[0] == 0x04 { &pubkey[1..] } else { pubkey.as_slice() };
    let hash = keccak256(pubkey);
    let address = Address::from_slice(&hash[12..]);
    // 5. Query balance
    let url = "https://ethereum.blockpi.network/v1/rpc/public";
    let balance = get_balance(url, address).await.expect("Failed to get balance");
    web_sys::console::log_1(&format!("Balance: {balance:?}").into());
    assert_eq!(balance, ethers_core::types::U256::zero(), "New keypair should have zero balance");
}

#[wasm_bindgen_test]
fn test_parse_signature_rs_v() {
    let mut sig = [0u8; 65];
    sig[31] = 1; sig[63] = 2; sig[64] = 27;
    let (r, s, v) = parse_signature_rs_v(&sig, 1).unwrap();
    assert_eq!(r, U256::from(1));
    assert_eq!(s, U256::from(2));
    assert_eq!(v, 27 + 1 * 2 + 8);
}