import random
from dataclasses import dataclass

from .song import Song

USER_SCORE_WEIGHT = 0.7
ARTIST_WEIGHT = 0.1
TAG_WEIGHT = 0.1
RANDOM_WEIGHT = 0.1
RECENT_PENALTY = 0.5
RECENT_COUNT = 10


type UserScoredSong = tuple[Song, int]


@dataclass
class Rank:
    user_score: float
    tag: float
    artist: float
    random: float
    recent_penalty: float

    def total(self) -> float:
        return self.user_score + self.tag + self.artist + self.random - self.recent_penalty


@dataclass
class Room:
    id: int
    coord: tuple[float, float]
    name: str
    pin: int | None
    tags: set[str]

    songs: dict[str, UserScoredSong]  # canzoni + voto
    history: list[Song]  # canzoni riprodotte (in ordine)
    playing: list[Song]  # canzoni che sono i riproduzione
    playing_idx: int

    def rank_song_from_id(self, id: str) -> Rank:
        scored = self.songs[id]
        return self.rank_song(scored[0], scored[1])

    def rank_song(self, song: Song, user_score: int) -> Rank:
        song_items = self.songs.items()

        lowest_score = min(song_items, key=lambda item: item[1][1])[1][1]
        highest_score = max(song_items, key=lambda item: item[1][1])[1][1]

        score_rank = translate(user_score, lowest_score, highest_score, 0.0, USER_SCORE_WEIGHT)

        recent_songs = self.history[-RECENT_COUNT:]

        tag_counts = {}
        artist_counts = {}
        for recent_song in recent_songs:
            for tag in recent_song.tags:
                if tag not in tag_counts:
                    tag_counts[tag] = 0
                tag_counts[tag] += 1
            if recent_song.artist not in artist_counts:
                artist_counts[recent_song.artist] = 0
            artist_counts[recent_song.artist] += 1

        tag_total = 0
        for tag in song.tags:
            if tag in tag_counts:
                tag_total += tag_counts[tag]

        artist_total = artist_counts[song.artist] if song.artist in artist_counts else 0

        tag_value = min(RECENT_COUNT, len(self.history)) - tag_total
        artist_value = min(RECENT_COUNT, len(self.history)) - artist_total

        tag_rank = translate(tag_value, 0, min(RECENT_COUNT, len(self.history)), 0, TAG_WEIGHT)
        artist_rank = translate(artist_value, 0, min(RECENT_COUNT, len(self.history)), 0, ARTIST_WEIGHT)

        random_rank = translate(random.random(), 0, 1, 0.0, RANDOM_WEIGHT)

        recent_penalty = RECENT_PENALTY if song in recent_songs else 0

        return Rank(score_rank, tag_rank, artist_rank, random_rank, recent_penalty)


def translate(value: float, in_min: float, in_max: float, out_min: float, out_max: float):
    if in_max == in_min:
        return out_min
    return (value - in_min) / (in_max - in_min) * (out_max - out_min) + out_min


def test_algo():
    songs = [
        Song("paulham", "Io e i miei banchi", "Paul Ham", ["pop"], "", ""),
        Song("cisco", "CiscoPT", "Cantarex", ["rap"], "", ""),
        Song("vpn", "VPN", "Cantarex", ["rap"], "", ""),
        Song("gang", "Gang Gang Gang", "Cantarex", ["rap"], "", ""),
        Song("bertha1", "Rindondantha", "Berthanetti", ["rock"], "", ""),
        Song("bertha2", "Ragatthi", "Berthanetti", ["rock"], "", ""),
        Song("bertha3", "Tranthathione", "Berthanetti", ["rock"], "", ""),
        Song("cexx", "Spritz", "Cex", ["kpop"], "", ""),
    ]

    room = Room(
        123,
        (0.0, 0.0),
        "test",
        None,
        set(["rock", "rap"]),
        {
            "paulham": (songs[0], 2),
            "cisco": (songs[1], 1),
            "vpn": (songs[2], 5),
            "gang": (songs[3], 1),
            "bertha1": (songs[4], 1),
            "bertha2": (songs[5], 1),
            "bertha3": (songs[6], 1),
            "cexx": (songs[7], -123123),
        },
        [songs[4], songs[5], songs[0]],
    )

    print(room.rank_song_from_id("paulham"), room.rank_song_from_id("paulham").total())
    print(room.rank_song_from_id("vpn"), room.rank_song_from_id("vpn").total())
    print(room.rank_song_from_id("cexx"), room.rank_song_from_id("cexx").total())