warchron_app/src/warchron/controller/war_controller.py

from typing import List, TYPE_CHECKING, Dict

from PyQt6.QtWidgets import QMessageBox, QDialog
from PyQt6.QtGui import QIcon

from warchron.constants import (
    RefreshScope,
    ItemType,
    ContextType,
    Icons,
    IconName,
    RANK_TO_ICON,
)
from warchron.model.exception import DomainError, ForbiddenOperation

if TYPE_CHECKING:
    from warchron.controller.app_controller import AppController
from warchron.controller.dtos import (
    ParticipantOption,
    WarParticipantScoreDTO,
    ObjectiveDTO,
)
from warchron.model.war import War
from warchron.model.war_participant import WarParticipant
from warchron.model.objective import Objective
from warchron.model.tie_manager import TieContext, TieResolver
from warchron.model.score_service import ScoreService
from warchron.model.result_checker import ResultChecker
from warchron.controller.closure_workflow import WarClosureWorkflow
from warchron.view.war_dialog import WarDialog
from warchron.view.objective_dialog import ObjectiveDialog
from warchron.view.war_participant_dialog import WarParticipantDialog
from warchron.view.tie_dialog import TieDialog


class WarController:
    def __init__(self, app: "AppController"):
        self.app = app

    def _compute_war_ranking_icons(self, war: War) -> Dict[str, QIcon]:
        scores = ScoreService.compute_scores(
            war,
            ContextType.WAR,
            war.id,
        )
        ranking = ResultChecker.get_effective_ranking(
            war, ContextType.WAR, war.id, scores
        )
        icon_map = {}
        for rank, group, token_map in ranking:
            base_icon = RANK_TO_ICON.get(rank, IconName.VPNTH)
            tie_id = f"{war.id}:score:{scores[group[0]].victory_points}"
            tie_resolved = TieResolver.is_tie_resolved(war, ContextType.WAR, tie_id)
            for pid in group:
                spent = token_map.get(pid, 0)
                if not tie_resolved and spent == 0:
                    icon_name = getattr(IconName, f"{base_icon.name}DRAW")
                elif tie_resolved and spent == 0 and len(group) > 1:
                    icon_name = getattr(IconName, f"{base_icon.name}DRAW")
                elif tie_resolved and spent > 0 and len(group) == 1:
                    icon_name = getattr(IconName, f"{base_icon.name}BREAK")
                elif tie_resolved and spent > 0 and len(group) > 1:
                    icon_name = getattr(IconName, f"{base_icon.name}TIEDRAW")
                else:
                    icon_name = base_icon
                icon_map[pid] = QIcon(Icons.get_pixmap(icon_name))
        return icon_map

    def _fill_war_details(self, war_id: str) -> None:
        war = self.app.model.get_war(war_id)
        self.app.view.show_war_details(name=war.name, year=war.year)
        self.app.view.set_war_objective_values(
            major=war.major_value,
            minor=war.minor_value,
            influence=war.influence_token,
        )
        objectives = war.get_all_objectives()
        objectives_for_display: List[ObjectiveDTO] = [
            ObjectiveDTO(id=obj.id, name=obj.name, description=obj.description)
            for obj in objectives
        ]
        self.app.view.display_war_objectives(objectives_for_display)
        scores = ScoreService.compute_scores(war, ContextType.WAR, war.id)
        rows: List[WarParticipantScoreDTO] = []
        icon_map = {}
        if war.is_over:
            icon_map = self._compute_war_ranking_icons(war)
        for war_part in war.get_all_war_participants():
            player_name = self.app.model.get_player_name(war_part.player_id)
            score = scores[war_part.id]
            rows.append(
                WarParticipantScoreDTO(
                    war_participant_id=war_part.id,
                    player_id=war_part.player_id,
                    player_name=player_name,
                    faction=war_part.faction or "",
                    victory_points=score.victory_points,
                    narrative_points=dict(score.narrative_points),
                    rank_icon=icon_map.get(war_part.id),
                )
            )
        self.app.view.display_war_participants(rows, objectives_for_display)
        self.app.view.endCampaignBtn.setEnabled(not war.is_over)

    def _validate_war_inputs(self, name: str, year: int) -> bool:
        if not name.strip():
            QMessageBox.warning(
                self.app.view, "Invalid name", "War name cannot be empty."
            )
            return False
        if not (1970 <= year <= 3000):
            QMessageBox.warning(
                self.app.view, "Invalid year", "Year must be between 1970 and 3000."
            )
            return False
        return True

    def create_war(self) -> War | None:
        dialog = WarDialog(
            self.app.view, default_year=self.app.model.get_default_war_values()["year"]
        )
        result = dialog.exec()
        if result != QDialog.DialogCode.Accepted:
            return None
        name = dialog.get_war_name()
        year = dialog.get_war_year()
        if not self._validate_war_inputs(name, year):
            return None
        return self.app.model.add_war(name, year)

    def edit_war(self, war_id: str) -> None:
        war = self.app.model.get_war(war_id)
        war_dialog = WarDialog(
            self.app.view, default_name=war.name, default_year=war.year
        )
        if war_dialog.exec() == QDialog.DialogCode.Accepted:
            name = war_dialog.get_war_name()
            year = war_dialog.get_war_year()
            if not self._validate_war_inputs(name, year):
                return
            self.app.model.update_war(war_id, name=name, year=year)

    def close_war(self) -> None:
        war_id = self.app.navigation.selected_war_id
        if not war_id:
            return
        war = self.app.model.get_war(war_id)
        workflow = WarClosureWorkflow(self.app)
        try:
            workflow.start(war)
        except DomainError as e:
            QMessageBox.warning(
                self.app.view,
                "Deletion forbidden",
                str(e),
            )
        self.app.is_dirty = True
        self.app.navigation.refresh(RefreshScope.CURRENT_SELECTION_DETAILS)
        self.app.navigation.refresh_and_select(
            RefreshScope.WARS_TREE, item_type=ItemType.WAR, item_id=war_id
        )

    def resolve_ties(
        self, war: War, contexts: List[TieContext]
    ) -> Dict[str, Dict[str, bool]]:
        bids_map = {}
        for ctx in contexts:
            active = TieResolver.get_active_participants(
                war, ctx.context_type, ctx.context_id, ctx.participants
            )
            players = [
                ParticipantOption(id=pid, name=self.app.model.get_participant_name(pid))
                for pid in active
            ]
            counters = [war.get_influence_tokens(pid) for pid in active]
            dialog = TieDialog(
                parent=self.app.view,
                players=players,
                counters=counters,
                context_type=ContextType.WAR,
                context_id=ctx.context_id,
            )
            if not dialog.exec():
                raise ForbiddenOperation("Tie resolution cancelled")
            bids_map[ctx.context_id] = dialog.get_bids()
        return bids_map

    def set_major_value(self, value: int) -> None:
        war_id = self.app.navigation.selected_war_id
        if not war_id:
            return
        try:
            self.app.model.set_major_value(war_id, value)
        except DomainError as e:
            QMessageBox.warning(
                self.app.view,
                "Setting forbidden",
                str(e),
            )
        self.app.is_dirty = True
        self.app.navigation.refresh(RefreshScope.CURRENT_SELECTION_DETAILS)

    def set_minor_value(self, value: int) -> None:
        war_id = self.app.navigation.selected_war_id
        if not war_id:
            return
        try:
            self.app.model.set_minor_value(war_id, value)
        except DomainError as e:
            QMessageBox.warning(
                self.app.view,
                "Setting forbidden",
                str(e),
            )
        self.app.is_dirty = True
        self.app.navigation.refresh(RefreshScope.CURRENT_SELECTION_DETAILS)

    def set_influence_token(self, checked: bool) -> None:
        war_id = self.app.navigation.selected_war_id
        if not war_id:
            return
        try:
            self.app.model.set_influence_token(war_id, checked)
        except DomainError as e:
            QMessageBox.warning(
                self.app.view,
                "Setting forbidden",
                str(e),
            )
        self.app.is_dirty = True
        self.app.navigation.refresh(RefreshScope.CURRENT_SELECTION_DETAILS)

    # Objective methods

    def _validate_objective_inputs(self, name: str, description: str | None) -> bool:
        if not name.strip():
            QMessageBox.warning(
                self.app.view, "Invalid name", "Objective name cannot be empty."
            )
            return False
        return True

    def create_objective(self) -> Objective | None:
        if not self.app.navigation.selected_war_id:
            return None
        dialog = ObjectiveDialog(self.app.view)
        if dialog.exec() != QDialog.DialogCode.Accepted:
            return None
        name = dialog.get_objective_name()
        description = dialog.get_objective_description()
        if not self._validate_objective_inputs(name, description):
            return None
        return self.app.model.add_objective(
            self.app.navigation.selected_war_id, name, description
        )

    def edit_objective(self, objective_id: str) -> None:
        obj = self.app.model.get_objective(objective_id)
        obj_dialog = ObjectiveDialog(
            self.app.view, default_name=obj.name, default_description=obj.description
        )
        if obj_dialog.exec() == QDialog.DialogCode.Accepted:
            name = obj_dialog.get_objective_name()
            description = obj_dialog.get_objective_description()
            if not self._validate_objective_inputs(name, description):
                return
            self.app.model.update_objective(
                objective_id, name=name, description=description
            )

    # War participant methods

    def create_war_participant(self) -> WarParticipant | None:
        if not self.app.navigation.selected_war_id:
            return None
        players = self.app.model.get_available_players(
            self.app.navigation.selected_war_id
        )
        play_opts: List[ParticipantOption] = [
            ParticipantOption(id=p.id, name=p.name) for p in players
        ]
        dialog = WarParticipantDialog(self.app.view, players=play_opts)
        if dialog.exec() != QDialog.DialogCode.Accepted:
            return None
        player_id = dialog.get_player_id()
        faction = dialog.get_participant_faction()
        if not player_id:
            return None
        return self.app.model.add_war_participant(
            self.app.navigation.selected_war_id, player_id, faction
        )

    def edit_war_participant(self, participant_id: str) -> None:
        war_part = self.app.model.get_war_participant(participant_id)
        player = self.app.model.get_player(war_part.player_id)
        play_opt = ParticipantOption(id=player.id, name=player.name)
        war_part_dialog = WarParticipantDialog(
            self.app.view,
            players=[play_opt],
            default_player_id=war_part.id,
            default_faction=war_part.faction,
            editable_player=False,
        )
        if war_part_dialog.exec() == QDialog.DialogCode.Accepted:
            faction = war_part_dialog.get_participant_faction()
            self.app.model.update_war_participant(participant_id, faction=faction)