<!-- Include required libraries in your HTML -->
<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/web3@1.10.0/dist/web3.min.js"></script>

// Coinley Configuration
const COINLEY_CONFIG = {
    baseURL: 'https://hub.coinley.io',
    apiKey: 'your_api_key_here',
    apiSecret: 'your_api_secret_here'
};

// Store cart and payment state
let cart = [];
let currentPayment = null;
let web3 = null;
let userAccount = null;
let availableNetworks = [];
let networkTokens = {};

async function connectMetaMaskAndPay() {
    const email = document.getElementById('customerEmail').value;
    const network = document.getElementById('paymentNetwork').value;
    const currency = document.getElementById('paymentCurrency').value;

    if (!email || cart.length === 0) {
        alert('Please enter your email and add items to cart');
        return;
    }

    const total = cart.reduce((sum, item) => sum + (item.price * item.quantity), 0);

    // Create payment via Coinley API
    const response = await axios.post(
        `${COINLEY_CONFIG.baseURL}/api/payments/create`,
        {
            amount: total.toFixed(2),        // e.g., "19.99"
            currency: currency,               // e.g., "USDT"
            network: network,                 // e.g., "polygon"
            customerEmail: email,
            orderId: `TICKET_${Date.now()}`,
            metadata: {
                tickets: cart,
                platform: 'SportsPass'
            }
        },
        {
            headers: {
                'X-API-Key': COINLEY_CONFIG.apiKey,
                'X-API-Secret': COINLEY_CONFIG.apiSecret,
                'Content-Type': 'application/json'
            }
        }
    );

    if (response.data.success) {
        currentPayment = response.data.payment;
        console.log('Payment created:', currentPayment);
        // Continue to wallet connection...
    }
}

{
  "success": true,
  "payment": {
    "id": "21870d6e-d53d-4e72-8761-e0208a8ceacb",
    "amount": "19.99",
    "currency": "USDT",
    "network": "polygon",
    "status": "pending",
    "contractAddress": "0x48E967d182F744EdB18AcA7092814f1FE17fcB2d",
    "splitterPaymentId": "21870d6e-d53d-4e72-8761-e0208a8ceacb",
    "merchantWallet": "0x9d961e093FFeC1577d124Cfe65233fE140E88Fc4",
    "coinleyWallet": "0xEe9025Cc02c060C03ba5dba3d19C7ea2e752f44d",
    "merchantPercentage": 9700,  // 98.5%
    "coinleyPercentage": 300,    // 1.5%
    "expiresAt": "2025-10-15T14:30:00.000Z"
  }
}

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 switchToNetwork(networkShortName) {
    const network = availableNetworks.find(n => n.shortName === networkShortName);
    if (!network) throw new Error('Network not found');

    // Convert chainId to hex format (required by MetaMask)
    const chainIdHex = '0x' + parseInt(network.chainId).toString(16);

    try {
        // Ask wallet to switch networks
        await window.ethereum.request({
            method: 'wallet_switchEthereumChain',
            params: [{ chainId: chainIdHex }]
        });

        console.log(`Switched to ${network.name}`);
    } catch (error) {
        if (error.code === 4902) {
            // Network not added to wallet yet
            alert(`Please add ${network.name} to your wallet manually`);
        }
        throw error;
    }
}

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-API-Key': COINLEY_CONFIG.apiKey,
                'X-API-Secret': COINLEY_CONFIG.apiSecret,
                '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');
    }
});