import pytest

from pyhmy import transaction

from pyhmy.rpc import exceptions


endpoint = "http://localhost:9500"
endpoint_shard_one = "http://localhost:9502"
fake_shard = "http://example.com"

# previously sent txs to get and check
tx_hash = "0xc26be5776aa57438bccf196671a2d34f3f22c9c983c0f844c62b2fb90403aa43"
tx_block_num = None
tx_block_hash = None
tx_index = None

cx_hash = "0xf73ba634cb96fc0e3e2c9d3b4c91379e223741be4a5aa56e6d6caf49c1ae75cf"

stx_hash = "0xc8177ace2049d9f4eb4a45fd6bd6b16f693573d036322c36774cc00d05a3e24f"
stx_block_num = None
stx_block_hash = None
stx_index = None

# new txs to send and check
raw_tx = "0xf86f0385174876e800825208808094c9c6d47ee5f2e3e08d7367ad1a1373ba9dd172418905b12aefafa80400008027a07a4952b90bf38723a9197179a8e6d2e9b3a86fd6da4e66a9cf09fdc59783f757a053910798b311245525bd77d6119332458c2855102e4fb9e564f6a3b710d18bb0"
raw_tx_hash = "0x7ccd80f8513f76ec58b357c7a82a12a95e025d88f1444e953f90e3d86e222571"

raw_stx = "0xf88302f494c9c6d47ee5f2e3e08d7367ad1a1373ba9dd1724194a5241513da9f4463f1d4874b548dfbac29d91f3489056bc75e2d631000008085174876e80082c35027a0808ea7d27adf3b1f561e8da4676814084bb75ac541b616bece87c6446e6cc54ea02f19f0b14240354bd42ad60b0c7189873c0be87044e13072b0981a837ca76f64"
raw_stx_hash = "0xe7d07ef6d9fca595a14ceb0ca917bece7bedb15efe662300e9334a32ac1da629"


def _test_transaction_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_pending_transactions(setup_blockchain):
    pool = _test_transaction_rpc(transaction.get_pending_transactions)
    assert isinstance(pool, list)


def test_get_transaction_by_hash(setup_blockchain):
    tx = _test_transaction_rpc(
        transaction.get_transaction_by_hash, tx_hash, endpoint=endpoint
    )
    assert tx
    assert isinstance(tx, dict)
    assert "blockNumber" in tx.keys()
    assert "blockHash" in tx.keys()
    global tx_block_num
    tx_block_num = int(tx["blockNumber"])
    global tx_block_hash
    tx_block_hash = tx["blockHash"]
    global tx_index
    tx_index = int(tx["transactionIndex"])


def test_get_transaction_by_block_hash_and_index(setup_blockchain):
    if not tx_block_hash:
        pytest.skip("Failed to get reference block hash")
    tx = _test_transaction_rpc(
        transaction.get_transaction_by_block_hash_and_index,
        tx_block_hash,
        tx_index,
        endpoint=endpoint,
    )
    assert tx
    assert isinstance(tx, dict)


def test_get_transaction_by_block_number_and_index(setup_blockchain):
    if not tx_block_num:
        pytest.skip("Failed to get reference block num")
    tx = _test_transaction_rpc(
        transaction.get_transaction_by_block_number_and_index,
        tx_block_num,
        tx_index,
        endpoint=endpoint,
    )
    assert tx
    assert isinstance(tx, dict)


def test_get_transaction_receipt(setup_blockchain):
    tx_receipt = _test_transaction_rpc(
        transaction.get_transaction_receipt, tx_hash, endpoint=endpoint
    )
    assert tx_receipt
    assert isinstance(tx_receipt, dict)


def test_get_transaction_error_sink(setup_blockchain):
    errors = _test_transaction_rpc(transaction.get_transaction_error_sink)
    assert isinstance(errors, list)


def test_send_and_confirm_raw_transaction(setup_blockchain):
    # Note: this test is not yet idempotent since the localnet will reject transactions which were previously finalized.
    test_tx = _test_transaction_rpc(
        transaction.send_and_confirm_raw_transaction, raw_tx
    )
    assert isinstance(test_tx, dict)
    assert test_tx["hash"] == raw_tx_hash


def test_get_pending_cx_receipts(setup_blockchain):
    pending = _test_transaction_rpc(transaction.get_pending_cx_receipts)
    assert isinstance(pending, list)


def test_get_cx_receipt_by_hash(setup_blockchain):
    cx = _test_transaction_rpc(
        transaction.get_cx_receipt_by_hash, cx_hash, endpoint_shard_one
    )
    assert cx
    assert isinstance(cx, dict)


def test_resend_cx_receipt(setup_blockchain):
    sent = _test_transaction_rpc(transaction.resend_cx_receipt, cx_hash)
    assert isinstance(sent, bool)
    assert sent


def test_get_staking_transaction_by_hash(setup_blockchain):
    staking_tx = _test_transaction_rpc(
        transaction.get_staking_transaction_by_hash, stx_hash
    )
    assert staking_tx
    assert isinstance(staking_tx, dict)
    assert "blockNumber" in staking_tx.keys()
    assert "blockHash" in staking_tx.keys()
    global stx_block_num
    stx_block_num = int(staking_tx["blockNumber"])
    global stx_block_hash
    stx_block_hash = staking_tx["blockHash"]
    global stx_index
    stx_index = int(staking_tx["transactionIndex"])


def test_get_transaction_by_block_hash_and_index(setup_blockchain):
    if not stx_block_hash:
        pytest.skip("Failed to get reference block hash")
    stx = _test_transaction_rpc(
        transaction.get_staking_transaction_by_block_hash_and_index,
        stx_block_hash,
        stx_index,
    )
    assert stx
    assert isinstance(stx, dict)


def test_get_transaction_by_block_number_and_index(setup_blockchain):
    if not stx_block_num:
        pytest.skip("Failed to get reference block num")
    stx = _test_transaction_rpc(
        transaction.get_staking_transaction_by_block_number_and_index,
        stx_block_num,
        stx_index,
    )
    assert stx
    assert isinstance(stx, dict)


def test_get_staking_transaction_error_sink(setup_blockchain):
    errors = _test_transaction_rpc(transaction.get_staking_transaction_error_sink)
    assert isinstance(errors, list)


def test_send_raw_staking_transaction(setup_blockchain):
    test_stx = _test_transaction_rpc(
        transaction.send_and_confirm_raw_staking_transaction, raw_stx, endpoint=endpoint
    )
    assert isinstance(test_stx, dict)
    assert test_stx["hash"] == raw_stx_hash


def test_get_pool_stats(setup_blockchain):
    test_pool_stats = _test_transaction_rpc(
        transaction.get_pool_stats, endpoint=endpoint
    )
    assert isinstance(test_pool_stats, dict)


def test_get_pending_staking_transactions(setup_blockchain):
    pending_staking_transactions = _test_transaction_rpc(
        transaction.get_pending_staking_transactions, endpoint=endpoint
    )
    assert isinstance(pending_staking_transactions, list)


def test_errors():
    with pytest.raises(exceptions.RPCError):
        transaction.get_pending_transactions(fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_transaction_error_sink(fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_pool_stats(fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_transaction_by_hash("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_transaction_by_block_hash_and_index("", 1, endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_transaction_by_block_number_and_index(1, 1, endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_transaction_receipt("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.send_raw_transaction("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_pending_cx_receipts(fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_cx_receipt_by_hash("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.resend_cx_receipt("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_staking_transaction_by_hash("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_staking_transaction_by_block_hash_and_index(
            "", 1, endpoint=fake_shard
        )
    with pytest.raises(exceptions.RPCError):
        transaction.get_staking_transaction_by_block_number_and_index(
            1, 1, endpoint=fake_shard
        )
    with pytest.raises(exceptions.RPCError):
        transaction.get_staking_transaction_error_sink(endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.send_raw_staking_transaction("", endpoint=fake_shard)
    with pytest.raises(exceptions.RPCError):
        transaction.get_pending_staking_transactions(endpoint=fake_shard)