CricInfo

from __future__ import annotations
from enum import Enum
from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Optional


class MatchState(Enum):
    NOT_STARTED = "not_started"
    IN_PROGRESS = "in_progress"
    INNINGS_BREAK = "innings_break"
    COMPLETED = "completed"

    def can_transition_to(self, target: "MatchState") -> bool:
        valid = {
            MatchState.NOT_STARTED: [MatchState.IN_PROGRESS],
            MatchState.IN_PROGRESS: [MatchState.INNINGS_BREAK, MatchState.COMPLETED],
            # A match can finish straight from the innings break (second innings ended).
            MatchState.INNINGS_BREAK: [MatchState.IN_PROGRESS, MatchState.COMPLETED],
            MatchState.COMPLETED: [],
        }
        return target in valid[self]


class ExtraType(Enum):
    NONE = "none"
    WIDE = "wide"
    NO_BALL = "no_ball"
    BYE = "bye"
    LEG_BYE = "leg_bye"


class WicketType(Enum):
    BOWLED = "bowled"
    CAUGHT = "caught"
    LBW = "lbw"
    RUN_OUT = "run_out"
    STUMPED = "stumped"


class Player:
    def __init__(self, name: str):
        self.name = name
        self.runs_scored = 0
        self.balls_faced = 0
        self.wickets_taken = 0
        self.runs_conceded = 0
        self.balls_bowled = 0

    @property
    def strike_rate(self) -> float:
        return (self.runs_scored / self.balls_faced * 100) if self.balls_faced > 0 else 0.0

    @property
    def economy(self) -> float:
        overs = self.balls_bowled / 6
        return (self.runs_conceded / overs) if overs > 0 else 0.0

    def __str__(self) -> str:
        return self.name


class Team:
    def __init__(self, name: str, players: list[Player]):
        self.name = name
        self.players = players

    def __str__(self) -> str:
        return self.name


@dataclass
class Wicket:
    wicket_type: WicketType
    batsman_out: Player
    fielder: Optional[Player] = None

    def __str__(self) -> str:
        if self.fielder:
            return f"{self.wicket_type.value} ({self.fielder.name})"
        return self.wicket_type.value


@dataclass
class Ball:
    """Atomic scoring unit. Every aggregate computes upward from here."""
    batsman: Player
    bowler: Player
    runs_scored: int = 0
    extra_type: ExtraType = ExtraType.NONE
    extra_runs: int = 0
    wicket: Optional[Wicket] = None

    def is_legal_delivery(self) -> bool:
        return self.extra_type not in (ExtraType.WIDE, ExtraType.NO_BALL)

    def total_runs(self) -> int:
        return self.runs_scored + self.extra_runs

    def __str__(self) -> str:
        parts = []
        if self.extra_type != ExtraType.NONE:
            parts.append(self.extra_type.value)
        if self.runs_scored > 0:
            parts.append(f"{self.runs_scored} run{'s' if self.runs_scored > 1 else ''}")
        if self.wicket:
            parts.append(f"WICKET! {self.wicket.batsman_out.name} {self.wicket}")
        if not parts:
            parts.append("dot ball")
        return ", ".join(parts)


class Over:
    def __init__(self, over_number: int, bowler: Player):
        self.over_number = over_number
        self.bowler = bowler
        self._balls: list[Ball] = []

    def add_ball(self, ball: Ball) -> None:
        self._balls.append(ball)
        ball.bowler.runs_conceded += ball.total_runs()
        if ball.is_legal_delivery():
            ball.bowler.balls_bowled += 1
        if ball.wicket:
            ball.bowler.wickets_taken += 1

    @property
    def legal_deliveries(self) -> int:
        return sum(1 for b in self._balls if b.is_legal_delivery())

    def is_complete(self) -> bool:
        return self.legal_deliveries >= 6

    @property
    def runs(self) -> int:
        return sum(b.total_runs() for b in self._balls)

    @property
    def balls(self) -> list[Ball]:
        return list(self._balls)

    def __str__(self) -> str:
        ball_str = " ".join(str(b.total_runs()) for b in self._balls)
        return f"Over {self.over_number}: {ball_str} ({self.runs} runs)"


class Innings:
    def __init__(self, batting_team: Team, bowling_team: Team, innings_number: int):
        self.batting_team = batting_team
        self.bowling_team = bowling_team
        self.innings_number = innings_number
        self._overs: list[Over] = []
        self._current_over: Optional[Over] = None
        self._wickets = 0

    def start_over(self, bowler: Player) -> Over:
        over_num = len(self._overs) + 1
        self._current_over = Over(over_num, bowler)
        self._overs.append(self._current_over)
        return self._current_over

    def add_ball(self, ball: Ball) -> None:
        if self._current_over is None:
            raise RuntimeError("No over in progress. Call start_over() first.")
        self._current_over.add_ball(ball)
        if ball.is_legal_delivery():
            ball.batsman.balls_faced += 1
        ball.batsman.runs_scored += ball.runs_scored
        if ball.wicket:
            self._wickets += 1

    @property
    def total_runs(self) -> int:
        return sum(over.runs for over in self._overs)

    @property
    def wickets(self) -> int:
        return self._wickets

    @property
    def overs_completed(self) -> str:
        completed = sum(1 for o in self._overs if o.is_complete())
        current_balls = 0
        if self._current_over and not self._current_over.is_complete():
            current_balls = self._current_over.legal_deliveries
        if current_balls > 0:
            return f"{completed}.{current_balls}"
        return str(completed)

    @property
    def overs(self) -> list[Over]:
        return list(self._overs)

    @property
    def current_over(self) -> Optional[Over]:
        return self._current_over


class MatchObserver(ABC):
    """Observer interface for live score consumers."""

    @abstractmethod
    def on_score_update(self, innings: Innings, ball: Ball) -> None: ...

    @abstractmethod
    def on_wicket(self, innings: Innings, ball: Ball) -> None: ...

    @abstractmethod
    def on_over_complete(self, innings: Innings, over: Over) -> None: ...

    @abstractmethod
    def on_state_change(self, old_state: MatchState, new_state: MatchState) -> None: ...


class ConsoleMatchObserver(MatchObserver):
    def __init__(self, name: str):
        self._name = name

    def on_score_update(self, innings: Innings, ball: Ball) -> None:
        print(f"  [{self._name}] {innings.batting_team}: "
              f"{innings.total_runs}/{innings.wickets} "
              f"({innings.overs_completed} ov) | {ball}")

    def on_wicket(self, innings: Innings, ball: Ball) -> None:
        print(f"  [{self._name}] WICKET! {ball.wicket.batsman_out.name} "
              f"is out {ball.wicket}")

    def on_over_complete(self, innings: Innings, over: Over) -> None:
        print(f"  [{self._name}] End of {over} | "
              f"Score: {innings.total_runs}/{innings.wickets}")

    def on_state_change(self, old_state: MatchState, new_state: MatchState) -> None:
        print(f"  [{self._name}] Match state: {old_state.value} -> {new_state.value}")


class Scorecard:
    """Stateless. Computes everything from raw ball data on each call."""

    @staticmethod
    def summary(innings: Innings) -> str:
        return (f"{innings.batting_team.name}: "
                f"{innings.total_runs}/{innings.wickets} "
                f"({innings.overs_completed} overs)")

    @staticmethod
    def batting_card(innings: Innings) -> str:
        lines = [f"{'Batsman':<20} {'R':>4} {'B':>4} {'SR':>7}"]
        lines.append("-" * 38)
        seen = set()
        for over in innings.overs:
            for ball in over.balls:
                p = ball.batsman
                if p.name not in seen:
                    seen.add(p.name)
                    lines.append(
                        f"{p.name:<20} {p.runs_scored:>4} "
                        f"{p.balls_faced:>4} {p.strike_rate:>7.1f}"
                    )
        return "\n".join(lines)

    @staticmethod
    def bowling_card(innings: Innings) -> str:
        lines = [f"{'Bowler':<20} {'O':>4} {'R':>4} {'W':>4} {'Econ':>7}"]
        lines.append("-" * 42)
        seen = set()
        for over in innings.overs:
            b = over.bowler
            if b.name not in seen:
                seen.add(b.name)
                overs_display = f"{b.balls_bowled // 6}.{b.balls_bowled % 6}"
                lines.append(
                    f"{b.name:<20} {overs_display:>4} "
                    f"{b.runs_conceded:>4} {b.wickets_taken:>4} "
                    f"{b.economy:>7.1f}"
                )
        return "\n".join(lines)


class CricketMatch:
    def __init__(self, team1: Team, team2: Team, toss_winner: Team):
        self.teams = [team1, team2]
        self.toss_winner = toss_winner
        self._innings: list[Innings] = []
        self._current_innings: Optional[Innings] = None
        self._state = MatchState.NOT_STARTED
        self._observers: list[MatchObserver] = []
        self._scorecard = Scorecard()

    @property
    def state(self) -> MatchState:
        return self._state

    @property
    def scorecard(self) -> Scorecard:
        return self._scorecard

    @property
    def innings(self) -> list[Innings]:
        return list(self._innings)

    def add_observer(self, observer: MatchObserver) -> None:
        self._observers.append(observer)

    def _transition_to(self, new_state: MatchState) -> None:
        if not self._state.can_transition_to(new_state):
            raise RuntimeError(
                f"Invalid transition: {self._state.value} -> {new_state.value}"
            )
        old_state = self._state
        self._state = new_state
        for obs in self._observers:
            obs.on_state_change(old_state, new_state)

    def start_match(self) -> None:
        self._transition_to(MatchState.IN_PROGRESS)

    def start_innings(self, batting_team: Team, bowling_team: Team) -> Innings:
        if self._state == MatchState.NOT_STARTED:
            self._transition_to(MatchState.IN_PROGRESS)
        elif self._state == MatchState.INNINGS_BREAK:
            self._transition_to(MatchState.IN_PROGRESS)
        innings_num = len(self._innings) + 1
        innings = Innings(batting_team, bowling_team, innings_num)
        self._innings.append(innings)
        self._current_innings = innings
        print(f"\n=== Innings {innings_num}: {batting_team.name} batting ===")
        return innings

    def record_ball(self, ball: Ball) -> None:
        if self._current_innings is None:
            raise RuntimeError("No innings in progress")
        self._current_innings.add_ball(ball)

        for obs in self._observers:
            obs.on_score_update(self._current_innings, ball)
            if ball.wicket:
                obs.on_wicket(self._current_innings, ball)

        cur_over = self._current_innings.current_over
        if cur_over and cur_over.is_complete():
            for obs in self._observers:
                obs.on_over_complete(self._current_innings, cur_over)

    def end_innings(self) -> None:
        self._transition_to(MatchState.INNINGS_BREAK)
        self._current_innings = None

    def complete_match(self) -> None:
        self._transition_to(MatchState.COMPLETED)


if __name__ == "__main__":
    # Create players
    rohit = Player("Rohit Sharma")
    virat = Player("Virat Kohli")
    bumrah = Player("Jasprit Bumrah")

    warner = Player("David Warner")
    smith = Player("Steve Smith")
    starc = Player("Mitchell Starc")
    cummins = Player("Pat Cummins")

    india = Team("India", [rohit, virat, bumrah])
    australia = Team("Australia", [warner, smith, starc, cummins])

    # Set up match with observer
    match = CricketMatch(india, australia, toss_winner=india)
    match.add_observer(ConsoleMatchObserver("TV Overlay"))

    # First innings: India batting
    innings1 = match.start_innings(india, australia)
    innings1.start_over(starc)

    print("\nOver 1 (Starc bowling to Rohit):")
    match.record_ball(Ball(rohit, starc, runs_scored=4))
    match.record_ball(Ball(rohit, starc, runs_scored=0))
    match.record_ball(Ball(rohit, starc, runs_scored=1))
    match.record_ball(Ball(virat, starc, runs_scored=0,
                           extra_type=ExtraType.WIDE, extra_runs=1))
    match.record_ball(Ball(virat, starc, runs_scored=6))
    match.record_ball(Ball(virat, starc, runs_scored=0,
                           wicket=Wicket(WicketType.CAUGHT, virat, cummins)))
    match.record_ball(Ball(rohit, starc, runs_scored=2))

    # Second over
    innings1.start_over(cummins)
    print("\nOver 2 (Cummins bowling to Rohit):")
    match.record_ball(Ball(rohit, cummins, runs_scored=0))
    match.record_ball(Ball(rohit, cummins, runs_scored=4))
    match.record_ball(Ball(rohit, cummins, runs_scored=1))
    match.record_ball(Ball(rohit, cummins, runs_scored=0,
                           extra_type=ExtraType.NO_BALL, extra_runs=1))
    match.record_ball(Ball(rohit, cummins, runs_scored=2))
    match.record_ball(Ball(rohit, cummins, runs_scored=0))
    match.record_ball(Ball(rohit, cummins, runs_scored=1))

    # End first innings
    match.end_innings()

    # Display scorecard
    scorecard = match.scorecard
    print("\n" + "=" * 42)
    print("SCORECARD")
    print("=" * 42)
    print(scorecard.summary(innings1))
    print()
    print(scorecard.batting_card(innings1))
    print()
    print(scorecard.bowling_card(innings1))

    print(f"\nTotal runs: {innings1.total_runs}")
    print(f"Wickets: {innings1.wickets}")
    print(f"Overs: {innings1.overs_completed}")
    print(f"Match state: {match.state.value}")

    # Verify state machine
    assert innings1.wickets == 1
    assert match.state == MatchState.INNINGS_BREAK

    # Start second innings
    innings2 = match.start_innings(australia, india)
    assert match.state == MatchState.IN_PROGRESS
    print(f"\nSecond innings started. Match state: {match.state.value}")

    # Complete match
    match.end_innings()
    match.complete_match()
    assert match.state == MatchState.COMPLETED
    print(f"Match completed. Final state: {match.state.value}")
    print("All assertions passed.")