from django.db import models
from django.core.exceptions import ObjectDoesNotExist

from . import TournamentSubModel, Match, TeamRegistration, FederalMatchCategory
import uuid
from .match import Team  # Import Team only when needed

class TeamScore(TournamentSubModel):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=True)
    match = models.ForeignKey(Match, on_delete=models.SET_NULL, related_name="team_scores", null=True)
    team_registration = models.ForeignKey(TeamRegistration, on_delete=models.SET_NULL, null=True, blank=True, related_name="team_scores")
    score = models.CharField(max_length=50, null=True, blank=True)
    walk_out = models.IntegerField(null=True, blank=True) # TODO type of WO: forfeit, injury...
    lucky_loser = models.IntegerField(null=True, blank=True)

    def delete_dependencies(self):
        pass

    def __str__(self):
        try:
            if self.match and self.team_registration:
                return f"{self.match.stage_name()} #{self.match.index}: {self.player_names()}"
            if self.match:
                return f"{self.match.stage_name()} #{self.match.index}"
        except ObjectDoesNotExist:
            pass
        return "--"

    def get_tournament(self): # mandatory method for TournamentSubModel
        if self.team_registration:
            return self.team_registration.tournament
        elif self.match:
            return self.match.get_tournament()
        else:
            return None

    # def save(self, *args, **kwargs):
    #     self.store_id = str(self.get_tournament_id())
    #     super().save(*args, **kwargs)

    # def tournament(self):
    #     if self.team_registration:
    #         return self.team_registration.tournament
    #     elif self.match:
    #         return self.match.tournament()
    #     else:
    #         return None

    # def get_tournament_id(self):
    #     tournament = self.tournament()
    #     if tournament:
    #         return tournament.id
    #     else:
    #         return None

    def player_names(self):
        try:
            if self.team_registration: # this can cause an exception when deleted
                if self.team_registration.name:
                    return self.team_registration.name
                else:
                    names = self.team_registration.team_names()
                    return " - ".join(names)
        except TeamRegistration.DoesNotExist:
            pass
        return "--"

    def shortened_team_names(self, forced=False):
        names = []
        if self.team_registration:
            names = self.team_registration.shortened_team_names(forced=forced)
        return names

    def team_names(self):
        names = []
        if self.team_registration:
            if self.team_registration.name:
                names.append(self.team_registration.name)
            else:
                names = self.team_registration.team_names()
        return names

    def scores(self):
        if self.score:
            return [
                int(x.split('-')[0])  # Extract the integer part before the hyphen
                for x in self.score.split(',')  # Split by commas for multiple scores
            ]
        else:
            return []

    def parsed_scores(self):
        if self.score:
            return [
                {
                    'main': int(x.split('-')[0]),  # Main score
                    'tiebreak': x.split('-')[1] if '-' in x else None  # Tiebreak
                }
                for x in self.score.split(',')
            ]
        return []

    def scores_array(self):
        if self.score:
            return [x for x in self.score.split(',')]
        else:
            return []

    def estimated_number_of_games(self):
        scores = self.scores()
        format = FederalMatchCategory.NINE_GAMES_DECISIVE_POINT
        games = 0.0
        if self.match.format:
            format = self.match.format
        if format == FederalMatchCategory.TWO_SETS_OF_SUPER_TIE:
            games = sum(scores) / 4
            return games
        if FederalMatchCategory.last_set_is_tie_break(format) and len(scores) == FederalMatchCategory.max_number_of_sets(format):
            points = scores.pop()
            games += points / 4 # we take 4 points in average for a game
        games += sum(scores)
        return games

    def number_of_games(self):
        scores = self.scores()
        return sum(scores)

    def live_team(self, match, short_names=False):
        if self.team_registration:
            id = self.team_registration.id
            image = self.team_registration.logo
            is_winner = self.team_registration.id == match.winning_team_id
            if self.team_registration.players_sorted_by_rank.count() == 0:
                weight = None
            else:
                weight = self.team_registration.weight
        else:
            id = None
            image = None
            weight= None
            is_winner = False
        names = self.shortened_team_names(forced=short_names)
        scores = self.parsed_scores()
        walk_out = self.walk_out
        is_lucky_loser = self.lucky_loser is not None
        team = Team(id, image, names, scores, weight, is_winner, walk_out, is_lucky_loser)
        return team