/*
AI ASSISTANT INTEGRATION GUIDE:
-----------------------------
To have the AI assistant automatically implement this API handler for your game:

1. Share your game's details with the AI:
   - Game name
   - Base URL (if different from default)
   - Any specific requirements for score tracking
   - Any special game states or events that need API integration

2. The AI will:
   - Replace "GAME_NAME" with your actual game name
   - Update the base URL if needed
   - Add any game-specific score tracking
   - Integrate with your game's existing code
   - Add necessary event listeners
   - Set up proper score submission points

3. The AI will also:
   - Check your game's code structure
   - Identify where to add API calls
   - Ensure proper initialization
   - Add necessary logging
   - Handle any game-specific edge cases

4. After implementation, the AI will:
   - Verify the integration
   - Test the score submission flow
   - Ensure proper error handling
   - Check for any conflicts with existing code

Example prompt for the AI:
"I need to implement the API handler for my game [GAME_NAME]. 
The game uses [FRAMEWORK/ENGINE] and tracks scores in [LOCATION].
Please help me integrate the API handler and ensure proper score submission."

The AI will then:
1. Analyze your game's code
2. Make necessary modifications
3. Add the API handler
4. Ensure everything works together
*/

// API Handler Template for Games
// --------------------------------
// HOW TO USE:
// 1. Copy this file to your new game project
// 2. Replace "GAME_NAME" with your actual game name (e.g., "zombiearrow", "woodtreasurehunt")
// 3. Include this file in your HTML before your main game script
// 4. Call apiHandler.generateToken() at game start
// 5. Call apiHandler.submitScoreIfNeeded(score) at game end

class APIHandler {
    constructor(baseUrl = 'https://cgames.unlimitedgames.info/multicolorcards') {
        this.baseUrl = baseUrl; // Base URL without /api.php
        this.session_id = Date.now().toString();
        this.cachedToken = localStorage.getItem('gameToken');
        this.cachedDeviceInfo = localStorage.getItem('deviceInfo') ? JSON.parse(localStorage.getItem('deviceInfo')) : null;
        this.scoreSubmitted = false; // Flag to track if score has been submitted
        this.gameStartTime = Date.now(); // When the game session started - initialize immediately
        this.lastActivityTime = Date.now(); // Initialize with current time
        this.lastScoreSubmissionTime = 0; // Track when the last score was submitted
        this.lastSubmittedScore = 0; // Track the last score value that was submitted
        this.gameToken = null; // Will store the verified token
        
        // Start tracking activity immediately
        this.setupGlobalActivityTracking();
        
        console.log('API Handler initialized with session_id:', this.session_id);
        console.log('Using base URL:', this.baseUrl);
    }
    
    // Verify token at game start
    async verifyTokenAtStart() {
        try {
            this.gameToken = await this.generateToken();
            console.log('Token verified at game start:', this.gameToken ? this.gameToken.substring(0, 10) + '...' : 'null');
            return this.gameToken;
        } catch (error) {
            console.error('Failed to verify token at game start:', error);
            
            // Create an emergency token even if verification fails
            console.log('Generating emergency token due to verification failure');
            this.gameToken = 'emergency_token_' + Date.now();
            return this.gameToken;
        }
    }

    // Set up global activity tracking - called on initialization
    setupGlobalActivityTracking() {
        // Set up global inactivity checker if not already done
        if (!window.inactivityChecker) {
            window.inactivityChecker = setInterval(() => {
                // Check if game has been inactive for too long
                const inactiveTime = Date.now() - this.lastActivityTime;
                console.log('Inactive time:', Math.floor(inactiveTime/1000), 'seconds');
                
                if (this.isInactive(15 * 60 * 1000)) { // Changed back to 15 minutes
                    console.log('Inactivity detected! Showing message panel...');
                    this.handleInactivity();
                    
                    // Clear the interval after handling inactivity
                    clearInterval(window.inactivityChecker);
                    window.inactivityChecker = null;
                }
            }, 5000); // Check every 5 seconds for faster response
        }
        
        // Set up global activity event listeners
        if (!window.activityTrackingInitialized) {
            // Track common user interactions
            document.addEventListener('click', () => this.updateActivity());
            document.addEventListener('keydown', () => this.updateActivity());
            document.addEventListener('touchstart', () => this.updateActivity());
            document.addEventListener('mousemove', () => this.updateActivity());
            
            // Add visibility change listener for tab switching
            document.addEventListener('visibilitychange', () => {
                if (document.visibilityState === 'hidden') {
                    console.log('Tab visibility changed - submitting score');
                    this.submitScoreIfNeeded();
                }
            });
            
            // Mark tracking as initialized to prevent duplicates
            window.activityTrackingInitialized = true;
        }
    }
    
    // Handle inactivity - directly shows message and terminates session
    handleInactivity() {
        // Don't handle multiple times
        if (document.getElementById('inactivity-overlay')) {
            return;
        }
        
        console.log('Session inactive for too long - displaying message');
        
        // Try to pause the game using available methods
        this.attemptPauseGame();
        
        // Ensure score is submitted
        this.submitScoreIfNeeded();
        
        // Add warning message through API system or show our own
        this.showInactivityMessage();
    }
    
    // Method to attempt pausing the game using various techniques
    attemptPauseGame() {
        try {
            // Method 1: Check for common game pause functions
            if (typeof window.pauseGame === 'function') {
                window.pauseGame();
                console.log('Game paused using window.pauseGame()');
                return true;
            }
            
            // Method 2: Check for global game object with pause function
            if (window.game && typeof window.game.pause === 'function') {
                window.game.pause();
                console.log('Game paused using game.pause()');
                return true;
            }
            
            // Method 3: Try to stop game loops by overriding requestAnimationFrame
            const originalRAF = window.requestAnimationFrame;
            window.requestAnimationFrame = function(callback) {
                console.log('RequestAnimationFrame intercepted due to inactivity');
                return null; // Return an ID that can never be canceled
            };
            
            // Store the original to potentially restore later
            window._originalRequestAnimationFrame = originalRAF;
            
            console.log('Game attempted to pause by overriding requestAnimationFrame');
            return true;
        } catch (error) {
            console.error('Failed to pause game:', error);
            return false;
        }
    }
    
    // Submit score if needed based on conditions
    async submitScoreIfNeeded(currentScore = window.playerData?.score || 0) {
        try {
            // Store 0 in session storage if no gameplay has occurred
            if (currentScore === 100000) {
                sessionStorage.setItem('gameScore', '0');
                console.log('No gameplay yet - storing 0 in session storage');
                return false;
            }

            // Store the score in session storage for actual gameplay
            if (currentScore > 0) {
                sessionStorage.setItem('gameScore', currentScore.toString());
                console.log('Stored score in session storage:', currentScore);
            }

            // If no token yet, try to get one
            if (!this.gameToken) {
                this.gameToken = await this.generateToken().catch(e => {
                    console.warn('Failed to generate token for score submission:', e);
                    return null;
                });
            }

            // Always validate the token before submitting the score
            let isValid = false;
            if (this.gameToken) {
                isValid = await this.validateToken(this.gameToken).catch(() => false);
            }
            if (!isValid) {
                console.warn('Token invalid before score submission, generating new token');
                this.gameToken = await this.generateToken().catch(e => {
                    console.warn('Failed to generate token for score submission:', e);
                    return null;
                });
            }
            // Don't continue if no valid token or already submitted
            if (!this.gameToken || this.scoreSubmitted) {
                console.log('Score not submitted: ', 
                    !this.gameToken ? 'No valid token' : 'Already submitted');
                return false;
            }
            // Get current player score
            console.log('Current score to submit:', currentScore);
            // Don't submit if score is unchanged and was recently submitted
            const scoreChanged = currentScore !== this.lastSubmittedScore;
            const now = Date.now();
            const recentlySubmitted = (now - this.lastScoreSubmissionTime) < 5000; // 5 seconds
            if (!scoreChanged && recentlySubmitted) {
                console.log('Score unchanged and recently submitted - skipping');
                return false;
            }
            // Track this submission
            this.lastScoreSubmissionTime = now;
            this.lastSubmittedScore = currentScore;
            // Submit the score
            const result = await this.submitFinalScore(
                this.gameToken, 
                currentScore, 
                Math.floor((now - this.gameStartTime) / 1000));
            return result;
        } catch (error) {
            console.error('Error in submitScoreIfNeeded:', error);
            return false;
        }
    }
    
    // Show inactivity message when timeout is reached
    showInactivityMessage() {
        console.log('Attempting to show inactivity message overlay...');
        
        try {
            // Force removal of any existing overlay first to avoid conflicts
            const existingOverlay = document.getElementById('inactivity-overlay');
            if (existingOverlay && existingOverlay.parentNode) {
                existingOverlay.parentNode.removeChild(existingOverlay);
                console.log('Removed existing overlay to create a new one');
            }
            
            // Create a new overlay container
            console.log('Creating inactivity overlay element');
            const overlay = document.createElement('div');
            overlay.id = 'inactivity-overlay';
            overlay.style.position = 'fixed';
            overlay.style.top = '0';
            overlay.style.left = '0';
            overlay.style.width = '100%';
            overlay.style.height = '100%';
            overlay.style.backgroundColor = 'rgba(0, 0, 0, 0.9)';
            overlay.style.zIndex = '999999'; // Very high z-index to ensure visibility
            overlay.style.display = 'flex';
            overlay.style.flexDirection = 'column';
            overlay.style.alignItems = 'center';
            overlay.style.justifyContent = 'center';
            overlay.style.fontFamily = 'Arial, sans-serif';
            overlay.style.color = 'white';
            overlay.style.textAlign = 'center';
            overlay.style.padding = '20px';
            
            // Create message elements
            const message = document.createElement('div');
            message.style.fontSize = '24px';
            message.style.marginBottom = '20px';
            message.style.maxWidth = '80%';
            message.innerHTML = '<strong>Your game session has timed out due to inactivity</strong>';
            
            const submessage = document.createElement('div');
            submessage.style.fontSize = '18px';
            submessage.style.marginBottom = '30px';
            submessage.style.maxWidth = '80%';
            submessage.innerHTML = 'Your progress has been saved. Click the button below to return to the game.';
            
            // Create button
            const button = document.createElement('button');
            button.innerText = 'Refresh';
            button.style.padding = '15px 30px';
            button.style.fontSize = '18px';
            button.style.backgroundColor = '#4CAF50';
            button.style.color = 'white';
            button.style.border = 'none';
            button.style.borderRadius = '4px';
            button.style.cursor = 'pointer';
            button.style.fontWeight = 'bold';
            button.style.boxShadow = '0 4px 6px rgba(0,0,0,0.1)';
            
            // Hover effect
            button.onmouseover = () => {
                button.style.backgroundColor = '#45a049';
            };
            button.onmouseout = () => {
                button.style.backgroundColor = '#4CAF50';
            };
            
            // Click handler
            button.onclick = () => {
                console.log('Inactivity overlay button clicked - performing full page refresh');
                
                // Force a complete refresh with no cache
                window.location.href = window.location.href.split('#')[0] + '?refresh=' + Date.now();
                
                // As a fallback, also use the standard reload with cache bypass
                setTimeout(() => {
                    console.log('Using fallback reload method');
                    window.location.reload(true);
                }, 100);
            };
            
            // Assemble the overlay
            overlay.appendChild(message);
            overlay.appendChild(submessage);
            overlay.appendChild(button);
            
            // Add to document
            document.body.appendChild(overlay);
            console.log('Inactivity message overlay added to document.body');
            
            // Add a subtle fade-in animation
            overlay.style.opacity = '0';
            setTimeout(() => {
                overlay.style.transition = 'opacity 0.5s ease-in-out';
                overlay.style.opacity = '1';
                console.log('Inactivity overlay fade-in animation applied');
            }, 10);
            
            return true;
        } catch (error) {
            console.error('Error in showInactivityMessage:', error);
            // Fallback method if the fancy overlay fails
            try {
                alert('Your game session has timed out due to inactivity. The page will now reload.');
                window.location.reload();
            } catch (alertError) {
                console.error('Even the alert fallback failed:', alertError);
            }
            return false;
        }
    }
    
    // Check if game is inactive for the specified duration (in milliseconds)
    isInactive(durationMs = 60 * 60 * 1000) { // Default to 1 hour
        const inactiveTime = Date.now() - this.lastActivityTime;
        return inactiveTime > durationMs;
    }
    
    // Update the last activity timestamp whenever user interaction is detected
    updateActivity() {
        this.lastActivityTime = Date.now();
    }
    
    // Get device info, using cache if available
    _getDeviceInfo() {
        // Use cached info if available
        if (this.cachedDeviceInfo) {
            return this.cachedDeviceInfo;
        }
        
        // Default values for browser environment
        const deviceInfo = {
            handset_os: 'unknown',
            device_brand: 'unknown',
            device_model: 'browser'
        };
        
        try {
            // Try to detect operating system
            const userAgent = navigator.userAgent;
            
            if (/Windows/.test(userAgent)) {
                deviceInfo.handset_os = 'windows';
            } else if (/Android/.test(userAgent)) {
                deviceInfo.handset_os = 'android';
            } else if (/iPhone|iPad|iPod/.test(userAgent)) {
                deviceInfo.handset_os = 'ios';
            } else if (/Mac OS X/.test(userAgent)) {
                deviceInfo.handset_os = 'macos';
            } else if (/Linux/.test(userAgent)) {
                deviceInfo.handset_os = 'linux';
            }
            
            // Try to detect browser as "brand"
            if (/Chrome/.test(userAgent)) {
                deviceInfo.device_brand = 'chrome';
            } else if (/Firefox/.test(userAgent)) {
                deviceInfo.device_brand = 'firefox';
            } else if (/Safari/.test(userAgent)) {
                deviceInfo.device_brand = 'safari';
            } else if (/Edge/.test(userAgent)) {
                deviceInfo.device_brand = 'edge';
            } else if (/Opera|OPR/.test(userAgent)) {
                deviceInfo.device_brand = 'opera';
            } else if (/MSIE|Trident/.test(userAgent)) {
                deviceInfo.device_brand = 'ie';
            }
            
            // Add mobile indication if needed
            if (/Mobi|Android/.test(userAgent)) {
                deviceInfo.device_model = 'mobile_browser';
            }
            
            // Add more detailed device detection for mobile
            if (/iPhone/.test(userAgent)) {
                deviceInfo.device_brand = 'apple';
                deviceInfo.device_model = 'iphone';
            } else if (/iPad/.test(userAgent)) {
                deviceInfo.device_brand = 'apple';
                deviceInfo.device_model = 'ipad';
            } else if (/Android/.test(userAgent)) {
                // Try to extract manufacturer from user agent
                const match = userAgent.match(/Android.*?; ([^;]+) Build[/ ]/);
                if (match && match[1]) {
                    const manufacturer = match[1].split(' ')[0].toLowerCase();
                    deviceInfo.device_brand = manufacturer;
                    deviceInfo.device_model = 'android_device';
                }
            }
            
            // Cache the device info for future use
            localStorage.setItem('deviceInfo', JSON.stringify(deviceInfo));
            this.cachedDeviceInfo = deviceInfo;
            
            return deviceInfo;
        } catch (error) {
            console.error('Error detecting device info:', error);
            return deviceInfo;
        }
    }
    
    // Generate a token for the game session
    async generateToken() {
        try {
            // Check if we have a cached token
            if (this.cachedToken) {
                // Verify the cached token first
                const isValid = await this.validateToken(this.cachedToken).catch(() => false);
                
                if (isValid) {
                    console.log('Using cached token:', this.cachedToken.substring(0, 10) + '...');
                    this.gameToken = this.cachedToken;
                    return this.cachedToken;
                } else {
                    console.log('Cached token invalid, generating new token');
                    localStorage.removeItem('gameToken');
                    this.cachedToken = null;
                }
            }
            
            // Get device info
            const deviceInfo = this._getDeviceInfo();
            const { handset_os, device_brand, device_model } = deviceInfo;
            
            // Default values for additional required parameters
            const msisdn = '9800000000'; // Default phone number for web
            const country = 'US';         // Default country
            const operator = device_brand; // Use browser brand as operator
            
            // Construct token request URL with all required parameters
            const url = `${this.baseUrl}/api.php/protoken?handset_os=${encodeURIComponent(handset_os)}&device_brand=${encodeURIComponent(device_brand)}&device_model=${encodeURIComponent(device_model)}&msisdn=${encodeURIComponent(msisdn)}&_country=${encodeURIComponent(country)}&_operator=${encodeURIComponent(operator)}`;
            
            console.log('Generating token from URL:', url);
            
            try {
                const response = await fetch(url, {
                    method: 'GET',
                    headers: {
                        'Accept': 'application/json',
                        'Cache-Control': 'no-cache'
                    }
                });
                
                if (!response.ok) {
                    throw new Error(`HTTP error! status: ${response.status}`);
                }
                
                // Clone the response so we can read it multiple ways if needed
                const responseClone = response.clone();
                
                // First, try to get the response as text
                const textResponse = await response.text();
                console.log('Token API response received');
                
                // Check if the response is direct token text (no JSON formatting)
                if (textResponse && textResponse.length > 10 && !textResponse.includes('{') && !textResponse.includes(':')) {
                    // The response appears to be a raw token
                    const token = textResponse.trim();
                    console.log('Direct token received:', token.substring(0, 10) + '...');
                    
                    // Store token and reset game start time
                    localStorage.setItem('gameToken', token);
                    this.cachedToken = token;
                    this.gameToken = token;
                    this.gameStartTime = Date.now();
                    
                    return token;
                }
                
                // If not a direct token, try to parse as JSON
                try {
                    const data = JSON.parse(textResponse);
                    
                    if (data && data.token) {
                        console.log('Token extracted from JSON:', data.token.substring(0, 10) + '...');
                        
                        // Store token and reset game start time
                        localStorage.setItem('gameToken', data.token);
                        this.cachedToken = data.token;
                        this.gameToken = data.token;
                        this.gameStartTime = Date.now();
                        
                        return data.token;
                    }
                } catch (jsonError) {
                    // Not valid JSON, try to extract token using regex
                    const tokenMatch = textResponse.match(/"token"\s*:\s*"([^"]+)"/i);
                    if (tokenMatch && tokenMatch[1]) {
                        const extractedToken = tokenMatch[1];
                        console.log('Extracted token from text response:', extractedToken.substring(0, 10) + '...');
                        
                        // Store token and reset game start time
                        localStorage.setItem('gameToken', extractedToken);
                        this.cachedToken = extractedToken;
                        this.gameToken = extractedToken;
                        this.gameStartTime = Date.now();
                        
                        return extractedToken;
                    }
                }
                
                // If we've reached this point, couldn't extract a token
                console.log('Could not extract token from response, using fallback');
                const fallbackToken = 'fallback_token_' + Date.now();
                this.gameToken = fallbackToken;
                return fallbackToken;
            } catch (fetchError) {
                console.warn('API error during token generation:', fetchError.message);
                
                // Generate a development token if API fails
                const devToken = 'dev_token_' + Date.now();
                console.log('Using development token:', devToken);
                
                // Store token
                localStorage.setItem('gameToken', devToken);
                this.cachedToken = devToken;
                this.gameToken = devToken;
                
                return devToken;
            }
        } catch (error) {
            console.error('Error in generateToken:', error);
            throw error;
        }
    }
    
    // Validate token with server
    async validateToken(token) {
        if (!token) {
            console.warn('No token provided for validation');
            return false;
        }
        try {
            const url = `${this.baseUrl}/api.php/chktoken?token=${encodeURIComponent(token)}`;
            console.log('Validating token at URL:', url);
            const response = await fetch(url, { 
                method: 'GET',
                headers: {
                    'Cache-Control': 'no-cache',
                    'Pragma': 'no-cache'
                }
            });
            
            if (!response.ok) {
                console.warn('Token validation failed with status:', response.status);
                return false;
            }
            
            const validationText = await response.text();
            const isValid = validationText.trim().toLowerCase() === 'valid';
            console.log('Token validation result:', isValid ? 'valid' : 'invalid');
            return isValid;
        } catch (error) {
            console.error('Error validating token:', error);
            return false;
        }
    }
    
    // Simple token check without async verification - only used for basic format validation
    isTokenValid(token) {
        // Check if token exists and has a reasonable format
        return token && 
               token.length > 10 && 
               !token.startsWith('emergency_token_') && 
               !token.startsWith('fallback_token_') && 
               !token.startsWith('dev_token_');
    }
    
    // Submit final score for the game
    async submitFinalScore(token, currentScore, totalDuration) {
        try {
            // Prevent multiple score submissions with the same token
            if (this.scoreSubmitted) {
                console.warn('⚠️ Score has already been submitted for this session');
                return { status: 'skipped', message: 'Score already submitted for this session' };
            }
            
            if (!token || totalDuration === undefined) {
                console.warn('⚠️ Cannot submit score: missing token or duration');
                return { status: 'error', message: 'Missing token or duration' };
            }
            
            // ✅ Basic validation passed
            console.log('🔵 SUBMIT SCORE: Valid token and duration');
            
            // ✅ Continue only if checks passed
            console.log('🔵 SUBMIT SCORE: Starting submission for score:', currentScore);
            const deviceInfo = this._getDeviceInfo();
            const { handset_os, device_brand, device_model } = deviceInfo;
            console.log('🔵 SUBMIT SCORE: Device info:', { handset_os, device_brand, device_model });
            
            const gameStartTime = this.gameStartTime || (Date.now() - totalDuration * 1000);
            const gameEndTime = Date.now();

            // Format dates in exactly the format the API expects (yyyy-mm-dd hh:mm:ss)
            const formatDate = (date) => {
                const d = new Date(date);
                const local = new Date(d.getTime() - d.getTimezoneOffset() * 60000);
                return `${local.getFullYear()}-${String(local.getMonth() + 1).padStart(2, '0')}-${String(local.getDate()).padStart(2, '0')} ${String(local.getHours()).padStart(2, '0')}:${String(local.getMinutes()).padStart(2, '0')}:${String(local.getSeconds()).padStart(2, '0')}`;
            };

            // Format the timestamps in the requested format
            const formattedStartTime = formatDate(gameStartTime);
            const formattedEndTime = formatDate(gameEndTime);
            
            // Format and log the timestamps in the requested format
            console.log('gamestarttime');
            console.log(formattedStartTime);
            console.log('gameendtime');
            console.log(formattedEndTime);

            // Get the level number - check multiple possible sources
            let gameLevelNumber = 1; // Default to 1 if no level found
            
            // Try to get level from different possible sources
            if (window.gameData && typeof window.gameData.challengeNum !== 'undefined') {
                // Use challengeNum which is the displayed level number
                gameLevelNumber = window.gameData.challengeNum;
                console.log('Using level from gameData.challengeNum:', gameLevelNumber);
            } else if (window.gameData && typeof window.gameData.levelNum !== 'undefined') {
                // Use levelNum directly without adding 1
                gameLevelNumber = window.gameData.levelNum;
                console.log('Using level from gameData.levelNum:', gameLevelNumber);
            } else if (window.playerData?.categoryIndex !== undefined) {
                gameLevelNumber = window.playerData.categoryIndex;
                console.log('Using level from playerData.categoryIndex:', gameLevelNumber);
            } else if (window.playerData?.level !== undefined) {
                gameLevelNumber = window.playerData.level;
                console.log('Using level from playerData.level:', gameLevelNumber);
            } else if (window.game?.level !== undefined) {
                gameLevelNumber = window.game.level;
                console.log('Using level from game.level:', gameLevelNumber);
            } else if (window.currentLevel !== undefined) {
                gameLevelNumber = window.currentLevel;
                console.log('Using level from window.currentLevel:', gameLevelNumber);
            }
            
            // Ensure level is a number and at least 1
            gameLevelNumber = Math.max(1, parseInt(gameLevelNumber) || 1);
            console.log('Final level number to submit:', gameLevelNumber);

            // Build API request parameters with EXACTLY the required fields in the exact order
            const params = [
                // Matching exact order as specified in the API documentation
                `handset_os=${encodeURIComponent(handset_os || 'android')}`,
                `device_brand=${encodeURIComponent(device_brand || 'samsung')}`,
                `device_model=${encodeURIComponent(device_model || 'browser')}`,
                `gamename=multicolorcards`,
                `gamelevel=${encodeURIComponent(gameLevelNumber)}`,
                `gamestarttime=${encodeURIComponent(formattedStartTime)}`,
                `gameendtime=${encodeURIComponent(formattedEndTime)}`,
                `gduration=${totalDuration}`,
                `gscore=${currentScore}`,
                `session_id=${this.session_id}`
            ];

            // Construct the URL using the correct endpoint format
            const url = `${this.baseUrl}/api.php/scorepost?${params.join('&')}`;
            console.log('SUBMIT SCORE: Submitting to API');
            
            try {
                const response = await fetch(url, {
                    method: 'GET',
                    headers: {
                        'Authorization': `Bearer ${token}`,
                        'Content-Type': 'application/json',
                        'Cache-Control': 'no-cache, no-store, must-revalidate',
                        'Pragma': 'no-cache',
                        'Expires': '0'
                    },
                    cache: 'no-cache'
                });
                
                if (!response.ok) {
                    throw new Error(`HTTP error! status: ${response.status}`);
                }

                // Mark score as submitted
                this.scoreSubmitted = true;
                console.log('✅ SUBMIT SCORE: Score successfully submitted!');
                
                try {
                    const data = await response.json();
                    console.log('✅ SUBMIT SCORE: Server response:', data);
                    return data;
                } catch (parseError) {
                    const textResponse = await response.text();
                    console.log('✅ SUBMIT SCORE: Server text response:', textResponse);
                    return { status: 'success', message: textResponse };
                }
            } catch (fetchError) {
                console.warn('⚠️ API error during score submission:', fetchError.message);
                
                // For development: Create a success response if API fails
                console.log('✅ FALLBACK: Recording score locally');
                
                // Still mark as submitted for tracking purposes
                this.scoreSubmitted = true;
                
                // Return mock response
                return { 
                    status: 'success', 
                    message: 'Development mode: Score recorded locally', 
                    score: currentScore,
                    timestamp: new Date().toISOString()
                };
            }
        } catch (error) {
            console.error('❌ SUBMIT SCORE: Error in score submission:', error);
            return { status: 'error', message: error.message };
        }
    }

    // Legacy method maintained for compatibility
    async submitScore(score) {
        console.log('submitScore called with score:', score);
        return this.submitScoreIfNeeded(score);
    }
}

// ✅ Use updated base URL (without /api.php)
const API_BASE_URL = 'https://cgames.unlimitedgames.info/multicolorcards';

// Create apiHandler immediately when the script is loaded
window.apiHandler = new APIHandler(API_BASE_URL);

// Ensure inactivity tracking is active from the moment the page loads
document.addEventListener('DOMContentLoaded', () => {
    console.log("Page loaded - activity tracking initialized");
    if (window.apiHandler) {
        window.apiHandler.updateActivity();
    }
});

document.addEventListener('game:tabchange', (event) => {
    // This can be used to handle tab changes in the game scripts
    console.log('Tab change detected:', event.detail?.message || 'No details');
    // Only submit score if it exists in session storage
    if (window.apiHandler && sessionStorage.getItem('gameScore')) {
        const storedScore = parseInt(sessionStorage.getItem('gameScore'));
        console.log('Found stored score:', storedScore);
        window.apiHandler.submitScoreIfNeeded(storedScore);
    } else {
        console.log('No stored score found - skipping submission on tab change');
    }
});

document.addEventListener('game:unload', (event) => {
    // This can be used to handle page unload in the game scripts
    console.log('Page unload detected:', event.detail?.message || 'No details');
    // Only submit score if it exists in session storage
    if (window.apiHandler && sessionStorage.getItem('gameScore')) {
        const storedScore = parseInt(sessionStorage.getItem('gameScore'));
        console.log('Found stored score:', storedScore);
        window.apiHandler.submitScoreIfNeeded(storedScore);
    } else {
        console.log('No stored score found - skipping submission on unload');
    }
});

/* 
INTEGRATION GUIDE:

1. In your HTML file, include this script before your main game script:
   <script src="apiHandler.js"></script>
   <script src="your-game-script.js"></script>

2. In your game initialization code, generate a token:
   if(window.apiHandler && typeof window.apiHandler.generateToken === 'function') {
     window.apiHandler.generateToken();
   }

3. In your game end function, submit the score:
   if(window.apiHandler && typeof window.apiHandler.submitScoreIfNeeded === 'function') {
     window.apiHandler.submitScoreIfNeeded(yourGameScore);
   }

4. Make sure your game exposes the score in a playerData object:
   window.playerData = { 
     score: 0,
     // other game data
   };

5. Update the score in both your game and playerData:
   function updateScore(newScore) {
     // Update your game's internal score
     yourGameScore = newScore;
     
     // Update the playerData object for the API handler
     if (window.playerData) {
       window.playerData.score = newScore;
     }
   }
*/
