from typing import Any, Dict, List
from pathlib import Path
import json
import shutil
from datetime import datetime

from warchron.model.player import Player
from warchron.model.war import War
from warchron.model.war_participant import WarParticipant
from warchron.model.objective import Objective
from warchron.model.campaign import Campaign
from warchron.model.campaign_participant import CampaignParticipant
from warchron.model.sector import Sector
from warchron.model.round import Round
from warchron.model.choice import Choice
from warchron.model.battle import Battle


class Model:
    def __init__(self) -> None:
        self.players: Dict[str, Player] = {}
        self.wars: Dict[str, War] = {}

    # File management methods

    def new(self) -> None:
        self.players.clear()
        self.wars.clear()

    def load(self, path: Path) -> None:
        self.players.clear()
        self.wars.clear()
        self._load_data(path)

    def save(self, path: Path) -> None:
        self._save_data(path)

    def _load_data(self, path: Path) -> None:
        if not path.exists() or path.stat().st_size == 0:
            return  # Start empty
        try:
            with open(path, "r", encoding="utf-8") as f:
                data = json.load(f)
            self.players.clear()
            self.wars.clear()
            for p in data.get("players", []):
                player = Player.fromDict(p)
                self.players[player.id] = player
            for w in data.get("wars", []):
                war = War.fromDict(w)
                self.wars[war.id] = war
        except json.JSONDecodeError:
            raise RuntimeError("Data file is corrupted")

    def _save_data(self, path: Path) -> None:
        if path.exists():
            shutil.copy(path, path.with_suffix(".json.bak"))
        data = {
            "version": "1.0",
            "players": [p.toDict() for p in self.players.values()],
            "wars": [w.toDict() for w in self.wars.values()],
        }
        with open(path, "w", encoding="utf-8") as f:
            json.dump(data, f, indent=2)

    # Player methods

    def add_player(self, name: str) -> Player:
        player = Player(name)
        self.players[player.id] = player
        return player

    def get_player(self, id: str) -> Player:
        return self.players[id]

    def get_player_name(self, player_id: str) -> str:
        return self.players[player_id].name

    def update_player(self, player_id: str, *, name: str) -> None:
        player = self.get_player(player_id)
        player.set_name(name)

    def get_all_players(self) -> List[Player]:
        return list(self.players.values())

    def remove_player(self, player_id: str) -> None:
        # TODO manage war_participants referring to it
        del self.players[player_id]

    # War methods

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

    def add_war(self, name: str, year: int) -> War:
        war = War(name, year)
        self.wars[war.id] = war
        return war

    def get_war(self, id: str) -> War:
        return self.wars[id]

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

    def get_war_by_sector(self, sector_id: str) -> War:
        for war in self.wars.values():
            for camp in war.campaigns:
                for sect in camp.sectors.values():
                    if sect.id == sector_id:
                        return war
        raise KeyError(f"Sector {sector_id} not found in any War")

    def get_war_by_round(self, round_id: str) -> War:
        for war in self.wars.values():
            for camp in war.campaigns:
                for rnd in camp.rounds:
                    if rnd.id == round_id:
                        return war
        raise KeyError(f"Round {round_id} not found in any War")

    def get_war_by_objective(self, objective_id: str) -> War:
        for war in self.wars.values():
            for obj in war.objectives.values():
                if obj.id == objective_id:
                    return war
        raise KeyError(f"Objective {objective_id} not found in any War")

    def get_war_by_war_participant(self, participant_id: str) -> War:
        for war in self.wars.values():
            if war.has_participant(participant_id):
                return war
        raise KeyError(f"Participant {participant_id} not found in any War")

    def get_war_by_campaign_participant(self, participant_id: str) -> War:
        for war in self.wars.values():
            camp = war.get_campaign_by_campaign_participant(participant_id)
            if camp is not None:
                return war
        raise KeyError(f"Participant {participant_id} not found")

    def update_war(self, war_id: str, *, name: str, year: int) -> None:
        war = self.get_war(war_id)
        war.set_name(name)
        war.set_year(year)

    def get_all_wars(self) -> List[War]:
        return list(self.wars.values())

    def remove_war(self, war_id: str) -> None:
        del self.wars[war_id]

    # Objective methods

    def add_objective(self, war_id: str, name: str, description: str) -> Objective:
        war = self.get_war(war_id)
        return war.add_objective(name, description)

    def get_objective(self, objective_id: str) -> Objective:
        for war in self.wars.values():
            for obj in war.objectives.values():
                if obj.id == objective_id:
                    return obj
        raise KeyError("Objective not found")

    def update_objective(
        self, objective_id: str, *, name: str, description: str
    ) -> None:
        war = self.get_war_by_objective(objective_id)
        war.update_objective(objective_id, name=name, description=description)

    def remove_objective(self, objective_id: str) -> None:
        war = self.get_war_by_objective(objective_id)
        war.remove_objective(objective_id)

    # War participant methods

    def get_available_players(self, war_id: str) -> List[Player]:
        war = self.get_war(war_id)
        return [
            player for player in self.players.values() if not war.has_player(player.id)
        ]

    def add_war_participant(
        self, war_id: str, player_id: str, faction: str
    ) -> WarParticipant:
        war = self.get_war(war_id)
        return war.add_war_participant(player_id, faction)

    def get_war_participant(self, participant_id: str) -> WarParticipant:
        for war in self.wars.values():
            for part in war.participants.values():
                if part.id == participant_id:
                    return part
        raise KeyError("Participant not found")

    def get_player_from_war_participant(self, war_part: WarParticipant) -> Player:
        return self.get_player(war_part.player_id)

    def update_war_participant(self, participant_id: str, *, faction: str) -> None:
        war = self.get_war_by_war_participant(participant_id)
        war.update_war_participant(participant_id, faction=faction)

    def remove_war_participant(self, participant_id: str) -> None:
        war = self.get_war_by_war_participant(participant_id)
        war.remove_war_participant(participant_id)

    # Campaign methods

    def get_default_campaign_values(self, war_id: str) -> Dict[str, Any]:
        war = self.get_war(war_id)
        return war.get_default_campaign_values()

    def add_campaign(self, war_id: str, name: str, month: int) -> Campaign:
        war = self.get_war(war_id)
        return war.add_campaign(name, month)

    def get_campaign(self, campaign_id: str) -> Campaign:
        for war in self.wars.values():
            for campaign in war.campaigns:
                if campaign.id == campaign_id:
                    return campaign
        raise KeyError("Campaign not found")

    def get_campaign_by_round(self, round_id: str) -> Campaign:
        for war in self.wars.values():
            camp = war.get_campaign_by_round(round_id)
            if camp is not None:
                return camp
        raise KeyError(f"Round {round_id} not found")

    def get_campaign_by_campaign_participant(self, participant_id: str) -> Campaign:
        for war in self.wars.values():
            camp = war.get_campaign_by_campaign_participant(participant_id)
            if camp is not None:
                return camp
        raise KeyError(f"Participant {participant_id} not found")

    def get_campaign_by_sector(self, sector_id: str) -> Campaign:
        for war in self.wars.values():
            camp = war.get_campaign_by_sector(sector_id)
            if camp is not None:
                return camp
        raise KeyError(f"Sector {sector_id} not found")

    def update_campaign(self, campaign_id: str, *, name: str, month: int) -> None:
        war = self.get_war_by_campaign(campaign_id)
        war.update_campaign(campaign_id, name=name, month=month)

    def remove_campaign(self, campaign_id: str) -> None:
        war = self.get_war_by_campaign(campaign_id)
        war.remove_campaign(campaign_id)

    # Sector methods

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

    def get_sector(self, sector_id: str) -> Sector:
        for war in self.wars.values():
            for camp in war.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,
        major_id: str,
        minor_id: str,
        influence_id: str,
    ) -> None:
        war = self.get_war_by_sector(sector_id)
        war.update_sector(
            sector_id,
            name=name,
            round_id=round_id,
            major_id=major_id,
            minor_id=minor_id,
            influence_id=influence_id,
        )

    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]:
        war = self.get_war_by_campaign(campaign_id)
        return war.get_available_war_participants(campaign_id)

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

    def get_participant_name(self, participant_id: str) -> str:
        war = self.get_war_by_war_participant(participant_id)
        war_part = war.get_war_participant(participant_id)
        return self.players[war_part.player_id].name

    def get_campaign_participant(self, participant_id: str) -> CampaignParticipant:
        for war in self.wars.values():
            for camp in war.campaigns:
                for part in camp.participants.values():
                    if part.id == participant_id:
                        return part
        raise KeyError("Participant not found")

    def get_player_from_campaign_participant(
        self, camp_part: CampaignParticipant
    ) -> Player:
        war_part = self.get_war_participant(camp_part.war_participant_id)
        return self.get_player(war_part.player_id)

    def update_campaign_participant(
        self,
        participant_id: str,
        *,
        leader: str,
        theme: str,
    ) -> None:
        war = self.get_war_by_campaign_participant(participant_id)
        war.update_campaign_participant(participant_id, leader=leader, theme=theme)

    def remove_campaign_participant(self, participant_id: str) -> None:
        war = self.get_war_by_campaign_participant(participant_id)
        war.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 get_round(self, round_id: str) -> Round:
        for war in self.wars.values():
            for camp in war.campaigns:
                for rnd in camp.rounds:
                    if rnd.id == round_id:
                        return rnd
        raise KeyError("Round not found")

    def get_round_index(self, round_id: str) -> int:
        camp = self.get_campaign_by_round(round_id)
        return camp.get_round_index(round_id)

    def get_round_sectors(self, round_id: str) -> List[Sector]:
        camp = self.get_campaign_by_round(round_id)
        return [s for s in camp.sectors.values() if s.round_id == round_id]

    def get_round_participants(self, round_id: str) -> List[CampaignParticipant]:
        camp = self.get_campaign_by_round(round_id)
        return list(camp.participants.values())

    def remove_round(self, round_id: str) -> None:
        war = self.get_war_by_round(round_id)
        war.remove_round(round_id)

    # Choice methods

    def create_choice(self, round_id: str, participant_id: str) -> Choice:
        war = self.get_war_by_round(round_id)
        return war.create_choice(round_id, participant_id)

    def update_choice(
        self,
        round_id: str,
        participant_id: str,
        priority_sector_id: str | None,
        secondary_sector_id: str | None,
        comment: str | None,
    ) -> None:
        war = self.get_war_by_round(round_id)
        war.update_choice(
            round_id, participant_id, priority_sector_id, secondary_sector_id, comment
        )

    def remove_choice(self, round_id: str, participant_id: str) -> None:
        war = self.get_war_by_round(round_id)
        war.remove_choice(round_id, participant_id)

    # Battle methods

    def create_battle(self, round_id: str, sector_id: str) -> Battle:
        war = self.get_war_by_round(round_id)
        return war.create_battle(round_id, sector_id)

    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:
        war = self.get_war_by_round(round_id)
        war.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:
        war = self.get_war_by_round(round_id)
        war.remove_battle(round_id, sector_id)