warchron_app/src/warchron/model/war.py

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

from warchron.model.war_event import WarEvent, InfluenceGained, InfluenceSpent
from warchron.model.exception import ForbiddenOperation
from warchron.model.war_participant import WarParticipant
from warchron.model.objective import Objective
from warchron.model.campaign_participant import CampaignParticipant
from warchron.model.sector import Sector
from warchron.model.campaign import Campaign
from warchron.model.round import Round
from warchron.model.choice import Choice
from warchron.model.battle import Battle


class War:
    def __init__(self, name: str, year: int) -> None:
        self.id: str = str(uuid4())
        self.name: str = name
        self.year: int = year
        self.major_value: int = 2
        self.minor_value: int = 1
        self.influence_token: bool = True
        self.participants: Dict[str, WarParticipant] = {}
        self.objectives: Dict[str, Objective] = {}
        self.campaigns: List[Campaign] = []
        self.events: List[WarEvent] = []
        self.is_over: bool = False

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

    def set_name(self, new_name: str) -> None:
        self.name = new_name

    def set_year(self, new_year: int) -> None:
        self.year = new_year

    def set_major_value(self, new_value: int) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't set major value of a closed war.")
        if new_value < self.minor_value:
            raise ValueError("Can' set major value < minor value")
        self.major_value = new_value

    def set_minor_value(self, new_value: int) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't set minor value of a closed war.")
        if new_value > self.major_value:
            raise ValueError("Can't set minor value > major value")
        self.minor_value = new_value

    def set_influence_token(self, new_state: bool) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't set influence token of a closed war.")
        # TODO raise RequiresConfirmation
        #   * disable: cleanup if any token has already been gained/spent
        #   * enable: retrigger battle_outcomes and resolve tie again if any draw
        self.influence_token = new_state

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

    def toDict(self) -> Dict[str, Any]:
        return {
            "id": self.id,
            "name": self.name,
            "year": self.year,
            "major_value": self.major_value,
            "minor_value": self.minor_value,
            "influence_token": self.influence_token,
            "participants": [part.toDict() for part in self.participants.values()],
            "objectives": [obj.toDict() for obj in self.objectives.values()],
            "campaigns": [camp.toDict() for camp in self.campaigns],
            "events": [ev.toDict() for ev in self.events],
            "is_over": self.is_over,
        }

    @staticmethod
    def fromDict(data: Dict[str, Any]) -> War:
        war = War(name=data["name"], year=data["year"])
        war.set_id(data["id"])
        war.set_major_value(data["major_value"])
        war.set_minor_value(data["minor_value"])
        war.set_influence_token(data["influence_token"])
        for part_data in data.get("participants", []):
            part = WarParticipant.fromDict(part_data)
            war.participants[part.id] = part
        for obj_data in data.get("objectives", []):
            obj = Objective.fromDict(obj_data)
            war.objectives[obj.id] = obj
        for camp_data in data.get("campaigns", []):
            war.campaigns.append(Campaign.fromDict(camp_data))
        for ev_data in data.get("events", []):
            war.events.append(WarEvent.fromDict(ev_data))
        war.set_state(data.get("is_over", False))
        return war

    # Objective methods

    def add_objective(self, name: str, description: str | None) -> Objective:
        if self.is_over:
            raise ForbiddenOperation("Can't add objective in a closed war.")
        obj = Objective(name, description)
        self.objectives[obj.id] = obj
        return obj

    def get_objective(self, id: str) -> Objective:
        return self.objectives[id]

    def get_all_objectives(self) -> List[Objective]:
        return list(self.objectives.values())

    def get_objective_name(self, objective_id: str | None) -> str:
        if objective_id is None:
            return ""
        obj = self.objectives.get(objective_id)
        return obj.name if obj else ""

    def update_objective(
        self, objective_id: str, *, name: str, description: str | None
    ) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't update objective in a closed war.")
        obj = self.get_objective(objective_id)
        obj.set_name(name)
        obj.set_description(description)

    def remove_objective(self, objective_id: str) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't remove objective in a closed war.")
        camp_using_obj: List[str] = []
        for camp in self.campaigns:
            if camp.has_sector_with_objective(objective_id):
                camp_using_obj.append(camp.name)
        if camp_using_obj:
            camps_str = ", ".join(camp_using_obj)
            raise ForbiddenOperation(
                f"This objective is used in campaign(s) sector(s): {camps_str}.\n"
                "Remove it from campaign(s) first."
            )
        del self.objectives[objective_id]

    # War participant methods

    def get_all_war_participants_ids(self) -> set[str]:
        return set(self.participants.keys())

    def has_participant(self, participant_id: str) -> bool:
        return participant_id in self.participants

    def has_player(self, player_id: str) -> bool:
        return any(part.player_id == player_id for part in self.participants.values())

    def add_war_participant(self, player_id: str, faction: str) -> WarParticipant:
        if self.is_over:
            raise ForbiddenOperation("Can't add participant in a closed war.")
        if self.has_player(player_id):
            raise ValueError("Player already registered in this war")
        participant = WarParticipant(player_id=player_id, faction=faction)
        self.participants[participant.id] = participant
        return participant

    def get_war_participant(self, id: str) -> WarParticipant:
        return self.participants[id]

    def get_all_war_participants(self) -> List[WarParticipant]:
        return list(self.participants.values())

    def update_war_participant(self, participant_id: str, *, faction: str) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't update participant in a closed war.")
        part = self.get_war_participant(participant_id)
        # Can't change referred Model.players
        part.set_faction(faction)

    def remove_war_participant(self, participant_id: str) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't remove participant in a closed war.")
        camp_using_part: List[str] = []
        for camp in self.campaigns:
            if camp.has_war_participant(participant_id):
                camp_using_part.append(camp.name)
        if camp_using_part:
            camps_str = ", ".join(camp_using_part)
            raise ForbiddenOperation(
                f"This war participant is used in campaign(s): {camps_str}.\n"
                "Remove it from campaign(s) first."
            )
        del self.participants[participant_id]

    # Campaign methods

    def has_campaign(self, campaign_id: str) -> bool:
        return any(c.id == campaign_id for c in self.campaigns)

    def get_default_campaign_values(self) -> Dict[str, Any]:
        return {"month": datetime.now().month}

    def has_finished_campaign(self) -> bool:
        return any(c.is_over for c in self.campaigns)

    def has_finished_round(self) -> bool:
        return any(c.has_finished_round() for c in self.campaigns)

    def has_finished_battle(self) -> bool:
        return any(c.has_finished_battle() for c in self.campaigns)

    def all_campaigns_finished(self) -> bool:
        return all(c.is_over for c in self.campaigns)

    def add_campaign(self, name: str, month: int | None = None) -> Campaign:
        if self.is_over:
            raise ForbiddenOperation("Can't add campaign in a closed war.")
        if month is None:
            month = self.get_default_campaign_values()["month"]
        campaign = Campaign(name, month)
        self.campaigns.append(campaign)
        return campaign

    def get_campaign(self, campaign_id: str) -> Campaign:
        for camp in self.campaigns:
            if camp.id == campaign_id:
                return camp
        raise KeyError(f"Campaign {campaign_id} not found in War {self.id}")

    # TODO replace multiloops by internal has_* method
    def get_campaign_by_round(self, round_id: str) -> Campaign | None:
        for camp in self.campaigns:
            for rnd in camp.rounds:
                if rnd.id == round_id:
                    return camp
        return None

    # TODO replace multiloops by internal has_* method
    def get_campaign_by_sector(self, sector_id: str) -> Campaign:
        for camp in self.campaigns:
            for sect in camp.sectors.values():
                if sect.id == sector_id:
                    return camp
        raise KeyError(f"Sector {sector_id} not found in any Campaign")

    def get_campaign_by_campaign_participant(
        self, participant_id: str
    ) -> Campaign | None:
        for camp in self.campaigns:
            if camp.has_participant(participant_id):
                return camp
        return None

    def update_campaign(self, campaign_id: str, *, name: str, month: int) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't update campaign in a closed war.")
        camp = self.get_campaign(campaign_id)
        if camp.is_over:
            raise ForbiddenOperation("Can't update a closed campaign.")
        camp.set_name(name)
        camp.set_month(month)

    def get_all_campaigns(self) -> List[Campaign]:
        return list(self.campaigns)

    def remove_campaign(self, campaign_id: str) -> None:
        if self.is_over:
            raise ForbiddenOperation("Can't remove campaign in a closed war.")
        camp = self.get_campaign(campaign_id)
        if camp:
            if camp.is_over:
                raise ForbiddenOperation("Can't remove closed campaign.")
            if camp.has_finished_round():
                raise ForbiddenOperation(
                    "Can't remove campaign with finished round(s)."
                )
            if camp.has_finished_battle():
                raise ForbiddenOperation(
                    "Can't remove campaign with finished battle(s) in round(s)."
                )
        self.campaigns.remove(camp)

    # Sector methods

    def add_sector(
        self,
        campaign_id: str,
        name: str,
        round_id: str,
        major_id: str,
        minor_id: str,
        influence_id: str,
        mission: str,
        description: str,
    ) -> Sector:
        camp = self.get_campaign(campaign_id)
        return camp.add_sector(
            name, round_id, major_id, minor_id, influence_id, mission, description
        )

    # TODO replace multiloops by internal has_* method
    def get_sector(self, sector_id: str) -> Sector:
        for camp in self.campaigns:
            for sect in camp.sectors.values():
                if sect.id == sector_id:
                    return sect
        raise KeyError("Sector not found")

    def update_sector(
        self,
        sector_id: str,
        *,
        name: str,
        round_id: str | None,
        major_id: str | None,
        minor_id: str | None,
        influence_id: str | None,
        mission: str | None,
        description: str | None,
    ) -> None:
        camp = self.get_campaign_by_sector(sector_id)
        camp.update_sector(
            sector_id,
            name=name,
            round_id=round_id,
            major_id=major_id,
            minor_id=minor_id,
            influence_id=influence_id,
            mission=mission,
            description=description,
        )

    def remove_sector(self, sector_id: str) -> None:
        camp = self.get_campaign_by_sector(sector_id)
        camp.remove_sector(sector_id)

    # Campaign participant methods

    def get_available_war_participants(self, campaign_id: str) -> List[WarParticipant]:
        camp = self.get_campaign(campaign_id)
        return [
            part
            for part in self.participants.values()
            if not camp.has_war_participant(part.id)
        ]

    def add_campaign_participant(
        self, campaign_id: str, participant_id: str, leader: str, theme: str
    ) -> CampaignParticipant:
        camp = self.get_campaign(campaign_id)
        return camp.add_campaign_participant(participant_id, leader, theme)

    # TODO replace multiloops by internal has_* method
    def get_campaign_participant(self, participant_id: str) -> CampaignParticipant:
        for camp in self.campaigns:
            for part in camp.participants.values():
                if part.id == participant_id:
                    return part
        raise KeyError("Participant not found")

    def update_campaign_participant(
        self, participant_id: str, *, leader: str, theme: str
    ) -> None:
        camp = self.get_campaign_by_campaign_participant(participant_id)
        if camp is not None:
            camp.update_campaign_participant(participant_id, leader=leader, theme=theme)

    def remove_campaign_participant(self, participant_id: str) -> None:
        camp = self.get_campaign_by_campaign_participant(participant_id)
        if camp is not None:
            camp.remove_campaign_participant(participant_id)

    # Round methods

    def add_round(self, campaign_id: str) -> Round:
        camp = self.get_campaign(campaign_id)
        return camp.add_round()

    def remove_round(self, round_id: str) -> None:
        camp = self.get_campaign_by_round(round_id)
        if camp is not None:
            camp.remove_round(round_id)

    # Choice methods

    def create_choice(self, round_id: str, participant_id: str) -> Choice:
        camp = self.get_campaign_by_round(round_id)
        if camp is not None:
            return camp.create_choice(round_id, participant_id)
        raise KeyError("Campaign with round {round_id} doesn't exist")

    def update_choice(
        self,
        round_id: str,
        participant_id: str,
        priority_sector_id: str | None,
        secondary_sector_id: str | None,
        comment: str | None,
    ) -> None:
        camp = self.get_campaign_by_round(round_id)
        if camp is not None:
            camp.update_choice(
                round_id,
                participant_id,
                priority_sector_id,
                secondary_sector_id,
                comment,
            )

    def remove_choice(self, round_id: str, participant_id: str) -> None:
        camp = self.get_campaign_by_round(round_id)
        if camp is not None:
            camp.remove_choice(round_id, participant_id)

    # Battle methods

    # TODO replace multiloops by internal has_* method
    def get_battle(self, battle_id: str) -> Battle:
        for camp in self.campaigns:
            for rnd in camp.rounds:
                for bat in rnd.battles.values():
                    if bat.sector_id == battle_id:
                        return bat
        raise KeyError("Round not found")

    def create_battle(self, round_id: str, sector_id: str) -> Battle:
        camp = self.get_campaign_by_round(round_id)
        if camp is not None:
            return camp.create_battle(round_id, sector_id)
        raise KeyError("Campaign with round {round_id} doesn't exist")

    def update_battle(
        self,
        round_id: str,
        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:
        camp = self.get_campaign_by_round(round_id)
        if camp is not None:
            camp.update_battle(
                round_id,
                sector_id,
                player_1_id,
                player_2_id,
                winner_id,
                score,
                victory_condition,
                comment,
            )

    def remove_battle(self, round_id: str, sector_id: str) -> None:
        camp = self.get_campaign_by_round(round_id)
        if camp is not None:
            camp.remove_battle(round_id, sector_id)

    # Event methods

    def get_influence_tokens(self, participant_id: str) -> int:
        gained = sum(
            e.amount
            for e in self.events
            if isinstance(e, InfluenceGained) and e.participant_id == participant_id
        )
        spent = sum(
            e.amount
            for e in self.events
            if isinstance(e, InfluenceSpent) and e.participant_id == participant_id
        )
        return gained - spent