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

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

    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,
            # "sectors" : self.sectors,
            # "choices" : self.choices,
            # "battles" : self.battles,
            "is_over": self.is_over,
        }

    @staticmethod
    def fromDict(data: Dict[str, Any]) -> Round:
        rnd = Round()
        rnd.set_id(data["id"])
        # rnd.sectors = data.get("sectors", {})
        # rnd.choices = data.get("choices", {})
        # rnd.battles = data.get("battles", {})
        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 create_choice(self, participant_id: str) -> Choice:
        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:
        choice = self.get_choice(participant_id)
        if choice:
            choice.set_priority(priority_sector_id)
            choice.set_secondary(secondary_sector_id)
            choice.set_comment(comment)

    def remove_choice(self, participant_id: str) -> None:
        del self.choices[participant_id]

    # Battle methods

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

    def create_battle(self, sector_id: str) -> Battle:
        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:
        bat = self.get_battle(sector_id)
        if bat:
            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)

    def remove_battle(self, sector_id: str) -> None:
        del self.battles[sector_id]