Update main.py

main.py

@@ -1,4 +1,3 @@
-from contextlib import asynccontextmanager
 from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
@@ -10,213 +9,73 @@ import chess.engine
 import asyncio
 import json
 
-# ─── Constants ────────────────────────────────────────────────────────────────
-ENGINE_PATH = os.environ.get("ENGINE_PATH", "/app/engine/deepcastle")
-NNUE_PATH   = os.environ.get("NNUE_PATH",   "/app/engine/output.nnue")
-POOL_SIZE   = 4
-
-# ─── Engine Pool ───────────────────────────────────────────────────────────────
-class EnginePool:
-    def __init__(self):
-        self._queue: asyncio.Queue = asyncio.Queue()
-        self._all_engines: list    = []
-
-    async def _spawn(self):
-        transport, engine = await chess.engine.popen_uci(ENGINE_PATH)
-
-        # Conservative, proven-safe values — 4×128MB = 512MB total
-        options = {"Threads": 1, "Hash": 128}
-
-        # Only set EvalFile if the NNUE actually exists — missing file = exit code 1
-        for candidate in [
-            NNUE_PATH,
-            "/app/engine/custom_big.nnue",
-            "/app/engine/nn-9a0cc2a62c52.nnue",
-            "/app/engine/nn-47fc8b7fff06.nnue",
-        ]:
-            if os.path.exists(candidate):
-                options["EvalFile"] = candidate
-                print(f"[Pool] Using NNUE: {candidate}")
-                break
-        else:
-            print("[Pool] WARNING: No NNUE file found — using classical eval")
-
-        try:
-            await engine.configure(options)
-        except Exception as e:
-            print(f"[Pool] configure warning: {e}")
-
-        # Verify the engine is actually alive before returning it
-        try:
-            test_board = chess.Board()
-            await asyncio.wait_for(
-                engine.analyse(test_board, chess.engine.Limit(time=0.05)),
-                timeout=5.0
-            )
-            print("[Pool] Engine spawn verified OK")
-        except Exception as e:
-            print(f"[Pool] Engine failed verification: {e}")
-            try:
-                await engine.quit()
-            except Exception:
-                pass
-            raise RuntimeError(f"Engine spawn failed verification: {e}")
-
-        return engine
-
-    async def start(self):
-        for i in range(POOL_SIZE):
-            try:
-                engine = await self._spawn()
-                self._all_engines.append(engine)
-                await self._queue.put(engine)
-                print(f"[Pool] Engine {i+1}/{POOL_SIZE} ready")
-            except Exception as e:
-                print(f"[Pool] CRITICAL: Engine {i+1} failed to start: {e}")
-
-        ready = self._queue.qsize()
-        if ready == 0:
-            raise RuntimeError("No engines could start — check ENGINE_PATH and binary")
-        print(f"[Pool] {ready}/{POOL_SIZE} engines ready")
-
-    async def _replace_engine(self):
-        try:
-            fresh = await self._spawn()
-            await self._queue.put(fresh)
-            print("[Pool] Replacement engine added to pool")
-        except Exception as e:
-            print(f"[Pool] CRITICAL: could not replace engine: {e}")
-
-    @asynccontextmanager
-    async def acquire(self, timeout: float = 10.0):
-        try:
-            engine = await asyncio.wait_for(self._queue.get(), timeout=timeout)
-        except asyncio.TimeoutError:
-            raise HTTPException(status_code=503,
-                                detail="All engines busy — try again shortly")
-        healthy = True
-        try:
-            yield engine
-        except chess.engine.EngineTerminatedError:
-            healthy = False
-            raise HTTPException(status_code=500,
-                                detail="Engine crashed — please retry")
-        except Exception:
-            healthy = False
-            raise
-        finally:
-            if healthy:
-                await self._queue.put(engine)
-            else:
-                try:
-                    await engine.quit()
-                except Exception:
-                    pass
-                asyncio.create_task(self._replace_engine())
-
-    async def shutdown(self):
-        engines = []
-        while not self._queue.empty():
-            try:
-                engines.append(self._queue.get_nowait())
-            except asyncio.QueueEmpty:
-                break
-        for e in engines:
-            try:
-                await e.quit()
-            except Exception:
-                pass
-        print("[Pool] all engines shut down")
-
-
-pool = EnginePool()
-
-
-# ─── Openings DB ────────────────────────────────────────────────────���─────────
-openings_db: dict = {}
-
-def load_openings():
-    global openings_db
-    path = os.path.join(os.path.dirname(__file__), "openings.json")
-    if os.path.exists(path):
-        try:
-            with open(path, "r", encoding="utf-8") as f:
-                openings_db = json.load(f)
-            print(f"[Openings] Loaded {len(openings_db)} positions")
-        except Exception as e:
-            print(f"[Openings] Load error: {e}")
-    else:
-        print("[Openings] openings.json not found — opening detection disabled")
-
-
-# ─── FastAPI Lifespan ─────────────────────────────────────────────────────────
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    load_openings()
-    await pool.start()
-    yield
-    await pool.shutdown()
-
-app = FastAPI(title="Deepcastle Engine API", lifespan=lifespan)
-
-
-# ─── CORS ─────────────────────────────────────────────────────────────────────
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+app = FastAPI(title="Deepcastle Engine API")
 
-
-# ─── WebSocket / Multiplayer ──────────────────────────────────────────────────
+# ─── Multiplaying / Challenge Manager ──────────────────────────────────────────
 class ConnectionManager:
     def __init__(self):
+        # match_id -> list of websockets
         self.active_connections: Dict[str, List[WebSocket]] = {}
 
     async def connect(self, websocket: WebSocket, match_id: str):
         await websocket.accept()
-        self.active_connections.setdefault(match_id, []).append(websocket)
+        if match_id not in self.active_connections:
+            self.active_connections[match_id] = []
+        self.active_connections[match_id].append(websocket)
 
     def disconnect(self, websocket: WebSocket, match_id: str):
         if match_id in self.active_connections:
-            try:
+            if websocket in self.active_connections[match_id]:
                 self.active_connections[match_id].remove(websocket)
-            except ValueError:
-                pass
             if not self.active_connections[match_id]:
                 del self.active_connections[match_id]
 
     async def broadcast(self, message: str, match_id: str, exclude: WebSocket = None):
-        for conn in self.active_connections.get(match_id, []):
-            if conn != exclude:
-                try:
-                    await conn.send_text(message)
-                except Exception:
-                    pass
+        if match_id in self.active_connections:
+            for connection in self.active_connections[match_id]:
+                if connection != exclude:
+                    try:
+                        await connection.send_text(message)
+                    except Exception:
+                        pass
 
 manager = ConnectionManager()
 
 @app.websocket("/ws/{match_id}")
 async def websocket_endpoint(websocket: WebSocket, match_id: str):
     await manager.connect(websocket, match_id)
+    room = manager.active_connections.get(match_id, [])
+    # Notify others that someone joined
     await manager.broadcast(json.dumps({"type": "join"}), match_id, exclude=websocket)
     try:
         while True:
             data = await websocket.receive_text()
+            # Relay the message (move, etc.) to others in the same room
             await manager.broadcast(data, match_id, exclude=websocket)
     except WebSocketDisconnect:
         manager.disconnect(websocket, match_id)
+        # Notify remaining players that opponent disconnected → they win
         await manager.broadcast(json.dumps({"type": "opponent_disconnected"}), match_id)
     except Exception:
         manager.disconnect(websocket, match_id)
         await manager.broadcast(json.dumps({"type": "opponent_disconnected"}), match_id)
 
 
-# ─── Pydantic Models ──────────────────────────────────────────────────────────
+# Allow ALL for easy testing (we can restrict this later if needed)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Paths relative to the Docker container
+ENGINE_PATH = os.environ.get("ENGINE_PATH", "/app/engine/deepcastle")
+NNUE_PATH = os.environ.get("NNUE_PATH", "/app/engine/output.nnue")
+
 class MoveRequest(BaseModel):
     fen: str
-    time: float = 1.0
+    time: float = 1.0  # seconds
     depth: Optional[int] = None
 
 class MoveResponse(BaseModel):
@@ -251,9 +110,30 @@ class AnalyzeResponse(BaseModel):
     moves: List[MoveAnalysis]
     counts: Dict[str, int]
 
+@app.get("/")
+def home():
+    return {"status": "online", "engine": "Deepcastle Hybrid Neural", "platform": "Hugging Face Spaces"}
+
+@app.get("/health")
+def health():
+    if not os.path.exists(ENGINE_PATH):
+        return {"status": "error", "message": "Engine binary not found"}
+    return {"status": "ok", "engine": "Deepcastle"}
+
+async def get_engine():
+    if not os.path.exists(ENGINE_PATH):
+        raise HTTPException(status_code=500, detail="Engine binary not found")
+    transport, engine = await chess.engine.popen_uci(ENGINE_PATH)
+    if os.path.exists(NNUE_PATH):
+        try:
+            await engine.configure({"EvalFile": NNUE_PATH})
+            await engine.configure({"Hash": 512, "Threads": 2})
+        except Exception:
+            pass
+    return engine
 
-# ─── Score Utilities ──────────────────────────────────────────────────────────
 def get_normalized_score(info) -> tuple[float, Optional[int]]:
+    """Returns the score from White's perspective in centipawns."""
     if "score" not in info:
         return 0.0, None
     raw = info["score"].white()
@@ -262,6 +142,80 @@ def get_normalized_score(info) -> tuple[float, Optional[int]]:
         return (10000.0 if m > 0 else -10000.0), m
     return raw.score() or 0.0, None
 
+# ─── Engine Inference Route ────────────────────────────────────────────────────
+@app.post("/move", response_model=MoveResponse)
+async def get_move(request: MoveRequest):
+    engine = None
+    try:
+        engine = await get_engine()
+        board = chess.Board(request.fen)
+        limit = chess.engine.Limit(time=request.time, depth=request.depth)
+        
+        result = await engine.play(board, limit)
+        info = await engine.analyse(board, limit)
+        
+        # From White's perspective in CP -> converted to Pawns for UI
+        score_cp, mate_in = get_normalized_score(info)
+        
+        depth = info.get("depth", 0)
+        nodes = info.get("nodes", 0)
+        nps = info.get("nps", 0)
+
+        pv_board = board.copy()
+        pv_parts = []
+        for m in info.get("pv", [])[:5]:
+            if m in pv_board.legal_moves:
+                try:
+                    pv_parts.append(pv_board.san(m))
+                    pv_board.push(m)
+                except Exception:
+                    break
+            else:
+                break
+        pv = " ".join(pv_parts)
+
+        # Map mate score to pawns representation to not break old UI
+        score_pawns = score_cp / 100.0 if abs(score_cp) < 9900 else (100.0 if score_cp > 0 else -100.0)
+
+        # Check for opening name
+        board_fen_only = board.fen().split(" ")[0]
+        opening_name = openings_db.get(board_fen_only)
+
+        return MoveResponse(
+            bestmove=result.move.uci(),
+            score=score_pawns,
+            depth=depth,
+            nodes=nodes,
+            nps=nps,
+            pv=pv,
+            mate_in=mate_in,
+            opening=opening_name
+        )
+    except Exception as e:
+        print(f"Error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if engine:
+            try:
+                await engine.quit()
+            except Exception:
+                pass
+
+
+import math
+import json
+import os
+from typing import Optional, List, Tuple
+
+openings_db = {}
+openings_path = os.path.join(os.path.dirname(__file__), "openings.json")
+if os.path.exists(openings_path):
+    try:
+        with open(openings_path, "r", encoding="utf-8") as f:
+            openings_db = json.load(f)
+    except Exception as e:
+        pass
+
 def get_win_percentage_from_cp(cp: int) -> float:
     cp_ceiled = max(-1000, min(1000, cp))
     MULTIPLIER = -0.00368208
@@ -274,23 +228,22 @@ def get_win_percentage(info: dict) -> float:
         return 50.0
     white_score = score.white()
     if white_score.is_mate():
-        return 100.0 if white_score.mate() > 0 else 0.0
+        mate_val = white_score.mate()
+        return 100.0 if mate_val > 0 else 0.0
     return get_win_percentage_from_cp(white_score.score())
 
 def is_losing_or_alt_winning(pos_win_pct: float, alt_win_pct: float, is_white_move: bool) -> bool:
-    is_losing      = pos_win_pct < 50.0 if is_white_move else pos_win_pct > 50.0
+    is_losing = pos_win_pct < 50.0 if is_white_move else pos_win_pct > 50.0
     is_alt_winning = alt_win_pct > 97.0 if is_white_move else alt_win_pct < 3.0
     return is_losing or is_alt_winning
 
 def get_has_changed_outcome(last_win_pct: float, pos_win_pct: float, is_white_move: bool) -> bool:
     diff = (pos_win_pct - last_win_pct) * (1 if is_white_move else -1)
-    return diff > 10.0 and (
-        (last_win_pct < 50.0 and pos_win_pct > 50.0) or
-        (last_win_pct > 50.0 and pos_win_pct < 50.0)
-    )
+    return diff > 10.0 and ((last_win_pct < 50.0 and pos_win_pct > 50.0) or (last_win_pct > 50.0 and pos_win_pct < 50.0))
 
 def get_is_only_good_move(pos_win_pct: float, alt_win_pct: float, is_white_move: bool) -> bool:
-    return (pos_win_pct - alt_win_pct) * (1 if is_white_move else -1) > 10.0
+    diff = (pos_win_pct - alt_win_pct) * (1 if is_white_move else -1)
+    return diff > 10.0
 
 def is_simple_recapture(fen_two_moves_ago: str, previous_move: chess.Move, played_move: chess.Move) -> bool:
     if previous_move.to_square != played_move.to_square:
@@ -299,8 +252,7 @@ def is_simple_recapture(fen_two_moves_ago: str, previous_move: chess.Move, playe
     return b.piece_at(previous_move.to_square) is not None
 
 def get_material_difference(board: chess.Board) -> int:
-    values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3,
-              chess.ROOK: 5, chess.QUEEN: 9, chess.KING: 0}
+    values = {chess.PAWN: 1, chess.KNIGHT: 3, chess.BISHOP: 3, chess.ROOK: 5, chess.QUEEN: 9, chess.KING: 0}
     w = sum(values.get(p.piece_type, 0) for p in board.piece_map().values() if p.color == chess.WHITE)
     b = sum(values.get(p.piece_type, 0) for p in board.piece_map().values() if p.color == chess.BLACK)
     return w - b
@@ -308,20 +260,29 @@ def get_material_difference(board: chess.Board) -> int:
 def get_is_piece_sacrifice(board: chess.Board, played_move: chess.Move, best_pv: list) -> bool:
     if not best_pv:
         return False
+    start_diff = get_material_difference(board)
     white_to_play = board.turn == chess.WHITE
+    
     sim_board = board.copy()
     moves = [played_move] + best_pv
     if len(moves) % 2 == 1:
         moves = moves[:-1]
-    captured_w, captured_b = [], []
+        
+    captured_w = []
+    captured_b = []
     non_capturing = 1
+    
     for m in moves:
         if m in sim_board.legal_moves:
             captured_piece = sim_board.piece_at(m.to_square)
             if sim_board.is_en_passant(m):
                 captured_piece = chess.Piece(chess.PAWN, not sim_board.turn)
+                
             if captured_piece:
-                (captured_b if sim_board.turn == chess.WHITE else captured_w).append(captured_piece.piece_type)
+                if sim_board.turn == chess.WHITE:
+                    captured_b.append(captured_piece.piece_type)
+                else:
+                    captured_w.append(captured_piece.piece_type)
                 non_capturing = 1
             else:
                 non_capturing -= 1
@@ -330,20 +291,32 @@ def get_is_piece_sacrifice(board: chess.Board, played_move: chess.Move, best_pv:
             sim_board.push(m)
         else:
             break
+            
     for p in captured_w[:]:
         if p in captured_b:
             captured_w.remove(p)
             captured_b.remove(p)
+            
     if abs(len(captured_w) - len(captured_b)) <= 1 and all(p == chess.PAWN for p in captured_w + captured_b):
         return False
-    mat_diff = get_material_difference(sim_board) - get_material_difference(board)
-    return (mat_diff if white_to_play else -mat_diff) < 0
+        
+    end_diff = get_material_difference(sim_board)
+    mat_diff = end_diff - start_diff
+    player_rel = mat_diff if white_to_play else -mat_diff
+    
+    return player_rel < 0
 
 def get_move_classification(
-    last_win_pct, pos_win_pct, is_white_move,
-    played_move, best_move_before, alt_win_pct,
-    fen_two_moves_ago, uci_next_two_moves,
-    board_before_move, best_pv_after
+    last_win_pct: float,
+    pos_win_pct: float,
+    is_white_move: bool,
+    played_move: chess.Move,
+    best_move_before: chess.Move,
+    alt_win_pct: Optional[float],
+    fen_two_moves_ago: Optional[str],
+    uci_next_two_moves: Optional[Tuple[chess.Move, chess.Move]],
+    board_before_move: chess.Board,
+    best_pv_after: list
 ) -> str:
     diff = (pos_win_pct - last_win_pct) * (1 if is_white_move else -1)
 
@@ -355,10 +328,10 @@ def get_move_classification(
     if alt_win_pct is not None and diff >= -2.0:
         is_recapture = False
         if fen_two_moves_ago and uci_next_two_moves:
-            is_recapture = is_simple_recapture(fen_two_moves_ago, *uci_next_two_moves)
+             is_recapture = is_simple_recapture(fen_two_moves_ago, uci_next_two_moves[0], uci_next_two_moves[1])
+             
         if not is_recapture and not is_losing_or_alt_winning(pos_win_pct, alt_win_pct, is_white_move):
-            if get_has_changed_outcome(last_win_pct, pos_win_pct, is_white_move) or \
-               get_is_only_good_move(pos_win_pct, alt_win_pct, is_white_move):
+            if get_has_changed_outcome(last_win_pct, pos_win_pct, is_white_move) or get_is_only_good_move(pos_win_pct, alt_win_pct, is_white_move):
                 return "Great"
 
     if best_move_before and played_move == best_move_before:
@@ -366,147 +339,90 @@ def get_move_classification(
 
     if diff < -20.0: return "Blunder"
     if diff < -10.0: return "Mistake"
-    if diff < -5.0:  return "Inaccuracy"
-    if diff < -2.0:  return "Good"
+    if diff < -5.0: return "Inaccuracy"
+    if diff < -2.0: return "Good"
     return "Excellent"
 
-
-# ─── Routes ───────────────────────────────────────────────────────────────────
-@app.get("/")
-def home():
-    return {
-        "status": "online",
-        "engine": "Deepcastle Hybrid Neural",
-        "platform": "Hugging Face Spaces",
-        "pool_size": POOL_SIZE,
-    }
-
-@app.get("/health")
-def health():
-    if not os.path.exists(ENGINE_PATH):
-        return {"status": "error", "message": "Engine binary not found"}
-    return {
-        "status": "ok",
-        "engine": "Deepcastle",
-        "pool_size": POOL_SIZE,
-        "idle_engines": pool._queue.qsize(),
-    }
-
-@app.get("/pool-status")
-def pool_status():
-    return {"idle_engines": pool._queue.qsize(), "total_engines": POOL_SIZE}
-
-
-@app.post("/move", response_model=MoveResponse)
-async def get_move(request: MoveRequest):
-    async with pool.acquire(timeout=10.0) as engine:
-        board = chess.Board(request.fen)
-        limit = chess.engine.Limit(time=request.time, depth=request.depth)
-
-        result = await engine.play(board, limit)
-        info   = await engine.analyse(board, limit)
-
-        score_cp, mate_in = get_normalized_score(info)
-        depth = info.get("depth", 0)
-        nodes = info.get("nodes", 0)
-        nps   = info.get("nps", 0)
-
-        pv_board, pv_parts = board.copy(), []
-        for m in info.get("pv", [])[:5]:
-            if m in pv_board.legal_moves:
-                try:
-                    pv_parts.append(pv_board.san(m))
-                    pv_board.push(m)
-                except Exception:
-                    break
-            else:
-                break
-
-        score_pawns    = score_cp / 100.0 if abs(score_cp) < 9900 else (100.0 if score_cp > 0 else -100.0)
-        board_fen_only = board.fen().split(" ")[0]
-
-        return MoveResponse(
-            bestmove=result.move.uci(),
-            score=score_pawns,
-            depth=depth,
-            nodes=nodes,
-            nps=nps,
-            pv=" ".join(pv_parts),
-            mate_in=mate_in,
-            opening=openings_db.get(board_fen_only),
-        )
-
-
 @app.post("/analyze-game", response_model=AnalyzeResponse)
 async def analyze_game(request: AnalyzeRequest):
-    async with pool.acquire(timeout=30.0) as engine:
+    engine = None
+    try:
+        engine = await get_engine()
         board = chess.Board(request.start_fen) if request.start_fen else chess.Board()
         limit = chess.engine.Limit(time=request.time_per_move)
-
-        analysis_results   = []
+        
+        analysis_results = []
+        
+        infos_before = await engine.analyse(board, limit, multipv=2)
+        infos_before = infos_before if isinstance(infos_before, list) else [infos_before]
+        
         counts = {
-            "Book": 0, "Brilliant": 0, "Great": 0, "Best": 0,
-            "Excellent": 0, "Good": 0, "Inaccuracy": 0,
-            "Mistake": 0, "Blunder": 0,
+            "Book": 0, "Brilliant": 0, "Great": 0, "Best": 0, 
+            "Excellent": 0, "Good": 0, "Inaccuracy": 0, 
+            "Mistake": 0, "Blunder": 0
         }
 
-        player_is_white    = request.player_color.lower() == "white"
-        fen_history        = [board.fen()]
-        move_history       = []
-        total_cpl          = 0.0
+        player_is_white = (request.player_color.lower() == "white")
+        
+        fen_history = [board.fen()]
+        move_history = []
+        total_cpl = 0.0
         player_moves_count = 0
-
-        infos_before = await engine.analyse(board, limit, multipv=2)
-        if not isinstance(infos_before, list):
-            infos_before = [infos_before]
         current_score, _ = get_normalized_score(infos_before[0])
 
         for i, san_move in enumerate(request.moves):
-            is_white_turn  = board.turn == chess.WHITE
+            is_white_turn = board.turn == chess.WHITE
             is_player_turn = is_white_turn if player_is_white else not is_white_turn
-
-            info_dict        = infos_before[0]
-            pv_list          = info_dict.get("pv", [])
-            best_move_before = pv_list[0] if pv_list else None
-
-            score_before, _ = get_normalized_score(info_dict)
-            win_pct_before  = get_win_percentage(info_dict)
-
-            # Parse move early so we can compare against alt lines
+            
+            score_before = current_score
+            
             try:
                 move = board.parse_san(san_move)
             except Exception:
-                break
+                break # Invalid move
 
+            info_dict = infos_before[0]
+            pv_list = info_dict.get("pv", [])
+            best_move_before = pv_list[0] if pv_list else None
+            
+            score_before, _ = get_normalized_score(info_dict)
+            win_pct_before = get_win_percentage(info_dict)
             alt_win_pct_before: Optional[float] = None
-            for line in infos_before:
-                if line.get("pv") and line["pv"][0] != move:
-                    alt_win_pct_before = get_win_percentage(line)
-                    break
+            if len(infos_before) > 1:
+                # Find the first alternative move that is not the played move
+                for line in infos_before:
+                    if line.get("pv") and line.get("pv")[0] != move:
+                        alt_win_pct_before = get_win_percentage(line)
+                        break
 
             board_before_move = board.copy()
             board.push(move)
+            
             move_history.append(move)
             fen_history.append(board.fen())
-
+            
             infos_after_raw = await engine.analyse(board, limit, multipv=2)
             infos_after: List[dict] = infos_after_raw if isinstance(infos_after_raw, list) else [infos_after_raw]
-            info_after_dict = infos_after[0]
-
-            win_pct_after  = get_win_percentage(info_after_dict)
+            
+            info_after_dict: dict = infos_after[0]
+            
+            win_pct_after = get_win_percentage(info_after_dict)
             score_after, _ = get_normalized_score(info_after_dict)
-            current_score  = score_after
-            best_pv_after  = info_after_dict.get("pv", [])
-
-            fen_two_moves_ago  = None
+            current_score = score_after
+            
+            best_pv_after = info_after_dict.get("pv", [])
+            
+            fen_two_moves_ago = None
             uci_next_two_moves = None
             if len(move_history) >= 2:
-                fen_two_moves_ago  = fen_history[-3]
+                fen_two_moves_ago = fen_history[-3]
                 uci_next_two_moves = (move_history[-2], move_history[-1])
 
+            cls = "Book"
+            opening_name = None
             board_fen_only = board.fen().split(" ")[0]
             if board_fen_only in openings_db:
-                cls          = "Book"
+                cls = "Book"
                 opening_name = openings_db[board_fen_only]
             else:
                 cls = get_move_classification(
@@ -519,50 +435,63 @@ async def analyze_game(request: AnalyzeRequest):
                     fen_two_moves_ago=fen_two_moves_ago,
                     uci_next_two_moves=uci_next_two_moves,
                     board_before_move=board_before_move,
-                    best_pv_after=best_pv_after,
+                    best_pv_after=best_pv_after
                 )
-                opening_name = None
-
+            
             move_gain = score_after - score_before if is_white_turn else score_before - score_after
-            cpl       = min(max(0.0, -move_gain), 1000.0)
-
+            cpl = max(0, -move_gain)
+            cpl = min(cpl, 1000.0)
+            
             if is_player_turn:
-                total_cpl          += cpl
+                total_cpl += cpl
                 player_moves_count += 1
-                counts[cls]         = counts.get(cls, 0) + 1
-
+                counts[cls] = counts.get(cls, 0) + 1
+            
             analysis_results.append(MoveAnalysis(
-                move_num=i + 1,
+                move_num=i+1,
                 san=san_move,
+                fen=board.fen(),
                 classification=cls,
                 cpl=float(cpl),
                 score_before=float(score_before / 100.0),
                 score_after=float(score_after / 100.0),
                 best_move=best_move_before.uci() if best_move_before else "",
-                opening=opening_name,
+                opening=opening_name
             ))
-
+            
             infos_before = infos_after
 
-        avg_cpl       = total_cpl / max(1, player_moves_count)
-        accuracy      = max(10.0, min(100.0, 100.0 * math.exp(-0.005 * avg_cpl)))
+        # Win probability matching accuracy formula
+        # Accuracy = 100 * exp(-0.02 * avg_cpl) smoothed
+        avg_cpl = total_cpl / max(1, player_moves_count)
+        
+        # Simple heuristic mapping for Accuracy & Elo
+        # 0 avg loss -> 100%
+        # ~100 avg loss -> ~60%
+        accuracy = max(10.0, min(100.0, 100.0 * math.exp(-0.005 * avg_cpl)))
+        
+        # Exponential Elo Decay calibrated to 3600 max engine strength
         estimated_elo = int(max(400, min(3600, round(3600 * math.exp(-0.015 * avg_cpl)))))
 
         return AnalyzeResponse(
             accuracy=round(accuracy, 1),
             estimated_elo=estimated_elo,
             moves=analysis_results,
-            counts=counts,
+            counts=counts
         )
+        
+    except Exception as e:
+        print(f"Analysis Error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if engine:
+            try:
+                await engine.quit()
+            except Exception:
+                pass
 
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(
-        "main:app",
-        host="0.0.0.0",
-        port=7860,
-        workers=1,       # Must stay 1 — pool lives in-process
-        loop="uvloop",   # Faster async event loop
-        log_level="info",
-    )
+    # Hugging Face Spaces port is 7860
+    uvicorn.run(app, host="0.0.0.0", port=7860)