# Copyright (C) 2020 by Animath
# SPDX-License-Identifier: GPL-3.0-or-later

from datetime import date
import os

from django.conf import settings
from django.core.exceptions import ValidationError
from django.core.validators import MaxValueValidator, MinValueValidator, RegexValidator
from django.db import models
from django.db.models import Index
from django.urls import reverse_lazy
from django.utils import timezone
from django.utils.crypto import get_random_string
from django.utils.text import format_lazy
from django.utils.translation import gettext_lazy as _
from registration.models import Payment, VolunteerRegistration
from tfjm.lists import get_sympa_client


def get_motivation_letter_filename(instance, filename):
    return f"authorization/motivation_letters/motivation_letter_{instance.trigram}"


class Team(models.Model):
    """
    The Team model represents a real team that participates to the TFJM².
    This only includes the registration detail.
    """
    name = models.CharField(
        max_length=255,
        verbose_name=_("name"),
        unique=True,
    )

    trigram = models.CharField(
        max_length=3,
        verbose_name=_("trigram"),
        help_text=_("The trigram must be composed of three uppercase letters."),
        unique=True,
        validators=[
            RegexValidator(r"^[A-Z]{3}$"),
            RegexValidator(fr"^(?!{'|'.join(f'{t}$' for t in settings.FORBIDDEN_TRIGRAMS)})",
                           message=_("This trigram is forbidden.")),
        ],
    )

    access_code = models.CharField(
        max_length=6,
        verbose_name=_("access code"),
        help_text=_("The access code let other people to join the team."),
    )

    motivation_letter = models.FileField(
        verbose_name=_("motivation letter"),
        upload_to=get_motivation_letter_filename,
        blank=True,
        default="",
    )

    @property
    def students(self):
        return self.participants.filter(studentregistration__isnull=False)

    @property
    def coaches(self):
        return self.participants.filter(coachregistration__isnull=False)

    def can_validate(self):
        if any(not r.email_confirmed for r in self.participants.all()):
            return False
        if self.students.count() < 4:
            return False
        if not self.coaches.exists():
            return False
        if not self.participation.tournament:
            return False
        if any(not r.photo_authorization for r in self.participants.all()):
            return False
        if not self.motivation_letter:
            return False
        if not self.participation.tournament.remote:
            if any(r.under_18 and not r.health_sheet for r in self.students.all()):
                return False
            if any(r.under_18 and not r.vaccine_sheet for r in self.students.all()):
                return False
            if any(r.under_18 and not r.parental_authorization for r in self.students.all()):
                return False
        return True

    def important_informations(self):
        informations = []

        if self.participation.valid is None:
            if not self.participation.tournament:
                text = _("The team {trigram} is not registered to any tournament. "
                         "You can register the team to a tournament using <a href='{url}'>this link</a>.")
                url = reverse_lazy("participation:update_team", args=(self.pk,))
                content = format_lazy(text, trigram=self.trigram, url=url)
                informations.append({
                    'title': _("No tournament"),
                    'type': "danger",
                    'priority': 4,
                    'content': content,
                })
            else:
                text = _("Registrations for the tournament of {tournament} are ending on the {date:%Y-%m-%d %H:%M}.")
                content = format_lazy(text,
                                      tournament=self.participation.tournament.name,
                                      date=self.participation.tournament.inscription_limit)
                informations.append({
                    'title': _("Registrations closure"),
                    'type': "info",
                    'priority': 1,
                    'content': content,
                })

                if not self.motivation_letter:
                    text = _("The team {trigram} has not uploaded a motivation letter. "
                             "You can upload your motivation letter using <a href='{url}'>this link</a>.")
                    url = reverse_lazy("participation:upload_team_motivation_letter", args=(self.pk,))
                    content = format_lazy(text, trigram=self.trigram, url=url)
                    informations.append({
                        'title': _("No motivation letter"),
                        'type': "danger",
                        'priority': 10,
                        'content': content,
                    })

                nb_students = self.students.count()
                nb_coaches = self.coaches.count()
                if nb_students < 4:
                    text = _("The team {trigram} has less than 4 students ({nb_students}). "
                             "You can invite more students to join the team using "
                             "the invite code <strong>{code}</strong>.")
                    content = format_lazy(text, trigram=self.trigram, nb_students=nb_students, code=self.access_code)
                    informations.append({
                        'title': _("Not enough students"),
                        'type': "warning",
                        'priority': 7,
                        'content': content,
                    })

                if not nb_coaches:
                    text = _("The team {trigram} has no coach. "
                             "You can invite a coach to join the team using the invite code <strong>{code}</strong>.")
                    content = format_lazy(text, trigram=self.trigram, nb_students=nb_students, code=self.access_code)
                    informations.append({
                        'title': _("No coach"),
                        'type': "warning",
                        'priority': 8,
                        'content': content,
                    })

                if nb_students > 6 or nb_coaches > 2:
                    text = _("The team {trigram} has more than 6 students ({nb_students}) "
                             "or more than 2 coaches ({nb_coaches})."
                             "You have to restrict the number of students and coaches to 6 and 2, respectively.")
                    content = format_lazy(text, trigram=self.trigram, nb_students=nb_students, nb_coaches=nb_coaches)
                    informations.append({
                        'title': _("Too many members"),
                        'type': "warning",
                        'priority': 7,
                        'content': content,
                    })
                elif nb_students >= 4 and nb_coaches >= 1:
                    if self.can_validate():
                        text = _("The team {trigram} is ready to be validated. "
                                 "You can request validation on <a href='{url}'>the page of your team</a>.")
                        url = reverse_lazy("participation:team_detail", args=(self.pk,))
                        content = format_lazy(text, trigram=self.trigram, url=url)
                        informations.append({
                            'title': _("Validate team"),
                            'type': "success",
                            'priority': 2,
                            'content': content,
                        })
                    else:
                        text = _("The team {trigram} has enough participants, but is not ready to be validated. "
                                 "Please make sure that all the participants have uploaded the required documents. "
                                 "To invite more participants, use the invite code <strong>{code}</strong>.")
                        content = format_lazy(text, trigram=self.trigram, code=self.access_code)
                        informations.append({
                            'title': _("Validate team"),
                            'type': "warning",
                            'priority': 10,
                            'content': content,
                        })
        elif self.participation.valid is False:
            text = _("The team {trigram} has not been validated by the organizers yet. Please be patient.")
            content = format_lazy(text, trigram=self.trigram)
            informations.append({
                'title': _("Pending validation"),
                'type': "warning",
                'priority': 2,
                'content': content,
            })
        else:
            informations.extend(self.participation.important_informations())

        return informations

    @property
    def email(self):
        """
        :return: The mailing list to contact the team members.
        """
        return f"equipe-{self.trigram.lower()}@{os.getenv('SYMPA_HOST', 'localhost')}"

    def create_mailing_list(self):
        """
        Create a new Sympa mailing list to contact the team.
        """
        get_sympa_client().create_list(
            f"equipe-{self.trigram.lower()}",
            f"Equipe {self.name} ({self.trigram})",
            "hotline",  # TODO Use a custom sympa template
            f"Liste de diffusion pour contacter l'equipe {self.name} du TFJM2",
            "education",
            raise_error=False,
        )

    def delete_mailing_list(self):
        """
        Drop the Sympa mailing list, if the team is empty or if the trigram changed.
        """
        if self.participation.valid:  # pragma: no cover
            get_sympa_client().unsubscribe(
                self.email, f"equipes-{self.participation.tournament.name.lower().replace(' ', '-')}", False)
        else:
            get_sympa_client().unsubscribe(self.email, "equipes-non-valides", False)
        get_sympa_client().delete_list(f"equipe-{self.trigram}")

    def save(self, *args, **kwargs):
        if not self.access_code:
            # if the team got created, generate the access code, create the contact mailing list
            self.access_code = get_random_string(6)
            self.create_mailing_list()

        return super().save(*args, **kwargs)

    def get_absolute_url(self):
        return reverse_lazy("participation:team_detail", args=(self.pk,))

    def __str__(self):
        return _("Team {name} ({trigram})").format(name=self.name, trigram=self.trigram)

    class Meta:
        verbose_name = _("team")
        verbose_name_plural = _("teams")
        ordering = ('trigram',)
        indexes = [
            Index(fields=("trigram", )),
        ]


class Tournament(models.Model):
    name = models.CharField(
        max_length=255,
        verbose_name=_("name"),
        unique=True,
    )

    date_start = models.DateField(
        verbose_name=_("start"),
        default=date.today,
    )

    date_end = models.DateField(
        verbose_name=_("end"),
        default=date.today,
    )

    place = models.CharField(
        max_length=255,
        verbose_name=_("place"),
    )

    max_teams = models.PositiveSmallIntegerField(
        verbose_name=_("max team count"),
        default=9,
    )

    price = models.PositiveSmallIntegerField(
        verbose_name=_("price"),
        default=21,
    )

    remote = models.BooleanField(
        verbose_name=_("remote"),
        default=False,
    )

    inscription_limit = models.DateTimeField(
        verbose_name=_("limit date for registrations"),
        default=timezone.now,
    )

    solution_limit = models.DateTimeField(
        verbose_name=_("limit date to upload solutions"),
        default=timezone.now,
    )

    solutions_draw = models.DateTimeField(
        verbose_name=_("random draw for solutions"),
        default=timezone.now,
    )

    syntheses_first_phase_limit = models.DateTimeField(
        verbose_name=_("limit date to upload the syntheses for the first phase"),
        default=timezone.now,
    )

    solutions_available_second_phase = models.DateTimeField(
        verbose_name=_("date when the solutions for the second round become available"),
        default=timezone.now,
    )

    syntheses_second_phase_limit = models.DateTimeField(
        verbose_name=_("limit date to upload the syntheses for the second phase"),
        default=timezone.now,
    )

    description = models.TextField(
        verbose_name=_("description"),
        blank=True,
    )

    organizers = models.ManyToManyField(
        VolunteerRegistration,
        verbose_name=_("organizers"),
        related_name="organized_tournaments",
    )

    final = models.BooleanField(
        verbose_name=_("final"),
        default=False,
    )

    @property
    def teams_email(self):
        """
        :return: The mailing list to contact the team members.
        """
        return f"equipes-{self.name.lower().replace(' ', '-')}@{os.getenv('SYMPA_HOST', 'localhost')}"

    @property
    def organizers_email(self):
        """
        :return: The mailing list to contact the team members.
        """
        return f"organisateurs-{self.name.lower().replace(' ', '-')}@{os.getenv('SYMPA_HOST', 'localhost')}"

    @property
    def jurys_email(self):
        """
        :return: The mailing list to contact the team members.
        """
        return f"jurys-{self.name.lower().replace(' ', '-')}@{os.getenv('SYMPA_HOST', 'localhost')}"

    def create_mailing_lists(self):
        """
        Create a new Sympa mailing list to contact the team.
        """
        get_sympa_client().create_list(
            f"equipes-{self.name.lower().replace(' ', '-')}",
            f"Equipes du tournoi de {self.name}",
            "hotline",  # TODO Use a custom sympa template
            f"Liste de diffusion pour contacter les equipes du tournoi {self.name} du TFJM²",
            "education",
            raise_error=False,
        )
        get_sympa_client().create_list(
            f"organisateurs-{self.name.lower().replace(' ', '-')}",
            f"Organisateurs du tournoi de {self.name}",
            "hotline",  # TODO Use a custom sympa template
            f"Liste de diffusion pour contacter les equipes du tournoi {self.name} du TFJM²",
            "education",
            raise_error=False,
        )

    @staticmethod
    def final_tournament():
        qs = Tournament.objects.filter(final=True)
        if qs.exists():
            return qs.get()

    @property
    def participations(self):
        if self.final:
            return Participation.objects.filter(final=True)
        return self.participation_set

    @property
    def solutions(self):
        if self.final:
            return Solution.objects.filter(final_solution=True)
        return Solution.objects.filter(participation__tournament=self)

    @property
    def syntheses(self):
        if self.final:
            return Synthesis.objects.filter(final_solution=True)
        return Synthesis.objects.filter(participation__tournament=self)

    @property
    def best_format(self):
        n = len(self.participations.filter(valid=True).all())
        fmt = [n] if n <= 5 else [3] * (n // 3 - 1) + [3 + n % 3]
        return '+'.join(map(str, sorted(fmt)))

    def get_absolute_url(self):
        return reverse_lazy("participation:tournament_detail", args=(self.pk,))

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = _("tournament")
        verbose_name_plural = _("tournaments")
        indexes = [
            Index(fields=("name", "date_start", "date_end", )),
        ]


class Participation(models.Model):
    """
    The Participation model contains all data that are related to the participation:
    chosen problem, validity status, solutions,...
    """
    team = models.OneToOneField(
        Team,
        on_delete=models.CASCADE,
        verbose_name=_("team"),
    )

    tournament = models.ForeignKey(
        Tournament,
        on_delete=models.SET_NULL,
        null=True,
        blank=True,
        default=None,
        verbose_name=_("tournament"),
    )

    valid = models.BooleanField(
        null=True,
        default=None,
        verbose_name=_("valid team"),
        help_text=_("The participation got the validation of the organizers."),
    )

    final = models.BooleanField(
        default=False,
        verbose_name=_("selected for final"),
        help_text=_("The team is selected for the final tournament."),
    )

    def get_absolute_url(self):
        return reverse_lazy("participation:participation_detail", args=(self.pk,))

    def __str__(self):
        return _("Participation of the team {name} ({trigram})").format(name=self.team.name, trigram=self.team.trigram)

    def important_informations(self):
        informations = []

        missing_payments = Payment.objects.filter(registrations__in=self.team.participants.all(), valid=False)
        if missing_payments.exists():
            text = _("<p>The team {trigram} has {nb_missing_payments} missing payments. Each member of the team "
                     "must have a valid payment (or send a scholarship notification) "
                     "to participate to the tournament.</p>"
                     "<p>Participants that have not paid yet are: {participants}.</p>")
            content = format_lazy(text, trigram=self.team.trigram, nb_missing_payments=missing_payments.count(),
                                  participants=", ".join(", ".join(str(r) for r in p.registrations.all())
                                                         for p in missing_payments.all()))
            informations.append({
                'title': _("Missing payments"),
                'type': "danger",
                'priority': 10,
                'content': content,
            })

        if timezone.now() <= self.tournament.solution_limit:
            text = _("<p>The solutions for the tournament of {tournament} are due on the {date:%Y-%m-%d %H:%M}.</p>"
                     "<p>You have currently sent <strong>{nb_solutions}</strong> solutions. "
                     "We suggest to send at least <strong>{min_solutions}</strong> different solutions.</p>"
                     "<p>You can upload your solutions on <a href='{url}'>your participation page</a>.</p>")
            url = reverse_lazy("participation:participation_detail", args=(self.pk,))
            content = format_lazy(text, tournament=self.tournament.name, date=self.tournament.solution_limit,
                                  nb_solutions=self.solutions.count(), min_solutions=len(settings.PROBLEMS) - 3,
                                  url=url)
            informations.append({
                'title': _("Solutions due"),
                'type': "info",
                'priority': 1,
                'content': content,
            })

        return informations

    class Meta:
        verbose_name = _("participation")
        verbose_name_plural = _("participations")
        ordering = ('valid', 'team__trigram',)


class Pool(models.Model):
    tournament = models.ForeignKey(
        Tournament,
        on_delete=models.CASCADE,
        related_name="pools",
        verbose_name=_("tournament"),
    )

    round = models.PositiveSmallIntegerField(
        verbose_name=_("round"),
        choices=[
            (1, format_lazy(_("Round {round}"), round=1)),
            (2, format_lazy(_("Round {round}"), round=2)),
        ]
    )

    letter = models.PositiveSmallIntegerField(
        choices=[
            (1, 'A'),
            (2, 'B'),
            (3, 'C'),
            (4, 'D'),
        ],
        verbose_name=_('letter'),
    )

    participations = models.ManyToManyField(
        Participation,
        related_name="pools",
        verbose_name=_("participations"),
    )

    juries = models.ManyToManyField(
        VolunteerRegistration,
        related_name="jury_in",
        verbose_name=_("juries"),
    )

    jury_president = models.ForeignKey(
        VolunteerRegistration,
        on_delete=models.SET_NULL,
        null=True,
        default=None,
        related_name="pools_presided",
        verbose_name=_("president of the jury"),
    )

    bbb_url = models.CharField(
        max_length=255,
        blank=True,
        default="",
        verbose_name=_("BigBlueButton URL"),
        help_text=_("The link of the BBB visio for this pool."),
    )

    results_available = models.BooleanField(
        default=False,
        verbose_name=_("results available"),
        help_text=_("Check this case when results become accessible to teams. "
                    "They stay accessible to you. Only averages are given."),
    )

    @property
    def solutions(self):
        return [passage.defended_solution for passage in self.passages.all()]

    def average(self, participation):
        return sum(passage.average(participation) for passage in self.passages.all()) \
               + sum(tweak.diff for tweak in participation.tweaks.filter(pool=self).all())

    async def aaverage(self, participation):
        return sum([passage.average(participation) async for passage in self.passages.all()]) \
               + sum([tweak.diff async for tweak in participation.tweaks.filter(pool=self).all()])

    def get_absolute_url(self):
        return reverse_lazy("participation:pool_detail", args=(self.pk,))

    def validate_constraints(self, exclude=None):
        if self.jury_president not in self.juries.all():
            raise ValidationError({'jury_president': _("The president of the jury must be part of the jury.")})
        return super().validate_constraints()

    def __str__(self):
        return _("Pool of day {round} for tournament {tournament} with teams {teams}")\
            .format(round=self.round,
                    tournament=str(self.tournament),
                    teams=", ".join(participation.team.trigram for participation in self.participations.all()))

    class Meta:
        verbose_name = _("pool")
        verbose_name_plural = _("pools")
        ordering = ('round', 'letter',)


class Passage(models.Model):
    pool = models.ForeignKey(
        Pool,
        on_delete=models.CASCADE,
        verbose_name=_("pool"),
        related_name="passages",
    )

    position = models.PositiveSmallIntegerField(
        verbose_name=_("position"),
        choices=zip(range(1, 6), range(1, 6)),
        default=1,
        validators=[MinValueValidator(1), MaxValueValidator(5)],
    )

    solution_number = models.PositiveSmallIntegerField(
        verbose_name=_("defended solution"),
        choices=[
            (i, format_lazy(_("Problem #{problem}"), problem=i)) for i in range(1, len(settings.PROBLEMS) + 1)
        ],
    )

    defender = models.ForeignKey(
        Participation,
        on_delete=models.PROTECT,
        verbose_name=_("defender"),
        related_name="+",
    )

    opponent = models.ForeignKey(
        Participation,
        on_delete=models.PROTECT,
        verbose_name=_("opponent"),
        related_name="+",
    )

    reporter = models.ForeignKey(
        Participation,
        on_delete=models.PROTECT,
        verbose_name=_("reporter"),
        related_name="+",
    )

    observer = models.ForeignKey(
        Participation,
        on_delete=models.PROTECT,
        null=True,
        blank=True,
        default=None,
        verbose_name=_("observer"),
        related_name="+",
    )

    defender_penalties = models.PositiveSmallIntegerField(
        verbose_name=_("penalties"),
        default=0,
        help_text=_("Number of penalties for the defender. "
                    "The defender will loose a 0.5 coefficient per penalty."),
    )

    @property
    def defended_solution(self) -> "Solution":
        return Solution.objects.get(
            participation=self.defender,
            problem=self.solution_number,
            final_solution=self.pool.tournament.final)

    def avg(self, iterator) -> float:
        items = [i for i in iterator if i]
        return sum(items) / len(items) if items else 0

    @property
    def average_defender_writing(self) -> float:
        return self.avg(note.defender_writing for note in self.notes.all())

    @property
    def average_defender_oral(self) -> float:
        return self.avg(note.defender_oral for note in self.notes.all())

    @property
    def average_defender(self) -> float:
        return self.average_defender_writing + (1.6 - 0.4 * self.defender_penalties) * self.average_defender_oral

    @property
    def average_opponent_writing(self) -> float:
        return self.avg(note.opponent_writing for note in self.notes.all())

    @property
    def average_opponent_oral(self) -> float:
        return self.avg(note.opponent_oral for note in self.notes.all())

    @property
    def average_opponent(self) -> float:
        return 0.9 * self.average_opponent_writing + 2 * self.average_opponent_oral

    @property
    def average_reporter_writing(self) -> float:
        return self.avg(note.reporter_writing for note in self.notes.all())

    @property
    def average_reporter_oral(self) -> float:
        return self.avg(note.reporter_oral for note in self.notes.all())

    @property
    def average_reporter(self) -> float:
        return 0.9 * self.average_reporter_writing + self.average_reporter_oral

    @property
    def average_observer(self) -> float:
        return self.avg(note.observer_oral for note in self.notes.all())

    @property
    def averages(self):
        yield self.average_defender_writing
        yield self.average_defender_oral
        yield self.average_opponent_writing
        yield self.average_opponent_oral
        yield self.average_reporter_writing
        yield self.average_reporter_oral
        if self.observer:
            yield self.average_observer

    def average(self, participation):
        return self.average_defender if participation == self.defender else self.average_opponent \
            if participation == self.opponent else self.average_reporter if participation == self.reporter \
            else self.average_observer if participation == self.observer else 0

    def get_absolute_url(self):
        return reverse_lazy("participation:passage_detail", args=(self.pk,))

    def clean(self):
        if self.defender not in self.pool.participations.all():
            raise ValidationError(_("Team {trigram} is not registered in the pool.")
                                  .format(trigram=self.defender.team.trigram))
        if self.opponent not in self.pool.participations.all():
            raise ValidationError(_("Team {trigram} is not registered in the pool.")
                                  .format(trigram=self.opponent.team.trigram))
        if self.reporter not in self.pool.participations.all():
            raise ValidationError(_("Team {trigram} is not registered in the pool.")
                                  .format(trigram=self.reporter.team.trigram))
        if self.observer and self.observer not in self.pool.participations.all():
            raise ValidationError(_("Team {trigram} is not registered in the pool.")
                                  .format(trigram=self.observer.team.trigram))
        return super().clean()

    def __str__(self):
        return _("Passage of {defender} for problem {problem}")\
            .format(defender=self.defender.team, problem=self.solution_number)

    class Meta:
        verbose_name = _("passage")
        verbose_name_plural = _("passages")
        ordering = ('pool', 'position',)


class Tweak(models.Model):
    pool = models.ForeignKey(
        Pool,
        on_delete=models.CASCADE,
        verbose_name=_("passage"),
    )

    participation = models.ForeignKey(
        Participation,
        on_delete=models.CASCADE,
        verbose_name=_("participation"),
        related_name='tweaks',
    )

    diff = models.IntegerField(
        verbose_name=_("difference"),
        help_text=_("Score to add/remove on the final score"),
    )

    def __str__(self):
        return f"Tweak for {self.participation.team} of {self.diff} points"

    class Meta:
        verbose_name = _("tweak")
        verbose_name_plural = _("tweaks")


def get_solution_filename(instance, filename):
    return f"solutions/{instance.participation.team.trigram}_{instance.problem}" \
           + ("final" if instance.final_solution else "")


def get_synthesis_filename(instance, filename):
    return f"syntheses/{instance.participation.team.trigram}_{instance.type}_{instance.passage.pk}"


class Solution(models.Model):
    participation = models.ForeignKey(
        Participation,
        on_delete=models.CASCADE,
        verbose_name=_("participation"),
        related_name="solutions",
    )

    problem = models.PositiveSmallIntegerField(
        verbose_name=_("problem"),
        choices=[
            (i, format_lazy(_("Problem #{problem}"), problem=i)) for i in range(1, len(settings.PROBLEMS) + 1)
        ],
    )

    final_solution = models.BooleanField(
        verbose_name=_("solution for the final tournament"),
        default=False,
    )

    file = models.FileField(
        verbose_name=_("file"),
        upload_to=get_solution_filename,
        unique=True,
    )

    @property
    def tournament(self):
        return Tournament.final_tournament() if self.final_solution else self.participation.tournament

    def __str__(self):
        return _("Solution of team {team} for problem {problem}")\
            .format(team=self.participation.team.name, problem=self.problem)\
            + (" " + str(_("for final")) if self.final_solution else "")

    class Meta:
        verbose_name = _("solution")
        verbose_name_plural = _("solutions")
        unique_together = (('participation', 'problem', 'final_solution', ), )
        ordering = ('participation__team__trigram', 'final_solution', 'problem',)


class Synthesis(models.Model):
    participation = models.ForeignKey(
        Participation,
        on_delete=models.CASCADE,
        verbose_name=_("participation"),
    )

    passage = models.ForeignKey(
        Passage,
        on_delete=models.CASCADE,
        related_name="syntheses",
        verbose_name=_("passage"),
    )

    type = models.PositiveSmallIntegerField(
        choices=[
            (1, _("opponent"), ),
            (2, _("reporter"), ),
        ]
    )

    file = models.FileField(
        verbose_name=_("file"),
        upload_to=get_synthesis_filename,
        unique=True,
    )

    def __str__(self):
        return _("Synthesis of {team} as {type} for problem {problem} of {defender}").format(
            team=self.participation.team.trigram,
            type=self.get_type_display(),
            problem=self.passage.solution_number,
            defender=self.passage.defender.team.trigram,
        )

    class Meta:
        verbose_name = _("synthesis")
        verbose_name_plural = _("syntheses")
        unique_together = (('participation', 'passage', 'type', ), )
        ordering = ('passage__pool__round', 'type',)


class Note(models.Model):
    jury = models.ForeignKey(
        VolunteerRegistration,
        on_delete=models.CASCADE,
        verbose_name=_("jury"),
        related_name="notes",
    )

    passage = models.ForeignKey(
        Passage,
        on_delete=models.CASCADE,
        verbose_name=_("passage"),
        related_name="notes",
    )

    defender_writing = models.PositiveSmallIntegerField(
        verbose_name=_("defender writing note"),
        choices=[(i, i) for i in range(0, 21)],
        default=0,
    )

    defender_oral = models.PositiveSmallIntegerField(
        verbose_name=_("defender oral note"),
        choices=[(i, i) for i in range(0, 21)],
        default=0,
    )

    opponent_writing = models.PositiveSmallIntegerField(
        verbose_name=_("opponent writing note"),
        choices=[(i, i) for i in range(0, 11)],
        default=0,
    )

    opponent_oral = models.PositiveSmallIntegerField(
        verbose_name=_("opponent oral note"),
        choices=[(i, i) for i in range(0, 11)],
        default=0,
    )

    reporter_writing = models.PositiveSmallIntegerField(
        verbose_name=_("reporter writing note"),
        choices=[(i, i) for i in range(0, 11)],
        default=0,
    )

    reporter_oral = models.PositiveSmallIntegerField(
        verbose_name=_("reporter oral note"),
        choices=[(i, i) for i in range(0, 11)],
        default=0,
    )

    observer_oral = models.SmallIntegerField(
        verbose_name=_("observer note"),
        choices=zip(range(-4, 5), range(-4, 5)),
        default=0,
    )

    def get_all(self):
        yield self.defender_writing
        yield self.defender_oral
        yield self.opponent_writing
        yield self.opponent_oral
        yield self.reporter_writing
        yield self.reporter_oral
        if self.passage.observer:
            yield self.observer_oral

    def set_all(self, defender_writing: int, defender_oral: int, opponent_writing: int, opponent_oral: int,
                reporter_writing: int, reporter_oral: int, observer_oral: int = 0):
        self.defender_writing = defender_writing
        self.defender_oral = defender_oral
        self.opponent_writing = opponent_writing
        self.opponent_oral = opponent_oral
        self.reporter_writing = reporter_writing
        self.reporter_oral = reporter_oral
        self.observer_oral = observer_oral

    def get_absolute_url(self):
        return reverse_lazy("participation:passage_detail", args=(self.passage.pk,))

    @property
    def modal_name(self):
        return f"updateNotes{self.pk}"

    def has_any_note(self):
        return any(self.get_all())

    def __str__(self):
        return _("Notes of {jury} for {passage}").format(jury=self.jury, passage=self.passage)

    class Meta:
        verbose_name = _("note")
        verbose_name_plural = _("notes")