async function connectWallet() {
    // Check if user has a Web3 wallet installed
    if (typeof window.ethereum === 'undefined') {
        alert('Please install MetaMask or another Web3 wallet');
        window.open('https://metamask.io/download/', '_blank');
        return;
    }

    // Initialize Web3
    web3 = new Web3(window.ethereum);

    // Request account access
    const accounts = await window.ethereum.request({
        method: 'eth_requestAccounts'
    });

    if (!accounts || accounts.length === 0) {
        throw new Error('No wallet accounts found');
    }

    userAccount = accounts[0];
    console.log('Connected wallet:', userAccount);
    return userAccount;
}

async function checkTokenBalance(tokenAddress, requiredAmount, decimals) {
    // ERC20 standard ABI for balanceOf
    const erc20ABI = [{
        "constant": true,
        "inputs": [{"name": "_owner", "type": "address"}],
        "name": "balanceOf",
        "outputs": [{"name": "balance", "type": "uint256"}],
        "type": "function"
    }];

    const tokenContract = new web3.eth.Contract(erc20ABI, tokenAddress);

    // Get user's token balance
    const balanceWei = await tokenContract.methods
        .balanceOf(userAccount)
        .call();

    // Convert to decimal (e.g., USDT uses 6 decimals)
    const balanceDecimal = parseFloat(balanceWei) / Math.pow(10, decimals);

    console.log(`Balance: ${balanceDecimal} | Required: ${requiredAmount}`);

    // Check if sufficient
    if (balanceDecimal < requiredAmount) {
        const shortfall = (requiredAmount - balanceDecimal).toFixed(2);
        throw new Error(
            `Insufficient balance!\n\n` +
            `Required: ${requiredAmount}\n` +
            `Available: ${balanceDecimal.toFixed(2)}\n` +
            `Shortfall: ${shortfall}\n\n` +
            `Please add more funds to your wallet.`
        );
    }

    return true;
}

async function executePayment() {
    const networkShortName = currentPayment.network;
    const currency = currentPayment.currency;
    const tokenData = networkTokens[networkShortName].find(t => t.symbol === currency);

    const decimals = tokenData.decimals || 6;
    const amount = parseFloat(currentPayment.amount);
    const amountWei = (amount * Math.pow(10, decimals)).toString();

    // ERC20 Token ABI
    const erc20ABI = [
        {
            "constant": false,
            "inputs": [
                {"name": "_spender", "type": "address"},
                {"name": "_value", "type": "uint256"}
            ],
            "name": "approve",
            "outputs": [{"name": "", "type": "bool"}],
            "type": "function"
        },
        {
            "constant": true,
            "inputs": [{"name": "_owner", "type": "address"}],
            "name": "balanceOf",
            "outputs": [{"name": "balance", "type": "uint256"}],
            "type": "function"
        }
    ];

    const tokenContract = new web3.eth.Contract(erc20ABI, tokenData.contractAddress);

    // ✅ CRITICAL: Check balance first
    const balance = await tokenContract.methods.balanceOf(userAccount).call();
    if (BigInt(balance) < BigInt(amountWei)) {
        throw new Error('Insufficient token balance');
    }

    // ✅ STEP 1: Approve token spending
    console.log('Requesting token approval...');
    const approveTx = await tokenContract.methods
        .approve(currentPayment.contractAddress, amountWei)
        .send({ from: userAccount });

    console.log('Approved! Tx:', approveTx.transactionHash);

    // ✅ STEP 2: Execute payment via splitter contract
    const splitterABI = [{
        "inputs": [{
            "components": [
                {"name": "token", "type": "address"},
                {"name": "amount", "type": "uint256"},
                {"name": "paymentId", "type": "string"},
                {"name": "recipient1", "type": "address"},
                {"name": "recipient2", "type": "address"},
                {"name": "recipient3", "type": "address"},
                {"name": "recipient1Percentage", "type": "uint256"},
                {"name": "recipient2Percentage", "type": "uint256"},
                {"name": "recipient3Percentage", "type": "uint256"}
            ],
            "name": "params",
            "type": "tuple"
        }],
        "name": "splitPayment",
        "outputs": [],
        "stateMutability": "nonpayable",
        "type": "function"
    }];

    const splitterContract = new web3.eth.Contract(
        splitterABI,
        currentPayment.contractAddress
    );

    const splitParams = {
        token: tokenData.contractAddress,
        amount: amountWei,
        paymentId: currentPayment.splitterPaymentId,
        recipient1: currentPayment.merchantWallet,
        recipient2: currentPayment.coinleyWallet,
        recipient3: '0x0000000000000000000000000000000000000000',
        recipient1Percentage: currentPayment.merchantPercentage,
        recipient2Percentage: currentPayment.coinleyPercentage,
        recipient3Percentage: 0
    };

    console.log('Executing payment...');
    const paymentTx = await splitterContract.methods
        .splitPayment(splitParams)
        .send({ from: userAccount });

    console.log('Payment successful! Tx:', paymentTx.transactionHash);

    // ✅ STEP 3: Verify payment with Coinley
    await verifyPayment(paymentTx.transactionHash);
}

async function verifyPayment(txHash) {
    const response = await axios.post(
        `${COINLEY_CONFIG.baseURL}/api/payments/process`,
        {
            paymentId: currentPayment.id,
            transactionHash: txHash,
            network: currentPayment.network,
            senderAddress: userAccount
        },
        {
            headers: {
                'X-Public-Key': COINLEY_CONFIG.publicKey,
                'Content-Type': 'application/json'
            }
        }
    );

    if (!response.data.success) {
        throw new Error(response.data.error || 'Verification failed');
    }

    console.log('Payment verified!', response.data);
}

{
  "success": true,
  "message": "Payment processed successfully",
  "payment": {
    "id": "21870d6e-d53d-4e72-8761-e0208a8ceacb",
    "status": "completed",
    "amount": "19.99",
    "transactionHash": "0xabcdef1234567890...",
    "senderAddress": "0x581c333..."
  },
  "onChainData": {
    "blockNumber": 18745123,
    "gasUsed": "65432",
    "confirmed": true
  }
}

// Show fee warning based on selected network
networkSelect.addEventListener('change', (e) => {
    const selectedNetwork = e.target.value;
    const networkWarning = document.getElementById('networkWarning');
    const highFeeNetworks = ['optimism', 'arbitrum', 'ethereum'];
    const total = cart.reduce((sum, item) => sum + (item.price * item.quantity), 0);

    if (highFeeNetworks.includes(selectedNetwork)) {
        let estimatedFee = 0;

        if (selectedNetwork === 'optimism') {
            estimatedFee = 0.61;
            networkWarning.innerHTML = `
                ⚠️ OPTIMISM ALERT: Expected fee ~$${estimatedFee}
                (${(estimatedFee / total * 100).toFixed(0)}% of transaction).
                Switch to Polygon for ~$0.01 fees.
            `;
        } else if (selectedNetwork === 'ethereum') {
            estimatedFee = 15;
            networkWarning.innerHTML = `
                🚨 ETHEREUM: Fees typically $10-20.
                DO NOT USE for small transactions! Use Polygon instead.
            `;
        }

        networkWarning.classList.remove('hidden');
    } else {
        networkWarning.classList.add('hidden');
    }
});