server.py

from flask import Flask, render_template, jsonify, request
from poker.game import GameState
from poker.player import Player
from poker.bot import Bot
from poker.hand import HandEvaluator

app = Flask(__name__)

# Global Game Instance
game = None

def serialize_card(card):
    return {"rank": card.rank, "suit": card.suit, "display": str(card)}

def serialize_player(p):
    return {
        "name": p.name,
        "stack": p.stack,
        "bet": p.current_bet,
        "is_folded": p.is_folded,
        "is_all_in": p.is_all_in,
        # Show hole cards if it's Hero OR if it's Showdown
        "hole_cards": [serialize_card(c) for c in p.hole_cards] if (p.name == "Hero" or (game and game.stage == "SHOWDOWN")) else []
    }

@app.route('/')
def home():
    return render_template('index.html')

@app.route('/api/start', methods=['POST'])
def start_game():
    global game
    # Deep Stack 10,000 chips
    hero = Player("Hero", 10000)
    bot1 = Bot("Bot 1", 10000)
    bot2 = Bot("Bot 2", 10000)
    players = [hero, bot1, bot2]
    
    game = GameState(players)
    game.start_hand()
    
    return jsonify({"status": "Game Started"})

@app.route('/api/next_hand', methods=['POST'])
def next_hand():
    global game
    if not game:
        return jsonify({"error": "No game active"}), 400
        
    game.start_hand()
    return jsonify({"status": "New Hand Started"})


    
# Cache for equity
last_game_state_hash = None
cached_equity = 0
cached_recommendation = "Wait"

@app.route('/api/state', methods=['GET'])
def get_state():
    global game, last_game_state_hash, cached_equity, cached_recommendation
    if not game:
        return jsonify({"error": "No game active"}), 400
    
    # Calculate Equity for Hero
    # We use a hash of the board and stage and hole cards to decide if we need to re-run
    hero = game.players[0] # Hero is index 0
    
    current_hash = hash((
        game.stage, 
        tuple(str(c) for c in game.board), 
        tuple(str(c) for c in hero.hole_cards),
        hero.is_folded
    ))
    
    if current_hash != last_game_state_hash:
        from engine.simulator import MonteCarloSimulator
        
        if not hero.is_folded and game.stage != "SHOWDOWN":
            sim = MonteCarloSimulator()
            # Increase iterations for better accuracy since we cache it now
            equity = sim.calculate_equity(hero.hole_cards, game.board, iterations=2000)
            
            # Simple Recommendation Logic
            rec_text = "Wait"
            rec_amount = 0
            
            if equity > 0.8:
                 rec_text = "All-In / Large Raise"
                 rec_amount = game.pot * 1.5 # Overbet
            elif equity > 0.65:
                 rec_text = "Raise (Strong)"
                 rec_amount = game.pot * 0.75 # 3/4 Pot
            elif equity > 0.55:
                 rec_text = "Value Bet / Raise"
                 rec_amount = game.pot * 0.5 # Half Pot
            elif equity > 0.4:
                 rec_text = "Call / Check"
            else:
                 rec_text = "Fold / Check"
                 
            cached_equity = equity
            cached_recommendation = f"{rec_text}"
            if rec_amount > 0:
                cached_recommendation += f" (${int(rec_amount)})"
        else:
            cached_equity = 0
            cached_recommendation = "--"
            
        last_game_state_hash = current_hash

    response = {
        "pot": game.pot,
        "board": [serialize_card(c) for c in game.board],
        "stage": game.stage,
        "current_player": game.players[game.current_player_idx].name,
        "players": [serialize_player(p) for p in game.players],
        "hero_equity": round(cached_equity * 100, 1),
        "recommendation": cached_recommendation
    }
    return jsonify(response)

@app.route('/api/action', methods=['POST'])
def player_action():
    global game
    if not game:
         return jsonify({"error": "No game"}), 400

    data = request.json
    action = data.get('action')
    amount = data.get('amount', 0)
    
    # Process Action with amount
    # We map 'raise' or 'bet' to passing the amount
    hero = game.players[0]
    
    game.handle_action(hero.name, action, int(amount))
    
    # For simplified flow, we still auto-advance stage after user acts (plus bots)
    game.next_stage()
    
    return jsonify({"status": "Action processed", "new_stage": game.stage})

if __name__ == '__main__':
    app.run(debug=True, port=8888)