// Variables and functions: camelCase
const gameState = {};
const currentPlayer = 'white';
function calculateMoveScore(move) { }

// Constants: SCREAMING_SNAKE_CASE
const MAX_GAME_TIME = 3600000;
const DEFAULT_TIME_CONTROL = {
  initial: 600000,
  increment: 5000
};

// Classes: PascalCase
class ChessEngine {
  constructor() {}
}

class GameStateManager {
  updatePosition(fen) {}
}

// Interfaces and Types: PascalCase
interface ChessPosition {
  rank: number;
  file: number;
}

type GameResult = 'white' | 'black' | 'draw' | 'ongoing';

// Enums: PascalCase with SCREAMING_SNAKE_CASE values
enum PieceType {
  PAWN = 'pawn',
  KNIGHT = 'knight',
  BISHOP = 'bishop',
  ROOK = 'rook',
  QUEEN = 'queen',
  KING = 'king'
}

// Private properties: prefix with underscore
class ChessGame {
  constructor() {
    this._internalState = {};
    this.publicProperty = 'visible';
  }

  _privateMethod() {
    // Internal implementation
  }

  publicMethod() {
    // Public API
  }
}

// Function documentation with JSDoc
/**
 * Validates a chess move according to game rules
 * @param {ChessMove} move - The move to validate
 * @param {ChessPosition} position - Current board position
 * @param {GameState} gameState - Current game state
 * @returns {MoveValidationResult} Validation result with details
 * @throws {InvalidMoveError} When move format is invalid
 */
function validateMove(move, position, gameState) {
  // Input validation
  if (!move || typeof move !== 'object') {
    throw new InvalidMoveError('Move must be a valid object');
  }

  // Early returns for clarity
  if (!isValidSquare(move.from)) {
    return { valid: false, reason: 'Invalid source square' };
  }

  if (!isValidSquare(move.to)) {
    return { valid: false, reason: 'Invalid destination square' };
  }

  // Main logic
  const piece = position.getPieceAt(move.from);
  if (!piece) {
    return { valid: false, reason: 'No piece at source square' };
  }

  // Validate piece movement
  const isLegal = validatePieceMove(piece, move, position);

  return {
    valid: isLegal,
    reason: isLegal ? null : 'Move violates piece movement rules'
  };
}

// Async function standards
async function fetchGameData(gameId) {
  try {
    // Use descriptive variable names
    const response = await apiClient.get(`/games/${gameId}`);
    const gameData = response.data;

    // Validate response
    if (!gameData || !gameData.id) {
      throw new Error('Invalid game data received');
    }

    return gameData;
  } catch (error) {
    // Enhance error context
    throw new Error(`Failed to fetch game ${gameId}: ${error.message}`);
  }
}

// Pure functions preferred
function calculateMoveTime(startTime, endTime) {
  // No side effects, predictable output
  return endTime - startTime;
}

// Avoid deeply nested functions
function processGameMoves(moves) {
  // Extract complex logic into separate functions
  const validatedMoves = moves.filter(isValidMove);
  const processedMoves = validatedMoves.map(processSingleMove);

  return processedMoves;
}

function processSingleMove(move) {
  // Focused, single-purpose function
  return {
    ...move,
    timestamp: Date.now(),
    processed: true
  };
}

// Use object destructuring for clarity
function createGameState({ fen, timeControl, players }) {
  // Destructure parameters for readability
  const { initial, increment } = timeControl;
  const { white, black } = players;

  return {
    position: new ChessPosition(fen),
    clock: new GameClock(initial, increment),
    players: { white, black },
    status: 'active'
  };
}

// Prefer object spread over Object.assign
const updatedGameState = {
  ...currentGameState,
  position: newPosition,
  moveNumber: currentGameState.moveNumber + 1
};

// Use consistent property ordering
const chessMove = {
  // Identifiers first
  id: generateMoveId(),
  gameId: game.id,

  // Core data
  from: 'e2',
  to: 'e4',
  piece: 'pawn',
  notation: 'e4',

  // Metadata
  timestamp: Date.now(),
  duration: 1500,

  // Optional properties last
  capture: null,
  promotion: null,
  check: false,
  checkmate: false
};

// Use Maps for key-value collections when appropriate
const piecePositions = new Map([
  ['e1', { type: 'king', color: 'white' }],
  ['e8', { type: 'king', color: 'black' }]
]);

// Use Sets for unique collections
const visitedSquares = new Set(['e2', 'e4', 'd4']);

// Custom error classes for better error handling
class ChessError extends Error {
  constructor(message, code = 'CHESS_ERROR') {
    super(message);
    this.name = 'ChessError';
    this.code = code;
  }
}

class InvalidMoveError extends ChessError {
  constructor(message, move = null) {
    super(message, 'INVALID_MOVE');
    this.name = 'InvalidMoveError';
    this.move = move;
  }
}

class GameEndedError extends ChessError {
  constructor(result) {
    super(`Game has ended: ${result}`);
    this.name = 'GameEndedError';
    this.result = result;
  }
}

// Consistent error handling patterns
async function makeMove(gameId, move) {
  try {
    // Validate inputs
    if (!gameId) {
      throw new ChessError('Game ID is required', 'MISSING_GAME_ID');
    }

    // Business logic
    const game = await findGame(gameId);
    if (!game) {
      throw new ChessError(`Game not found: ${gameId}`, 'GAME_NOT_FOUND');
    }

    if (game.status !== 'active') {
      throw new GameEndedError(game.result);
    }

    const validationResult = validateMove(move, game.position);
    if (!validationResult.valid) {
      throw new InvalidMoveError(validationResult.reason, move);
    }

    // Execute move
    return await executeMove(game, move);

  } catch (error) {
    // Add context to errors
    if (error instanceof ChessError) {
      // Re-throw chess-specific errors
      throw error;
    } else {
      // Wrap unexpected errors
      throw new ChessError(`Unexpected error in makeMove: ${error.message}`, 'INTERNAL_ERROR');
    }
  }
}

// Component structure and organization
import React, { useState, useEffect, useCallback, useMemo } from 'react';
import PropTypes from 'prop-types';
import { ChessEngine } from '@shared/chess';
import { useGameState } from '../hooks/useGameState';
import './ChessBoard.css';

/**
 * Interactive chess board component
 * @param {Object} props - Component props
 * @param {string} props.gameId - Unique game identifier
 * @param {Function} props.onMove - Move callback function
 * @param {boolean} props.disabled - Whether board is interactive
 */
function ChessBoard({ gameId, onMove, disabled = false }) {
  // Group related state
  const [selectedSquare, setSelectedSquare] = useState(null);
  const [highlightedSquares, setHighlightedSquares] = useState([]);

  // Custom hooks
  const { gameState, makeMove, error } = useGameState(gameId);

  // Memoized values
  const legalMoves = useMemo(() => {
    if (!selectedSquare || !gameState) return [];
    return gameState.getLegalMoves(selectedSquare);
  }, [selectedSquare, gameState]);

  // Event handlers with useCallback
  const handleSquareClick = useCallback((square) => {
    if (disabled) return;

    if (selectedSquare === square) {
      // Deselect if clicking same square
      setSelectedSquare(null);
      setHighlightedSquares([]);
    } else if (selectedSquare && legalMoves.includes(square)) {
      // Make move
      const move = { from: selectedSquare, to: square };
      makeMove(move);
      setSelectedSquare(null);
      setHighlightedSquares([]);
    } else {
      // Select new square
      setSelectedSquare(square);
      setHighlightedSquares(gameState?.getLegalMoves(square) || []);
    }
  }, [disabled, selectedSquare, legalMoves, makeMove, gameState]);

  // Effects
  useEffect(() => {
    if (error) {
      console.error('Chess board error:', error);
    }
  }, [error]);

  // Early returns
  if (!gameState) {
    return <div className="chess-board loading">Loading game...</div>;
  }

  if (error) {
    return <div className="chess-board error">Error: {error.message}</div>;
  }

  // Render
  return (
    <div className="chess-board">
      <div className="board-grid">
        {gameState.getSquares().map((square) => (
          <ChessSquare
            key={square}
            square={square}
            piece={gameState.getPieceAt(square)}
            selected={selectedSquare === square}
            highlighted={highlightedSquares.includes(square)}
            onClick={handleSquareClick}
            disabled={disabled}
          />
        ))}
      </div>
    </div>
  );
}

// PropTypes for runtime validation
ChessBoard.propTypes = {
  gameId: PropTypes.string.isRequired,
  onMove: PropTypes.func,
  disabled: PropTypes.bool
};

// Default props
ChessBoard.defaultProps = {
  onMove: () => {},
  disabled: false
};

export default ChessBoard;

// Custom hook example
function useGameState(gameId) {
  const [gameState, setGameState] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  const makeMove = useCallback(async (move) => {
    try {
      const updatedState = await apiClient.makeMove(gameId, move);
      setGameState(updatedState);
    } catch (err) {
      setError(err);
    }
  }, [gameId]);

  useEffect(() => {
    let cancelled = false;

    const loadGame = async () => {
      try {
        setLoading(true);
        const state = await apiClient.getGame(gameId);

        if (!cancelled) {
          setGameState(state);
          setError(null);
        }
      } catch (err) {
        if (!cancelled) {
          setError(err);
        }
      } finally {
        if (!cancelled) {
          setLoading(false);
        }
      }
    };

    loadGame();

    return () => {
      cancelled = true;
    };
  }, [gameId]);

  return { gameState, makeMove, loading, error };
}

// chessEngine.test.js
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { ChessEngine } from '../src/chess/ChessEngine';

describe('ChessEngine', () => {
  let engine;

  beforeEach(() => {
    engine = new ChessEngine();
  });

  afterEach(() => {
    engine.cleanup();
  });

  describe('initialization', () => {
    it('should initialize with standard starting position', () => {
      expect(engine.getFEN()).toBe('rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1');
    });

    it('should set current player to white', () => {
      expect(engine.getCurrentPlayer()).toBe('white');
    });
  });

  describe('move validation', () => {
    it('should allow valid pawn moves', () => {
      const move = { from: 'e2', to: 'e4' };
      const result = engine.validateMove(move);

      expect(result.valid).toBe(true);
      expect(result.reason).toBeNull();
    });

    it('should reject invalid moves', () => {
      const move = { from: 'e2', to: 'e5' }; // Two squares from non-starting position
      engine.makeMove({ from: 'e2', to: 'e3' }); // Move pawn first

      const result = engine.validateMove(move);

      expect(result.valid).toBe(false);
      expect(result.reason).toContain('Invalid pawn move');
    });

    it('should handle edge cases gracefully', () => {
      const invalidMoves = [
        null,
        undefined,
        {},
        { from: 'e2' }, // Missing 'to'
        { to: 'e4' }, // Missing 'from'
        { from: 'z9', to: 'e4' }, // Invalid square
      ];

      invalidMoves.forEach((move) => {
        expect(() => engine.validateMove(move)).toThrow();
      });
    });
  });

  describe('game state management', () => {
    it('should track move history', () => {
      engine.makeMove({ from: 'e2', to: 'e4' });
      engine.makeMove({ from: 'e7', to: 'e5' });

      const history = engine.getHistory();

      expect(history).toHaveLength(2);
      expect(history[0]).toMatchObject({
        from: 'e2',
        to: 'e4',
        piece: 'pawn',
        notation: 'e4'
      });
    });
  });
});

// Integration test example
describe('Chess Game Integration', () => {
  it('should play a complete game scenario', async () => {
    const game = new ChessGame();
    await game.initialize();

    // Scholar's mate scenario
    const moves = [
      { from: 'e2', to: 'e4' },
      { from: 'e7', to: 'e5' },
      { from: 'f1', to: 'c4' },
      { from: 'b8', to: 'c6' },
      { from: 'd1', to: 'h5' },
      { from: 'g8', to: 'f6' },
      { from: 'h5', to: 'f7' }
    ];

    for (const move of moves) {
      const result = await game.makeMove(move);
      expect(result.success).toBe(true);
    }

    expect(game.getStatus()).toBe('checkmate');
    expect(game.getWinner()).toBe('white');
  });
});

/**
 * @fileoverview Chess engine implementation with move validation and game state management
 * @author Your Name
 * @version 2.1.0
 */

/**
 * Represents a chess game engine with full rule implementation
 * @class
 * @example
 * const engine = new ChessEngine();
 * engine.makeMove({ from: 'e2', to: 'e4' });
 */
class ChessEngine {
  /**
   * Creates a new chess engine instance
   * @param {string} [fen] - Starting position in FEN notation
   * @param {Object} [options] - Configuration options
   * @param {boolean} [options.validateMoves=true] - Whether to validate moves
   * @param {string} [options.variant='standard'] - Chess variant to play
   */
  constructor(fen = STARTING_FEN, options = {}) {
    // Implementation
  }

  /**
   * Validates a chess move according to game rules
   * @param {ChessMove} move - The move to validate
   * @param {string} move.from - Source square (e.g., 'e2')
   * @param {string} move.to - Destination square (e.g., 'e4')
   * @param {string} [move.promotion] - Promotion piece type
   * @returns {MoveValidationResult} Validation result
   * @throws {InvalidMoveError} When move format is invalid
   * @example
   * const result = engine.validateMove({ from: 'e2', to: 'e4' });
   * if (result.valid) {
   *   console.log('Move is legal');
   * }
   */
  validateMove(move) {
    // Implementation
  }

  /**
   * Gets all legal moves for a piece at the given square
   * @param {string} square - Square notation (e.g., 'e2')
   * @returns {string[]} Array of legal destination squares
   * @since 2.0.0
   */
  getLegalMoves(square) {
    // Implementation
  }
}

/**
 * @typedef {Object} ChessMove
 * @property {string} from - Source square
 * @property {string} to - Destination square
 * @property {string} [promotion] - Promotion piece type
 */

/**
 * @typedef {Object} MoveValidationResult
 * @property {boolean} valid - Whether the move is valid
 * @property {string|null} reason - Reason for invalidity
 * @property {ChessMove} [suggestedMove] - Alternative valid move
 */