from datetime import date, timedelta
from uuid import uuid4

from django.contrib.auth.models import User
from django.shortcuts import redirect
from django.http import HttpResponse
from django.template import loader
from django.contrib.auth.decorators import login_required

from colloscope.models import *
from colloscope.table import table_colloscope
from colloscope.pdfexport import handle
from colloscope.icalexport import to_calendar


def handler404(request):
    template = loader.get_template("404.html")
    #response.status_code = 404
    context = {}
    return HttpResponse(template.render(context))


def home_redirect(request):
    return redirect("/colloscope/dashboard.html")


@login_required
def choix_profil(request):
    user = request.user
    session = request.session

    if not Profil.objects.filter(utilisateur=user).exists():
        profil = Profil(utilisateur=user)
        profil.save()
    else:
        profil = Profil.objects.get(utilisateur=user)

    if profil.etudiant is not None and profil.colleur is None:
        session["profil"] = "etudiant"
        return redirect("/colloscope/")
    elif profil.colleur is not None and profil.etudiant is None:
        session["profil"] = "colleur"
        return redirect("/colloscope/")
    else:
        if profil.etudiant is not None:
            template = loader.get_template("choix_profil.html")
        else:
            template = loader.get_template("profil_non_associe.html")

        context = {
            "profil": profil,
        }
        return HttpResponse(template.render(context))


def get_lien_calendrier(etudiant, periode):
    try:
        lien = LienCalendrier.objects.get(etudiant=etudiant, periode=periode)
    except LienCalendrier.DoesNotExist:
        code = uuid4().hex
        lien = LienCalendrier(code=code, etudiant=etudiant, periode=periode)
        lien.save()

    return f"calendrier.ics?key={lien.code}"


@login_required
def dashboard(request):
    try:
        etudiant = Profil.from_request(
            request,
            preprocess=lambda query: query \
                .select_related("etudiant__classe") \
                .prefetch_related("etudiant__classe__periode_set")
        )
    except ValueError:
        return redirect("colloscope.choix_profil")

    if not isinstance(etudiant, Etudiant):
        return HttpResponse("pas encore supporté")

    periode = etudiant.classe.periode_actuelle()
    groupe = etudiant.groupe_de_colle(periode)

    rotations = periode.query_rotations_etudiant(etudiant)

    colles_par_sem = [None] * len(periode.range_semaines())
    for i, n in enumerate(periode.range_semaines()):
        lundi = periode.classe.date_debut_sem(n)
        colles = rotations.filter(date__gte=lundi, date__lt=lundi+timedelta(weeks=1))
        colles_par_sem[i] = n, lundi, colles

    template = loader.get_template("dashboard.html")
    lien_calendrier = get_lien_calendrier(etudiant, periode)

    context = {
        "etudiant": etudiant,
        "periode": periode,
        "groupe": groupe,
        "rotations": colles_par_sem,
        "lien_calendrier": lien_calendrier,
    }

    return HttpResponse(template.render(context, request))


@login_required
def marketplace(request):
    try:
        etudiant = Profil.from_request(
            request,
            preprocess=lambda query: query \
                .select_related("etudiant__classe") \
                .prefetch_related("etudiant__classe__periode_set")
        )
    except ValueError:
        return redirect("colloscope.choix_profil")

    if not isinstance(etudiant, Etudiant):
        return HttpResponse("pas encore supporté")


    periode = etudiant.classe.periode_actuelle()
    colles = periode.query_rotations_not_full()

    template = loader.get_template("marketplace.html")

    context = {
        "colles" : colles
    }

    return HttpResponse(template.render(context, request))


@login_required
def colloscope(request):
    try:
        etudiant = Profil.from_request(
            request,
            preprocess=lambda query: query \
                .select_related("etudiant__classe") \
                .prefetch_related("etudiant__classe__periode_set")
        )
    except ValueError:
        return redirect("colloscope.choix_profil")

    if not isinstance(etudiant, Etudiant):
        return HttpResponse("pas encore supporté")

    periode_str = request.GET.get("periode")
    if periode_str is None:
        periode = etudiant.classe.periode_actuelle()
    else:
        try:
            periode = Periode.objects.get(id=int(periode_str), classe=etudiant.classe)
        except Periode.DoesNotExist:
            template = loader.get_template("404.html")
            context = {}
            response = HttpResponse(template.render(context, request))
            response.status_code = 404

    creneaux = Creneau.objects \
        .filter(periode=periode, est_colle=True) \
        .prefetch_related("rotation_set")

    semaines = periode.range_semaines()
    rotations = [(c, []) for c in creneaux]
    for c, l in rotations:
        for sem in semaines:
            lundi = periode.classe.date_debut_sem(sem)

            rot = Rotation.objects.filter(creneau=c, date__gte=lundi, date__lt=lundi + timedelta(weeks=1))
            exists = rot.exists()

            if exists:
                r = rot.first()
                est_modifiee = r.est_modifiee()
                groupes = (g.libelle for g in r.groupes.all())
            else:
                r = est_modifiee = groupes = None

            l.append((sem, exists, r, est_modifiee, groupes))

    template = loader.get_template("table.html")

    context = {
        "periode": periode,
        "semaines": semaines,
        "lundis": [periode.classe.date_debut_sem(n) for n in semaines],
        "jours": ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"],
        "rotations": rotations,
    }

    return HttpResponse(template.render(context, request))


@login_required
def export(request):
    return HttpResponse(bytes(handle(request).output()), content_type="application/pdf")


def get_lien_calendrier(etudiant, periode):
    try:
        lien = LienCalendrier.objects.get(etudiant=etudiant, periode=periode)
    except LienCalendrier.DoesNotExist:
        code = uuid4().hex
        lien = LienCalendrier(code=code, etudiant=etudiant, periode=periode)
        lien.save()

    return f"calendrier.ics?key={lien.code}"


def icalendar(request):
    if request.GET.get("key") is not None:
        try:
            lien = LienCalendrier.objects.get(code=request.GET.get("key"))

            if not request.GET.get("edt"):
                return HttpResponse(to_calendar(lien.etudiant, lien.periode, include_EDT=True).to_ical(),
                                    content_type="text/calendar")

            return HttpResponse(to_calendar(lien.etudiant, lien.periode, include_EDT=True).to_ical(),
                                content_type="text/calendar")

        except LienCalendrier.DoesNotExist:
            return HttpResponse("Invalid key", status=404)
    else:
        return HttpResponse("Unspecified key", status=404)


@login_required
def amender(request, colle_id, est_positif):
    try:
        etudiant = Profil.from_request(
            request,
            preprocess=lambda query: query \
                .select_related("etudiant__classe") \
                .prefetch_related("etudiant__classe__periode_set")
        )
    except ValueError:
        return redirect("colloscope.choix_profil")

    if not isinstance(etudiant, Etudiant):
        return HttpResponse("pas encore supporté")

    #try:
    if est_positif:
        (Rotation.objects
            .get(id=colle_id, creneau__periode__classe=etudiant.classe)
            .amender(est_positif=True, etudiant=etudiant, notifier=True))
    else:
        (Rotation.objects
            .get(id=colle_id, groupes__etudiant=etudiant)
            .amender(est_positif=False, etudiant=etudiant, notifier=True))

    return HttpResponse("ok")
    #except Exception as e:
    #    return HttpResponse(f"aïe : {e}")


@login_required
def inscription(request, colle_id):
    return amender(request, colle_id, True)

@login_required
def desinscription(request, colle_id):
    return amender(request, colle_id, False)


def data_dump(request):
    template = loader.get_template("data_dump.html")
    return HttpResponse(template.render())