from pathlib import Path
import json
import shutil

from warchron.model.player import Player
from warchron.model.war import War
from warchron.model.campaign import Campaign
from warchron.model.round import Round

class Model:
    def __init__(self):
        self.players = {}
        self.wars = {}

    def new(self):
        self.players.clear()
        self.wars.clear()

    def load(self, path: Path):
        self.players.clear()
        self.wars.clear()
        self._load_data(path)
        
    def save(self, path: Path):
        self._save_data(path)
        
    def _load_data(self, path: Path):
        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):
        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)

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

    def get_player(self, id):
        return self.players[id]
        
    def update_player(self, id, name):
        player = self.get_player(id)
        player.set_name(name)

    def delete_player(self, id):
        del self.players[id]

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

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

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

    def get_all_wars(self) -> list[War]:
        return list(self.wars.values())
    
    def add_campaign(self, war_id: str, name: str) -> Campaign:
        war = self.get_war(war_id)
        return war.add_campaign(name)

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