from typing import List, Dict, Tuple, Any

from bemani.api.exceptions import APIException
from bemani.api.objects.base import BaseObject
from bemani.common import APIConstants, DBConstants, GameConstants
from bemani.data import Attempt, UserID


class StatisticsObject(BaseObject):
    def __format_statistics(self, stats: Dict[str, Any]) -> Dict[str, Any]:
        return {
            "cards": [],
            "song": str(stats["id"]),
            "chart": str(stats["chart"]),
            "plays": stats.get("plays", -1),
            "clears": stats.get("clears", -1),
            "combos": stats.get("combos", -1),
        }

    def __format_user_statistics(
        self, cardids: List[str], stats: Dict[str, Any]
    ) -> Dict[str, Any]:
        base = self.__format_statistics(stats)
        base["cards"] = cardids
        return base

    @property
    def music_version(self) -> int:
        if self.game in {
            GameConstants.IIDX,
            GameConstants.MUSECA,
            GameConstants.JUBEAT,
            GameConstants.POPN_MUSIC,
        }:
            if self.omnimix:
                return self.version + DBConstants.OMNIMIX_VERSION_BUMP
            else:
                return self.version
        else:
            return self.version

    def __is_play(self, attempt: Attempt) -> bool:
        if self.game in {
            GameConstants.DDR,
            GameConstants.JUBEAT,
            GameConstants.MUSECA,
            GameConstants.POPN_MUSIC,
        }:
            return True
        if self.game == GameConstants.IIDX:
            return (
                attempt.data.get_int("clear_status")
                != DBConstants.IIDX_CLEAR_STATUS_NO_PLAY
            )
        if self.game == GameConstants.REFLEC_BEAT:
            return (
                attempt.data.get_int("clear_type")
                != DBConstants.REFLEC_BEAT_CLEAR_TYPE_NO_PLAY
            )
        if self.game == GameConstants.SDVX:
            return (
                attempt.data.get_int("clear_type")
                != DBConstants.SDVX_CLEAR_TYPE_NO_PLAY
            )

        return False

    def __is_clear(self, attempt: Attempt) -> bool:
        if not self.__is_play(attempt):
            return False

        if self.game == GameConstants.DDR:
            return attempt.data.get_int("rank") != DBConstants.DDR_RANK_E
        if self.game == GameConstants.IIDX:
            return (
                attempt.data.get_int("clear_status")
                != DBConstants.IIDX_CLEAR_STATUS_FAILED
            )
        if self.game == GameConstants.JUBEAT:
            return attempt.data.get_int("medal") != DBConstants.JUBEAT_PLAY_MEDAL_FAILED
        if self.game == GameConstants.MUSECA:
            return (
                attempt.data.get_int("clear_type")
                != DBConstants.MUSECA_CLEAR_TYPE_FAILED
            )
        if self.game == GameConstants.POPN_MUSIC:
            return attempt.data.get_int("medal") not in [
                DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FAILED,
                DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FAILED,
                DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FAILED,
            ]
        if self.game == GameConstants.REFLEC_BEAT:
            return (
                attempt.data.get_int("clear_type")
                != DBConstants.REFLEC_BEAT_CLEAR_TYPE_FAILED
            )
        if self.game == GameConstants.SDVX:
            return attempt.data.get_int(
                "grade"
            ) != DBConstants.SDVX_GRADE_NO_PLAY and attempt.data.get_int(
                "clear_type"
            ) not in [
                DBConstants.SDVX_CLEAR_TYPE_NO_PLAY,
                DBConstants.SDVX_CLEAR_TYPE_FAILED,
            ]

        return False

    def __is_combo(self, attempt: Attempt) -> bool:
        if not self.__is_play(attempt):
            return False

        if self.game == GameConstants.DDR:
            return attempt.data.get_int("halo") != DBConstants.DDR_HALO_NONE
        if self.game == GameConstants.IIDX:
            return (
                attempt.data.get_int("clear_status")
                == DBConstants.IIDX_CLEAR_STATUS_FULL_COMBO
            )
        if self.game == GameConstants.JUBEAT:
            return attempt.data.get_int("medal") in [
                DBConstants.JUBEAT_PLAY_MEDAL_FULL_COMBO,
                DBConstants.JUBEAT_PLAY_MEDAL_NEARLY_EXCELLENT,
                DBConstants.JUBEAT_PLAY_MEDAL_EXCELLENT,
            ]
        if self.game == GameConstants.MUSECA:
            return (
                attempt.data.get_int("clear_type")
                == DBConstants.MUSECA_CLEAR_TYPE_FULL_COMBO
            )
        if self.game == GameConstants.POPN_MUSIC:
            return attempt.data.get_int("medal") in [
                DBConstants.POPN_MUSIC_PLAY_MEDAL_CIRCLE_FULL_COMBO,
                DBConstants.POPN_MUSIC_PLAY_MEDAL_DIAMOND_FULL_COMBO,
                DBConstants.POPN_MUSIC_PLAY_MEDAL_STAR_FULL_COMBO,
                DBConstants.POPN_MUSIC_PLAY_MEDAL_PERFECT,
            ]
        if self.game == GameConstants.REFLEC_BEAT:
            return attempt.data.get_int("combo_type") in [
                DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO,
                DBConstants.REFLEC_BEAT_COMBO_TYPE_FULL_COMBO_ALL_JUST,
            ]
        if self.game == GameConstants.SDVX:
            return attempt.data.get_int("clear_type") in [
                DBConstants.SDVX_CLEAR_TYPE_ULTIMATE_CHAIN,
                DBConstants.SDVX_CLEAR_TYPE_PERFECT_ULTIMATE_CHAIN,
            ]

        return False

    def __aggregate_global(self, attempts: List[Attempt]) -> List[Dict[str, Any]]:
        stats: Dict[int, Dict[int, Dict[str, int]]] = {}

        for attempt in attempts:
            if attempt.id not in stats:
                stats[attempt.id] = {}
            if attempt.chart not in stats[attempt.id]:
                stats[attempt.id][attempt.chart] = {
                    "plays": 0,
                    "clears": 0,
                    "combos": 0,
                }

            if self.__is_play(attempt):
                stats[attempt.id][attempt.chart]["plays"] += 1
            if self.__is_clear(attempt):
                stats[attempt.id][attempt.chart]["clears"] += 1
            if self.__is_combo(attempt):
                stats[attempt.id][attempt.chart]["combos"] += 1

        retval = []
        for songid in stats:
            for songchart in stats[songid]:
                stat = stats[songid][songchart]
                stat["id"] = songid
                stat["chart"] = songchart
                retval.append(self.__format_statistics(stat))

        return retval

    def __aggregate_local(
        self, cards: Dict[int, List[str]], attempts: List[Tuple[UserID, Attempt]]
    ) -> List[Dict[str, Any]]:
        stats: Dict[UserID, Dict[int, Dict[int, Dict[str, int]]]] = {}

        for userid, attempt in attempts:
            if userid not in stats:
                stats[userid] = {}
            if attempt.id not in stats[userid]:
                stats[userid][attempt.id] = {}
            if attempt.chart not in stats[userid][attempt.id]:
                stats[userid][attempt.id][attempt.chart] = {
                    "plays": 0,
                    "clears": 0,
                    "combos": 0,
                }

            if self.__is_play(attempt):
                stats[userid][attempt.id][attempt.chart]["plays"] += 1
            if self.__is_clear(attempt):
                stats[userid][attempt.id][attempt.chart]["clears"] += 1
            if self.__is_combo(attempt):
                stats[userid][attempt.id][attempt.chart]["combos"] += 1

        retval = []
        for userid in stats:
            for songid in stats[userid]:
                for songchart in stats[userid][songid]:
                    stat = stats[userid][songid][songchart]
                    stat["id"] = songid
                    stat["chart"] = songchart
                    retval.append(self.__format_user_statistics(cards[userid], stat))

        return retval

    def fetch_v1(
        self, idtype: APIConstants, ids: List[str], params: Dict[str, Any]
    ) -> List[Dict[str, Any]]:
        retval: List[Dict[str, Any]] = []

        # Fetch the attempts
        if idtype == APIConstants.ID_TYPE_SERVER:
            retval = self.__aggregate_global(
                [
                    attempt[1]
                    for attempt in self.data.local.music.get_all_attempts(
                        self.game, self.music_version
                    )
                ]
            )
        elif idtype == APIConstants.ID_TYPE_SONG:
            if len(ids) == 1:
                songid = int(ids[0])
                chart = None
            else:
                songid = int(ids[0])
                chart = int(ids[1])
            retval = self.__aggregate_global(
                [
                    attempt[1]
                    for attempt in self.data.local.music.get_all_attempts(
                        self.game, self.music_version, songid=songid, songchart=chart
                    )
                ]
            )
        elif idtype == APIConstants.ID_TYPE_INSTANCE:
            songid = int(ids[0])
            chart = int(ids[1])
            cardid = ids[2]
            userid = self.data.local.user.from_cardid(cardid)
            if userid is not None:
                retval = self.__aggregate_local(
                    {userid: self.data.local.user.get_cards(userid)},
                    self.data.local.music.get_all_attempts(
                        self.game,
                        self.music_version,
                        songid=songid,
                        songchart=chart,
                        userid=userid,
                    ),
                )
        elif idtype == APIConstants.ID_TYPE_CARD:
            id_to_cards: Dict[int, List[str]] = {}
            attempts: List[Tuple[UserID, Attempt]] = []
            for cardid in ids:
                userid = self.data.local.user.from_cardid(cardid)
                if userid is not None:
                    # Don't duplicate loads for users with multiple card IDs if multiples
                    # of those IDs are requested.
                    if userid in id_to_cards:
                        continue

                    id_to_cards[userid] = self.data.local.user.get_cards(userid)
                    attempts.extend(
                        self.data.local.music.get_all_attempts(
                            self.game, self.music_version, userid=userid
                        )
                    )
            retval = self.__aggregate_local(id_to_cards, attempts)
        else:
            raise APIException("Invalid ID type!")

        return retval