from django.db import models
from . import Round, GroupStage, FederalMatchCategory
from django.utils import timezone, formats
import uuid

class Match(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=True)
    round = models.ForeignKey(Round, null=True, blank=True, on_delete=models.CASCADE)
    group_stage = models.ForeignKey(GroupStage, null=True, blank=True, on_delete=models.CASCADE)
    name = models.CharField(max_length=200, null=True, blank=True)
    start_date = models.DateTimeField(null=True, blank=True)
    end_date = models.DateTimeField(null=True, blank=True)
    index = models.IntegerField(default=0)
    order = models.IntegerField(default=0)
    format = models.IntegerField(default=FederalMatchCategory.NINE_GAMES, choices=FederalMatchCategory.choices, null=True, blank=True)
    court = models.CharField(max_length=50, null=True, blank=True)
    serving_team_id = models.UUIDField(null=True, blank=True)
    winning_team_id = models.UUIDField(null=True, blank=True)
    losing_team_id = models.UUIDField(null=True, blank=True)
    broadcasted = models.BooleanField(default=False)

    def __str__(self):
        names = " / ".join(self.player_names())
        return f"{self.stage_name()}: {names}"

        # player_names = " / ".join(self.player_names())
        # if self.round:
        #     return f"{match_name} > {player_names}"
        # elif self.group_stage:
        #     return f"{match_name} > {player_names}"
        # else:
        #     return "--"

    def backup_name(self):
        items = []
        if self.round:
            items.append(self.round.name())
            items.append(f" #{self.index}")
        elif self.group_stage:
            items.append(self.group_stage.name())
            items.append(f"Match #{self.index}")
        return " ".join(items)

    def stage_name(self):
        if self.name:
            return self.name
        elif self.round:
            return self.round.name()
        elif self.group_stage:
            return self.group_stage.name()
        else:
            return '--'

    def player_names(self):
        return map(lambda ts: ts.player_names(), self.team_scores.all())

    def formatted_start_date(self):
        if self.start_date:
            timezoned_datetime = timezone.localtime(self.start_date)
            return formats.date_format(timezoned_datetime, format='H:i')
            # return formats.date_format(self.start_date, format='H:i')
        else:
            return ''
        # return str(self.start_date) #.strftime("%H:%M")

    def time_indication(self):
        if self.end_date:
            return self.formatted_duration()
        elif self.start_date:
            if self.started():
                return self.formatted_duration()
            else:
                timezoned_datetime = timezone.localtime(self.start_date)
                return formats.date_format(timezoned_datetime, format='l H:i')
        else:
            return 'À venir...'

    def current_duration(self):
        if self.start_date:
            if self.end_date:
                return (self.end_date - self.start_date).total_seconds()
            else:
                return (timezone.now() - self.start_date).total_seconds()
        else:
            return 0

    def started(self):
        if self.start_date:
            return timezone.now() > self.start_date
        else:
            return False

    def should_appear(self):
        return self.start_date and len(self.team_scores.all()) > 0

    def formatted_duration(self):

        _seconds = self.current_duration()

        if _seconds > 0:
            _hours = int(_seconds / 3600)
            _minutes = int((_seconds % 3600) / 60)
            return f"{_hours:02d}h{_minutes:02d}min"
        else :
            _seconds = _seconds * -1
            _hours = int(_seconds / 3600)
            _minutes = int((_seconds % 3600) / 60)
            return f"{_hours:02d}h{_minutes:02d}min"

    # def seconds(self):
    #     return (timezone.now() - self.start_date).total_seconds()

    def live_match(self):
        title = self.name if self.name else self.backup_name()
        date = self.formatted_start_date()
        duration = self.time_indication()
        court = ""
        if self.court:
            court = f"Terrain {self.court}"

        livematch = LiveMatch(title, date, duration, court, self.started())

        for team_score in self.sorted_team_scores():
            image  = team_score.team_registration.logo
            names = team_score.team_names()
            scores = team_score.scores_array()
            weight = team_score.team_registration.weight()
            is_winner = team_score.team_registration.id == self.winning_team_id
            walk_out = team_score.walk_out
            team = Team(image, names, scores, weight, is_winner, walk_out)
            livematch.add_team(team)

        return livematch

    def sorted_team_scores(self):
        if self.group_stage:
            return self.team_scores.order_by('team_registration__group_stage_position')
        else:
            return self.team_scores.order_by('team_registration__bracket_position')

    # def sort_value(self):
    #     sort_score = 0
    #     if self.round.index:
    #         sort_score += 1 / (self.round.index + 1) * 1000 ** 2
    #     if self.group_stage.index:
    #         sort_score += 1 / (self.group_stage.index + 1) * 1000
    #     sort_score += self.index
    #     print(sort_score)
    #     return sort_score

class Team:
    def __init__(self, image, names, scores, weight, is_winner, walk_out):
        # print(f"image = {image}, names= {names}, scores ={scores}, weight={weight}, win={is_winner}")
        self.image = image
        self.names = names
        self.scores = scores
        self.weight = weight
        self.is_winner = is_winner
        self.walk_out = walk_out

    def to_dict(self):
        return {
            "image": self.image,
            "names": self.names,
            "scores": self.scores,
            "weight": self.weight,
            "is_winner": self.is_winner,
            "walk_out": self.walk_out,
        }

class LiveMatch:
    def __init__(self, title, date, duration, court, started):
        self.title = title
        self.date = date
        self.teams = []
        self.duration = duration
        self.court = court
        self.started = started

    def add_team(self, team):
        self.teams.append(team)

    def to_dict(self):
        return {
            "title": self.title,
            "date": self.date,
            "teams": [team.to_dict() for team in self.teams],
            "duration": self.duration,
            "court": self.court,
            "started": self.started,
        }

    def has_walk_out(self):
        for team in self.teams:
            if team.walk_out:
                return True
        return False

    def show_duration(self):
        for team in self.teams:
            if team.walk_out and len(team.scores) == 0:
                return False
        return True