from io import BytesIO
from zipfile import ZipFile

from corres2math.lists import get_sympa_client
from corres2math.matrix import Matrix
from corres2math.views import AdminMixin
from django.contrib.auth.mixins import LoginRequiredMixin
from django.core.exceptions import PermissionDenied
from django.core.mail import send_mail
from django.db import transaction
from django.http import HttpResponse
from django.shortcuts import redirect
from django.template.loader import render_to_string
from django.urls import reverse_lazy
from django.utils.translation import gettext_lazy as _
from django.views.generic import CreateView, DeleteView, DetailView, FormView, RedirectView, TemplateView, UpdateView
from django.views.generic.edit import FormMixin, ProcessFormView
from django_tables2 import SingleTableView
from magic import Magic
from registration.models import AdminRegistration

from .forms import JoinTeamForm, ParticipationForm, PhaseForm, QuestionForm, \
    ReceiveParticipationForm, RequestValidationForm, SendParticipationForm, TeamForm, \
    UploadVideoForm, ValidateParticipationForm
from .models import Participation, Phase, Question, Team, Video
from .tables import CalendarTable


class CreateTeamView(LoginRequiredMixin, CreateView):
    """
    Display the page to create a team for new users.
    """

    model = Team
    form_class = TeamForm
    extra_context = dict(title=_("Create team"))
    template_name = "participation/create_team.html"

    def dispatch(self, request, *args, **kwargs):
        user = request.user
        registration = user.registration
        if not registration.participates:
            raise PermissionDenied(_("You don't participate, so you can't create a team."))
        elif registration.team:
            raise PermissionDenied(_("You are already in a team."))
        return super().dispatch(request, *args, **kwargs)

    @transaction.atomic
    def form_valid(self, form):
        """
        When a team is about to be created, the user automatically
        joins the team, a mailing list got created and the user is
        automatically subscribed to this mailing list, and finally
        a Matrix room is created and the user is invited in this room.
        """
        ret = super().form_valid(form)
        # The user joins the team
        user = self.request.user
        registration = user.registration
        registration.team = form.instance
        registration.save()

        # Subscribe the user mail address to the team mailing list
        get_sympa_client().subscribe(user.email, f"equipe-{form.instance.trigram.lower()}", False,
                                     f"{user.first_name} {user.last_name}")

        # Invite the user in the team Matrix room
        Matrix.invite(f"#equipe-{form.instance.trigram.lower()}:correspondances-maths.fr",
                      f"@{user.registration.matrix_username}:correspondances-maths.fr")
        return ret

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


class JoinTeamView(LoginRequiredMixin, FormView):
    """
    Participants can join a team with the access code of the team.
    """
    model = Team
    form_class = JoinTeamForm
    extra_context = dict(title=_("Join team"))
    template_name = "participation/create_team.html"

    def dispatch(self, request, *args, **kwargs):
        user = request.user
        registration = user.registration
        if not registration.participates:
            raise PermissionDenied(_("You don't participate, so you can't create a team."))
        elif registration.team:
            raise PermissionDenied(_("You are already in a team."))
        return super().dispatch(request, *args, **kwargs)

    @transaction.atomic
    def form_valid(self, form):
        """
        When a user joins a team, the user is automatically subscribed to
        the team mailing list,the user is invited in the team Matrix room.
        """
        self.object = form.instance
        ret = super().form_valid(form)

        # Join the team
        user = self.request.user
        registration = user.registration
        registration.team = form.instance
        registration.save()

        # Subscribe to the team mailing list
        get_sympa_client().subscribe(user.email, f"equipe-{form.instance.trigram.lower()}", False,
                                     f"{user.first_name} {user.last_name}")

        # Invite the user in the team Matrix room
        Matrix.invite(f"#equipe-{form.instance.trigram.lower()}:correspondances-maths.fr",
                      f"@{user.registration.matrix_username}:correspondances-maths.fr")
        return ret

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


class MyTeamDetailView(LoginRequiredMixin, RedirectView):
    """
    Redirect to the detail of the team in which the user is.
    """

    def get_redirect_url(self, *args, **kwargs):
        user = self.request.user
        registration = user.registration
        if registration.participates:
            if registration.team:
                return reverse_lazy("participation:team_detail", args=(registration.team_id,))
            raise PermissionDenied(_("You are not in a team."))
        raise PermissionDenied(_("You don't participate, so you don't have any team."))


class TeamDetailView(LoginRequiredMixin, FormMixin, ProcessFormView, DetailView):
    """
    Display the detail of a team.
    """
    model = Team

    def get(self, request, *args, **kwargs):
        user = request.user
        self.object = self.get_object()
        # Ensure that the user is an admin or a member of the team
        if user.registration.is_admin or user.registration.participates and \
                user.registration.team and user.registration.team.pk == kwargs["pk"]:
            return super().get(request, *args, **kwargs)
        raise PermissionDenied

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        team = self.get_object()
        context["title"] = _("Detail of team {trigram}").format(trigram=self.object.trigram)
        context["request_validation_form"] = RequestValidationForm(self.request.POST or None)
        context["validation_form"] = ValidateParticipationForm(self.request.POST or None)
        # A team is complete when there are at least 3 members that have sent their photo authorization
        # and confirmed their email address
        context["can_validate"] = team.students.count() >= 3 and \
            all(r.email_confirmed for r in team.students.all()) and \
            all(r.photo_authorization for r in team.students.all()) and \
            team.participation.problem

        return context

    def get_form_class(self):
        if not self.request.POST:
            return RequestValidationForm
        elif self.request.POST["_form_type"] == "RequestValidationForm":
            return RequestValidationForm
        elif self.request.POST["_form_type"] == "ValidateParticipationForm":
            return ValidateParticipationForm

    def form_valid(self, form):
        self.object = self.get_object()
        if isinstance(form, RequestValidationForm):
            return self.handle_request_validation(form)
        elif isinstance(form, ValidateParticipationForm):
            return self.handle_validate_participation(form)

    def handle_request_validation(self, form):
        """
        A team requests to be validated
        """
        if not self.request.user.registration.participates:
            form.add_error(None, _("You don't participate, so you can't request the validation of the team."))
            return self.form_invalid(form)
        if self.object.participation.valid is not None:
            form.add_error(None, _("The validation of the team is already done or pending."))
            return self.form_invalid(form)
        if not self.get_context_data()["can_validate"]:
            form.add_error(None, _("The team can't be validated: missing email address confirmations, "
                                   "photo authorizations, people or the chosen problem is not set."))
            return self.form_invalid(form)

        self.object.participation.valid = False
        self.object.participation.save()

        for admin in AdminRegistration.objects.all():
            mail_context = dict(user=admin.user, team=self.object)
            mail_plain = render_to_string("participation/mails/request_validation.txt", mail_context)
            mail_html = render_to_string("participation/mails/request_validation.html", mail_context)
            admin.user.email_user("[Corres2math] Validation d'équipe", mail_plain, html_message=mail_html)
        return super().form_valid(form)

    def handle_validate_participation(self, form):
        """
        An admin validates the team (or not)
        """
        if not self.request.user.registration.is_admin:
            form.add_error(None, _("You are not an administrator."))
            return self.form_invalid(form)
        elif self.object.participation.valid is not False:
            form.add_error(None, _("This team has no pending validation."))
            return self.form_invalid(form)

        if "validate" in self.request.POST:
            self.object.participation.valid = True
            self.object.participation.save()
            mail_context = dict(team=self.object, message=form.cleaned_data["message"])
            mail_plain = render_to_string("participation/mails/team_validated.txt", mail_context)
            mail_html = render_to_string("participation/mails/team_validated.html", mail_context)
            send_mail("[Corres2math] Équipe validée", mail_plain, None, [self.object.email], html_message=mail_html)
        elif "invalidate" in self.request.POST:
            self.object.participation.valid = None
            self.object.participation.save()
            mail_context = dict(team=self.object, message=form.cleaned_data["message"])
            mail_plain = render_to_string("participation/mails/team_not_validated.txt", mail_context)
            mail_html = render_to_string("participation/mails/team_not_validated.html", mail_context)
            send_mail("[Corres2math] Équipe non validée", mail_plain, None, [self.object.email],
                      html_message=mail_html)
        else:
            form.add_error(None, _("You must specify if you validate the registration or not."))
            return self.form_invalid(form)
        return super().form_valid(form)

    def get_success_url(self):
        return self.request.path


class TeamUpdateView(LoginRequiredMixin, UpdateView):
    """
    Update the detail of a team
    """
    model = Team
    form_class = TeamForm
    template_name = "participation/update_team.html"

    def dispatch(self, request, *args, **kwargs):
        user = request.user
        if user.registration.is_admin or user.registration.participates and \
                user.registration.team and \
                user.registration.team.pk == kwargs["pk"]:
            return super().dispatch(request, *args, **kwargs)
        raise PermissionDenied

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["participation_form"] = ParticipationForm(data=self.request.POST or None,
                                                          instance=self.object.participation)
        context["title"] = _("Update team {trigram}").format(trigram=self.object.trigram)
        return context

    @transaction.atomic
    def form_valid(self, form):
        participation_form = ParticipationForm(data=self.request.POST or None, instance=self.object.participation)
        if not participation_form.is_valid():
            return self.form_invalid(form)

        participation_form.save()
        return super().form_valid(form)

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


class TeamAuthorizationsView(LoginRequiredMixin, DetailView):
    """
    Get as a ZIP archive all the authorizations that are sent
    """
    model = Team

    def dispatch(self, request, *args, **kwargs):
        user = request.user
        if user.registration.is_admin or user.registration.participates and user.registration.team.pk == kwargs["pk"]:
            return super().dispatch(request, *args, **kwargs)
        raise PermissionDenied

    def get(self, request, *args, **kwargs):
        team = self.get_object()
        output = BytesIO()
        zf = ZipFile(output, "w")
        for student in team.students.all():
            magic = Magic(mime=True)
            mime_type = magic.from_file("media/" + student.photo_authorization.name)
            ext = mime_type.split("/")[1].replace("jpeg", "jpg")
            zf.write("media/" + student.photo_authorization.name,
                     _("Photo authorization of {student}.{ext}").format(student=str(student), ext=ext))
        zf.close()
        response = HttpResponse(content_type="application/zip")
        response["Content-Disposition"] = "attachment; filename=\"{filename}\"" \
            .format(filename=_("Photo authorizations of team {trigram}.zip").format(trigram=team.trigram))
        response.write(output.getvalue())
        return response


class TeamLeaveView(LoginRequiredMixin, TemplateView):
    """
    A team member leaves a team
    """
    template_name = "participation/team_leave.html"
    extra_context = dict(title=_("Leave team"))

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            return self.handle_no_permission()
        if not request.user.registration.participates or not request.user.registration.team:
            raise PermissionDenied(_("You are not in a team."))
        if request.user.registration.team.participation.valid is not None:
            raise PermissionDenied(_("The team is already validated or the validation is pending."))
        return super().dispatch(request, *args, **kwargs)

    @transaction.atomic()
    def post(self, request, *args, **kwargs):
        """
        When the team is left, the user is unsubscribed from the team mailing list
        and kicked from the team room.
        """
        team = request.user.registration.team
        request.user.registration.team = None
        request.user.registration.save()
        get_sympa_client().unsubscribe(request.user.email, f"equipe-{team.trigram.lower()}", False)
        Matrix.kick(f"#equipe-{team.trigram.lower()}:correspondances-maths.fr",
                    f"@{request.user.registration.matrix_username}:correspondances-maths.fr",
                    "Équipe quittée")
        if team.students.count() + team.coachs.count() == 0:
            team.delete()
        return redirect(reverse_lazy("index"))


class MyParticipationDetailView(LoginRequiredMixin, RedirectView):
    """
    Redirects to the detail view of the participation of the team.
    """
    def get_redirect_url(self, *args, **kwargs):
        user = self.request.user
        registration = user.registration
        if registration.participates:
            if registration.team:
                return reverse_lazy("participation:participation_detail", args=(registration.team.participation.id,))
            raise PermissionDenied(_("You are not in a team."))
        raise PermissionDenied(_("You don't participate, so you don't have any team."))


class ParticipationDetailView(LoginRequiredMixin, DetailView):
    """
    Display detail about the participation of a team, and manage the video submission.
    """
    model = Participation

    def dispatch(self, request, *args, **kwargs):
        user = request.user
        if not self.get_object().valid:
            raise PermissionDenied(_("The team is not validated yet."))
        if user.registration.is_admin or user.registration.participates \
                and user.registration.team.participation \
                and user.registration.team.participation.pk == kwargs["pk"]:
            return super().dispatch(request, *args, **kwargs)
        raise PermissionDenied

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        context["title"] = lambda: _("Participation of team {trigram}").format(trigram=self.object.team.trigram)
        context["current_phase"] = Phase.current_phase()

        return context


class SetParticipationReceiveParticipationView(AdminMixin, UpdateView):
    """
    Define the solution that a team will receive.
    """
    model = Participation
    form_class = ReceiveParticipationForm
    template_name = "participation/receive_participation_form.html"

    def get_success_url(self):
        return reverse_lazy("participation:participation_detail", args=(self.kwargs["pk"],))


class SetParticipationSendParticipationView(AdminMixin, UpdateView):
    """
    Define the team where the solution will be sent.
    """
    model = Participation
    form_class = SendParticipationForm
    template_name = "participation/send_participation_form.html"

    def get_success_url(self):
        return reverse_lazy("participation:participation_detail", args=(self.kwargs["pk"],))


class CreateQuestionView(LoginRequiredMixin, CreateView):
    """
    Ask a question to another team.
    """
    participation: Participation
    model = Question
    form_class = QuestionForm
    extra_context = dict(title=_("Create question"))

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            return self.handle_no_permission()
        self.participation = Participation.objects.get(pk=kwargs["pk"])
        if request.user.registration.is_admin or \
                request.user.registration.participates and \
                self.participation.valid and \
                request.user.registration.team.pk == self.participation.team_id:
            return super().dispatch(request, *args, **kwargs)
        raise PermissionDenied

    def form_valid(self, form):
        form.instance.participation = self.participation
        return super().form_valid(form)

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


class UpdateQuestionView(LoginRequiredMixin, UpdateView):
    """
    Edit a question.
    """
    model = Question
    form_class = QuestionForm

    def dispatch(self, request, *args, **kwargs):
        self.object = self.get_object()
        if not request.user.is_authenticated:
            return self.handle_no_permission()
        if request.user.registration.is_admin or \
                request.user.registration.participates and \
                self.object.participation.valid and \
                request.user.registration.team.pk == self.object.participation.team_id:
            return super().dispatch(request, *args, **kwargs)
        raise PermissionDenied

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


class DeleteQuestionView(LoginRequiredMixin, DeleteView):
    """
    Remove a question.
    """
    model = Question
    extra_context = dict(title=_("Delete question"))

    def dispatch(self, request, *args, **kwargs):
        self.object = self.get_object()
        if not request.user.is_authenticated:
            return self.handle_no_permission()
        if request.user.registration.is_admin or \
                request.user.registration.participates and \
                self.object.participation.valid and \
                request.user.registration.team.pk == self.object.participation.team_id:
            return super().dispatch(request, *args, **kwargs)
        raise PermissionDenied

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


class UploadVideoView(LoginRequiredMixin, UpdateView):
    """
    Upload a solution video for a team.
    """
    model = Video
    form_class = UploadVideoForm
    template_name = "participation/upload_video.html"
    extra_context = dict(title=_("Upload video"))

    def dispatch(self, request, *args, **kwargs):
        user = request.user
        if user.registration.is_admin or user.registration.participates \
                and user.registration.team.participation.pk == self.get_object().participation.pk:
            return super().dispatch(request, *args, **kwargs)
        raise PermissionDenied

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


class CalendarView(SingleTableView):
    """
    Display the calendar of the action.
    """
    table_class = CalendarTable
    model = Phase
    extra_context = dict(title=_("Calendar"))


class PhaseUpdateView(AdminMixin, UpdateView):
    """
    Update a phase of the calendar, if we have sufficient rights.
    """
    model = Phase
    form_class = PhaseForm
    extra_context = dict(title=_("Calendar update"))

    def get_success_url(self):
        return reverse_lazy("participation:calendar")