from datetime import date, timedelta
from uuid import uuid4

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):
    user = request.user
    session = request.session
    
    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 = groupe.get_colles_par_sem()
    template = loader.get_template("dashboard.html")
    lien_calendrier = get_lien_calendrier(etudiant, periode)

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

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


@login_required
def colloscope(request):
    user = request.user
    session = request.session
    
    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"))

            return HttpResponse(to_calendar(lien.etudiant, lien.periode).to_ical(), content_type="text/calendar")
        except LienCalendrier.DoesNotExist:
            return HttpResponse("Invalid key", status=404)
    else:
        return HttpResponse("Unspecified key", status=404)

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