from __future__ import annotations

import itertools
import json
import time
import uuid
import warnings
from dataclasses import dataclass, field
from html import escape

warnings.filterwarnings(
    "ignore",
    message="'HTTP_422_UNPROCESSABLE_ENTITY' is deprecated.*",
)

import gradio as gr

from token_holdem.agents import ROSTER, fallback_decide
from token_holdem.cards import cards_label
from token_holdem.engine import GameState, make_players
from token_holdem.leaderboard import Leaderboard
from token_holdem.logging_utils import get_logger, log_event
from token_holdem.logging_utils import LOG_FILE
from token_holdem.model_runtime import ModelRuntimeUnavailable, SUPPORTED_TRANSFORMERS_MODELS, get_model_runtime, model_runtime_statuses
from token_holdem.render import CSS, hall_markdown, leaderboard_markdown, log_markdown, table_html


HAND_COUNTER = itertools.count(1)


@dataclass
class AppSession:
    game: GameState | None = None
    chats: list[str] = field(default_factory=list)
    stopped: bool = False
    session_id: str = field(default_factory=lambda: uuid.uuid4().hex[:10])
    hand_no: int = 0
    orbit_no: int = 1


leaderboard = Leaderboard()
model_runtime = get_model_runtime()
logger = get_logger("token_holdem.app")


def _play_outputs(session: AppSession | None, status: str = ""):
    game = session.game if session else None
    return (
        session,
        table_html(game, chats=session.chats if session else None),
        log_markdown(game, session.chats if session else None),
        _leaderboard_md(),
        _hall_md(),
        status or _play_status(session),
        hand_review_markdown(session),
        *_action_button_updates(session),
        gr.update(interactive=bool(session and session.stopped)),
    )


def _play_status(session: AppSession | None) -> str:
    if session is None or session.game is None:
        return "Quick Seat starts a cash-game session."
    if session.stopped:
        return "You are busted. Rebuy to keep playing this cash game."
    game = session.game
    human = next((player for player in game.players if player.is_human), None)
    human_status = ""
    if human:
        to_call = min(max(0, game.current_bet - human.bet), human.stack)
        human_status = f" To Call: {to_call} · Your Stack: {human.stack}."
    if game.result:
        return f"Hand complete: {game.result.summary} Click Next Hand to continue with current stacks.{human_status}"
    current = game.current_player()
    if current.is_human:
        legal = game.legal_actions(current.id)
        return f"Your turn. To Call: {legal['to_call']} · Your Stack: {current.stack}."
    return f"{current.name} is thinking...{human_status}"


def _action_button_updates(session: AppSession | None):
    hidden = [
        gr.update(interactive=False, visible=False, value="Fold"),
        gr.update(interactive=False, visible=False, value="Check"),
        gr.update(interactive=False, visible=False, value="Call"),
        gr.update(interactive=False, visible=False, value="Min Raise"),
        gr.update(interactive=False, visible=False, value="Half-Pot"),
        gr.update(interactive=False, visible=False, value="Pot"),
        gr.update(interactive=False, visible=False, value="All-In"),
    ]
    disabled = [
        gr.update(interactive=False, visible=True, value="Fold"),
        gr.update(interactive=False, visible=True, value="Check"),
        gr.update(interactive=False, visible=True, value="Call"),
        gr.update(interactive=False, visible=True, value="Min Raise"),
        gr.update(interactive=False, visible=True, value="Half-Pot"),
        gr.update(interactive=False, visible=True, value="Pot"),
        gr.update(interactive=False, visible=True, value="All-In"),
    ]
    if session is None or session.game is None or session.game.result or session.stopped:
        return hidden
    game = session.game
    current = game.current_player()
    if not current.is_human:
        return disabled
    legal = game.legal_actions(current.id)
    actions = set(legal["actions"])
    presets = legal["raise_presets"]
    return [
        gr.update(interactive="fold" in actions, visible=True, value="Fold"),
        gr.update(interactive="check" in actions, visible=True, value="Check"),
        gr.update(interactive="call" in actions, visible=True, value=f"Call {legal['to_call']}"),
        gr.update(interactive="raise" in actions, visible=True, value=f"Min {presets.get('min', 0)}"),
        gr.update(interactive="raise" in actions, visible=True, value=f"Half-Pot {presets.get('half_pot', 0)}"),
        gr.update(interactive="raise" in actions, visible=True, value=f"Pot {presets.get('pot', 0)}"),
        gr.update(interactive="all_in" in actions, visible=True, value=f"All-In {presets.get('all_in', current.stack)}"),
    ]


def hand_review_markdown(session: AppSession | None) -> str:
    if session is None or session.game is None:
        return "**Hand Review:** No active hand."
    game = session.game
    button = game.players[game.dealer_index].name
    small_blind = game.players[game.small_blind_index].name if game.small_blind_index is not None else "-"
    big_blind = game.players[game.big_blind_index].name if game.big_blind_index is not None else "-"
    current = "Complete" if game.result else game.current_player().name
    legal = {} if game.result else game.legal_actions(game.current_player().id)
    showdown = ""
    if game.result and game.result.showdown:
        showdown_lines = []
        for player in game.players:
            if player.id in game.result.showdown:
                marker = " winner" if player.id in game.result.winners else ""
                showdown_lines.append(f"  - {player.name}: {game.result.showdown[player.id]}{marker}")
        showdown = "\n- Showdown:\n" + "\n".join(showdown_lines)
    return (
        "**Hand Review**\n\n"
        f"- Session: `{game.session_id or '-'}`\n"
        f"- Hand: `{game.hand_id or '-'}`\n"
        f"- Orbit: `{game.orbit_id or '-'}`\n"
        f"- Button: **{button}**\n"
        f"- Small blind: **{small_blind}**\n"
        f"- Big blind: **{big_blind}**\n"
        f"- Street: **{game.street.value}**\n"
        f"- Current actor: **{current}**\n"
        f"- Legal actions: `{legal}`"
        f"{showdown}"
    )


def _ensure_roster() -> None:
    for idx, profile in enumerate(ROSTER):
        leaderboard.ensure_player(f"ai_{idx}", profile.name, "model", profile.model_id, profile.persona)


def _start_game(human_name: str, seed: int | None, mode: str) -> AppSession:
    _ensure_roster()
    human_name = (human_name or "Human Wanderer").strip()[:32]
    if mode == "play":
        leaderboard.ensure_player("human", human_name, "human")
        profiles = ROSTER[:7]
        players = make_players([profile.name for profile in profiles], human_name=human_name)
    else:
        profiles = ROSTER[:7]
        players = make_players([profile.name for profile in profiles])
    hand_no = 1
    session = AppSession(hand_no=hand_no, orbit_no=1)
    game = GameState(
        players=players,
        seed=(seed or int(time.time())) + next(HAND_COUNTER),
        session_id=session.session_id,
        hand_id=f"{session.session_id}-h{hand_no:03d}",
        orbit_id=f"{session.session_id}-o{session.orbit_no:02d}",
    )
    game.start_hand()
    session.game = game
    log_event(logger, "session_started", mode=mode, session_id=session.session_id, hand_id=game.hand_id, orbit_id=game.orbit_id, hand_no=hand_no, seed=game.seed, players=[player.name for player in players])
    return session


def _start_next_cash_hand(session: AppSession, seed: int | None, human_name: str) -> AppSession:
    if session.game is None:
        return _start_game(human_name, seed, "play")
    game = session.game
    for player in game.players:
        if not player.is_human and player.stack <= 0:
            player.stack = 1_000
            log_event(logger, "ai_auto_rebuy", player=player.name, amount=1_000)
    human = next((player for player in game.players if player.is_human), None)
    if human and human.stack <= 0:
        session.stopped = True
        session.chats.append(f"{human.name}: busted and needs a rebuy to keep playing.")
        log_event(logger, "human_busted_rebuy_required", player=human.name)
        return session
    next_button = game.next_active_index(game.dealer_index)
    session.hand_no += 1
    session.orbit_no = ((session.hand_no - 1) // len(game.players)) + 1
    next_game = GameState(
        players=game.players,
        dealer_index=next_button,
        seed=(seed or int(time.time())) + next(HAND_COUNTER),
        session_id=session.session_id,
        hand_id=f"{session.session_id}-h{session.hand_no:03d}",
        orbit_id=f"{session.session_id}-o{session.orbit_no:02d}",
    )
    next_game.start_hand()
    session.game = next_game
    session.stopped = False
    log_event(
        logger,
        "cash_hand_started",
        session_id=session.session_id,
        hand_id=next_game.hand_id,
        orbit_id=next_game.orbit_id,
        hand_no=session.hand_no,
        seed=next_game.seed,
        button=next_game.players[next_game.dealer_index].name,
        small_blind=next_game.players[next_game.small_blind_index].name if next_game.small_blind_index is not None else None,
        big_blind=next_game.players[next_game.big_blind_index].name if next_game.big_blind_index is not None else None,
        stacks={player.name: player.stack for player in next_game.players},
    )
    return session


def start_play(human_name: str, seed: int | None):
    try:
        log_event(logger, "callback_start", callback="start_play", human_name=human_name, seed=seed)
        session = _start_game(human_name, seed, "play")
        _advance_ai_until_human(session, next(HAND_COUNTER))
        return _play_outputs(session)
    except Exception:
        logger.exception("callback_failed", extra={"event": {"callback": "start_play"}})
        raise


def start_play_with_runtime(human_name: str, seed: int | None):
    try:
        log_event(logger, "callback_start", callback="start_play_with_runtime", human_name=human_name, seed=seed, use_models=True)
        session = _start_game(human_name, seed, "play")
        yielded = False
        for output in _advance_ai_until_human_stream(session, next(HAND_COUNTER), use_models=True):
            yielded = True
            yield output
        if not yielded:
            yield _play_outputs(session)
    except Exception:
        logger.exception("callback_failed", extra={"event": {"callback": "start_play_with_runtime"}})
        raise


def human_action(session: AppSession | None, action: str):
    try:
        log_event(logger, "callback_start", callback="human_action", action=action, use_models=True, has_session=session is not None)
        if session is None or session.game is None or session.game.result:
            yield _play_outputs(session)
            return
        game = session.game
        legal = game.legal_actions()
        amount = 0
        if action == "min_raise":
            action = "raise"
            amount = legal["raise_presets"].get("min", 0)
        elif action == "half_pot":
            action = "raise"
            amount = legal["raise_presets"].get("half_pot", 0)
        elif action == "pot":
            action = "raise"
            amount = legal["raise_presets"].get("pot", 0)
        game.apply_action(action, amount)
        yield _play_outputs(session, status="Action accepted. The tavern waits for the next move...")
        for output in _advance_ai_until_human_stream(session, next(HAND_COUNTER), use_models=True):
            yield output
        if game.result:
            _record_result(game, "play")
        yield _play_outputs(session)
    except Exception:
        logger.exception("callback_failed", extra={"event": {"callback": "human_action", "action": action}})
        raise


def next_play_hand(session: AppSession | None, human_name: str, seed: int | None):
    try:
        log_event(logger, "callback_start", callback="next_play_hand", human_name=human_name, seed=seed, use_models=True)
        if session is None:
            for output in start_play_with_runtime(human_name, seed):
                yield output
            return
        session = _start_next_cash_hand(session, seed, human_name)
        if not session.stopped:
            yielded = False
            for output in _advance_ai_until_human_stream(session, next(HAND_COUNTER), use_models=True):
                yielded = True
                yield output
            if not yielded:
                yield _play_outputs(session)
        else:
            yield _play_outputs(session)
    except Exception:
        logger.exception("callback_failed", extra={"event": {"callback": "next_play_hand"}})
        raise


def rebuy_user(session: AppSession | None, amount: int = 1_000):
    try:
        log_event(logger, "callback_start", callback="rebuy_user", amount=amount, has_session=session is not None)
        if session and session.game:
            for player in session.game.players:
                if player.is_human:
                    player.stack = amount
                    session.stopped = False
                    session.chats.append(f"{player.name} rebuys for {amount} chips.")
                    log_event(logger, "human_rebuy", player=player.name, amount=amount)
                    break
        return _play_outputs(session)
    except Exception:
        logger.exception("callback_failed", extra={"event": {"callback": "rebuy_user"}})
        raise


def action_handler(action: str):
    def handle(session: AppSession | None):
        yield from human_action(session, action)

    return handle


def run_arena(seed: int | None, hands: int):
    try:
        log_event(logger, "callback_start", callback="run_arena", seed=seed, hands=hands, use_models=True)
        session = _start_game("", seed, "arena")
        for _ in range(max(1, min(int(hands or 1), 10))):
            if session.game is None or session.game.result:
                session = _start_game("", seed, "arena")
            hand_no = next(HAND_COUNTER)
            while session.game and not session.game.result:
                try:
                    _take_ai_turn(session, hand_no, use_models=True)
                except ModelRuntimeUnavailable as exc:
                    _surface_model_error(session, session.game.current_player().name if session.game else "unknown", exc)
                    yield table_html(session.game, reveal_all=True, chats=session.chats), log_markdown(session.game, session.chats), _leaderboard_md(), _hall_md()
                    return
                yield table_html(session.game, reveal_all=True, chats=session.chats), log_markdown(session.game, session.chats), _leaderboard_md(), _hall_md()
                time.sleep(0.25)
            if session.game and session.game.result:
                _record_result(session.game, "arena")
                session.chats.append(_chronicle(session.game))
                yield table_html(session.game, reveal_all=True, chats=session.chats), log_markdown(session.game, session.chats), _leaderboard_md(), _hall_md()
                time.sleep(0.5)
    except Exception:
        logger.exception("callback_failed", extra={"event": {"callback": "run_arena", "seed": seed, "hands": hands, "use_models": True}})
        raise


def _advance_ai_until_human(session: AppSession, hand_no: int, use_models: bool = False) -> None:
    while session.game and not session.game.result and not session.game.current_player().is_human:
        _take_ai_turn(session, hand_no, use_models=use_models)


def _advance_ai_until_human_stream(session: AppSession, hand_no: int, use_models: bool = False):
    while session.game and not session.game.result and not session.game.current_player().is_human:
        player = session.game.current_player()
        yield _play_outputs(session, status=f"{player.name} is thinking with {'model runtime' if use_models else 'fallback persona'}...")
        try:
            _take_ai_turn(session, hand_no, use_models=use_models)
        except ModelRuntimeUnavailable as exc:
            _surface_model_error(session, player.name, exc)
            yield _play_outputs(session, status=f"Model unavailable: {exc}")
            return
        yield _play_outputs(session, status=f"{player.name} acted. {_play_status(session)}")


def _take_ai_turn(session: AppSession, hand_no: int, use_models: bool = False) -> None:
    game = session.game
    if game is None:
        return
    player = game.current_player()
    profile = next((profile for profile in ROSTER if profile.name == player.name), ROSTER[0])
    summary = {
        "hand_no": hand_no,
        "street": game.street.value,
        "hole_cards": player.hole_cards,
        "community_cards": game.community_cards,
        "stack": player.stack,
        "pot": game.pot(),
        "legal": game.legal_actions(player.id),
        "history": game.action_log,
        "recent_chats": session.chats[-12:],
        "seed": game.seed,
        "session_id": game.session_id,
        "hand_id": game.hand_id,
        "orbit_id": game.orbit_id,
    }
    if use_models:
        runtime_result = model_runtime.decide(profile, summary)
        decision = runtime_result.decision
        session.chats.append(f"{player.name}: {decision['table_talk']}")
        log_event(logger, "ai_decision", session_id=game.session_id, hand_id=game.hand_id, orbit_id=game.orbit_id, player=player.name, source=runtime_result.source, status=runtime_result.status, action=decision.get("action"), amount=decision.get("amount"), street=game.street.value)
    else:
        decision = fallback_decide(profile, summary, seed=game.seed)
        session.chats.append(f"{player.name}: {decision['table_talk']}")
        log_event(logger, "ai_decision", session_id=game.session_id, hand_id=game.hand_id, orbit_id=game.orbit_id, player=player.name, source="fallback", status="disabled", action=decision.get("action"), amount=decision.get("amount"), street=game.street.value)
    game.apply_action(decision["action"], int(decision.get("amount") or 0))


def _surface_model_error(session: AppSession, player_name: str, exc: ModelRuntimeUnavailable) -> None:
    game = session.game
    session.chats.append(f"System: {player_name} could not act because model inference is unavailable: {exc}")
    if game:
        log_event(logger, "ai_decision_blocked", session_id=game.session_id, hand_id=game.hand_id, orbit_id=game.orbit_id, player=player_name, error=str(exc))


def _record_result(game: GameState, mode: str) -> None:
    if not game.result:
        return
    if getattr(game, "_recorded", False):
        log_event(logger, "hand_record_skipped_duplicate", mode=mode, summary=game.result.summary)
        return
    names = {player.id: player.name for player in game.players}
    leaderboard.record_hand(
        mode,
        game.result.pot,
        cards_label(game.result.board),
        game.result.winners,
        game.result.deltas,
        names,
        game.result.summary,
        game.session_id,
        game.hand_id,
        game.orbit_id,
    )
    setattr(game, "_recorded", True)
    log_event(logger, "hand_recorded", mode=mode, session_id=game.session_id, hand_id=game.hand_id, orbit_id=game.orbit_id, pot=game.result.pot, winners=game.result.winners, deltas=game.result.deltas)


def _chronicle(game: GameState) -> str:
    if not game.result:
        return ""
    winner = game.player(game.result.winners[0]).name
    return f"Chronicle: {winner} raises a tiny mug to the rafters after dragging {game.result.pot} chips through the candle smoke."


def _leaderboard_md() -> str:
    return leaderboard_markdown(leaderboard.rows())


def _hall_md() -> str:
    return hall_markdown(leaderboard.hall_of_fame())


def recent_logs(limit: int = 80) -> str:
    if not LOG_FILE.exists():
        return "No app logs yet. Trigger a hand or Arena run first."
    lines = LOG_FILE.read_text(encoding="utf-8").splitlines()[-limit:]
    return "```json\n" + "\n".join(lines) + "\n```"


def model_runtime_report(limit: int = 800) -> str:
    rows: dict[str, dict[str, str]] = {
        profile.name: {
            "model": SUPPORTED_TRANSFORMERS_MODELS.get(profile.name, profile.model_id),
            "source": "not observed",
            "reason": "No decision logged in the recent log window.",
            "last_action": "-",
        }
        for profile in ROSTER
    }
    if LOG_FILE.exists():
        for line in LOG_FILE.read_text(encoding="utf-8").splitlines()[-limit:]:
            try:
                event = json.loads(line)
            except json.JSONDecodeError:
                continue
            player = event.get("player")
            if player not in rows:
                continue
            message = event.get("message")
            if message == "model_runtime_success":
                rows[player]["source"] = "real inference"
                rows[player]["reason"] = event.get("model_id", rows[player]["model"])
                rows[player]["last_action"] = _runtime_action_label(event)
            elif message == "model_runtime_partial_fallback":
                rows[player]["source"] = "partial fallback"
                rows[player]["reason"] = f"{event.get('model_id', rows[player]['model'])}: {event.get('reason', 'unknown')}"
                rows[player]["last_action"] = _runtime_action_label(event)
            elif message == "model_runtime_unsupported":
                rows[player]["source"] = "fallback"
                rows[player]["reason"] = f"{event.get('model_id', rows[player]['model'])}: {event.get('reason', 'unsupported runtime')}"
            elif message == "model_runtime_failed":
                rows[player]["source"] = "fallback"
                rows[player]["reason"] = f"{event.get('error_type', 'Error')}: {str(event.get('error', 'unknown'))[:180]}"
            elif message == "model_runtime_modal_success":
                rows[player]["source"] = "modal inference"
                rows[player]["reason"] = event.get("model_id", rows[player]["model"])
                rows[player]["last_action"] = _runtime_action_label(event)
            elif message == "model_runtime_modal_failed":
                rows[player]["source"] = "unavailable"
                rows[player]["reason"] = f"Modal: {str(event.get('error', 'unknown'))[:180]}"
            elif message == "model_runtime_modal_disabled":
                rows[player]["source"] = "disabled"
                rows[player]["reason"] = str(event.get("reason", "disabled"))[:180]
            elif message == "model_runtime_modal_call_started":
                rows[player]["source"] = "modal call started"
                rows[player]["reason"] = event.get("model_id", rows[player]["model"])
            elif message == "model_runtime_deterministic_dev":
                rows[player]["source"] = "deterministic dev"
                rows[player]["reason"] = "Explicit TOKEN_HOLDEM_ALLOW_DETERMINISTIC_BOTS=1 mode"
                rows[player]["last_action"] = _runtime_action_label(event)
            elif message == "ai_decision":
                rows[player]["last_action"] = _runtime_action_label(event)
                if event.get("source") in {"fallback", "local_model", "local_model_partial_fallback", "modal_model", "deterministic_dev"}:
                    rows[player]["source"] = {
                        "fallback": "fallback",
                        "local_model": "real inference",
                        "local_model_partial_fallback": "partial fallback",
                        "modal_model": "modal inference",
                        "deterministic_dev": "deterministic dev",
                    }[event["source"]]
                    rows[player]["reason"] = str(event.get("status", rows[player]["reason"]))[:220]
    lines = [
        '<div class="runtime-report">',
        "<h3>Model Runtime Status</h3>",
        "<table><thead><tr><th>Seat</th><th>Configured model</th><th>Recent source</th><th>Last action</th><th>Reason/status</th></tr></thead><tbody>",
    ]
    for profile in ROSTER:
        row = rows[profile.name]
        lines.append(
            "<tr>"
            f"<td>{escape(profile.name)}</td>"
            f"<td><code>{escape(row['model'])}</code></td>"
            f"<td>{escape(row['source'])}</td>"
            f"<td>{escape(row['last_action'])}</td>"
            f"<td>{escape(row['reason'])}</td>"
            "</tr>"
        )
    lines.append("</tbody></table></div>")
    lines.append('<div class="runtime-report"><h3>Configured Roster</h3><table><thead><tr><th>Seat</th><th>Runtime state</th><th>Note</th></tr></thead><tbody>')
    for row in model_runtime_statuses():
        lines.append(
            "<tr>"
            f"<td>{escape(row['name'])}</td>"
            f"<td>{escape(row['state'])}</td>"
            f"<td>{escape(row['note'])}</td>"
            "</tr>"
        )
    lines.append("</tbody></table></div>")
    return "\n".join(lines)


def _runtime_action_label(event: dict) -> str:
    action = event.get("action") or "-"
    amount = event.get("amount")
    if amount not in {None, "", 0, "0"}:
        return f"{action} {amount}"
    return str(action)


def diagnostics_outputs():
    return model_runtime_report(), recent_logs()


def build_app() -> gr.Blocks:
    _ensure_roster()
    with gr.Blocks(title="Token Hold'em") as demo:
        gr.HTML('<div class="app-title"><h1>Token Hold\'em</h1><p>Candlelit Texas Hold\'em for one human challenger and seven tavern-tuned LLMs.</p></div>')
        play_state = gr.State(None)
        with gr.Tab("Play Mode"):
            with gr.Group(elem_classes="tavern-app-shell"):
                gr.HTML(
                    """
                    <div class="tavern-background" aria-hidden="true">
                      <div class="tavern-stonework"></div>
                      <div class="tavern-bar-backdrop"></div>
                      <div class="tavern-floor"></div>
                    </div>
                    <div class="tavern-ambient-lights" aria-hidden="true">
                      <span></span><span></span><span></span><span></span>
                    </div>
                    """
                    ,
                    elem_classes="tavern-scene-chrome",
                )
                with gr.Column(elem_classes="tavern-left-rail"):
                    gr.HTML(
                        """
                        <section class="rail-plaque">
                          <div class="rail-kicker">Thousand Token Wood</div>
                          <h2>Token Hold'em</h2>
                          <p>Quick-seat into the bottom chair. The seven model regulars handle the rest.</p>
                        </section>
                        """
                    )
                    with gr.Group(elem_classes="tavern-panel setup-panel"):
                        human_name = gr.Textbox(label="Your tavern name", value="Human Wanderer")
                        play_seed = gr.Number(label="Seed", value=0, precision=0)
                        start_btn = gr.Button("Quick Seat", variant="primary")
                        next_btn = gr.Button("Next Hand")
                        rebuy_btn = gr.Button("Rebuy 1000", interactive=False)
                with gr.Column(elem_classes="poker-stage"):
                    play_table = gr.HTML(table_html(None))
                with gr.Column(elem_classes="tavern-right-rail"):
                    play_log = gr.Markdown("No hand yet.", elem_classes="tavern-panel log-panel")
                with gr.Group(elem_classes="action-bar"):
                    play_status = gr.Markdown("Quick Seat starts a cash-game session.", elem_classes="status-scroll action-status")
                    gr.HTML('<div class="action-bar-caption"><span>Live poker controls</span><strong>Choose your move</strong></div>')
                    with gr.Row(elem_classes="action-row"):
                        fold_btn = gr.Button("Fold", interactive=False, elem_classes="poker-action fold-action")
                        check_btn = gr.Button("Check", interactive=False, elem_classes="poker-action check-action")
                        call_btn = gr.Button("Call", interactive=False, elem_classes="poker-action call-action")
                        min_btn = gr.Button("Min Raise", interactive=False, elem_classes="poker-action raise-action")
                        half_btn = gr.Button("Half-Pot", interactive=False, elem_classes="poker-action raise-action")
                        pot_btn = gr.Button("Pot", interactive=False, elem_classes="poker-action raise-action")
                        all_in_btn = gr.Button("All-In", interactive=False, elem_classes="poker-action all-in-action")
                with gr.Group(elem_classes="bottom-status-panel"):
                    hand_review = gr.Markdown("**Hand Review:** No active hand.", elem_classes="tavern-panel review-panel")
        with gr.Tab("AI Arena"):
            with gr.Row(elem_classes="tavern-panel setup-panel"):
                arena_seed = gr.Number(label="Seed", value=0, precision=0)
                arena_hands = gr.Slider(label="Hands to auto-play", minimum=1, maximum=10, value=3, step=1)
                arena_btn = gr.Button("Start Arena", variant="primary")
            arena_table = gr.HTML(table_html(None))
            arena_log = gr.Markdown("The tavern is quiet.", elem_classes="tavern-panel log-panel")
        with gr.Tab("Leaderboard"):
            leaderboard_out = gr.Markdown(_leaderboard_md(), elem_classes="tavern-panel leaderboard-panel")
        with gr.Tab("Hall of Fame"):
            hall_out = gr.Markdown(_hall_md(), elem_classes="tavern-panel hall-panel")
        with gr.Tab("About"):
            gr.Markdown(
                "## Token Hold'em\n\n"
                "A deterministic Texas Hold'em engine runs the table while local model personas choose actions and table talk. "
                "The tavern cast uses inspired character identities, not logos or brand marks, so every seat feels like part of the same cozy poker room.\n\n"
                "- **Play Mode:** sit as the bottom-center human challenger.\n"
                "- **AI Arena:** watch the seven LLM seats battle with revealed cards.\n"
                "- **Leaderboard:** track bankrolls, records, and Hall of Fame plaques.",
                elem_classes="tavern-panel about-panel",
            )
        with gr.Tab("Diagnostics"):
            gr.Markdown("Structured app logs are written to `logs/token_holdem.jsonl`. Framework warnings from Gradio/Starlette may still appear in the terminal separately.", elem_classes="tavern-panel")
            refresh_logs = gr.Button("Refresh Recent Logs")
            runtime_out = gr.Markdown(model_runtime_report(), elem_classes="tavern-panel runtime-panel")
            logs_out = gr.Markdown(recent_logs(), elem_classes="tavern-panel log-panel")

        play_outputs = [play_state, play_table, play_log, leaderboard_out, hall_out, play_status, hand_review, fold_btn, check_btn, call_btn, min_btn, half_btn, pot_btn, all_in_btn, rebuy_btn]
        start_btn.click(start_play_with_runtime, inputs=[human_name, play_seed], outputs=play_outputs)
        next_btn.click(next_play_hand, inputs=[play_state, human_name, play_seed], outputs=play_outputs)
        rebuy_btn.click(rebuy_user, inputs=[play_state], outputs=play_outputs)
        for button, action in [
            (fold_btn, "fold"),
            (check_btn, "check"),
            (call_btn, "call"),
            (min_btn, "min_raise"),
            (half_btn, "half_pot"),
            (pot_btn, "pot"),
            (all_in_btn, "all_in"),
        ]:
            button.click(action_handler(action), inputs=[play_state], outputs=play_outputs)
        arena_btn.click(run_arena, inputs=[arena_seed, arena_hands], outputs=[arena_table, arena_log, leaderboard_out, hall_out])
        refresh_logs.click(diagnostics_outputs, outputs=[runtime_out, logs_out])
    return demo


demo = build_app()


if __name__ == "__main__":
    demo.launch(css=CSS, allowed_paths=["assets"])