import pytest
import requests

from pyhmy import account

from pyhmy.rpc import exceptions


explorer_endpoint = "http://localhost:9700"
endpoint_shard_one = "http://localhost:9502"
local_test_address = "one155jp2y76nazx8uw5sa94fr0m4s5aj8e5xm6fu3"
test_validator_address = local_test_address
genesis_block_number = 0
test_block_number = 1
fake_shard = "http://example.com"


def _test_account_rpc(fn, *args, **kwargs):
    if not callable(fn):
        pytest.fail(f"Invalid function: {fn}")

    try:
        response = fn(*args, **kwargs)
    except Exception as e:
        if isinstance(
            e, exceptions.RPCError
        ) and "does not exist/is not available" in str(e):
            pytest.skip(f"{str(e)}")
        pytest.fail(f"Unexpected error: {e.__class__} {e}")
    return response


def test_get_balance(setup_blockchain):
    balance = _test_account_rpc(account.get_balance, local_test_address)
    assert isinstance(balance, int)
    assert balance > 0


def test_get_balance_by_block(setup_blockchain):
    balance = _test_account_rpc(
        account.get_balance_by_block, local_test_address, genesis_block_number
    )
    assert isinstance(balance, int)
    assert balance > 0


def test_get_account_nonce(setup_blockchain):
    true_nonce = _test_account_rpc(
        account.get_account_nonce,
        local_test_address,
        test_block_number,
        endpoint=endpoint_shard_one,
    )
    assert isinstance(true_nonce, int)


def test_get_transaction_history(setup_blockchain):
    tx_history = _test_account_rpc(
        account.get_transaction_history, local_test_address, endpoint=explorer_endpoint
    )
    assert isinstance(tx_history, list)
    assert len(tx_history) >= 0


def test_get_staking_transaction_history(setup_blockchain):
    staking_tx_history = _test_account_rpc(
        account.get_staking_transaction_history,
        test_validator_address,
        endpoint=explorer_endpoint,
    )
    assert isinstance(staking_tx_history, list)
    assert len(staking_tx_history) > 0


def test_get_balance_on_all_shards(setup_blockchain):
    balances = _test_account_rpc(account.get_balance_on_all_shards, local_test_address)
    assert isinstance(balances, list)
    assert len(balances) == 2


def test_get_total_balance(setup_blockchain):
    total_balance = _test_account_rpc(account.get_total_balance, local_test_address)
    assert isinstance(total_balance, int)
    assert total_balance > 0


def test_is_valid_address():
    assert account.is_valid_address("one1zksj3evekayy90xt4psrz8h6j2v3hla4qwz4ur")
    assert not account.is_valid_address("one1wje75aedczmj4dwjs0812xcg7vx0dy231cajk0")


def test_get_transaction_count(setup_blockchain):
    tx_count = _test_account_rpc(
        account.get_transaction_count, local_test_address, "latest", explorer_endpoint
    )
    assert isinstance(tx_count, int)
    assert tx_count > 0


def test_get_transactions_count(setup_blockchain):
    tx_count = _test_account_rpc(
        account.get_transactions_count, local_test_address, "ALL", explorer_endpoint
    )


def test_get_staking_transactions_count(setup_blockchain):
    tx_count = _test_account_rpc(
        account.get_staking_transactions_count,
        local_test_address,
        "ALL",
        explorer_endpoint,
    )
    assert isinstance(tx_count, int)


def test_errors():
    with pytest.raises(exceptions.RPCError):
        account.get_balance("", fake_shard)
    with pytest.raises(exceptions.RPCError):
        account.get_balance_by_block("", 1, fake_shard)
    with pytest.raises(exceptions.RPCError):
        account.get_account_nonce("", 1, fake_shard)
    with pytest.raises(exceptions.RPCError):
        account.get_transaction_count("", 1, fake_shard)
    with pytest.raises(exceptions.RPCError):
        account.get_transactions_count("", 1, fake_shard)
    with pytest.raises(exceptions.RPCError):
        account.get_transactions_count("", "ALL", fake_shard)
    with pytest.raises(exceptions.RPCError):
        account.get_transaction_history("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        account.get_staking_transaction_history("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        account.get_balance_on_all_shards("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        account.get_total_balance("", endpoint=fake_shard)