app.py

from flask import Flask, render_template, request, jsonify, session
import sys
import os
import inspect # Ajout pour inspecter

# --- VÉRIFICATION DE L'IMPORT DE STOCKFISH (Doit être au tout début) ---
# Cet import doit être celui de la bibliothèque zhelyabuzhsky-stockfish
try:
    from stockfish import Stockfish, StockfishException
    STOCKFISH_LIB_PATH = inspect.getfile(Stockfish)
    print(f"--- Stockfish class imported from: {STOCKFISH_LIB_PATH} ---")
except ImportError as e:
    print(f"ERREUR CRITIQUE: Impossible d'importer la bibliothèque Stockfish: {e}")
    print("Assurez-vous que la bibliothèque zhelyabuzhsky-stockfish est dans votre PYTHONPATH ou installée.")
    sys.exit(1) # Arrêter si la lib principale manque
# --- Fin de la vérification ---

import chess
import chess.svg
import logging

app = Flask(__name__)

# --- Configuration de la clé secrète ---
IS_DEBUG_MODE = True # Forcer le mode debug pour le développement local
# Pour la production, gérez FLASK_DEBUG et FLASK_SECRET_KEY via les variables d'environnement
default_depth_for_max_strength = 22 

max_strength_params = {
            "Debug Log File": "",
            "Contempt": 0,
            "Min Split Depth": 0,
            "Threads": 4,
            "Ponder": "false",
            "Hash": 8192,
            "MultiPV": 1,
            "Skill Level": 20,
            "Move Overhead": 30,
            "Minimum Thinking Time": 20,
            "Slow Mover": 100,
            "UCI_Chess960": "false",
            "UCI_LimitStrength": "false",
            "UCI_Elo": 3500 
        }

if IS_DEBUG_MODE:
    app.secret_key = 'dev_secret_key_pour_eviter_perte_session_rechargement_et_tests_v3' # Changez si besoin
    logging.warning("MODE DEBUG ACTIVÉ. Utilisation d'une clé secrète statique.")
    app.debug = True
else:
    app.secret_key = os.environ.get("FLASK_SECRET_KEY")
    if not app.secret_key:
        app.secret_key = os.urandom(32)
        logging.warning("MODE PRODUCTION. FLASK_SECRET_KEY non définie. Clé aléatoire générée.")
    app.debug = False

# --- Configuration des Cookies de Session ---
app.config.update(
    SESSION_COOKIE_SECURE=False,
    SESSION_COOKIE_HTTPONLY=True,
    SESSION_COOKIE_SAMESITE='Lax',
)

logging.basicConfig(level=logging.DEBUG)

# --- Configuration Globale de Stockfish (Exécutable) ---
STOCKFISH_EXECUTABLE_PATH_GLOBAL = "stockfish" # Valeur par défaut
HAS_STOCKFISH_EXECUTABLE_GLOBAL = False

def find_stockfish_on_startup():
    global STOCKFISH_EXECUTABLE_PATH_GLOBAL, HAS_STOCKFISH_EXECUTABLE_GLOBAL
    
    # Priorité à une variable d'environnement si définie
    env_path = os.environ.get("STOCKFISH_EXECUTABLE_PATH")
    paths_to_check = [env_path] if env_path else []
    
    paths_to_check.extend([
        "stockfish", "./stockfish", # Relatif au répertoire de travail
        "/usr/games/stockfish", "/usr/local/bin/stockfish", 
        "/opt/homebrew/bin/stockfish", "stockfish.exe" # Chemins communs
    ])
    
    for p in paths_to_check:
        if p and os.path.exists(p) and os.access(p, os.X_OK):
            STOCKFISH_EXECUTABLE_PATH_GLOBAL = p
            HAS_STOCKFISH_EXECUTABLE_GLOBAL = True
            app.logger.info(f"Stockfish exécutable trouvé à: {STOCKFISH_EXECUTABLE_PATH_GLOBAL}")
            return
            
    app.logger.warning(
        "AVERTISSEMENT: Exécutable Stockfish non trouvé dans les chemins courants ou via STOCKFISH_EXECUTABLE_PATH. "
        "L'IA ne fonctionnera pas. Veuillez installer Stockfish ou définir la variable d'environnement."
    )
    HAS_STOCKFISH_EXECUTABLE_GLOBAL = False

find_stockfish_on_startup() # Exécuter au démarrage de l'application

def get_stockfish_engine():
    """Initialise et retourne une instance de la classe Stockfish."""
    if not HAS_STOCKFISH_EXECUTABLE_GLOBAL:
        app.logger.error("Exécutable Stockfish non disponible. L'IA ne peut pas démarrer.")
        return None
    try:
        #engine = Stockfish(path=STOCKFISH_EXECUTABLE_PATH_GLOBAL, depth=15, parameters={"Threads": 1, "Hash": 64})
        engine = Stockfish(path=STOCKFISH_EXECUTABLE_PATH_GLOBAL, 
                           depth=default_depth_for_max_strength, 
                           parameters=max_strength_params)
        if engine._stockfish.poll() is not None:
             app.logger.error("Le processus Stockfish s'est terminé de manière inattendue lors de l'initialisation.")
             raise StockfishException("Stockfish process terminated unexpectedly on init.")
        engine.set_fen_position(chess.STARTING_FEN) # Test léger
        engine.get_best_move() 
        engine.set_fen_position(chess.STARTING_FEN) # Reset après test
        app.logger.info(f"Moteur Stockfish (classe) initialisé avec succès utilisant l'exécutable: {STOCKFISH_EXECUTABLE_PATH_GLOBAL}.")
        return engine
    except Exception as e:
        app.logger.error(f"Erreur lors de l'initialisation de la classe Stockfish (exécutable: {STOCKFISH_EXECUTABLE_PATH_GLOBAL}): {e}", exc_info=True)
        return None

# --- Définition des Routes ---

@app.route('/')
def index():
    app.logger.debug(f"Session au début de GET /: {dict(session.items())}")
    if 'board_fen' not in session or 'game_mode' not in session:
        app.logger.info("Initialisation de la session (board_fen, game_mode, player_color) dans GET /")
        session['board_fen'] = chess.Board().fen()
        session['game_mode'] = 'pvp'
        session['player_color'] = 'white'

    board = chess.Board(session['board_fen'])
    app.logger.debug(f"Session à la fin de GET /: {dict(session.items())}")
    return render_template('index.html',
                           initial_board_svg=chess.svg.board(board=board, size=400),
                           initial_fen=session['board_fen'],
                           game_mode=session['game_mode'],
                           player_color=session.get('player_color', 'white'),
                           is_game_over=board.is_game_over(),
                           outcome=get_outcome_message(board) if board.is_game_over() else "",
                           current_turn = 'white' if board.turn == chess.WHITE else 'black')

def get_outcome_message(board):
    if board.is_checkmate():
        winner_color = "Blancs" if board.turn == chess.BLACK else "Noirs"
        return f"Échec et mat ! {winner_color} gagnent."
    if board.is_stalemate(): return "Pat ! Partie nulle."
    if board.is_insufficient_material(): return "Matériel insuffisant. Partie nulle."
    if board.is_seventyfive_moves(): return "Règle des 75 coups. Partie nulle."
    if board.is_fivefold_repetition(): return "Répétition (5 fois). Partie nulle."
    if board.is_game_over(): return "Partie terminée." 
    return ""

@app.route('/make_move', methods=['POST'])
def make_move():
    app.logger.debug(f"Session au début de POST /make_move: {dict(session.items())}")
    if 'board_fen' not in session:
        app.logger.error("ERREUR CRITIQUE: 'board_fen' non trouvé dans la session pour POST /make_move!")
        return jsonify({'error': 'Erreur de session, "board_fen" manquant. Veuillez rafraîchir ou réinitialiser.',
                        'fen': chess.Board().fen(), 'game_over': False, 'board_svg': chess.svg.board(board=chess.Board(), size=400)}), 500

    board = chess.Board(session['board_fen'])
    if board.is_game_over():
        app.logger.info("Tentative de jouer alors que la partie est terminée.")
        return jsonify({'error': 'La partie est terminée.', 'fen': board.fen(), 'game_over': True, 'outcome': get_outcome_message(board), 'board_svg': chess.svg.board(board=board, size=400)})

    move_uci_san = request.json.get('move')
    if not move_uci_san:
        app.logger.warning("Aucun mouvement fourni dans la requête POST /make_move.")
        return jsonify({'error': 'Mouvement non fourni.', 'fen': board.fen(), 'game_over': board.is_game_over(), 'board_svg': chess.svg.board(board=board, size=400)})

    ai_move_made = False
    ai_move_uci = None
    move_to_highlight = None
    move = None 

    try:
        move = board.parse_uci(move_uci_san)
        app.logger.info(f"Mouvement joueur (tentative UCI): {move.uci()}")
    except ValueError:
        try:
            move = board.parse_san(move_uci_san)
            app.logger.info(f"Mouvement joueur (tentative SAN): {board.san(move)}")
        except ValueError:
            app.logger.warning(f"Mouvement invalide (ni UCI ni SAN): {move_uci_san} pour FEN {board.fen()}")
            return jsonify({'error': f'Mouvement invalide: {move_uci_san}', 'fen': board.fen(), 'game_over': board.is_game_over(), 'board_svg': chess.svg.board(board=board, size=400)})

    if move and move in board.legal_moves:
        board.push(move)
        move_to_highlight = move 
        session['board_fen'] = board.fen()
        app.logger.info(f"Mouvement joueur {move.uci()} appliqué. Nouveau FEN: {board.fen()}")

        if session.get('game_mode') == 'ai' and not board.is_game_over():
            app.logger.info(f"Mode IA, tour de l'IA. Joueur humain est {session.get('player_color')}.")
            current_turn_is_ai_turn = (session.get('player_color') == 'white' and board.turn == chess.BLACK) or \
                                      (session.get('player_color') == 'black' and board.turn == chess.WHITE)
            
            if not current_turn_is_ai_turn:
                 app.logger.error(f"Logique d'alternance erronée: C'est le tour de {'Blanc' if board.turn == chess.WHITE else 'Noir'}, mais l'IA ne devrait pas jouer.")
            else:
                stockfish_engine = get_stockfish_engine()
                if stockfish_engine:
                    stockfish_engine.set_fen_position(board.fen())
                    thinking_time_ms = 20000
                    best_move_ai = stockfish_engine.get_best_move(thinking_time_ms)
                    if best_move_ai:
                        app.logger.info(f"Stockfish propose le coup: {best_move_ai}")
                        try:
                            ai_move_obj = board.parse_uci(best_move_ai)
                            board.push(ai_move_obj)
                            session['board_fen'] = board.fen()
                            ai_move_made = True
                            ai_move_uci = best_move_ai
                            move_to_highlight = ai_move_obj 
                            app.logger.info(f"Mouvement IA {ai_move_uci} appliqué. Nouveau FEN: {board.fen()}")
                        except Exception as e:
                            app.logger.error(f"Erreur en appliquant le coup de l'IA {best_move_ai}: {e}", exc_info=True)
                    else:
                        app.logger.warning("L'IA (Stockfish) n'a pas retourné de coup.")
                    
                    # APPEL À send_quit_command() COMMENTÉ COMME DEMANDÉ
                    # if hasattr(stockfish_engine, 'send_quit_command'):
                    #     stockfish_engine.send_quit_command()
                    #     app.logger.info("Moteur Stockfish arrêté après le coup de l'IA.")
                    # elif hasattr(stockfish_engine, '__del__') and callable(getattr(stockfish_engine, '__del__')):
                    #     app.logger.warning("send_quit_command() n'existe pas, __del__ sera potentiellement utilisé.")
                    # else:
                    #     app.logger.error("Ni send_quit_command ni __del__ ne semblent disponibles pour arrêter Stockfish proprement.")
                    app.logger.info("Appel explicite à send_quit_command retiré (après coup IA). Le processus Stockfish peut rester actif.")
                    # del stockfish_engine # Optionnel: pour essayer de forcer __del__ si la lib le gère bien

                else:
                    app.logger.error("Moteur Stockfish non disponible pour le coup de l'IA.")
    elif move: 
        app.logger.warning(f"Mouvement illégal tenté: {move.uci() if hasattr(move, 'uci') else move_uci_san} depuis FEN: {session['board_fen']}")
        return jsonify({'error': f'Mouvement illégal: {move.uci() if hasattr(move, "uci") else move_uci_san}', 'fen': board.fen(), 'game_over': board.is_game_over(), 'board_svg': chess.svg.board(board=board, size=400)})
    else: 
        app.logger.error("La variable 'move' est None après la tentative de parsing, ce qui ne devrait pas arriver ici.")
        return jsonify({'error': 'Erreur interne de parsing de coup.', 'fen': board.fen(), 'game_over': board.is_game_over(), 'board_svg': chess.svg.board(board=board, size=400)}), 500

    game_over = board.is_game_over()
    outcome = get_outcome_message(board) if game_over else ""
    if game_over:
        app.logger.info(f"Partie terminée. Résultat: {outcome}")
    
    app.logger.debug(f"Session à la fin de POST /make_move: {dict(session.items())}")
    return jsonify({
        'fen': board.fen(),
        'board_svg': chess.svg.board(board=board, size=400, lastmove=move_to_highlight),
        'game_over': game_over,
        'outcome': outcome,
        'ai_move_uci': ai_move_uci,
        'turn': 'white' if board.turn == chess.WHITE else 'black'
    })

@app.route('/reset_game', methods=['POST'])
def reset_game():
    app.logger.debug(f"Session au début de POST /reset_game: {dict(session.items())}")
    session['board_fen'] = chess.Board().fen()
    if 'game_mode' not in session: session['game_mode'] = 'pvp'
    if 'player_color' not in session: session['player_color'] = 'white'

    app.logger.info(f"Jeu réinitialisé. Nouveau FEN: {session['board_fen']}. Mode: {session.get('game_mode')}, Couleur joueur: {session.get('player_color')}")
    
    board = chess.Board(session['board_fen'])
    app.logger.debug(f"Session à la fin de POST /reset_game: {dict(session.items())}")
    return jsonify({
        'fen': session['board_fen'],
        'board_svg': chess.svg.board(board=board, size=400),
        'game_mode': session.get('game_mode'),
        'player_color': session.get('player_color'),
        'turn': 'white' if board.turn == chess.WHITE else 'black',
        'game_over': False,
        'outcome': ""
    })

@app.route('/set_mode', methods=['POST'])
def set_mode_route():
    app.logger.debug(f"Session au début de POST /set_mode: {dict(session.items())}")
    mode = request.json.get('game_mode')
    player_color = request.json.get('player_color', 'white') 
    
    if mode in ['pvp', 'ai']:
        session['game_mode'] = mode
        session['player_color'] = player_color
        session['board_fen'] = chess.Board().fen()
        app.logger.info(f"Mode de jeu réglé sur {mode}. Joueur humain: {player_color if mode == 'ai' else 'N/A'}. FEN réinitialisé.")
        
        board = chess.Board()
        initial_ai_move_uci = None
        move_to_highlight_init = None

        if mode == 'ai' and player_color == 'black':
            app.logger.info("L'IA (Blancs) commence la partie.")
            stockfish_engine = get_stockfish_engine()
            if stockfish_engine:
                stockfish_engine.set_fen_position(board.fen())
                best_move_ai = stockfish_engine.get_best_move()
                if best_move_ai:
                    try:
                        ai_move_obj = board.parse_uci(best_move_ai)
                        board.push(ai_move_obj)
                        session['board_fen'] = board.fen() 
                        initial_ai_move_uci = best_move_ai
                        move_to_highlight_init = ai_move_obj
                        app.logger.info(f"Premier coup de l'IA (Blancs): {initial_ai_move_uci}. Nouveau FEN: {board.fen()}")
                    except Exception as e:
                        app.logger.error(f"Erreur en appliquant le premier coup de l'IA {best_move_ai}: {e}", exc_info=True)
                
                # APPEL À send_quit_command() COMMENTÉ COMME DEMANDÉ
                # if hasattr(stockfish_engine, 'send_quit_command'):
                #     stockfish_engine.send_quit_command()
                #     app.logger.info("Moteur Stockfish arrêté après le premier coup de l'IA.")
                # elif hasattr(stockfish_engine, '__del__') and callable(getattr(stockfish_engine, '__del__')):
                #     app.logger.warning("send_quit_command() n'existe pas, __del__ sera potentiellement utilisé.")
                # else:
                #     app.logger.error("Ni send_quit_command ni __del__ pour arrêter Stockfish (premier coup IA).")
                app.logger.info("Appel explicite à send_quit_command retiré (après premier coup IA). Le processus Stockfish peut rester actif.")
                # del stockfish_engine # Optionnel

            else:
                app.logger.error("Moteur Stockfish non disponible pour le premier coup de l'IA.")

        app.logger.debug(f"Session à la fin de POST /set_mode: {dict(session.items())}")
        return jsonify({
            'message': f'Mode de jeu réglé sur {mode.upper()}. {"Vous jouez " + player_color.capitalize() if mode == "ai" else ""}',
            'fen': session['board_fen'],
            'board_svg': chess.svg.board(board=board, size=400, lastmove=move_to_highlight_init),
            'game_mode': mode,
            'player_color': player_color,
            'turn': 'white' if board.turn == chess.WHITE else 'black',
            'initial_ai_move_uci': initial_ai_move_uci,
            'game_over': board.is_game_over(),
            'outcome': get_outcome_message(board) if board.is_game_over() else ""
        })
    else:
        app.logger.warning(f"Tentative de définir un mode de jeu invalide: {mode}")
        return jsonify({'error': 'Mode invalide'}), 400

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000) # IS_DEBUG_MODE et app.debug sont gérés plus haut