import base58
import requests
import ecdsa
from bitcoin import *
import hashlib

def decode_wif(wif):
    b = base58.b58decode(wif)
    if len(b) == 38 and b[-5] == 0x01:
        return b[1:-5], True  # compressed
    elif len(b) == 37:
        return b[1:-1], False  # uncompressed
    raise ValueError("Invalid WIF format")

def get_pubkey(priv_bytes, compressed=True):
    sk = ecdsa.SigningKey.from_string(priv_bytes, curve=ecdsa.SECP256k1)
    vk = sk.get_verifying_key()
    x = vk.pubkey.point.x()
    y = vk.pubkey.point.y()
    return ('02' if y % 2 == 0 else '03') + f"{x:064x}"  # Always compressed

def get_address(pubkey):
    pubkey_bytes = bytes.fromhex(pubkey)
    pubkey_hash = hash160(pubkey_bytes)
    return pubkey_to_address(pubkey)  # Always compressed P2PKH

def is_legacy_address(address):
    return address.startswith('1')

def fetch_utxos(address):
    if not is_legacy_address(address):
        raise ValueError("Only legacy addresses (starting with '1') are supported")
    
    try:
        url = f"https://mempool.space/api/address/{address}/utxo"
        r = requests.get(url)
        r.raise_for_status()
        return r.json()
    except Exception as e:
        print("Failed to fetch UTXOs:", e)
        return []

def estimate_fee(num_inputs, num_outputs, fee_rate):
    # Legacy transaction size estimation with compressed pubkeys
    input_size = 148  # Standard for P2PKH with compressed pubkey
    output_size = 34   # P2PKH output size
    total_size = 10 + num_inputs * input_size + num_outputs * output_size
    return total_size * fee_rate

def create_transaction(wif, to_address, amount_btc, fee_rate):
    # Validate addresses are legacy
    if not is_legacy_address(to_address):
        raise ValueError("Only legacy addresses (starting with '1') are supported for recipient")
    
    priv_bytes, _ = decode_wif(wif)  
    pubkey = get_pubkey(priv_bytes)
    from_address = get_address(pubkey)
    
    if not is_legacy_address(from_address):
        raise ValueError("Only legacy addresses (starting with '1') are supported for sender")

    utxos = fetch_utxos(from_address)
    if not utxos:
        raise RuntimeError("No UTXOs available")

    # Sort UTXOs by value (descending) to minimize number of inputs
    utxos.sort(key=lambda x: x['value'], reverse=True)

    inputs = []
    total = 0
    for utxo in utxos:
        inputs.append({'output': f"{utxo['txid']}:{utxo['vout']}", 'value': utxo['value']})
        total += utxo['value']
        if total >= int(amount_btc * 1e8) + estimate_fee(len(inputs), 2, fee_rate):
            break  # We have enough including fees

    if total == 0:
        raise RuntimeError("No UTXOs available")

    send_amount = int(amount_btc * 1e8)
    fee = estimate_fee(len(inputs), 2, fee_rate)

    if total < send_amount + fee:
        raise RuntimeError(f"Insufficient funds. Need {send_amount + fee} satoshis, have {total}")

    change = total - send_amount - fee
    outputs = [{'address': to_address, 'value': send_amount}]
    if change > 546:  # Minimum dust amount
        outputs.append({'address': from_address, 'value': change})
    elif change > 0:
        fee += change  # Add remaining change to fee if it's too small

    tx = mktx(inputs, outputs)
    for i in range(len(inputs)):
        tx = sign(tx, i, wif)
    return tx

# === Example Usage ===
if __name__ == "__main__":
    WIF = "<wif_private_key>"
    TO_ADDRESS = "1YourLegacyAddressHere"  # must start with '1'
    AMOUNT_BTC = 6.70013241
    FEE_RATE = 20  # sats/vB

    try:
        raw_tx = create_transaction(WIF, TO_ADDRESS, AMOUNT_BTC, FEE_RATE)
        print("Raw Transaction:", raw_tx)
        
        # To broadcast the transaction (uncomment to use)
        # broadcast_url = "https://mempool.space/api/tx"
        # response = requests.post(broadcast_url, data=raw_tx)
        # print("Broadcast response:", response.text)
    except Exception as e:
        print("Error:", e)