script.js

// Game Constants and Configuration
const PIECE_TYPES = {
    RAJA: 'king',
    MANTRI: 'queen', 
    RATHA: 'rook',
    GAJA: 'bishop',
    ASHVA: 'knight',
    PADATI: 'pawn'
};

const BOT_CONFIGS = {
    beginner: { depth: 1, elo: 800, name: "Beginner Bot" },
    intermediate: { depth: 2, elo: 1200, name: "Intermediate Bot" },
    advanced: { depth: 3, elo: 1600, name: "Advanced Bot" },
    expert: { depth: 4, elo: 2000, name: "Expert Bot" }
};

const THEMES = {
    modern: { light: '#f0d9b5', dark: '#b58863' },
    classic: { light: '#f0d0a0', dark: '#a07855' },
    dark: { light: '#8ca2ad', dark: '#4a6572' }
};

// Game State
let gameState = {
    board: [],
    currentPlayer: 'white',
    selectedPiece: null,
    validMoves: [],
    moveHistory: [],
    moveNotation: [],
    gameOver: false,
    winner: null,
    check: false,
    checkmate: false,
    stalemate: false,
    boardFlipped: false,
    moveHistoryVisible: true,
    lastMove: null,
    draggingPiece: null,
    dragOffset: { x: 0, y: 0 },
    
    // Settings
    soundEnabled: true,
    musicEnabled: false,
    currentTheme: 'modern',
    colorBlindMode: false,
    
    // Game configuration
    opponent: 'human',
    botDifficulty: 'intermediate',
    ruleSet: 'jump',
    
    // Timers
    timerWhite: 600,
    timerBlack: 600,
    timerInterval: null,
    lastTimerUpdate: Date.now(),
    
    // Stats
    playerStats: {
        elo: 1200,
        wins: 0,
        losses: 0,
        draws: 0
    },
    
    // Achievements
    achievements: [
        { name: "First Win", description: "Win your first game", unlocked: false },
        { name: "Checkmate Master", description: "Deliver 10 checkmates", unlocked: false },
        { name: "Pawn Promoter", description: "Promote 5 pawns", unlocked: false },
        { name: "Bot Slayer", description: "Defeat all bot levels", unlocked: false }
    ]
};

// Initialize the game
function initGame() {
    loadStats();
    createBoard();
    setupPieces();
    startTimer();
    updateDisplay();
    showMessage("Game started! White's turn.");
}

function createBoard() {
    const board = document.getElementById('chess-board');
    const coordinates = document.getElementById('board-coordinates');
    
    // Clear existing board
    board.innerHTML = '';
    coordinates.innerHTML = '';
    
    // Create files coordinates (a-h)
    const filesContainer = document.createElement('div');
    filesContainer.className = 'coord-files';
    filesContainer.style.gridTemplateColumns = 'repeat(8, 1fr)';
    filesContainer.style.display = 'grid';
    filesContainer.style.marginBottom = '5px';
    
    for (let i = 0; i < 8; i++) {
        const file = document.createElement('div');
        file.className = 'coord-file';
        file.textContent = String.fromCharCode(97 + (gameState.boardFlipped ? 7 - i : i));
        filesContainer.appendChild(file);
    }
    
    // Create ranks coordinates (1-8)
    const ranksContainer = document.createElement('div');
    ranksContainer.className = 'coord-ranks';
    ranksContainer.style.display = 'flex';
    ranksContainer.style.flexDirection = 'column';
    ranksContainer.style.gap = 'calc(100% / 8 - 1em)';
    ranksContainer.style.position = 'absolute';
    ranksContainer.style.left = '-25px';
    ranksContainer.style.top = '0';
    ranksContainer.style.height = '100%';
    ranksContainer.style.justifyContent = 'space-around';
    
    for (let i = 0; i < 8; i++) {
        const rank = document.createElement('div');
        rank.className = 'coord-rank';
        rank.textContent = gameState.boardFlipped ? (i + 1) : (8 - i);
        ranksContainer.appendChild(rank);
    }
    
    coordinates.appendChild(filesContainer);
    coordinates.appendChild(ranksContainer);
    
    // Create squares
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const square = document.createElement('div');
            square.className = 'square';
            square.dataset.row = row;
            square.dataset.col = col;
            
            // Set square color based on theme and position
            const isLight = (row + col) % 2 === 0;
            square.classList.add(isLight ? 'light' : 'dark');
            
            // Add event listeners
            square.addEventListener('click', () => handleSquareClick(row, col));
            square.addEventListener('dragover', handleDragOver);
            square.addEventListener('drop', (e) => handleDrop(e, row, col));
            
            board.appendChild(square);
        }
    }
}

function setupPieces() {
    // Clear existing pieces
    gameState.board = Array(8).fill().map(() => Array(8).fill(null));
    
    // Setup pawns
    for (let col = 0; col < 8; col++) {
        gameState.board[1][col] = { type: PIECE_TYPES.PADATI, color: 'black', row: 1, col: col };
        gameState.board[6][col] = { type: PIECE_TYPES.PADATI, color: 'white', row: 6, col: col };
    }
    
    // Setup back rows
    const backRow = [
        PIECE_TYPES.RATHA, PIECE_TYPES.ASHVA, PIECE_TYPES.GAJA, PIECE_TYPES.MANTRI,
        PIECE_TYPES.RAJA, PIECE_TYPES.GAJA, PIECE_TYPES.ASHVA, PIECE_TYPES.RATHA
    ];
    
    for (let col = 0; col < 8; col++) {
        gameState.board[0][col] = { type: backRow[col], color: 'black', row: 0, col: col };
        gameState.board[7][col] = { type: backRow[col], color: 'white', row: 7, col: col };
    }
    
    renderPieces();
}

function renderPieces() {
    // Clear all pieces from board
    document.querySelectorAll('.piece').forEach(piece => piece.remove());
    
    // Render pieces
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const piece = gameState.board[row][col];
            if (piece) {
                const square = getSquareElement(row, col);
                if (square) {
                    const pieceElement = createPieceElement(piece, row, col);
                    square.appendChild(pieceElement);
                }
            }
        }
    }
    
    // Highlight last move
    highlightLastMove();
    
    // Highlight check
    if (gameState.check) {
        highlightCheck();
    }
}

function createPieceElement(piece, row, col) {
    const pieceElement = document.createElement('div');
    pieceElement.className = `piece ${piece.color} ${piece.type}`;
    pieceElement.textContent = getPieceSymbol(piece.type);
    pieceElement.draggable = true;
    
    pieceElement.addEventListener('dragstart', (e) => handleDragStart(e, piece, row, col));
    pieceElement.addEventListener('click', (e) => {
        e.stopPropagation();
        handlePieceClick(row, col);
    });
    
    return pieceElement;
}

function getPieceSymbol(type) {
    const symbols = {
        [PIECE_TYPES.RAJA]: 'K',
        [PIECE_TYPES.MANTRI]: 'Q',
        [PIECE_TYPES.RATHA]: 'R',
        [PIECE_TYPES.GAJA]: 'B',
        [PIECE_TYPES.ASHVA]: 'N',
        [PIECE_TYPES.PADATI]: 'P'
    };
    return symbols[type] || '?';
}

function getSquareElement(row, col) {
    if (gameState.boardFlipped) {
        row = 7 - row;
        col = 7 - col;
    }
    return document.querySelector(`.square[data-row="${row}"][data-col="${col}"]`);
}

// Event Handlers
function handleSquareClick(row, col) {
    if (gameState.gameOver) return;
    
    if (gameState.selectedPiece) {
        // Try to move to this square
        const [selectedRow, selectedCol] = gameState.selectedPiece;
        if (isValidMove(selectedRow, selectedCol, row, col)) {
            makeMove(selectedRow, selectedCol, row, col);
            clearSelection();
        } else {
            // Select different piece or clear selection
            const piece = gameState.board[row][col];
            if (piece && piece.color === gameState.currentPlayer) {
                selectPiece(row, col);
            } else {
                clearSelection();
            }
        }
    } else {
        // Select piece if it's the player's turn
        const piece = gameState.board[row][col];
        if (piece && piece.color === gameState.currentPlayer) {
            selectPiece(row, col);
        }
    }
}

function handlePieceClick(row, col) {
    if (gameState.gameOver) return;
    
    const piece = gameState.board[row][col];
    if (piece && piece.color === gameState.currentPlayer) {
        selectPiece(row, col);
    }
}

function handleDragStart(e, piece, row, col) {
    if (gameState.gameOver || piece.color !== gameState.currentPlayer) {
        e.preventDefault();
        return;
    }
    
    gameState.draggingPiece = { piece, row, col };
    e.dataTransfer.setData('text/plain', ''); // Required for Firefox
    e.dataTransfer.effectAllowed = 'move';
    
    // Add visual feedback
    setTimeout(() => {
        e.target.style.opacity = '0.4';
    }, 0);
}

function handleDragOver(e) {
    e.preventDefault();
    e.dataTransfer.dropEffect = 'move';
}

function handleDrop(e, targetRow, targetCol) {
    e.preventDefault();
    
    if (!gameState.draggingPiece) return;
    
    const { piece, row: fromRow, col: fromCol } = gameState.draggingPiece;
    gameState.draggingPiece = null;
    
    // Reset opacity
    document.querySelectorAll('.piece').forEach(p => p.style.opacity = '1');
    
    if (isValidMove(fromRow, fromCol, targetRow, targetCol)) {
        makeMove(fromRow, fromCol, targetRow, targetCol);
    }
    
    clearSelection();
}

function selectPiece(row, col) {
    gameState.selectedPiece = [row, col];
    gameState.validMoves = getValidMoves(row, col);
    
    // Update visual selection
    clearHighlights();
    highlightSelectedSquare();
    highlightValidMoves();
}

function clearSelection() {
    gameState.selectedPiece = null;
    gameState.validMoves = [];
    clearHighlights();
}

function clearHighlights() {
    document.querySelectorAll('.square').forEach(square => {
        square.classList.remove('selected', 'valid-move');
    });
}

function highlightSelectedSquare() {
    if (gameState.selectedPiece) {
        const [row, col] = gameState.selectedPiece;
        const square = getSquareElement(row, col);
        if (square) square.classList.add('selected');
    }
}

function highlightValidMoves() {
    gameState.validMoves.forEach(([row, col]) => {
        const square = getSquareElement(row, col);
        if (square) square.classList.add('valid-move');
    });
}

function highlightLastMove() {
    if (gameState.lastMove) {
        const [from, to] = gameState.lastMove;
        [from, to].forEach(([row, col]) => {
            const square = getSquareElement(row, col);
            if (square) square.classList.add('last-move');
        });
    }
}

function highlightCheck() {
    // Find king in check and highlight its square
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const piece = gameState.board[row][col];
            if (piece && piece.type === PIECE_TYPES.RAJA && piece.color === gameState.currentPlayer) {
                const square = getSquareElement(row, col);
                if (square) square.classList.add('check');
                break;
            }
        }
    }
}

// Move Validation and Game Logic
function isValidMove(fromRow, fromCol, toRow, toCol) {
    return gameState.validMoves.some(([r, c]) => r === toRow && c === toCol);
}

function getValidMoves(row, col) {
    const piece = gameState.board[row][col];
    if (!piece) return [];
    
    const rawMoves = getRawMoves(row, col);
    return rawMoves.filter(([r, c]) => !wouldBeInCheck(piece, r, c));
}

function getRawMoves(row, col) {
    const piece = gameState.board[row][col];
    if (!piece) return [];
    
    const moves = [];
    
    switch (piece.type) {
        case PIECE_TYPES.RAJA: // King
            for (let dr = -1; dr <= 1; dr++) {
                for (let dc = -1; dc <= 1; dc++) {
                    if (dr === 0 && dc === 0) continue;
                    const newRow = row + dr;
                    const newCol = col + dc;
                    if (isInBoard(newRow, newCol)) {
                        const target = gameState.board[newRow][newCol];
                        if (!target || target.color !== piece.color) {
                            moves.push([newRow, newCol]);
                        }
                    }
                }
            }
            break;
            
        case PIECE_TYPES.MANTRI: // Minister/Queen
            for (const [dr, dc] of [[-1, -1], [-1, 1], [1, -1], [1, 1]]) {
                const newRow = row + dr;
                const newCol = col + dc;
                if (isInBoard(newRow, newCol)) {
                    const target = gameState.board[newRow][newCol];
                    if (!target || target.color !== piece.color) {
                        moves.push([newRow, newCol]);
                    }
                }
            }
            break;
            
        case PIECE_TYPES.RATHA: // Chariot/Rook
            for (const [dr, dc] of [[0, 1], [1, 0], [0, -1], [-1, 0]]) {
                for (let i = 1; i < 8; i++) {
                    const newRow = row + dr * i;
                    const newCol = col + dc * i;
                    if (!isInBoard(newRow, newCol)) break;
                    
                    const target = gameState.board[newRow][newCol];
                    if (!target) {
                        moves.push([newRow, newCol]);
                    } else {
                        if (target.color !== piece.color) {
                            moves.push([newRow, newCol]);
                        }
                        break;
                    }
                }
            }
            break;
            
        case PIECE_TYPES.GAJA: // Elephant/Bishop
            if (gameState.ruleSet === 'jump') {
                for (const [dr, dc] of [[-2, -2], [-2, 2], [2, -2], [2, 2]]) {
                    const newRow = row + dr;
                    const newCol = col + dc;
                    if (isInBoard(newRow, newCol)) {
                        const target = gameState.board[newRow][newCol];
                        if (!target || target.color !== piece.color) {
                            moves.push([newRow, newCol]);
                        }
                    }
                }
            } else {
                // Non-jump mode - check intermediate square
                for (const [dr, dc] of [[-2, -2], [-2, 2], [2, -2], [2, 2]]) {
                    const midRow = row + dr / 2;
                    const midCol = col + dc / 2;
                    const newRow = row + dr;
                    const newCol = col + dc;
                    
                    if (isInBoard(newRow, newCol) && isInBoard(midRow, midCol) && 
                        !gameState.board[midRow][midCol]) {
                        const target = gameState.board[newRow][newCol];
                        if (!target || target.color !== piece.color) {
                            moves.push([newRow, newCol]);
                        }
                    }
                }
            }
            break;
            
        case PIECE_TYPES.ASHVA: // Horse/Knight
            for (const [dr, dc] of [[-2, -1], [-2, 1], [-1, -2], [-1, 2], 
                                   [1, -2], [1, 2], [2, -1], [2, 1]]) {
                const newRow = row + dr;
                const newCol = col + dc;
                if (isInBoard(newRow, newCol)) {
                    const target = gameState.board[newRow][newCol];
                    if (!target || target.color !== piece.color) {
                        moves.push([newRow, newCol]);
                    }
                }
            }
            break;
            
        case PIECE_TYPES.PADATI: // Pawn
            const direction = piece.color === 'white' ? -1 : 1;
            const newRow = row + direction;
            
            // Forward move
            if (isInBoard(newRow, col) && !gameState.board[newRow][col]) {
                moves.push([newRow, col]);
            }
            
            // Captures
            for (const dc of [-1, 1]) {
                const newCol = col + dc;
                if (isInBoard(newRow, newCol)) {
                    const target = gameState.board[newRow][newCol];
                    if (target && target.color !== piece.color) {
                        moves.push([newRow, newCol]);
                    }
                }
            }
            break;
    }
    
    return moves;
}

function wouldBeInCheck(piece, newRow, newCol) {
    const oldRow = piece.row;
    const oldCol = piece.col;
    const captured = gameState.board[newRow][newCol];
    
    // Make temporary move
    gameState.board[oldRow][oldCol] = null;
    gameState.board[newRow][newCol] = { ...piece, row: newRow, col: newCol };
    
    const inCheck = isInCheck(piece.color);
    
    // Undo temporary move
    gameState.board[oldRow][oldCol] = piece;
    gameState.board[newRow][newCol] = captured;
    
    return inCheck;
}

function isInCheck(color) {
    let kingPos = null;
    
    // Find king
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const piece = gameState.board[row][col];
            if (piece && piece.type === PIECE_TYPES.RAJA && piece.color === color) {
                kingPos = [row, col];
                break;
            }
        }
        if (kingPos) break;
    }
    
    if (!kingPos) return false;
    
    const opponent = color === 'white' ? 'black' : 'white';
    
    // Check if any opponent piece can capture the king
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const piece = gameState.board[row][col];
            if (piece && piece.color === opponent) {
                const moves = getRawMoves(row, col);
                if (moves.some(([r, c]) => r === kingPos[0] && c === kingPos[1])) {
                    return true;
                }
            }
        }
    }
    
    return false;
}

function isCheckmate(color) {
    if (!isInCheck(color)) return false;
    
    // Check if any move can get out of check
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const piece = gameState.board[row][col];
            if (piece && piece.color === color) {
                const moves = getValidMoves(row, col);
                if (moves.length > 0) return false;
            }
        }
    }
    
    return true;
}

function isStalemate(color) {
    if (isInCheck(color)) return false;
    
    // Check if any legal move exists
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const piece = gameState.board[row][col];
            if (piece && piece.color === color) {
                const moves = getValidMoves(row, col);
                if (moves.length > 0) return false;
            }
        }
    }
    
    return true;
}

function makeMove(fromRow, fromCol, toRow, toCol) {
    const piece = gameState.board[fromRow][fromCol];
    const captured = gameState.board[toRow][toCol];
    
    // Update board
    gameState.board[toRow][toCol] = { ...piece, row: toRow, col: toCol };
    gameState.board[fromRow][fromCol] = null;
    
    // Handle pawn promotion
    if (piece.type === PIECE_TYPES.PADATI && (toRow === 0 || toRow === 7)) {
        gameState.board[toRow][toCol].type = PIECE_TYPES.MANTRI;
        showMessage("Pawn promoted to Minister!");
    }
    
    // Update game state
    gameState.lastMove = [[fromRow, fromCol], [toRow, toCol]];
    gameState.moveHistory.push({ from: [fromRow, fromCol], to: [toRow, toCol], captured });
    
    // Add move notation
    const notation = getMoveNotation(fromRow, fromCol, toRow, toCol, !!captured);
    gameState.moveNotation.push(notation);
    
    // Switch turns
    gameState.currentPlayer = gameState.currentPlayer === 'white' ? 'black' : 'white';
    
    // Check game state
    gameState.check = isInCheck(gameState.currentPlayer);
    if (gameState.check) {
        gameState.checkmate = isCheckmate(gameState.currentPlayer);
        if (gameState.checkmate) {
            gameState.gameOver = true;
            gameState.winner = gameState.currentPlayer === 'white' ? 'black' : 'white';
            showMessage(`Checkmate! ${gameState.winner} wins!`);
            endGame();
        } else {
            showMessage("Check!");
        }
    } else {
        gameState.stalemate = isStalemate(gameState.currentPlayer);
        if (gameState.stalemate) {
            gameState.gameOver = true;
            showMessage("Stalemate! Game is a draw.");
            endGame();
        }
    }
    
    // Update display
    updateDisplay();
    
    // Bot move
    if (!gameState.gameOver && gameState.opponent === 'bot' && gameState.currentPlayer === 'black') {
        setTimeout(makeBotMove, 500);
    }
}

function getMoveNotation(fromRow, fromCol, toRow, toCol, captured) {
    const piece = gameState.board[toRow][toCol];
    const files = 'abcdefgh';
    const ranks = '87654321';
    
    const fromSquare = `${files[fromCol]}${ranks[fromRow]}`;
    const toSquare = `${files[toCol]}${ranks[toRow]}`;
    
    const pieceSymbols = {
        [PIECE_TYPES.RAJA]: 'K',
        [PIECE_TYPES.MANTRI]: 'Q',
        [PIECE_TYPES.RATHA]: 'R',
        [PIECE_TYPES.GAJA]: 'B',
        [PIECE_TYPES.ASHVA]: 'N',
        [PIECE_TYPES.PADATI]: ''
    };
    
    const symbol = pieceSymbols[piece.type];
    const captureSymbol = captured ? 'x' : '';
    
    if (piece.type === PIECE_TYPES.PADATI) {
        return captured ? `${fromSquare[0]}x${toSquare}` : toSquare;
    } else {
        return `${symbol}${captureSymbol}${toSquare}`;
    }
}

function makeBotMove() {
    const allMoves = [];
    
    // Get all possible moves
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const piece = gameState.board[row][col];
            if (piece && piece.color === 'black') {
                const moves = getValidMoves(row, col);
                moves.forEach(move => {
                    allMoves.push({ from: [row, col], to: move });
                });
            }
        }
    }
    
    if (allMoves.length > 0) {
        // Simple bot: choose random move for now
        // In a real implementation, you'd use minimax with the configured depth
        const randomMove = allMoves[Math.floor(Math.random() * allMoves.length)];
        makeMove(...randomMove.from, ...randomMove.to);
    }
}

// UI Functions
function updateDisplay() {
    // Update turn indicator
    document.getElementById('turn-indicator').textContent = `Turn: ${gameState.currentPlayer.charAt(0).toUpperCase() + gameState.currentPlayer.slice(1)}`;
    
    // Update opponent info
    const opponentInfo = document.getElementById('opponent-info');
    if (gameState.opponent === 'bot') {
        opponentInfo.textContent = `Opponent: ${BOT_CONFIGS[gameState.botDifficulty].name}`;
    } else {
        opponentInfo.textContent = 'Opponent: Human';
    }
    
    // Update timers
    document.getElementById('timer-white').textContent = `White: ${formatTime(gameState.timerWhite)}`;
    document.getElementById('timer-black').textContent = `Black: ${formatTime(gameState.timerBlack)}`;
    
    // Update game status
    const statusElement = document.getElementById('game-status');
    if (gameState.checkmate) {
        statusElement.textContent = `Checkmate! ${gameState.winner} wins!`;
        statusElement.style.color = '#28a745';
    } else if (gameState.stalemate) {
        statusElement.textContent = 'Stalemate! Draw!';
        statusElement.style.color = '#ffc107';
    } else if (gameState.check) {
        statusElement.textContent = 'Check!';
        statusElement.style.color = '#dc3545';
    } else {
        statusElement.textContent = 'Game in progress';
        statusElement.style.color = '#6c757d';
    }
    
    // Update move count
    document.getElementById('move-count').textContent = `Moves: ${gameState.moveNotation.length}`;
    
    // Update move history
    updateMoveHistory();
    
    // Re-render pieces
    renderPieces();
}

function updateMoveHistory() {
    const moveList = document.getElementById('move-list');
    moveList.innerHTML = '';
    
    for (let i = 0; i < gameState.moveNotation.length; i += 2) {
        const moveNumber = Math.floor(i / 2) + 1;
        const whiteMove = gameState.moveNotation[i] || '';
        const blackMove = gameState.moveNotation[i + 1] || '';
        
        const moveElement = document.createElement('div');
        moveElement.className = 'move-pair';
        moveElement.textContent = `${moveNumber}. ${whiteMove} ${blackMove}`;
        moveList.appendChild(moveElement);
    }
    
    // Scroll to bottom
    moveList.scrollTop = moveList.scrollHeight;
}

function formatTime(seconds) {
    const minutes = Math.floor(seconds / 60);
    const secs = seconds % 60;
    return `${minutes}:${secs < 10 ? '0' : ''}${secs}`;
}

function showMessage(message, duration = 3000) {
    const messageElement = document.getElementById('game-message');
    messageElement.textContent = message;
    messageElement.classList.remove('hidden');
    
    setTimeout(() => {
        messageElement.classList.add('hidden');
    }, duration);
}

// Timer Functions
function startTimer() {
    gameState.lastTimerUpdate = Date.now();
    gameState.timerInterval = setInterval(updateTimers, 1000);
}

function updateTimers() {
    if (gameState.gameOver) {
        clearInterval(gameState.timerInterval);
        return;
    }
    
    const now = Date.now();
    const elapsed = Math.floor((now - gameState.lastTimerUpdate) / 1000);
    gameState.lastTimerUpdate = now;
    
    if (gameState.currentPlayer === 'white') {
        gameState.timerWhite = Math.max(0, gameState.timerWhite - elapsed);
        if (gameState.timerWhite === 0) {
            gameState.gameOver = true;
            gameState.winner = 'black';
            showMessage("White lost on time!");
            endGame();
        }
    } else {
        gameState.timerBlack = Math.max(0, gameState.timerBlack - elapsed);
        if (gameState.timerBlack === 0) {
            gameState.gameOver = true;
            gameState.winner = 'white';
            showMessage("Black lost on time!");
            endGame();
        }
    }
    
    updateDisplay();
}

function endGame() {
    clearInterval(gameState.timerInterval);
    
    // Update stats
    if (gameState.winner === 'white') {
        gameState.playerStats.wins++;
    } else if (gameState.winner === 'black') {
        gameState.playerStats.losses++;
    } else {
        gameState.playerStats.draws++;
    }
    
    saveStats();
    
    // Show analysis screen
    setTimeout(showAnalysisScreen, 1000);
}

function showAnalysisScreen() {
    const modal = document.getElementById('analysis-screen');
    const resultElement = document.getElementById('game-result');
    const moveListElement = document.getElementById('full-move-list');
    
    if (gameState.checkmate) {
        resultElement.textContent = `Final Result: ${gameState.winner} wins by checkmate!`;
    } else if (gameState.stalemate) {
        resultElement.textContent = 'Final Result: Draw by stalemate!';
    } else {
        resultElement.textContent = 'Final Result: Game ended!';
    }
    
    // Show full move history
    moveListElement.textContent = gameState.moveNotation.join(' ');
    
    modal.classList.remove('hidden');
}

// Game Control Functions
function resetGame() {
    clearInterval(gameState.timerInterval);
    
    // Reset game state
    gameState = {
        ...gameState,
        board: [],
        currentPlayer: 'white',
        selectedPiece: null,
        validMoves: [],
        moveHistory: [],
        moveNotation: [],
        gameOver: false,
        winner: null,
        check: false,
        checkmate: false,
        stalemate: false,
        lastMove: null,
        draggingPiece: null,
        timerWhite: 600,
        timerBlack: 600,
        lastTimerUpdate: Date.now()
    };
    
    // Close modals
    document.querySelectorAll('.modal').forEach(modal => modal.classList.add('hidden'));
    
    // Reinitialize game
    initGame();
}

function undoMove() {
    if (gameState.moveHistory.length === 0) {
        showMessage("No moves to undo!");
        return;
    }
    
    const lastMove = gameState.moveHistory.pop();
    const { from, to, captured } = lastMove;
    
    // Restore piece to original position
    const piece = gameState.board[to[0]][to[1]];
    gameState.board[from[0]][from[1]] = { ...piece, row: from[0], col: from[1] };
    gameState.board[to[0]][to[1]] = captured;
    
    // Remove last move notation
    gameState.moveNotation.pop();
    
    // Switch turn back
    gameState.currentPlayer = gameState.currentPlayer === 'white' ? 'black' : 'white';
    
    // Update last move
    if (gameState.moveHistory.length > 0) {
        const prevMove = gameState.moveHistory[gameState.moveHistory.length - 1];
        gameState.lastMove = [prevMove.from, prevMove.to];
    } else {
        gameState.lastMove = null;
    }
    
    // Reset game over state
    gameState.gameOver = false;
    gameState.check = false;
    gameState.checkmate = false;
    gameState.stalemate = false;
    
    // Restart timer if it was stopped
    if (!gameState.timerInterval) {
        startTimer();
    }
    
    updateDisplay();
    showMessage("Move undone!");
}

function showHint() {
    if (gameState.gameOver || gameState.currentPlayer !== 'white') {
        showMessage("No hints available!");
        return;
    }
    
    // Find first available move
    for (let row = 0; row < 8; row++) {
        for (let col = 0; col < 8; col++) {
            const piece = gameState.board[row][col];
            if (piece && piece.color === 'white') {
                const moves = getValidMoves(row, col);
                if (moves.length > 0) {
                    selectPiece(row, col);
                    showMessage("Hint shown! Selected piece highlighted.");
                    return;
                }
            }
        }
    }
    
    showMessage("No valid moves found!");
}

function flipBoard() {
    gameState.boardFlipped = !gameState.boardFlipped;
    createBoard();
    renderPieces();
    showMessage(`Board ${gameState.boardFlipped ? 'flipped' : 'orientation reset'}!`);
}

function toggleMoveHistory() {
    gameState.moveHistoryVisible = !gameState.moveHistoryVisible;
    const panel = document.getElementById('move-history-panel');
    panel.style.display = gameState.moveHistoryVisible ? 'block' : 'none';
}

// Screen Management
function showScreen(screenId) {
    // Hide all screens
    document.querySelectorAll('.screen').forEach(screen => {
        screen.classList.remove('active');
    });
    
    // Show target screen
    document.getElementById(screenId).classList.add('active');
    
    // Special handling for game screen
    if (screenId === 'game-screen') {
        initGame();
    }
}

function startGame(opponent, difficulty = 'intermediate') {
    gameState.opponent = opponent;
    gameState.botDifficulty = difficulty;
    showScreen('game-screen');
}

function startTutorial() {
    gameState.opponent = 'human';
    showScreen('game-screen');
    showMessage("Welcome to Chaturanga Tutorial! Select a piece to see valid moves.");
}

// Settings Functions
function toggleSound() {
    gameState.soundEnabled = !gameState.soundEnabled;
    const button = document.getElementById('sound-toggle');
    button.textContent = gameState.soundEnabled ? 'ON' : 'OFF';
    button.classList.toggle('active', gameState.soundEnabled);
}

function toggleMusic() {
    gameState.musicEnabled = !gameState.musicEnabled;
    const button = document.getElementById('music-toggle');
    button.textContent = gameState.musicEnabled ? 'ON' : 'OFF';
    button.classList.toggle('active', gameState.musicEnabled);
}

function cycleTheme() {
    const themes = Object.keys(THEMES);
    const currentIndex = themes.indexOf(gameState.currentTheme);
    gameState.currentTheme = themes[(currentIndex + 1) % themes.length];
    
    const button = document.getElementById('theme-toggle');
    button.textContent = gameState.currentTheme.charAt(0).toUpperCase() + gameState.currentTheme.slice(1);
    
    // Update board colors
    createBoard();
    renderPieces();
}

function toggleColorBlind() {
    gameState.colorBlindMode = !gameState.colorBlindMode;
    const button = document.getElementById('colorblind-toggle');
    button.textContent = gameState.colorBlindMode ? 'ON' : 'OFF';
    button.classList.toggle('active', gameState.colorBlindMode);
}

// Utility Functions
function isInBoard(row, col) {
    return row >= 0 && row < 8 && col >= 0 && col < 8;
}

function loadStats() {
    const saved = localStorage.getItem('chaturangaStats');
    if (saved) {
        gameState.playerStats = JSON.parse(saved);
    }
    updateStatsDisplay();
}

function saveStats() {
    localStorage.setItem('chaturangaStats', JSON.stringify(gameState.playerStats));
    updateStatsDisplay();
}

function updateStatsDisplay() {
    document.getElementById('player-elo').textContent = `ELO: ${gameState.playerStats.elo}`;
    document.getElementById('player-wins').textContent = `Wins: ${gameState.playerStats.wins}`;
    document.getElementById('player-losses').textContent = `Losses: ${gameState.playerStats.losses}`;
    document.getElementById('player-draws').textContent = `Draws: ${gameState.playerStats.draws}`;
}

// Move Review Functions
function startMoveReview() {
    document.getElementById('analysis-screen').classList.add('hidden');
    document.getElementById('move-review').classList.remove('hidden');
    // Implementation would track review state
}

function previousMove() {
    // Implementation for move review
}

function nextMove() {
    // Implementation for move review
}

function closeReview() {
    document.getElementById('move-review').classList.add('hidden');
    document.getElementById('analysis-screen').classList.remove('hidden');
}

// Help Functions
function closeHelp() {
    document.getElementById('help-modal').classList.add('hidden');
}

// Initialize the application
document.addEventListener('DOMContentLoaded', function() {
    // Populate achievements
    const achievementsList = document.getElementById('achievements-list');
    gameState.achievements.forEach(achievement => {
        const achievementElement = document.createElement('div');
        achievementElement.className = `achievement-item ${achievement.unlocked ? 'unlocked' : ''}`;
        achievementElement.innerHTML = `
            <div class="achievement-name">${achievement.name}</div>
            <div class="achievement-desc">${achievement.description}</div>
        `;
        achievementsList.appendChild(achievementElement);
    });
    
    // Show main menu
    showScreen('main-menu');
});