wallet.js

// Crypto Wallet Integration
// Supports MetaMask and other Ethereum-compatible wallets

let walletAddress = null;
let walletProvider = null;

// Check if MetaMask is installed
function isMetaMaskInstalled() {
    return typeof window.ethereum !== 'undefined';
}

// Connect to MetaMask wallet with message signing for identity verification
// Also supports Farcaster SDK authentication
async function connectWallet() {
    try {
        // Check if running in Farcaster client first
        // Use sdk.wallet.getEthereumProvider() as per official docs
        if (window.farcasterSDK && window.farcasterSDK.wallet) {
            try {
                console.log('🔍 Attempting to connect wallet via Farcaster SDK wallet provider...');
                
                // Get Ethereum provider from Farcaster SDK (EIP-1193 compatible)
                // NOTE: getEthereumProvider() returns a Promise, must await it!
                const ethereumProvider = await window.farcasterSDK.wallet.getEthereumProvider();
                
                if (ethereumProvider) {
                    console.log('✅ Got Ethereum provider from Farcaster SDK');
                    console.log('🔍 Provider object:', ethereumProvider);
                    console.log('🔍 Provider type:', typeof ethereumProvider);
                    console.log('🔍 Provider keys:', Object.keys(ethereumProvider));
                    console.log('🔍 Has request method?', typeof ethereumProvider.request === 'function');
                    console.log('🔍 Has send method?', typeof ethereumProvider.send === 'function');
                    console.log('🔍 Has sendAsync method?', typeof ethereumProvider.sendAsync === 'function');
                    
                    // Check if it's a valid EIP-1193 provider
                    if (typeof ethereumProvider.request !== 'function') {
                        console.error('❌ Provider does not have request() method - not a valid EIP-1193 provider');
                        console.log('💡 Provider structure:', JSON.stringify(ethereumProvider, null, 2));
                        throw new Error('Provider is not EIP-1193 compatible');
                    }
                    
                    // Request accounts (this will auto-connect if user already has wallet connected)
                    try {
                        const accounts = await ethereumProvider.request({ method: 'eth_requestAccounts' });
                        
                        if (accounts && accounts.length > 0) {
                            walletAddress = accounts[0];
                            walletProvider = ethereumProvider; // Store the provider, not 'farcaster'
                            
                            console.log('✅ Connected via Farcaster SDK wallet provider:', walletAddress);
                            
                            // Update UI and fetch high score
                            await updateWalletUI();
                            
                            // Save to localStorage
                            localStorage.setItem('walletAddress', walletAddress);
                            localStorage.setItem('walletProvider', 'farcaster-ethereum');
                            
                            // Track login event
                            const context = await window.farcasterSDK.context;
                            trackEvent('wallet_connected', {
                                address: walletAddress,
                                provider: 'farcaster-ethereum',
                                farcasterUser: context?.user,
                                timestamp: new Date().toISOString()
                            });
                            
                            return walletAddress;
                        } else {
                            console.log('⚠️  No accounts returned from Farcaster wallet provider');
                        }
                    } catch (requestError) {
                        console.log('⚠️  Error requesting accounts from Farcaster wallet:', requestError.message);
                        // User might have rejected or wallet not connected
                        // Fallback to FID
                        const context = await window.farcasterSDK.context;
                        if (context?.user?.fid) {
                            walletAddress = `farcaster:${context.user.fid}`;
                            walletProvider = 'farcaster';
                            console.log('💡 Using FID as fallback:', walletAddress);
                            await updateWalletUI();
                            return walletAddress;
                        }
                    }
                } else {
                    console.log('⚠️  No Ethereum provider available from Farcaster SDK');
                    // Fallback to FID
                    const context = await window.farcasterSDK.context;
                    if (context?.user?.fid) {
                        walletAddress = `farcaster:${context.user.fid}`;
                        walletProvider = 'farcaster';
                        console.log('💡 Using FID as fallback:', walletAddress);
                        await updateWalletUI();
                        return walletAddress;
                    }
                }
            } catch (farcasterError) {
                console.log('Farcaster wallet provider error, trying fallback:', farcasterError.message);
                // Fallback to context.user.custodyAddress if available
                try {
                    const context = await window.farcasterSDK.context;
                    if (context?.user?.custodyAddress) {
                        walletAddress = context.user.custodyAddress;
                        walletProvider = 'farcaster';
                        console.log('✅ Using custodyAddress from context:', walletAddress);
                        await updateWalletUI();
                        return walletAddress;
                    } else if (context?.user?.fid) {
                        walletAddress = `farcaster:${context.user.fid}`;
                        walletProvider = 'farcaster';
                        console.log('💡 Using FID as fallback:', walletAddress);
                        await updateWalletUI();
                        return walletAddress;
                    }
                } catch (contextError) {
                    console.log('Context error:', contextError.message);
                }
            }
        }
        
        // Fallback to MetaMask
        if (!isMetaMaskInstalled()) {
            alert('Please install MetaMask to connect your wallet!');
            return null;
        }

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

        if (accounts.length > 0) {
            walletAddress = accounts[0];
            walletProvider = window.ethereum;
            
            // Prompt to switch to Base Mainnet immediately after connect
            try {
                const switched = await ensureBaseMainnetNetwork();
                if (!switched) {
                    console.warn('User did not switch to Base Mainnet.');
                }
            } catch (netErr) {
                console.warn('Network switch error:', netErr?.message || netErr);
            }
            
            // Sign message to verify identity (non-transactional, no asset involved)
            try {
                const message = `Farcaster 2048\n\nSign this message to verify your identity.\n\nWallet: ${walletAddress}\nTimestamp: ${Date.now()}`;
                
                // Request signature
                const signature = await window.ethereum.request({
                    method: 'personal_sign',
                    params: [message, walletAddress]
                });
                
                console.log('✅ Message signed successfully:', signature);
                
                // Track login event with signature
                trackEvent('wallet_connected', {
                    address: walletAddress,
                    provider: 'metamask',
                    signature: signature,
                    timestamp: new Date().toISOString()
                });
            } catch (signError) {
                // If user rejects signature, still allow connection but log it
                if (signError.code === 4001) {
                    console.warn('⚠️  User rejected message signature');
                    alert('Connection successful, but identity verification was skipped.');
                } else {
                    console.error('Error signing message:', signError);
                    // Continue anyway - signature is optional for basic connection
                }
                
                // Track login event without signature
                trackEvent('wallet_connected', {
                    address: walletAddress,
                    provider: 'metamask',
                    signature: null,
                    timestamp: new Date().toISOString()
                });
            }
            
            // Update UI
            updateWalletUI();
            
            // Save to localStorage
            localStorage.setItem('walletAddress', walletAddress);
            localStorage.setItem('walletProvider', 'metamask');
            
            return walletAddress;
        }
    } catch (error) {
        console.error('Error connecting wallet:', error);
        alert('Failed to connect wallet: ' + error.message);
        return null;
    }
}

// Disconnect wallet
function disconnectWallet() {
    walletAddress = null;
    walletProvider = null;
    localStorage.removeItem('walletAddress');
    
    // Reset player name display to empty/default
    const playerNameDisplay = document.getElementById('player-name');
    if (playerNameDisplay) {
        playerNameDisplay.textContent = '';
    }
    
    // Update UI
    updateWalletUI();
    
    // Track disconnect event
    trackEvent('wallet_disconnected', {
        timestamp: new Date().toISOString()
    });
}

// Get short address format (0x1234...5678)
function getShortAddress(address) {
    if (!address) return '';
    return `${address.slice(0, 6)}...${address.slice(-4)}`;
}

// Fetch high score from contract
async function fetchHighScoreFromContract() {
    if (!walletAddress || !window.ethers || !window.CONTRACT_ADDRESS) {
        return null;
    }
    
    try {
        // Skip if using FID (not a real wallet address)
        if (walletAddress.startsWith('farcaster:')) {
            console.log('⏭️  Skipping contract fetch (using FID, not wallet address)');
            return null;
        }
        
        // Try to get Ethereum provider from Farcaster SDK first (official method)
        let validProvider = null;
        
        if (window.farcasterSDK && window.farcasterSDK.wallet && typeof window.farcasterSDK.wallet.getEthereumProvider === 'function') {
            try {
                // NOTE: getEthereumProvider() returns a Promise, must await it!
                const farcasterProvider = await window.farcasterSDK.wallet.getEthereumProvider();
                if (farcasterProvider && typeof farcasterProvider.request === 'function') {
                    validProvider = farcasterProvider;
                    console.log('✅ Using Ethereum provider from Farcaster SDK');
                }
            } catch (providerError) {
                console.log('⚠️  Could not get Ethereum provider from Farcaster SDK:', providerError.message);
            }
        }
        
        // Fallback to walletProvider if it's a valid provider object
        if (!validProvider && walletProvider && walletProvider !== 'farcaster' && typeof walletProvider.request === 'function') {
            validProvider = walletProvider;
            console.log('✅ Using stored walletProvider');
        }
        
        // Fallback to window.ethereum
        if (!validProvider && window.ethereum) {
            validProvider = window.ethereum;
            console.log('✅ Using window.ethereum');
        }
        
        if (!validProvider) {
            console.log('⏭️  Skipping contract fetch (no valid Ethereum provider)');
            return null;
        }
        
        // Ensure we're on Base Mainnet
        if (validProvider.request) {
            try {
                const current = await validProvider.request({ method: 'eth_chainId' });
                if (current !== '0x2105') { // Base Mainnet chain ID (8453)
                    console.log('⏭️  Not on Base Mainnet, skipping contract fetch');
                    return null;
                }
            } catch (chainError) {
                console.log('⏭️  Could not check chain ID, skipping contract fetch:', chainError.message);
                return null;
            }
        }
        
        const provider = new window.ethers.BrowserProvider(validProvider);
        const contractAddress = window.CONTRACT_ADDRESS;
        
        // Minimal ABI for getPlayerScore
        const abi = [
            "function getPlayerScore(address player) external view returns (string memory, uint256, uint256, uint256, uint256, uint256, uint256)"
        ];
        
        const contract = new window.ethers.Contract(contractAddress, abi, provider);
        const result = await contract.getPlayerScore(walletAddress);
        
        // Result: [playerName, score, highScore, gamesPlayed, totalMoves, totalPlayTime, timestamp]
        const highScore = result[2]; // highScore is at index 2
        return highScore.toString();
    } catch (error) {
        console.log('Could not fetch high score from contract:', error.message);
        return null;
    }
}

// Update wallet UI and fetch high score
async function updateWalletUI() {
    const walletBtn = document.getElementById('wallet-connect-btn');
    const walletInfo = document.getElementById('wallet-info');
    const highScoreDisplay = document.getElementById('high-score');
    const startGameBtn = document.getElementById('start-game-btn');
    
    // Check if in Farcaster client (users are auto-authenticated)
    let isFarcasterClient = false;
    let farcasterAddress = null;
    let farcasterFid = null;
    
    if (window.farcasterSDK) {
        try {
            const context = await window.farcasterSDK.context;
            
            // Check if Mini App is added
            const isMiniAppAdded = context?.client?.added;
            console.log('🔍 Mini App added status:', isMiniAppAdded);
            
            // Try to get wallet address using sdk.wallet.getEthereumProvider() (official method)
            let ethereumProvider = null;
            let providerAddress = null;
            
            console.log('═══════════════════════════════════════');
            console.log('🔍 CHECKING SDK.WALLET.GETETHEREUMPROVIDER');
            console.log('═══════════════════════════════════════');
            console.log('🔍 window.farcasterSDK exists?', !!window.farcasterSDK);
            console.log('🔍 window.farcasterSDK.wallet exists?', !!window.farcasterSDK?.wallet);
            console.log('🔍 window.farcasterSDK.wallet:', window.farcasterSDK?.wallet);
            console.log('🔍 window.farcasterSDK.wallet keys:', window.farcasterSDK?.wallet ? Object.keys(window.farcasterSDK.wallet) : 'no wallet object');
            console.log('🔍 getEthereumProvider type:', typeof window.farcasterSDK?.wallet?.getEthereumProvider);
            console.log('🔍 getEthereumProvider is function?', typeof window.farcasterSDK?.wallet?.getEthereumProvider === 'function');
            
            if (window.farcasterSDK.wallet && typeof window.farcasterSDK.wallet.getEthereumProvider === 'function') {
                try {
                    console.log('🔄 Calling getEthereumProvider()...');
                    // NOTE: getEthereumProvider() returns a Promise, must await it!
                    ethereumProvider = await window.farcasterSDK.wallet.getEthereumProvider();
                    console.log('✅ getEthereumProvider() returned:', ethereumProvider);
                    console.log('🔍 Return value type:', typeof ethereumProvider);
                    console.log('🔍 Return value is null?', ethereumProvider === null);
                    console.log('🔍 Return value is undefined?', ethereumProvider === undefined);
                    
                    if (ethereumProvider) {
                        console.log('✅ Got Ethereum provider from sdk.wallet.getEthereumProvider()');
                        console.log('🔍 Provider object:', ethereumProvider);
                        console.log('🔍 Provider type:', typeof ethereumProvider);
                        console.log('🔍 Provider keys:', Object.keys(ethereumProvider || {}));
                        console.log('🔍 Provider constructor:', ethereumProvider.constructor?.name);
                        console.log('🔍 Has request method?', typeof ethereumProvider.request === 'function');
                        console.log('🔍 Has send method?', typeof ethereumProvider.send === 'function');
                        console.log('🔍 Has sendAsync method?', typeof ethereumProvider.sendAsync === 'function');
                        console.log('🔍 All provider properties:', Object.getOwnPropertyNames(ethereumProvider));
                        
                        // Check if it's a valid EIP-1193 provider
                        if (typeof ethereumProvider.request === 'function') {
                            // Try to get accounts
                            try {
                                const accounts = await ethereumProvider.request({ method: 'eth_accounts' });
                                if (accounts && accounts.length > 0) {
                                    providerAddress = accounts[0];
                                    console.log('✅ Got wallet address from Ethereum provider:', providerAddress);
                                } else {
                                    console.log('⚠️  No accounts in Ethereum provider (wallet not connected)');
                                    // Try requesting accounts (might prompt user)
                                    try {
                                        const requestedAccounts = await ethereumProvider.request({ method: 'eth_requestAccounts' });
                                        if (requestedAccounts && requestedAccounts.length > 0) {
                                            providerAddress = requestedAccounts[0];
                                            console.log('✅ Got wallet address after requesting:', providerAddress);
                                        }
                                    } catch (requestError) {
                                        console.log('⚠️  Error requesting accounts:', requestError.message);
                                    }
                                }
                            } catch (accountsError) {
                                console.log('⚠️  Error getting accounts from provider:', accountsError.message);
                                console.log('🔍 Error details:', accountsError);
                            }
                        } else {
                            console.error('❌ Provider does not have request() method');
                            console.log('💡 Provider structure:', ethereumProvider);
                            console.log('💡 Available methods:', Object.getOwnPropertyNames(ethereumProvider));
                            console.log('💡 Provider prototype:', Object.getPrototypeOf(ethereumProvider));
                        }
                    } else {
                        console.log('⚠️  getEthereumProvider() returned null/undefined/falsy value');
                        console.log('💡 This means no wallet is connected or available');
                    }
                } catch (providerError) {
                    console.error('❌ Error getting Ethereum provider:', providerError);
                    console.log('🔍 Error message:', providerError.message);
                    console.log('🔍 Error stack:', providerError.stack);
                    console.log('🔍 Error details:', providerError);
                }
            } else {
                console.log('⚠️  sdk.wallet.getEthereumProvider is not available');
                console.log('🔍 SDK wallet object:', window.farcasterSDK?.wallet);
                console.log('🔍 SDK wallet keys:', window.farcasterSDK?.wallet ? Object.keys(window.farcasterSDK.wallet) : 'no wallet object');
                console.log('🔍 SDK wallet type:', typeof window.farcasterSDK?.wallet);
                console.log('💡 This might mean:');
                console.log('   1. SDK version does not support getEthereumProvider()');
                console.log('   2. Wallet is not initialized');
                console.log('   3. User has not connected a wallet in Farcaster app');
            }
            console.log('═══════════════════════════════════════');
            
            // Comprehensive logging to find wallet address
            console.log('═══════════════════════════════════════');
            console.log('🔍 FULL FARCASTER CONTEXT DEBUG');
            console.log('═══════════════════════════════════════');
            console.log('📦 Full context object:', context);
            console.log('📦 Context keys:', context ? Object.keys(context) : 'no context');
            console.log('📱 Context.client:', context?.client);
            console.log('📱 Context.client.added:', isMiniAppAdded);
            console.log('👤 Context.user:', context?.user);
            console.log('👤 Context.user keys:', context?.user ? Object.keys(context?.user) : 'no user');
            console.log('🔗 Ethereum provider available:', !!ethereumProvider);
            console.log('💼 Wallet address from provider:', providerAddress);
            
            // Log all user properties
            if (context?.user) {
                console.log('📋 All user properties:');
                for (const key in context.user) {
                    const value = context.user[key];
                    console.log(`  - ${key}:`, value, `(type: ${typeof value})`);
                    if (Array.isArray(value)) {
                        console.log(`    Array length: ${value.length}`);
                        value.forEach((item, index) => {
                            console.log(`    [${index}]:`, item);
                        });
                    }
                }
            }
            
            // Check if in Farcaster client
            if (context?.user) {
                isFarcasterClient = true;
                console.log('✅ Farcaster client detected!');
                
                // Get FID (Farcaster ID)
                if (context.user.fid) {
                    farcasterFid = context.user.fid;
                    console.log('✅ FID found:', farcasterFid);
                } else {
                    console.log('⚠️  No FID found');
                }
                
                // Try ALL possible methods to get wallet address
                console.log('🔍 Searching for wallet address...');
                
                // Method 1: sdk.wallet.getEthereumProvider() (OFFICIAL METHOD - PRIORITY)
                if (providerAddress) {
                    farcasterAddress = providerAddress;
                    console.log('✅ Method 1: Wallet address from sdk.wallet.getEthereumProvider():', farcasterAddress);
                    // Store the provider for later use
                    if (ethereumProvider) {
                        walletProvider = ethereumProvider;
                    }
                } else {
                    console.log('❌ Method 1: No wallet address from Ethereum provider');
                }
                
                // Method 2: custodyAddress (fallback)
                if (!farcasterAddress && context.user.custodyAddress) {
                    farcasterAddress = context.user.custodyAddress;
                    console.log('✅ Method 2: custodyAddress found:', farcasterAddress);
                } else if (!farcasterAddress) {
                    console.log('❌ Method 2: custodyAddress not found');
                }
                
                // Method 3: verifications array
                if (!farcasterAddress && context.user.verifications) {
                    console.log('🔍 Method 3: Checking verifications array...');
                    if (Array.isArray(context.user.verifications)) {
                        console.log(`  Verifications array length: ${context.user.verifications.length}`);
                        context.user.verifications.forEach((item, index) => {
                            console.log(`  [${index}]:`, item, `(type: ${typeof item})`);
                            if (item && typeof item === 'string' && item.startsWith('0x')) {
                                farcasterAddress = item;
                                console.log(`✅ Method 3: Found wallet in verifications[${index}]:`, farcasterAddress);
                            }
                        });
                    } else {
                        console.log('  Verifications is not an array:', typeof context.user.verifications);
                    }
                } else if (!farcasterAddress) {
                    console.log('❌ Method 3: verifications not found or already have address');
                }
                
                // Method 4: verifiedAddresses
                if (!farcasterAddress && context.user.verifiedAddresses) {
                    console.log('🔍 Method 4: Checking verifiedAddresses...');
                    if (Array.isArray(context.user.verifiedAddresses)) {
                        console.log(`  VerifiedAddresses array length: ${context.user.verifiedAddresses.length}`);
                        context.user.verifiedAddresses.forEach((item, index) => {
                            console.log(`  [${index}]:`, item);
                            if (item && typeof item === 'string' && item.startsWith('0x')) {
                                farcasterAddress = item;
                                console.log(`✅ Method 4: Found wallet in verifiedAddresses[${index}]:`, farcasterAddress);
                            }
                        });
                    }
                } else if (!farcasterAddress) {
                    console.log('❌ Method 4: verifiedAddresses not found or already have address');
                }
                
                // Method 5: Check all nested objects
                if (!farcasterAddress) {
                    console.log('🔍 Method 5: Searching all nested properties...');
                    const searchForWallet = (obj, path = '') => {
                        for (const key in obj) {
                            const value = obj[key];
                            const currentPath = path ? `${path}.${key}` : key;
                            
                                if (typeof value === 'string' && value.startsWith('0x') && value.length === 42) {
                                console.log(`✅ Found potential wallet at ${currentPath}:`, value);
                                if (!farcasterAddress) {
                                    farcasterAddress = value;
                                    console.log(`✅ Method 5: Using wallet from ${currentPath}:`, farcasterAddress);
                                }
                            } else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
                                searchForWallet(value, currentPath);
                            } else if (Array.isArray(value)) {
                                value.forEach((item, index) => {
                                    if (typeof item === 'string' && item.startsWith('0x') && item.length === 42) {
                                        console.log(`✅ Found potential wallet at ${currentPath}[${index}]:`, item);
                                        if (!farcasterAddress) {
                                            farcasterAddress = item;
                                            console.log(`✅ Method 5: Using wallet from ${currentPath}[${index}]:`, farcasterAddress);
                                        }
                                    } else if (typeof item === 'object' && item !== null) {
                                        searchForWallet(item, `${currentPath}[${index}]`);
                                    }
                                });
                            }
                        }
                    };
                    searchForWallet(context.user);
                }
                
                // Final result
                if (farcasterAddress) {
                    console.log('═══════════════════════════════════════');
                    console.log('✅ WALLET ADDRESS FOUND:', farcasterAddress);
                    console.log('═══════════════════════════════════════');
                } else {
                    console.log('═══════════════════════════════════════');
                    console.log('❌ NO WALLET ADDRESS FOUND');
                    console.log('═══════════════════════════════════════');
                }
                
                // Use wallet address from provider or context
                // PRIORITY: Always use real wallet address if available, only use FID as last resort
                if (farcasterAddress) {
                    // Real wallet address found - use it
                    walletAddress = farcasterAddress;
                    // If we got address from Ethereum provider, keep that provider
                    if (ethereumProvider && providerAddress === farcasterAddress) {
                        walletProvider = ethereumProvider;
                        console.log('✅ Auto-connected Farcaster wallet via Ethereum provider:', walletAddress);
                    } else {
                        walletProvider = 'farcaster';
                        console.log('✅ Auto-connected Farcaster wallet from context:', walletAddress);
                    }
                } else if (!walletAddress && farcasterFid) {
                    // Only use FID as identifier if NO real wallet address available (format: farcaster:fid)
                    // This is for display purposes only - will not be used for saving scores
                    walletAddress = `farcaster:${farcasterFid}`;
                    walletProvider = 'farcaster';
                    console.log('⚠️  Using FID as identifier (no real wallet address):', walletAddress);
                    console.log('💡 Note: Scores will not be saved without a real wallet address');
                }
            } else {
                console.log('⚠️  Farcaster context available but no user object');
            }
        } catch (e) {
            console.log('⚠️  Farcaster SDK error:', e.message);
            console.log('⚠️  Error stack:', e.stack);
            // Not in Farcaster client or context not available
        }
    } else {
        console.log('⚠️  Farcaster SDK not available');
    }
    
    // In Farcaster Mini App, always hide Connect Wallet button
    // Wallet will sync automatically when user adds mini app
    // Check if walletAddress is a real wallet (not FID format)
    const hasRealWallet = walletAddress && !walletAddress.startsWith('farcaster:') && walletAddress.startsWith('0x');
    
    if (isFarcasterClient) {
        // Always hide Connect Wallet button in Farcaster Mini App
        // Wallet syncs automatically when user adds mini app
        if (walletBtn) {
            walletBtn.style.display = 'none';
            console.log('💡 Hiding Connect Wallet button in Farcaster Mini App (wallet syncs automatically)');
        }
        // Always show Start Game button (can play with FID)
        if (startGameBtn) {
            startGameBtn.style.display = 'inline-block';
        }
    } else if (hasRealWallet) {
        // Regular browser with real wallet - hide Connect button
        if (walletBtn) {
            walletBtn.style.display = 'none';
        }
        // Show Start Game button
        if (startGameBtn) {
            startGameBtn.style.display = 'inline-block';
        }
    }
    
    // Show wallet info based on environment (separate from button logic)
    if (walletInfo && (walletAddress || isFarcasterClient)) {
        // Priority: Show wallet address if available, otherwise show FID
        if (isFarcasterClient && farcasterAddress) {
            // Show wallet address if available in Farcaster client (PRIORITY)
            walletInfo.style.display = 'block';
            console.log('✅ Displaying wallet address in Farcaster client:', farcasterAddress);
            walletInfo.innerHTML = `
                <div style="display: flex; align-items: center; gap: 10px; flex-wrap: wrap;">
                    <span style="color: #A855F7; font-weight: bold;">Wallet: ${getShortAddress(farcasterAddress)}</span>
                    ${farcasterFid ? `<span style="color: #A78BFA;">(Fid: ${farcasterFid})</span>` : ''}
                </div>
            `;
        } else if (isFarcasterClient && farcasterFid) {
            // Show FID in Farcaster Mini Apps if no wallet address (FALLBACK)
            walletInfo.style.display = 'block';
            console.log('⚠️  Displaying FID in Farcaster client (no wallet address):', farcasterFid);
            walletInfo.innerHTML = `
                <div style="display: flex; flex-direction: column; gap: 8px;">
                    <div style="display: flex; align-items: center; gap: 10px; flex-wrap: wrap;">
                        <span style="color: #A78BFA;">Fid: ${farcasterFid}</span>
                        <span style="color: #F59E0B; font-size: 12px;">(No wallet address)</span>
                    </div>
                    <div style="font-size: 11px; color: #A78BFA; padding: 8px; background: rgba(168, 85, 247, 0.1); border-radius: 4px;">
                        💡 To enable on-chain features, connect your wallet in Farcaster app settings
                    </div>
                </div>
            `;
        } else if (walletAddress && !walletAddress.startsWith('farcaster:')) {
            // Show wallet address in regular browser (with Disconnect button)
            walletInfo.style.display = 'block';
            console.log('✅ Displaying wallet in regular browser (with Disconnect button)');
            walletInfo.innerHTML = `
                <div style="display: flex; align-items: center; gap: 10px; flex-wrap: wrap;">
                    <span>Wallet: ${getShortAddress(walletAddress)}</span>
                    <button onclick="disconnectWallet()" style="padding: 5px 10px; font-size: 12px; background: #9333EA; border: none; border-radius: 4px; color: white; cursor: pointer;">Disconnect</button>
                </div>
            `;
        } else if (walletAddress && walletAddress.startsWith('farcaster:')) {
            // Show FID if using FID as identifier
            const fid = walletAddress.replace('farcaster:', '');
            walletInfo.style.display = 'block';
            console.log('✅ Displaying FID from walletAddress:', fid);
            walletInfo.innerHTML = `
                <div style="display: flex; align-items: center; gap: 10px; flex-wrap: wrap;">
                    <span>Fid: ${fid}</span>
                </div>
            `;
        } else {
            // Hide wallet info if no address/FID available
            console.log('⚠️  Hiding wallet info - no address/FID');
            walletInfo.style.display = 'none';
        }
    }
    
    // Fetch and display high score from backend API (same source as leaderboard)
    if (highScoreDisplay) {
        console.log('🔄 Fetching High Score for wallet:', walletAddress);
        
        if (walletAddress) {
            // Always fetch from backend API (same source as leaderboard) to ensure consistency
            try {
                console.log('🔄 Fetching high score from backend API (same as leaderboard)...');
                const response = await fetch(`${window.API_URL}/api/leaderboard?limit=100`);
                const data = await response.json();
                
                if (data.success && data.leaderboard) {
                    console.log('📊 Leaderboard data received:', data.leaderboard.length, 'entries');
                    
                    // Find user entry by wallet address (case-insensitive)
                    // Normalize both addresses to lowercase for comparison
                    const normalizedWalletAddress = walletAddress.toLowerCase();
                    const userEntry = data.leaderboard.find(entry => {
                        if (!entry.walletAddress) return false;
                        return entry.walletAddress.toLowerCase() === normalizedWalletAddress;
                    });
                    
                    if (userEntry && userEntry.highScore !== undefined) {
                        highScoreDisplay.textContent = userEntry.highScore;
                        console.log('✅ High Score from backend:', userEntry.highScore, 'for wallet:', walletAddress);
                        console.log('📊 Full entry data:', { wallet: userEntry.walletAddress, highScore: userEntry.highScore, currentScore: userEntry.currentScore });
                    } else {
                        highScoreDisplay.textContent = '0';
                        console.log('⚠️  No high score found in backend for wallet:', walletAddress);
                        console.log('📋 Available wallets in leaderboard:', data.leaderboard.slice(0, 5).map(e => ({ wallet: e.walletAddress, highScore: e.highScore })));
                    }
                } else {
                    highScoreDisplay.textContent = '0';
                    console.log('⚠️  Backend API returned success: false');
                }
            } catch (error) {
                console.log('⚠️  Could not fetch high score from backend:', error.message);
                highScoreDisplay.textContent = '0';
            }
        } else {
            highScoreDisplay.textContent = '0';
            console.log('⚠️  No wallet address available, setting High Score to 0');
        }
    }
    
    // Handle case when not in Farcaster client and no wallet
    if (!isFarcasterClient && !walletAddress) {
        // Show Connect Wallet button only if not in Farcaster client
        if (walletBtn) {
            walletBtn.style.display = 'block';
        }
        // Hide Start Game button
        if (startGameBtn) {
            startGameBtn.style.display = 'none';
        }
        if (walletInfo) {
            walletInfo.style.display = 'none';
        }
        // Reset high score
        if (highScoreDisplay) {
            highScoreDisplay.textContent = '0';
        }
    }
}

// Load saved wallet on page load
async function loadSavedWallet() {
    // Try Farcaster first (priority - users are auto-authenticated in Farcaster Mini Apps)
    if (window.farcasterSDK) {
        try {
            const context = await window.farcasterSDK.context;
            console.log('🔍 Full Farcaster context in loadSavedWallet:', JSON.stringify(context, null, 2));
            console.log('🔍 Context.user:', context?.user);
            console.log('🔍 Context.user keys:', context?.user ? Object.keys(context.user) : 'no user');
            
            if (context?.user) {
                let foundAddress = null;
                let foundFid = null;
                
                // Get FID first
                if (context.user.fid) {
                    foundFid = context.user.fid;
                    console.log('✅ Found FID:', foundFid);
                }
                
                // Try to get wallet address (optional)
                // Method 1: custodyAddress (primary)
                if (context.user.custodyAddress) {
                    foundAddress = context.user.custodyAddress;
                    console.log('✅ Found custodyAddress:', foundAddress);
                }
                // Method 2: verifications array
                else if (context.user.verifications && Array.isArray(context.user.verifications) && context.user.verifications.length > 0) {
                    const verifiedAddress = context.user.verifications[0];
                    if (verifiedAddress && verifiedAddress.startsWith('0x')) {
                        foundAddress = verifiedAddress;
                        console.log('✅ Found verified address:', foundAddress);
                    }
                }
                // Method 3: verifiedAddresses
                else if (context.user.verifiedAddresses && Array.isArray(context.user.verifiedAddresses) && context.user.verifiedAddresses.length > 0) {
                    const verifiedAddress = context.user.verifiedAddresses[0];
                    if (verifiedAddress && verifiedAddress.startsWith('0x')) {
                        foundAddress = verifiedAddress;
                        console.log('✅ Found verifiedAddresses:', foundAddress);
                    }
                }
                
                // Use wallet address if available, otherwise use FID
                if (foundAddress) {
                    walletAddress = foundAddress;
                    walletProvider = 'farcaster';
                    console.log('✅ Auto-connected Farcaster wallet on load:', walletAddress);
                } else if (foundFid) {
                    // Use FID as identifier
                    walletAddress = `farcaster:${foundFid}`;
                    walletProvider = 'farcaster';
                    console.log('✅ Using FID as identifier on load:', walletAddress);
                }
                
                if (walletAddress) {
                    await updateWalletUI(); // Make async to fetch high score
                    return;
                } else {
                    console.log('⚠️  Farcaster context exists but no wallet address or FID found');
                    console.log('⚠️  Available user properties:', context?.user ? Object.keys(context.user) : 'none');
                }
            }
        } catch (error) {
            console.log('⚠️  Farcaster context error:', error.message);
            console.log('⚠️  Error stack:', error.stack);
        }
    } else {
        console.log('⚠️  window.farcasterSDK not available yet');
    }
    
    // Fallback to saved MetaMask wallet (for non-Farcaster environments)
    const savedAddress = localStorage.getItem('walletAddress');
    const savedProvider = localStorage.getItem('walletProvider');
    
    if (savedAddress && savedProvider === 'metamask' && isMetaMaskInstalled()) {
        // Verify the account is still connected
        window.ethereum.request({ method: 'eth_accounts' })
            .then(async accounts => {
                if (accounts.includes(savedAddress)) {
                    walletAddress = savedAddress;
                    walletProvider = window.ethereum;
                    await updateWalletUI(); // Make async to fetch high score
                } else {
                    localStorage.removeItem('walletAddress');
                    localStorage.removeItem('walletProvider');
                }
            });
    } else if (savedAddress && savedProvider === 'farcaster') {
        // Farcaster wallet - restore (but prefer live context if available)
        if (!window.farcasterSDK) {
            walletAddress = savedAddress;
            walletProvider = 'farcaster';
            await updateWalletUI(); // Make async to fetch high score
        }
    }
}

// Listen for account changes
if (typeof window.ethereum !== 'undefined') {
    window.ethereum.on('accountsChanged', (accounts) => {
        if (accounts.length === 0) {
            disconnectWallet();
        } else {
            walletAddress = accounts[0];
            localStorage.setItem('walletAddress', walletAddress);
            updateWalletUI();
        }
    });
}

// Usage Statistics Tracking
const usageStats = {
    gamesPlayed: 0,
    totalMoves: 0,
    totalScore: 0,
    highestScore: 0,
    totalPlayTime: 0, // in seconds
    sessionStartTime: null,
    lastPlayDate: null
};

// Track game event
function trackEvent(eventType, data = {}) {
    const event = {
        type: eventType,
        walletAddress: walletAddress,
        timestamp: new Date().toISOString(),
        ...data
    };
    
    // Save to localStorage
    const events = JSON.parse(localStorage.getItem('gameEvents') || '[]');
    events.push(event);
    localStorage.setItem('gameEvents', JSON.stringify(events));
    
    // Send to backend if wallet is connected
    if (walletAddress) {
        sendEventToBackend(event);
    }
}

// Use window.API_URL from config.js (do not redeclare)

// Send event to backend
async function sendEventToBackend(event) {
    try {
        const response = await fetch(`${window.API_URL}/api/stats`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(event)
        });
        
        if (!response.ok) {
            console.error('Failed to send stats to backend');
        }
    } catch (error) {
        console.error('Error sending stats:', error);
    }
}

// Update usage statistics
function updateStats(score, moves, playTime) {
    usageStats.gamesPlayed++;
    usageStats.totalMoves += moves;
    usageStats.totalScore += score;
    usageStats.totalPlayTime += playTime;
    usageStats.lastPlayDate = new Date().toISOString();
    
    if (score > usageStats.highestScore) {
        usageStats.highestScore = score;
    }
    
    // Save to localStorage
    localStorage.setItem('usageStats', JSON.stringify(usageStats));
    
    // Track game completion
    trackEvent('game_completed', {
        score: score,
        moves: moves,
        playTime: playTime
    });
    
    // Send stats to backend
    if (walletAddress) {
        sendStatsToBackend();
    }
}

// Send stats to backend
async function sendStatsToBackend() {
    try {
        // Check if API_URL is defined
        const apiUrl = window.API_URL || '';
        if (!apiUrl) {
            console.warn('⚠️  API_URL not set, skipping stats update');
            return;
        }
        
        const response = await fetch(`${apiUrl}/api/stats/update`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                walletAddress: walletAddress,
                stats: usageStats
            })
        });
        
        if (!response.ok) {
            console.error('Failed to update stats on backend:', response.status, response.statusText);
        } else {
            console.log('✅ Stats updated on backend');
        }
    } catch (error) {
        console.error('Error updating stats:', error);
    }
}

// Load stats from localStorage
function loadStats() {
    const saved = localStorage.getItem('usageStats');
    if (saved) {
        Object.assign(usageStats, JSON.parse(saved));
    }
}

// Get formatted stats
function getFormattedStats() {
    const avgScore = usageStats.gamesPlayed > 0 
        ? Math.round(usageStats.totalScore / usageStats.gamesPlayed) 
        : 0;
    const avgMoves = usageStats.gamesPlayed > 0 
        ? Math.round(usageStats.totalMoves / usageStats.gamesPlayed) 
        : 0;
    const playTimeHours = Math.floor(usageStats.totalPlayTime / 3600);
    const playTimeMinutes = Math.floor((usageStats.totalPlayTime % 3600) / 60);
    
    return {
        gamesPlayed: usageStats.gamesPlayed,
        totalMoves: usageStats.totalMoves,
        totalScore: usageStats.totalScore,
        highestScore: usageStats.highestScore,
        averageScore: avgScore,
        averageMoves: avgMoves,
        totalPlayTime: `${playTimeHours}h ${playTimeMinutes}m`,
        lastPlayDate: usageStats.lastPlayDate
    };
}

// Initialize on page load
window.addEventListener('DOMContentLoaded', async () => {
    // Wait for Farcaster SDK to be available
    const checkSDK = async () => {
        if (window.farcasterSDK) {
            try {
                const context = await window.farcasterSDK.context;
                if (context?.user?.custodyAddress) {
                    console.log('✅ Farcaster SDK ready in wallet.js, address:', context.user.custodyAddress);
                }
            } catch (e) {
                console.log('⚠️  Farcaster context not ready yet');
            }
        }
        // Load wallet (will check Farcaster SDK inside)
        await loadSavedWallet();
        
        // Update wallet UI to fetch and display High Score
        if (typeof updateWalletUI === 'function') {
            console.log('🔄 Calling updateWalletUI() on page load to fetch High Score...');
            await updateWalletUI();
        }
    };
    
    // Try immediately
    await checkSDK();
    
    // Also retry after a short delay in case SDK loads later
    setTimeout(async () => {
        await checkSDK();
        // Also update wallet UI after retry
        if (typeof updateWalletUI === 'function') {
            console.log('🔄 Calling updateWalletUI() after SDK retry to fetch High Score...');
            await updateWalletUI();
        }
    }, 500);
    
    // Also try to update wallet UI after a longer delay (in case wallet loads later)
    setTimeout(async () => {
        if (typeof updateWalletUI === 'function') {
            console.log('🔄 Calling updateWalletUI() after delay to fetch High Score...');
            await updateWalletUI();
        }
    }, 2000);
    
    loadStats();
});

// Export functions for use in other files
window.connectWallet = connectWallet;
window.disconnectWallet = disconnectWallet;
window.trackEvent = trackEvent;
window.updateStats = updateStats;
window.getFormattedStats = getFormattedStats;
// Get wallet address - prioritize real wallet address over FID format
window.getWalletAddress = () => {
    // If walletAddress is FID format, try to get real wallet address from Farcaster context
    if (walletAddress && walletAddress.startsWith('farcaster:')) {
        // Try to get real wallet address from Farcaster SDK
        if (window.farcasterSDK) {
            try {
                // Check if we have a real wallet address stored elsewhere
                // This will be handled by updateWalletUI() which sets walletAddress to real address
                // For now, return null to prevent saving with FID format
                console.log('⚠️  getWalletAddress: Found FID format, checking for real wallet address...');
                return null; // Return null to skip save if only FID available
            } catch (e) {
                console.log('⚠️  Error checking for real wallet:', e.message);
            }
        }
        return null; // Don't use FID format for saving scores
    }
    return walletAddress; // Return real wallet address or null
};

// ============================
// On-chain submission (frontend, Base Mainnet)
// ============================

// Minimal contract ABI (must match deployed contract)
// IMPORTANT: Must match the exact function signature from your deployed contract
const CONTRACT_ABI = [
    "function updateScore(string memory playerName, uint256 score, uint256 gamesPlayed, uint256 totalMoves, uint256 totalPlayTime) external",
    "function getPlayerScore(address player) external view returns (string memory, uint256, uint256, uint256, uint256, uint256, uint256)",
    "function getTotalPlayers() external view returns (uint256)",
    "event ScoreUpdated(address indexed player, string playerName, uint256 score, uint256 highScore)"
];

// Base Mainnet chain data
const BASE_MAINNET = {
    chainIdHex: "0x2105", // 8453
    chainIdDec: 8453,
    chainName: "Base",
    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
    rpcUrls: ["https://mainnet.base.org"],
    blockExplorerUrls: ["https://basescan.org"]
};

async function ensureBaseMainnetNetwork() {
    // Check if in Farcaster Mini App (no wallet provider available)
    const isFarcasterMiniApp = window.farcasterSDK && typeof window.farcasterSDK.actions !== 'undefined';
    
    if (isFarcasterMiniApp) {
        // In Farcaster Mini App, network switching is handled by the wallet app
        // We just need to ensure we're requesting the correct chain
        console.log('✅ Farcaster Mini App detected - network switching handled by wallet');
        return true;
    }
    
    // Regular browser with MetaMask
    if (!walletProvider || !walletProvider.request) return false;
    try {
        const current = await walletProvider.request({ method: "eth_chainId" });
        if (current === BASE_MAINNET.chainIdHex) return true;
        // Try switch
        try {
            await walletProvider.request({
                method: "wallet_switchEthereumChain",
                params: [{ chainId: BASE_MAINNET.chainIdHex }]
            });
            return true;
        } catch (switchErr) {
            // Try add chain
            await walletProvider.request({
                method: "wallet_addEthereumChain",
                params: [BASE_MAINNET]
            });
            return true;
        }
    } catch (e) {
        console.error("Network switch/add failed:", e);
        return false;
    }
}

// Public function to submit score on-chain from the user's wallet
async function submitScoreOnChain(score, stats, playerName) {
    try {
        // Check if running in Farcaster Mini App
        const isFarcasterMiniApp = window.farcasterSDK && typeof window.farcasterSDK.actions !== 'undefined';
        
        if (isFarcasterMiniApp) {
            // Use Farcaster Mini App path
            return await submitScoreOnChainFarcaster(score, stats, playerName);
        } else {
            // Use regular browser path (MetaMask)
            return await submitScoreOnChainMetaMask(score, stats, playerName);
        }
    } catch (error) {
        console.error("❌ On-chain submit error:", error);
        // Check if user rejected/cancelled
        if (error?.code === 4001 || error?.message?.includes('rejected') || error?.message?.includes('denied') || error?.message?.includes('user rejected')) {
            console.log("🚫 User cancelled/rejected transaction");
            return { success: false, error: "USER_REJECTED", cancelled: true };
        }
        return { success: false, error: error?.shortMessage || error?.message || "UNKNOWN" };
    }
}

// Submit score on-chain for Farcaster Mini App
async function submitScoreOnChainFarcaster(score, stats, playerName) {
    try {
        console.log('🔄 Submitting score via Farcaster Mini App...');
        
        // Use sdk.wallet.getEthereumProvider() (official method)
        let ethereumProvider = null;
        let addressToUse = null;
        
        if (window.farcasterSDK && window.farcasterSDK.wallet && typeof window.farcasterSDK.wallet.getEthereumProvider === 'function') {
            try {
                // NOTE: getEthereumProvider() returns a Promise, must await it!
                ethereumProvider = await window.farcasterSDK.wallet.getEthereumProvider();
                if (ethereumProvider) {
                    console.log('✅ Got Ethereum provider from Farcaster SDK');
                    console.log('🔍 Provider object:', ethereumProvider);
                    console.log('🔍 Provider type:', typeof ethereumProvider);
                    console.log('🔍 Provider keys:', Object.keys(ethereumProvider || {}));
                    console.log('🔍 Has request method?', typeof ethereumProvider.request === 'function');
                    
                    // Check if it's a valid EIP-1193 provider
                    if (typeof ethereumProvider.request === 'function') {
                        // Get accounts from provider
                        try {
                            const accounts = await ethereumProvider.request({ method: 'eth_accounts' });
                            if (accounts && accounts.length > 0) {
                                addressToUse = accounts[0];
                                console.log('✅ Got wallet address from Ethereum provider:', addressToUse);
                            } else {
                                // Try requesting accounts (might prompt user)
                                const requestedAccounts = await ethereumProvider.request({ method: 'eth_requestAccounts' });
                                if (requestedAccounts && requestedAccounts.length > 0) {
                                    addressToUse = requestedAccounts[0];
                                    console.log('✅ Got wallet address after requesting:', addressToUse);
                                }
                            }
                        } catch (accountsError) {
                            console.log('⚠️  Error getting accounts from provider:', accountsError.message);
                            console.log('🔍 Error details:', accountsError);
                        }
                    } else {
                        console.error('❌ Provider does not have request() method');
                        console.log('💡 Provider structure:', ethereumProvider);
                        console.log('💡 Available methods:', Object.getOwnPropertyNames(ethereumProvider));
                    }
                }
            } catch (providerError) {
                console.error('❌ Failed to get Ethereum provider from Farcaster SDK:', providerError);
                console.log('🔍 Error details:', providerError);
            }
        } else {
            console.log('⚠️  sdk.wallet.getEthereumProvider is not available');
            console.log('🔍 SDK wallet object:', window.farcasterSDK?.wallet);
            console.log('🔍 SDK wallet keys:', window.farcasterSDK?.wallet ? Object.keys(window.farcasterSDK.wallet) : 'no wallet object');
        }
        
        // Fallback: Try to get wallet address from context
        if (!addressToUse) {
            try {
                const context = await window.farcasterSDK.context;
                if (context?.user) {
                    if (context.user.custodyAddress) {
                        addressToUse = context.user.custodyAddress;
                        console.log('✅ Got custodyAddress from Farcaster context (fallback):', addressToUse);
                    } else if (context.user.verifications && Array.isArray(context.user.verifications) && context.user.verifications.length > 0) {
                        const verifiedAddress = context.user.verifications[0];
                        if (verifiedAddress && verifiedAddress.startsWith('0x')) {
                            addressToUse = verifiedAddress;
                            console.log('✅ Got verified address from Farcaster context (fallback):', addressToUse);
                        }
                    }
                }
            } catch (contextError) {
                console.error('❌ Failed to get Farcaster context:', contextError);
            }
        }
        
        // If no wallet address available, we can't do on-chain submission
        // But we can still save to backend leaderboard
        if (!addressToUse || addressToUse.startsWith('farcaster:')) {
            console.log('⚠️  No wallet address available in Farcaster Mini App');
            console.log('💡 Score will be saved to backend leaderboard only (no on-chain submission)');
            // Return success but mark as backend-only
            return { success: true, backendOnly: true, message: "Saved to leaderboard (no wallet for on-chain)" };
        }
        
        // If we have Ethereum provider, use it directly for transaction
        if (ethereumProvider) {
            console.log('✅ Using Ethereum provider for transaction');
            return await submitScoreOnChainWithProvider(ethereumProvider, addressToUse, score, stats, playerName);
        }
        
        // Fallback: Use openUrl method if provider not available
        if (!window.ethers) {
            console.error('❌ Ethers not available');
            return { success: false, error: "ETHERS_NOT_AVAILABLE" };
        }
        
        const contractAddress = window.CONTRACT_ADDRESS;
        if (!contractAddress) {
            console.error('❌ Contract not configured');
            return { success: false, error: "CONTRACT_NOT_CONFIGURED" };
        }
        
        const gamesPlayed = stats?.gamesPlayed ?? 1;
        const totalMoves = stats?.totalMoves ?? 0;
        const totalPlayTime = stats?.totalPlayTime ?? 0;
        
        // Create a simple contract interface to encode data
        const iface = new window.ethers.Interface(CONTRACT_ABI);
        const functionData = iface.encodeFunctionData("updateScore", [
            playerName,
            BigInt(score),
            BigInt(gamesPlayed),
            BigInt(totalMoves),
            BigInt(totalPlayTime)
        ]);
        
        console.log('📝 Encoded transaction data:', functionData);
        
        // Try EIP-681 format (fallback method)
        const eip681Url = `ethereum:${contractAddress}@${BASE_MAINNET.chainIdDec}/transfer?data=${functionData}`;
        
        console.log('🔗 Opening wallet confirmation modal with EIP-681 format (fallback)...');
        
        try {
            await window.farcasterSDK.actions.openUrl(eip681Url);
            console.log('✅ Opened wallet confirmation modal');
            return { success: true, txHash: null, pending: true, message: "Wallet confirmation modal opened" };
        } catch (urlError) {
            console.error('❌ Failed to open wallet confirmation modal:', urlError);
            // If all methods fail, still save to backend
            console.log('💡 Falling back to backend-only save (wallet confirmation unavailable)');
            return { success: true, backendOnly: true, message: "Saved to leaderboard (wallet confirmation unavailable)" };
        }
    } catch (error) {
        console.error("❌ Farcaster on-chain submit error:", error);
        // Even if there's an error, we can still save to backend
        console.log('💡 Falling back to backend-only save due to error');
        return { success: true, backendOnly: true, error: error?.message || "FARCASTER_SUBMIT_FAILED" };
    }
}

// Submit score on-chain using Ethereum provider directly (works for both Farcaster and MetaMask)
async function submitScoreOnChainWithProvider(provider, address, score, stats, playerName) {
    try {
        if (!window.ethers) {
            console.error('❌ Ethers not available');
            return { success: false, error: "ETHERS_NOT_AVAILABLE" };
        }
        
        const contractAddress = window.CONTRACT_ADDRESS;
        if (!contractAddress) {
            console.error('❌ Contract not configured');
            return { success: false, error: "CONTRACT_NOT_CONFIGURED" };
        }
        
        const gamesPlayed = stats?.gamesPlayed ?? 1;
        const totalMoves = stats?.totalMoves ?? 0;
        const totalPlayTime = stats?.totalPlayTime ?? 0;
        
        // Create ethers provider and signer
        // Use let instead of const because we may need to recreate after network switch
        let ethersProvider = new window.ethers.BrowserProvider(provider);
        let signer = await ethersProvider.getSigner();
        
        // Create contract instance
        // Use let instead of const because we may need to recreate after network switch
        let contract = new window.ethers.Contract(contractAddress, CONTRACT_ABI, signer);
        
        // Ensure we're on Base Mainnet
        let networkSwitched = false;
        try {
            let network = await ethersProvider.getNetwork();
            console.log('🔍 Current network chainId:', network.chainId.toString());
            console.log('🔍 Target chainId:', BASE_MAINNET.chainIdDec.toString());
            
            if (network.chainId !== BigInt(BASE_MAINNET.chainIdDec)) {
                console.log('⚠️  Not on Base Mainnet, attempting to switch...');
                // Try to switch network via provider
                try {
                    await provider.request({
                        method: 'wallet_switchEthereumChain',
                        params: [{ chainId: BASE_MAINNET.chainIdHex }]
                    });
                    networkSwitched = true;
                    console.log('✅ Network switch requested');
                } catch (switchError) {
                    console.log('⚠️  Switch failed, trying to add chain:', switchError.message);
                    // Try to add chain
                    try {
                        await provider.request({
                            method: 'wallet_addEthereumChain',
                            params: [BASE_MAINNET]
                        });
                        networkSwitched = true;
                        console.log('✅ Network add requested');
                    } catch (addError) {
                        console.error('❌ Failed to switch/add network:', addError.message);
                        // Don't throw error - continue anyway, wallet might handle it
                        console.log('💡 Continuing with transaction - wallet may handle network switch');
                    }
                }
                
                // Wait for network to stabilize after switch (if switch was requested)
                if (networkSwitched) {
                    console.log('⏳ Waiting for network to stabilize...');
                    await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds
                    
                    try {
                        // Recreate provider and verify network
                        ethersProvider = new window.ethers.BrowserProvider(provider);
                        network = await ethersProvider.getNetwork();
                        
                        if (network.chainId !== BigInt(BASE_MAINNET.chainIdDec)) {
                            console.warn('⚠️  Still not on Base Mainnet after switch, but continuing...');
                            console.warn('💡 Wallet may handle network switch during transaction');
                        } else {
                            console.log('✅ Confirmed on Base Mainnet');
                        }
                        
                        // Recreate signer and contract instance with new provider
                        signer = await ethersProvider.getSigner();
                        contract = new window.ethers.Contract(contractAddress, CONTRACT_ABI, signer);
                    } catch (recreateError) {
                        console.warn('⚠️  Error recreating provider after switch:', recreateError.message);
                        console.warn('💡 Continuing with original provider - wallet may handle it');
                    }
                }
            } else {
                console.log('✅ Already on Base Mainnet');
            }
        } catch (networkError) {
            console.error('❌ Network error (non-fatal):', networkError.message);
            // Don't throw - continue with transaction, wallet may handle network switch
            console.log('💡 Continuing with transaction - wallet may handle network switch');
        }
        
        console.log('📝 Submitting transaction via Ethereum provider...');
        console.log('📋 Transaction details:', {
            to: contractAddress,
            function: 'updateScore',
            params: { playerName, score, gamesPlayed, totalMoves, totalPlayTime }
        });
        
        // Get fee data from network (let wallet estimate if possible)
        // Use fallback if network was just switched (to avoid network change errors)
        let feeOverrides = {};
        try {
            const feeData = await ethersProvider.getFeeData();
            console.log('📊 Fee data from network:', {
                maxFeePerGas: feeData.maxFeePerGas?.toString(),
                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas?.toString(),
                gasPrice: feeData.gasPrice?.toString()
            });
            
            // Use network fee data if available, otherwise use fallback
            // Base Mainnet typically has higher gas fees than testnet
            const fallbackMaxFee = window.ethers.parseUnits('0.01', 'gwei');       // 0.01 gwei for Base Mainnet (adjust as needed)
            const fallbackMaxPriority = window.ethers.parseUnits('0.001', 'gwei'); // 0.001 gwei for Base Mainnet (adjust as needed)
            
            // Estimate gas first to avoid "out of gas" errors
            let estimatedGas = null;
            try {
                console.log('⛽ Estimating gas for transaction...');
                estimatedGas = await contract.updateScore.estimateGas(
                    playerName,
                    BigInt(score),
                    BigInt(gamesPlayed),
                    BigInt(totalMoves),
                    BigInt(totalPlayTime)
                );
                console.log('✅ Estimated gas:', estimatedGas.toString());
                // Add 20% buffer for safety
                estimatedGas = (estimatedGas * BigInt(120)) / BigInt(100);
                console.log('✅ Gas with 20% buffer:', estimatedGas.toString());
            } catch (estimateError) {
                console.log('⚠️  Could not estimate gas, using default:', estimateError.message);
                // Use higher default if estimation fails
                estimatedGas = BigInt(400000);
            }
            
            feeOverrides = {
                gasLimit: estimatedGas || BigInt(400000), // Use estimated gas or safe default
                maxFeePerGas: feeData.maxFeePerGas ?? fallbackMaxFee,
                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas ?? fallbackMaxPriority
            };
            
            console.log('💰 Using fee overrides:', {
                maxFeePerGas: feeOverrides.maxFeePerGas?.toString(),
                maxPriorityFeePerGas: feeOverrides.maxPriorityFeePerGas?.toString(),
                gasLimit: feeOverrides.gasLimit.toString()
            });
        } catch (feeError) {
            console.log('⚠️  Could not get fee data, using fallback:', feeError.message);
            // Fallback fees for Base Mainnet (especially important after network switch)
            // Use higher gas limit to avoid "out of gas" errors
            // Base Mainnet typically has higher gas fees than testnet
            feeOverrides = {
                gasLimit: 400000, // Increased from 200000 to 400000
                maxFeePerGas: window.ethers.parseUnits('0.01', 'gwei'), // Adjust based on current Base Mainnet gas prices
                maxPriorityFeePerGas: window.ethers.parseUnits('0.001', 'gwei') // Adjust based on current Base Mainnet gas prices
            };
            console.log('💰 Using fallback fees (network may have just switched):', {
                maxFeePerGas: feeOverrides.maxFeePerGas?.toString(),
                maxPriorityFeePerGas: feeOverrides.maxPriorityFeePerGas?.toString(),
                gasLimit: feeOverrides.gasLimit
            });
        }
        
        // Send transaction
        console.log('📤 Sending transaction with gas limit:', feeOverrides.gasLimit.toString());
        const tx = await contract.updateScore(
            playerName,
            BigInt(score),
            BigInt(gamesPlayed),
            BigInt(totalMoves),
            BigInt(totalPlayTime),
            feeOverrides
        );
        
        console.log('✅ Transaction sent, hash:', tx.hash);
        
        // Try to wait for confirmation, but don't fail if Farcaster Wallet doesn't support it
        let receipt = null;
        try {
            console.log('⏳ Waiting for confirmation...');
            receipt = await tx.wait();
            console.log('✅ Transaction confirmed:', receipt);
        } catch (waitError) {
            // Farcaster Wallet may not support eth_getTransactionReceipt
            if (waitError?.message?.includes('unsupported') || 
                waitError?.message?.includes('eth_getTransactionReceipt') ||
                waitError?.code === 'UNSUPPORTED_OPERATION') {
                console.log('⚠️  Farcaster Wallet does not support waiting for receipt');
                console.log('💡 Transaction was sent successfully, hash:', tx.hash);
                console.log('💡 You can check the transaction on Base Mainnet explorer (basescan.org)');
            } else {
                // Re-throw if it's a different error
                throw waitError;
            }
        }
        
        return {
            success: true,
            txHash: tx.hash,
            receipt: receipt,
            message: receipt ? "Score submitted on-chain successfully" : "Transaction sent (receipt not available)"
        };
    } catch (error) {
        console.error("❌ On-chain submit error with provider:", error);
        // Check if user rejected/cancelled
        if (error?.code === 4001 || error?.message?.includes('rejected') || error?.message?.includes('denied') || error?.message?.includes('user rejected')) {
            console.log("🚫 User cancelled/rejected transaction");
            return { success: false, error: "USER_REJECTED", cancelled: true };
        }
        return { success: false, error: error?.shortMessage || error?.message || "UNKNOWN" };
    }
}

// Submit score on-chain for regular browser (MetaMask) - original code
async function submitScoreOnChainMetaMask(score, stats, playerName) {
    try {
        if (!walletAddress) {
            alert("Please connect your wallet first.");
            return { success: false, error: "WALLET_NOT_CONNECTED" };
        }
        if (!window.ethers) {
            alert("Ethers not available. Please refresh the page.");
            return { success: false, error: "ETHERS_NOT_AVAILABLE" };
        }
        const contractAddress = window.CONTRACT_ADDRESS;
        if (!contractAddress) {
            alert("Contract not configured. Please set window.CONTRACT_ADDRESS in config.js");
            return { success: false, error: "CONTRACT_NOT_CONFIGURED" };
        }

        const ok = await ensureBaseMainnetNetwork();
        if (!ok) {
            alert("Failed to switch to Base Mainnet.");
            return { success: false, error: "NETWORK_SWITCH_FAILED" };
        }

        const provider = new window.ethers.BrowserProvider(walletProvider);
        const signer = await provider.getSigner();
        const contract = new window.ethers.Contract(contractAddress, CONTRACT_ABI, signer);

        // Verify contract exists and is callable
        try {
            const code = await provider.getCode(contractAddress);
            if (code === "0x" || code === "0x0") {
                alert(`No contract found at address ${contractAddress}. Please verify the contract address.`);
                return { success: false, error: "NO_CONTRACT_AT_ADDRESS" };
            }
            console.log("Contract code found, length:", code.length);
        } catch (codeErr) {
            console.error("Failed to check contract code:", codeErr);
        }

        // Quick ABI sanity check
        try {
            contract.interface.getFunction("updateScore");
        } catch (abiErr) {
            console.error("ABI does not contain updateScore:", abiErr);
            alert("Contract ABI mismatch: updateScore(...) not found. Please provide the correct ABI of your contract.");
            return { success: false, error: "ABI_MISMATCH" };
        }

        // Try to call a view function to verify contract is accessible
        try {
            const totalPlayers = await contract.getTotalPlayers();
            console.log("Contract is accessible. Total players:", totalPlayers.toString());
        } catch (viewErr) {
            console.warn("Could not call view function (may not exist):", viewErr.message);
            // Continue anyway - view function might not exist
        }

        const gamesPlayed = stats?.gamesPlayed ?? 1;
        const totalMoves = stats?.totalMoves ?? 0;
        const totalPlayTime = stats?.totalPlayTime ?? 0;

        // Debug: Log parameters
        console.log("Submitting score:", {
            playerName,
            score,
            gamesPlayed,
            totalMoves,
            totalPlayTime,
            contractAddress
        });

        // Prepare fee overrides (helps wallets that fail to estimate on Base Mainnet)
        const feeData = await provider.getFeeData();
        // Fallback fees for Base Mainnet (adjust based on current network conditions)
        const fallbackMaxFee = window.ethers.parseUnits('0.01', 'gwei');       // 0.01 gwei (adjust as needed)
        const fallbackMaxPriority = window.ethers.parseUnits('0.001', 'gwei'); // 0.001 gwei (adjust as needed)
        const overrides = {
            gasLimit: 200000, // Increased for safety
            maxFeePerGas: feeData?.maxFeePerGas ?? fallbackMaxFee,
            maxPriorityFeePerGas: feeData?.maxPriorityFeePerGas ?? fallbackMaxPriority,
            value: 0 // explicit zero value
        };

        // Encode function data manually to debug
        let functionData;
        try {
            functionData = contract.interface.encodeFunctionData("updateScore", [
                playerName,
                score,
                gamesPlayed,
                totalMoves,
                totalPlayTime
            ]);
            console.log("Encoded function data:", functionData);
            console.log("Data length:", functionData.length);
        } catch (encodeErr) {
            console.error("Failed to encode function data:", encodeErr);
            alert(`Failed to encode transaction: ${encodeErr.message}`);
            return { success: false, error: "ENCODE_FAILED", details: encodeErr.message };
        }

        // Try static call first to simulate transaction (won't actually execute)
        // NOTE: Static call might fail on some contracts, so we'll continue anyway
        try {
            console.log("Simulating transaction (static call)...");
            await contract.updateScore.staticCall(
                playerName,
                BigInt(score),
                BigInt(gamesPlayed),
                BigInt(totalMoves),
                BigInt(totalPlayTime)
            );
            console.log("Static call succeeded - transaction should work");
        } catch (staticErr) {
            console.warn("Static call failed (but continuing anyway):", staticErr.message);
            // Don't block transaction - some contracts don't support static calls
            // The actual transaction might still work
        }

        // Send transaction with explicit gas and EIP-1559 fees
        console.log("Sending transaction...");
        const tx = await contract.updateScore(
            playerName,
            BigInt(score),
            BigInt(gamesPlayed),
            BigInt(totalMoves),
            BigInt(totalPlayTime),
            overrides
        );
        console.log("Transaction sent, waiting for confirmation...", tx.hash);
        const receipt = await tx.wait();
        console.log("✅ On-chain submit success:", receipt.hash);
        return { success: true, txHash: receipt.hash };
    } catch (error) {
        console.error("❌ On-chain submit error:", error);
        // Check if user rejected/cancelled
        if (error?.code === 4001 || error?.message?.includes('rejected') || error?.message?.includes('denied') || error?.message?.includes('user rejected')) {
            console.log("🚫 User cancelled/rejected transaction");
            return { success: false, error: "USER_REJECTED", cancelled: true };
        }
        return { success: false, error: error?.shortMessage || error?.message || "UNKNOWN" };
    }
}

// Expose to global
window.submitScoreOnChain = submitScoreOnChain;