warchron_app/src/warchron/model/round.py

from __future__ import annotations
from uuid import uuid4
from typing import Any, Dict, List, TYPE_CHECKING

if TYPE_CHECKING:
    from warchron.model.campaign import Campaign
    from warchron.model.war import War
    from warchron.constants import ContextType
from warchron.model.exception import (
    ForbiddenOperation,
    DomainError,
    RequiresConfirmation,
)
from warchron.model.choice import Choice
from warchron.model.battle import Battle


class Round:
    def __init__(self) -> None:
        self.id: str = str(uuid4())
        self.choices: Dict[str, Choice] = {}
        self.battles: Dict[str, Battle] = {}
        self.is_over: bool = False
        self._campaign: Campaign | None = None  # private link

    @property
    def campaign(self) -> "Campaign":
        if self._campaign is None:
            raise RuntimeError("Round is not linked to a Campaign")
        return self._campaign

    @property
    def war(self) -> "War":
        return self.campaign.war

    def set_id(self, new_id: str) -> None:
        self.id = new_id

    def set_state(self, new_state: bool) -> None:
        self.is_over = new_state

    def toDict(self) -> Dict[str, Any]:
        return {
            "id": self.id,
            "choices": [c.toDict() for c in self.choices.values()],
            "battles": [b.toDict() for b in self.battles.values()],
            "is_over": self.is_over,
        }

    @staticmethod
    def fromDict(data: Dict[str, Any]) -> Round:
        rnd = Round()
        rnd.set_id(data["id"])
        for c in data.get("choices", []):
            choice = Choice.fromDict(c)
            rnd.choices[choice.participant_id] = choice
        for b in data.get("battles", []):
            battle = Battle.fromDict(b)
            rnd.battles[battle.sector_id] = battle
        rnd.set_state(data.get("is_over", False))
        return rnd

    # Choice methods

    def get_choice(self, participant_id: str) -> Choice | None:
        return self.choices.get(participant_id)

    def has_choice_with_sector(self, sector_id: str) -> bool:
        return any(
            choice.priority_sector_id == sector_id
            or choice.secondary_sector_id == sector_id
            for choice in self.choices.values()
        )

    def has_choice_with_participant(self, participant_id: str) -> bool:
        return any(
            choice.participant_id == participant_id for choice in self.choices.values()
        )

    def create_choice(self, participant_id: str) -> Choice:
        if self.is_over:
            raise ForbiddenOperation("Can't create choice in a closed round.")
        if participant_id not in self.choices:
            choice = Choice(
                participant_id=participant_id,
                priority_sector_id=None,
                secondary_sector_id=None,
            )
            self.choices[participant_id] = choice
        return self.choices[participant_id]

    def update_choice(
        self,
        participant_id: str,
        priority_sector_id: str | None,
        secondary_sector_id: str | None,
        comment: str | None,
    ) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't update choice in a closed round.")
        choice = self.get_choice(participant_id)
        if choice:
            if self.has_battle_with_participant(participant_id) and (
                priority_sector_id != choice.priority_sector_id
                or secondary_sector_id != choice.secondary_sector_id
            ):
                raise ForbiddenOperation(
                    "Can't update choice already assigned to battle."
                )
            choice.set_priority(priority_sector_id)
            choice.set_secondary(secondary_sector_id)
            choice.set_comment(comment)

    def clear_sector_references(self, sector_id: str) -> None:
        for choice in self.choices.values():
            trigger_revert_ties = False
            if choice.priority_sector_id == sector_id:
                choice.priority_sector_id = None
                trigger_revert_ties = True
            if choice.secondary_sector_id == sector_id:
                choice.secondary_sector_id = None
                trigger_revert_ties = True
            if trigger_revert_ties:
                self.war.revert_choice_ties(self.id, sector_id=sector_id)

    def remove_choice(self, participant_id: str) -> None:
        if participant_id not in self.choices:
            return
        if self.is_over:
            raise ForbiddenOperation("Can't remove choice in a closed round.")
        if self.has_battle_with_participant(participant_id):
            raise ForbiddenOperation("Can't remove choice already assigned to battle.")
        self.war.revert_choice_ties(
            self.id,
            participants=[self.campaign.campaign_to_war_part_id(participant_id)],
        )
        del self.choices[participant_id]

    # Battle methods

    def get_battle(self, sector_id: str) -> Battle | None:
        return self.battles.get(sector_id)

    def get_battle_for_participant(
        self,
        campaign_participant_id: str,
    ) -> Battle | None:
        for battle in self.battles.values():
            if (
                battle.player_1_id == campaign_participant_id
                or battle.player_2_id == campaign_participant_id
            ):
                return battle
        return None

    def has_battle_with_sector(self, sector_id: str) -> bool:
        return any(bat.sector_id == sector_id for bat in self.battles.values())

    def has_battle_with_participant(self, participant_id: str) -> bool:
        return any(
            bat.player_1_id == participant_id or bat.player_2_id == participant_id
            for bat in self.battles.values()
        )

    def has_finished_battle(self) -> bool:
        return any(b.is_finished() for b in self.battles.values())

    def all_battles_finished(self) -> bool:
        return all(
            b.winner_id is not None or b.is_draw() for b in self.battles.values()
        )

    def get_battles_with_places(self) -> List[Battle]:
        return [
            battle for battle in self.battles.values() if battle.get_available_places()
        ]

    def create_battle(self, sector_id: str) -> Battle:
        if self.is_over:
            raise ForbiddenOperation("Can't create battle in a closed round.")
        if sector_id not in self.battles:
            battle = Battle(sector_id=sector_id, player_1_id=None, player_2_id=None)
            self.battles[sector_id] = battle
        return self.battles[sector_id]

    def update_battle(
        self,
        sector_id: str,
        player_1_id: str | None,
        player_2_id: str | None,
        winner_id: str | None,
        score: str | None,
        victory_condition: str | None,
        comment: str | None,
    ) -> None:
        from warchron.model.tie_manager import TieResolver

        if self.is_over:
            raise ForbiddenOperation("Can't update battle in a closed round.")
        bat = self.get_battle(sector_id)
        if not bat:
            raise DomainError(f"No battle found for sector {sector_id}")

        def apply_update() -> None:
            bat.set_player_1(player_1_id)
            bat.set_player_2(player_2_id)
            bat.set_winner(winner_id)
            bat.set_score(score)
            bat.set_victory_condition(victory_condition)
            bat.set_comment(comment)

        if bat.player_1_id == player_1_id and bat.player_2_id == player_2_id:
            apply_update()
            return
        affected_choices: List[Choice] = []
        affected_players: List[str | None] = list(
            {
                player_1_id,
                player_2_id,
                bat.player_1_id,
                bat.player_2_id,
            }
            - {None}
        )
        for choice in self.choices.values():
            for player in affected_players:
                if (
                    player
                    and self.has_choice_with_participant(player)
                    and TieResolver.participant_spent_token(
                        self.war,
                        ContextType.CHOICE,
                        self.id,
                        sector_id,
                        self.campaign.campaign_to_war_part_id(player),
                    )
                ):
                    affected_choices.append(choice)
        if not affected_choices:
            apply_update()
            return

        def cleanup_and_update() -> None:
            self.clear_sector_references(sector_id)
            apply_update()

        raise RequiresConfirmation(
            "Changing the player(s) of this sector will affect choices.\n"
            "Choices will be cleared and their tokens and tie-breaks will be deleted.\n"
            "Do you want to continue?",
            action=cleanup_and_update,
        )

    def clear_participant_references(self, participant_id: str) -> None:
        for battle in self.battles.values():
            trigger_revert_ties = False
            if battle.player_1_id == participant_id:
                battle.player_1_id = None
                trigger_revert_ties = True
            if battle.player_2_id == participant_id:
                battle.player_2_id = None
                trigger_revert_ties = True
            if battle.winner_id == participant_id:
                battle.winner_id = None
            if trigger_revert_ties:
                self.war.revert_battle_ties(
                    self.id,
                    participants=[
                        self.campaign.campaign_to_war_part_id(participant_id)
                    ],
                )

    def remove_battle(self, sector_id: str) -> None:
        if sector_id not in self.battles:
            return
        if self.is_over:
            raise ForbiddenOperation("Can't remove battle in a closed round.")
        bat = self.battles[sector_id]
        if bat and bat.is_finished():
            raise ForbiddenOperation("Can't remove finished battle.")
        self.war.revert_battle_ties(self.id, sector_id=sector_id)
        del self.battles[sector_id]