strat-gameplay-webapp/backend/terminal_client/commands.py

"""
Shared command implementations for terminal client.

This module contains the core logic for game commands that can be
used by both the REPL (repl.py) and CLI (main.py) interfaces.

Author: Claude
Date: 2025-10-27
"""
import asyncio
import logging
from uuid import UUID, uuid4
from typing import Optional, List, Tuple

from app.core.game_engine import game_engine
from app.core.state_manager import state_manager
from app.models.game_models import DefensiveDecision, OffensiveDecision
from app.database.operations import DatabaseOperations
from terminal_client import display
from terminal_client.config import Config

logger = logging.getLogger(f'{__name__}.commands')


class GameCommands:
    """Shared command implementations for game operations."""

    def __init__(self):
        self.db_ops = DatabaseOperations()

    async def create_new_game(
        self,
        league: str = 'sba',
        home_team: int = 1,
        away_team: int = 2,
        set_current: bool = True
    ) -> Tuple[UUID, bool]:
        """
        Create a new game with lineups and start it.

        Args:
            league: 'sba' or 'pd'
            home_team: Home team ID
            away_team: Away team ID
            set_current: Whether to set as current game

        Returns:
            Tuple of (game_id, success)
        """
        gid = uuid4()

        try:
            # Step 1: Create game in memory and database
            display.print_info("Step 1: Creating game...")

            state = await state_manager.create_game(
                game_id=gid,
                league_id=league,
                home_team_id=home_team,
                away_team_id=away_team
            )

            await self.db_ops.create_game(
                game_id=gid,
                league_id=league,
                home_team_id=home_team,
                away_team_id=away_team,
                game_mode="friendly",
                visibility="public"
            )

            display.print_success(f"Game created: {gid}")

            if set_current:
                Config.set_current_game(gid)
                display.print_info(f"Current game set to: {gid}")

            # Step 2: Setup lineups
            display.print_info("Step 2: Creating test lineups...")
            await self._create_test_lineups(gid, league, home_team, away_team)

            # Step 3: Start the game
            display.print_info("Step 3: Starting game...")
            state = await game_engine.start_game(gid)

            display.print_success(f"Game started - Inning {state.inning} {state.half}")
            display.display_game_state(state)

            return gid, True

        except Exception as e:
            display.print_error(f"Failed to create new game: {e}")
            logger.exception("New game error")
            return gid, False

    async def _create_test_lineups(
        self,
        game_id: UUID,
        league: str,
        home_team: int,
        away_team: int
    ) -> None:
        """Create test lineups for both teams."""
        positions = ['P', 'C', '1B', '2B', '3B', 'SS', 'LF', 'CF', 'RF']

        for team_id in [home_team, away_team]:
            team_name = "Home" if team_id == home_team else "Away"

            for i, position in enumerate(positions, start=1):
                if league == 'sba':
                    player_id = (team_id * 100) + i
                    await self.db_ops.add_sba_lineup_player(
                        game_id=game_id,
                        team_id=team_id,
                        player_id=player_id,
                        position=position,
                        batting_order=i,
                        is_starter=True
                    )
                else:
                    card_id = (team_id * 100) + i
                    await self.db_ops.add_pd_lineup_card(
                        game_id=game_id,
                        team_id=team_id,
                        card_id=card_id,
                        position=position,
                        batting_order=i,
                        is_starter=True
                    )

            display.console.print(f"  ✓ {team_name} team lineup created (9 players)")

    async def submit_defensive_decision(
        self,
        game_id: UUID,
        alignment: str = 'normal',
        infield: str = 'normal',
        outfield: str = 'normal',
        hold_runners: Optional[List[int]] = None
    ) -> bool:
        """
        Submit defensive decision.

        Returns:
            True if successful, False otherwise
        """
        try:
            decision = DefensiveDecision(
                alignment=alignment,
                infield_depth=infield,
                outfield_depth=outfield,
                hold_runners=hold_runners or []
            )

            state = await game_engine.submit_defensive_decision(game_id, decision)
            display.print_success("Defensive decision submitted")
            display.display_decision("defensive", decision)
            display.display_game_state(state)
            return True

        except Exception as e:
            display.print_error(f"Failed to submit defensive decision: {e}")
            logger.exception("Defensive decision error")
            return False

    async def submit_offensive_decision(
        self,
        game_id: UUID,
        approach: str = 'normal',
        steal_attempts: Optional[List[int]] = None,
        hit_and_run: bool = False,
        bunt_attempt: bool = False
    ) -> bool:
        """
        Submit offensive decision.

        Returns:
            True if successful, False otherwise
        """
        try:
            decision = OffensiveDecision(
                approach=approach,
                steal_attempts=steal_attempts or [],
                hit_and_run=hit_and_run,
                bunt_attempt=bunt_attempt
            )

            state = await game_engine.submit_offensive_decision(game_id, decision)
            display.print_success("Offensive decision submitted")
            display.display_decision("offensive", decision)
            display.display_game_state(state)
            return True

        except Exception as e:
            display.print_error(f"Failed to submit offensive decision: {e}")
            logger.exception("Offensive decision error")
            return False

    async def resolve_play(self, game_id: UUID) -> bool:
        """
        Resolve the current play.

        Returns:
            True if successful, False otherwise
        """
        try:
            result = await game_engine.resolve_play(game_id)
            state = await game_engine.get_game_state(game_id)

            if state:
                display.display_play_result(result, state)
                display.display_game_state(state)
                return True
            else:
                display.print_error(f"Game {game_id} not found after resolution")
                return False

        except Exception as e:
            display.print_error(f"Failed to resolve play: {e}")
            logger.exception("Resolve play error")
            return False

    async def quick_play_rounds(
        self,
        game_id: UUID,
        count: int = 1
    ) -> int:
        """
        Execute multiple plays with default decisions.

        Returns:
            Number of plays successfully executed
        """
        plays_completed = 0

        for i in range(count):
            try:
                state = await game_engine.get_game_state(game_id)
                if not state or state.status != "active":
                    display.print_warning(f"Game ended at play {i + 1}")
                    break

                display.print_info(f"Play {i + 1}/{count}")

                # Submit default decisions
                await game_engine.submit_defensive_decision(game_id, DefensiveDecision())
                await game_engine.submit_offensive_decision(game_id, OffensiveDecision())

                # Resolve
                result = await game_engine.resolve_play(game_id)
                state = await game_engine.get_game_state(game_id)

                if state:
                    display.print_success(f"{result.description}")
                    display.console.print(
                        f"[cyan]Score: Away {state.away_score} - {state.home_score} Home, "
                        f"Inning {state.inning} {state.half}, {state.outs} outs[/cyan]"
                    )
                    plays_completed += 1

                await asyncio.sleep(0.3)  # Brief pause for readability

            except Exception as e:
                display.print_error(f"Error on play {i + 1}: {e}")
                logger.exception("Quick play error")
                break

        # Show final state
        state = await game_engine.get_game_state(game_id)
        if state:
            display.print_info("Final state:")
            display.display_game_state(state)

        return plays_completed

    async def show_game_status(self, game_id: UUID) -> bool:
        """
        Display current game state.

        Returns:
            True if successful, False otherwise
        """
        try:
            state = await game_engine.get_game_state(game_id)
            if state:
                display.display_game_state(state)
                return True
            else:
                display.print_error(f"Game {game_id} not found")
                return False
        except Exception as e:
            display.print_error(f"Failed to get game status: {e}")
            return False

    async def show_box_score(self, game_id: UUID) -> bool:
        """
        Display box score.

        Returns:
            True if successful, False otherwise
        """
        try:
            state = await game_engine.get_game_state(game_id)
            if state:
                display.display_box_score(state)
                return True
            else:
                display.print_error(f"Game {game_id} not found")
                return False
        except Exception as e:
            display.print_error(f"Failed to get box score: {e}")
            return False


# Singleton instance
game_commands = GameCommands()