from __future__ import annotations

import json
import logging
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Dict, List, Optional, Union

from PySide2 import QtGui
from PySide2.QtCore import QItemSelectionModel
from PySide2.QtGui import QStandardItem, QStandardItemModel
from PySide2.QtWidgets import QAbstractItemView, QListView

import qt_ui.uiconstants as CONST
from game.theater import ConflictTheater, MizCampaignLoader
from game.version import CAMPAIGN_FORMAT_VERSION

PERF_FRIENDLY = 0
PERF_MEDIUM = 1
PERF_HARD = 2
PERF_NASA = 3


@dataclass(frozen=True)
class Campaign:
    name: str
    icon_name: str
    authors: str
    description: str

    #: The revision of the campaign format the campaign was built for. We do not attempt
    #: to migrate old campaigns, but this is used to show a warning in the UI when
    #: selecting a campaign that is not up to date.
    version: int

    recommended_player_faction: str
    recommended_enemy_faction: str
    performance: Union[PERF_FRIENDLY, PERF_MEDIUM, PERF_HARD, PERF_NASA]
    data: Dict[str, Any]
    path: Path

    @classmethod
    def from_json(cls, path: Path) -> Campaign:
        with path.open() as campaign_file:
            data = json.load(campaign_file)

        sanitized_theater = data["theater"].replace(" ", "")
        return cls(
            data["name"],
            f"Terrain_{sanitized_theater}",
            data.get("authors", "???"),
            data.get("description", ""),
            data.get("version", 0),
            data.get("recommended_player_faction", "USA 2005"),
            data.get("recommended_enemy_faction", "Russia 1990"),
            data.get("performance", 0),
            data,
            path,
        )

    def load_theater(self) -> ConflictTheater:
        return ConflictTheater.from_json(self.path.parent, self.data)

    @property
    def is_out_of_date(self) -> bool:
        """Returns True if this campaign is not up to date with the latest format."""
        return self.version < CAMPAIGN_FORMAT_VERSION

    @property
    def is_from_future(self) -> bool:
        """Returns True if this campaign is newer than the supported format."""
        return self.version > CAMPAIGN_FORMAT_VERSION

    @property
    def is_compatible(self) -> bool:
        """Returns True is this campaign was built for this version of the game."""
        if not self.version:
            return False
        if self.is_out_of_date:
            return False
        if self.is_from_future:
            return False
        return True


def load_campaigns() -> List[Campaign]:
    campaign_dir = Path("resources\\campaigns")
    campaigns = []
    for path in campaign_dir.glob("*.json"):
        try:
            logging.debug(f"Loading campaign from {path}...")
            campaign = Campaign.from_json(path)
            campaigns.append(campaign)
        except RuntimeError:
            logging.exception(f"Unable to load campaign from {path}")

    return sorted(campaigns, key=lambda x: x.name)


class QCampaignItem(QStandardItem):
    def __init__(self, campaign: Campaign) -> None:
        super(QCampaignItem, self).__init__()
        self.setIcon(QtGui.QIcon(CONST.ICONS[campaign.icon_name]))
        self.setEditable(False)
        if campaign.is_compatible:
            name = campaign.name
        else:
            name = f"[INCOMPATIBLE] {campaign.name}"
        self.setText(name)


class QCampaignList(QListView):
    def __init__(self, campaigns: List[Campaign]) -> None:
        super(QCampaignList, self).__init__()
        self.model = QStandardItemModel(self)
        self.setModel(self.model)
        self.setMinimumWidth(250)
        self.setMinimumHeight(350)
        self.campaigns = []
        self.setSelectionBehavior(QAbstractItemView.SelectItems)
        self.setup_content(campaigns)

    def setup_content(self, campaigns: List[Campaign]) -> None:
        for campaign in campaigns:
            self.campaigns.append(campaign)
            item = QCampaignItem(campaign)
            self.model.appendRow(item)
        self.setSelectedCampaign(0)
        self.repaint()

    def setSelectedCampaign(self, row):
        self.selectionModel().clearSelection()
        index = self.model.index(row, 0)
        if not index.isValid():
            index = self.model.index(0, 0)
        self.selectionModel().setCurrentIndex(index, QItemSelectionModel.Select)
        self.repaint()

    def clear_layout(self):
        self.model.removeRows(0, self.model.rowCount())