from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect, HttpResponse, JsonResponse
from django.shortcuts import render, get_object_or_404
from django.views.decorators.http import require_http_methods
from django.urls import reverse

from jarvis.people.models import Gymnast

from .models import (
    Event,
    EventParticipation,
)

from .forms import EventForm


@login_required
@require_http_methods(["POST"])
def event_lookup(request):
    """
    Récupère la liste de tous évènements suivant un pattern si celui-ci est
    définit.
    """
    results = []
    pattern = request.POST.get("pattern", None)

    if pattern is not None and len(pattern) >= 3:
        model_results = Event.objects.filter(name__icontains=pattern).order_by(
            "date_begin"
        )
        results = [{"ID": x.id, "Name": str(x)} for x in model_results]
    return JsonResponse(results, safe=False)


@login_required
@require_http_methods(["GET", "POST"])
def event_create_or_update(request, event_id=None):
    """
    Création ou mise à jour d'un évènement.
    """

    if event_id:
        event = get_object_or_404(Event, pk=event_id)
        data = {"place_related": event.place}
    else:
        event = None
        data = {}

    if request.method == "POST":
        form = EventForm(request.POST, instance=event)

        if form.is_valid():
            event = form.save()
            return HttpResponseRedirect(reverse("event_details", args=(event.pk,)))
        else:
            return render(request, "objectives/routines/create.html", {"form": form})

    form = EventForm(instance=event, initial=data)
    context = {"form": form, "event_id": event_id}
    return render(request, "events/create.html", context)


@require_http_methods(["POST"])
def link_gymnast_to_event(request):
    """Crée un lien entre un gymnaste et un évènement.

    Returns:
        Si tout se passe bien, un code 200 (Success) est retourné.

    Excepts:
        Si une erreur se produit lors de l'association, un code HTTP 409 (Conflict) est retourné.

    Remarks:
        Tu ne veux pas retourner le lien qui vient d'être créé ?
    """
    try:
        event_id = request.POST.get("event_id", None)
        gymnast_id = request.POST.get("gymnast_id", None)
        gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
        event = get_object_or_404(Event, pk=event_id)
        EventParticipation.objects.create(gymnast=gymnast, event=event)
    except Exception:
        return HttpResponse(409)

    return HttpResponse(200)


@require_http_methods(["POST"])
def unlink_gymnast_from_event(request):
    """Supprime le lien entre un gymnaste et un évènement.

    Remarks:
        Fonctions `link_gymnast_to_event` et `unlink_gymnast_from_event` sont _très_ similaires.
        Il faudrait sans doute mieux passer par une CBV, voire mieux: DRF ;-)
        Surtout qu'ici, on gère directement des `link_between_g_and_e`, à ajouter ou supprimer.
    """
    event_id = request.POST.get("event_id", None)
    gymnast_id = request.POST.get("gymnast_id", None)

    try:
        EventParticipation.objects.get(event=event_id, gymnast=gymnast_id).delete()
    except Exception:
        return HttpResponse(409)

    return HttpResponse(200)


def __get_event_list(request):
    """Récupère une liste d'évènement.

    Par défaut, la liste est triée chronologiquement - le plus ancien étant le premier élément.

    Cette fonction est utilisée pour l'affichage des évènements et au niveau du calendrier.

    Args:
        request (HttpRequest): La requête en entrée
        pattern (str?): Optionnel. Permet de spécifier un pattern à appliquer à la recherche.
    """
    pattern = request.GET.get("pattern", None)

    if pattern:
        event_list = Event.objects.filter(name__icontains=pattern)
    else:
        event_list = Event.objects.all()

    return event_list.order_by("date_begin")


@login_required
@require_http_methods(["GET"])
def calendar(request):
    """Récupère la liste de tous évènements suivant un pattern si celui-ci est définit."""
    event_list = __get_event_list(request)
    context = {"event_list": event_list}
    return render(request, "events/grid.html", context)


@login_required
@require_http_methods(["GET"])
def event_listing(request):
    """
    Récupère la liste de tous évènements suivant un pattern si celui-ci est
    définit.
    """
    event_list = __get_event_list(request)
    context = {"event_list": event_list}
    return render(request, "events/list.html", context)


@login_required
@require_http_methods(["GET"])
def event_detail(request, event_id=None):
    """
    Récupère toutes les informations d'un event.

    :return: une instance de la classe `Event` et une liste de gymnastes liés
    à l'évènement.
    """
    # event = get_object_or_404(Event, pk=event_id)
    event = Event.objects.get(pk=event_id)

    gymnast_list = []
    # today = timezone.now().date()
    # tohour = timezone.now().time()

    # if event.date_begin.date() > today:
    #     for gymnast in event.gymnasts.all():
    #         # pass
    #         gymnast_list.append((gymnast, counted, int((counted / 16) * 100)))
    # else:
    #     gymnast_list = [(x, None, None) for x in event.gymnasts.all()]
    gymnast_list = [(x, None, None) for x in event.gymnasts.all()]

    context = {"event": event, "gymnast_list": gymnast_list}

    return render(request, "events/details.html", context)