from operator import itemgetter

import zipfile, tempfile

from celery.result import AsyncResult
from django.contrib import messages
from django.contrib.auth.mixins import PermissionRequiredMixin
from django.http import (
    Http404,
    HttpResponse,
    HttpResponseBadRequest,
    HttpResponseRedirect,
)
from django.urls import reverse
from django.utils.html import escape, format_html
from django.utils.safestring import mark_safe
from django.utils.translation import gettext as _, ngettext
from django.views.generic import DetailView
from django.views.generic.detail import BaseDetailView

from judge.models import Language, Submission
from judge.tasks import apply_submission_filter, rejudge_problem_filter, rescore_problem
from judge.utils.celery import redirect_to_task_status
from judge.utils.views import TitleMixin
from judge.views.problem import ProblemMixin


class ManageProblemSubmissionMixin(ProblemMixin):
    def get_object(self, queryset=None):
        problem = super().get_object(queryset)
        user = self.request.user
        if not problem.is_subs_manageable_by(user):
            raise Http404()
        return problem


class ManageProblemSubmissionActionMixin(ManageProblemSubmissionMixin):
    def perform_action(self):
        raise NotImplementedError()

    def get(self, request, *args, **kwargs):
        raise Http404()

    def post(self, request, *args, **kwargs):
        try:
            self.object = self.get_object()
        except Http404:
            return self.no_such_problem()
        else:
            return self.perform_action()


class ManageProblemSubmissionView(TitleMixin, ManageProblemSubmissionMixin, DetailView):
    template_name = "problem/manage_submission.html"

    def get_title(self):
        return _("Managing submissions for %s") % (self.object.name,)

    def get_content_title(self):
        return mark_safe(
            escape(_("Managing submissions for %s"))
            % (
                format_html(
                    '<a href="{1}">{0}</a>',
                    self.object.name,
                    reverse("problem_detail", args=[self.object.code]),
                )
            )
        )

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["submission_count"] = self.object.submission_set.count()
        context["languages"] = [
            (lang_id, short_name or key)
            for lang_id, key, short_name in Language.objects.values_list(
                "id", "key", "short_name"
            )
        ]
        context["results"] = sorted(map(itemgetter(0), Submission.RESULT))
        return context


class BaseActionSubmissionsView(
    PermissionRequiredMixin, ManageProblemSubmissionActionMixin, BaseDetailView
):
    permission_required = "judge.rejudge_submission_lot"

    def perform_action(self):
        if self.request.POST.get("use_range", "off") == "on":
            try:
                start = int(self.request.POST.get("start"))
                end = int(self.request.POST.get("end"))
            except (KeyError, ValueError):
                return HttpResponseBadRequest()
            id_range = (start, end)
        else:
            id_range = None

        try:
            languages = list(map(int, self.request.POST.getlist("language")))
        except ValueError:
            return HttpResponseBadRequest()

        return self.generate_response(
            id_range, languages, self.request.POST.getlist("result")
        )

    def generate_response(self, id_range, languages, results):
        raise NotImplementedError()


class ActionSubmissionsView(BaseActionSubmissionsView):
    def rejudge_response(self, id_range, languages, results):
        status = rejudge_problem_filter.delay(
            self.object.id, id_range, languages, results
        )
        return redirect_to_task_status(
            status,
            message=_("Rejudging selected submissions for %s...") % (self.object.name,),
            redirect=reverse(
                "problem_submissions_rejudge_success",
                args=[self.object.code, status.id],
            ),
        )

    def download_response(self, id_range, languages, results):
        if not self.request.user.is_superuser:
            raise Http404

        queryset = Submission.objects.filter(problem_id=self.object.id)
        submissions = apply_submission_filter(queryset, id_range, languages, results)

        with tempfile.SpooledTemporaryFile() as tmp:
            with zipfile.ZipFile(tmp, "w", zipfile.ZIP_DEFLATED) as archive:
                for submission in submissions:
                    file_name = (
                        str(submission.id)
                        + "_"
                        + str(submission.user)
                        + "."
                        + str(submission.language.key)
                    )
                    archive.writestr(file_name, submission.source.source)

            # Reset file pointer
            tmp.seek(0)

            # Write file data to response
            response = HttpResponse(
                tmp.read(), content_type="application/x-zip-compressed"
            )
            response["Content-Disposition"] = 'attachment; filename="%s"' % (
                str(self.object.code) + "_submissions.zip"
            )
            return response

    def generate_response(self, id_range, languages, results):
        action = self.request.POST.get("action")
        if action == "rejudge":
            return self.rejudge_response(id_range, languages, results)
        elif action == "download":
            return self.download_response(id_range, languages, results)
        else:
            return Http404()


class PreviewActionSubmissionsView(BaseActionSubmissionsView):
    def generate_response(self, id_range, languages, results):
        queryset = apply_submission_filter(
            self.object.submission_set.all(), id_range, languages, results
        )
        return HttpResponse(str(queryset.count()))


class RescoreAllSubmissionsView(ManageProblemSubmissionActionMixin, BaseDetailView):
    def perform_action(self):
        status = rescore_problem.delay(self.object.id)
        return redirect_to_task_status(
            status,
            message=_("Rescoring all submissions for %s...") % (self.object.name,),
            redirect=reverse(
                "problem_submissions_rescore_success",
                args=[self.object.code, status.id],
            ),
        )


def rejudge_success(request, problem, task_id):
    count = AsyncResult(task_id).result
    if not isinstance(count, int):
        raise Http404()
    messages.success(
        request,
        ngettext(
            "Successfully scheduled %d submission for rejudging.",
            "Successfully scheduled %d submissions for rejudging.",
            count,
        )
        % (count,),
    )
    return HttpResponseRedirect(reverse("problem_manage_submissions", args=[problem]))


def rescore_success(request, problem, task_id):
    count = AsyncResult(task_id).result
    if not isinstance(count, int):
        raise Http404()
    messages.success(
        request,
        ngettext(
            "%d submission were successfully rescored.",
            "%d submissions were successfully rescored.",
            count,
        )
        % (count,),
    )
    return HttpResponseRedirect(reverse("problem_manage_submissions", args=[problem]))