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

from people.models import Gymnast
from .models import Skill, Routine, RoutineSkill
from .forms import RoutineForm

import simplejson


@login_required
@require_http_methods(["GET"])
def skill_lookup(request):
    """
    Récupère la liste des skill à la volée suivant des caractères de
    recherche entrés. (min 3 caractères)
    """

    results = []
    pattern = request.GET.get('pattern', None)

    # Ignore queries shorter than length 3
    if pattern is not None and len(pattern) > 3:
        model_results = Skill.objects.filter(
            Q(short_label__icontains=pattern) | Q(long_label__icontains=pattern)
        )
        results = [{'ID': x.id, 'Name': str(x), 'Notation': x.notation} for x in model_results]

    json = simplejson.dumps(results)
    return HttpResponse(json, content_type="application/json")


@login_required
@require_http_methods(["GET"])
def skill_listing(request, field=None, expression=None, value=None, level=None):
    """
    Récupère la liste des skills suivant un pattern si celui-ci est définit.
    """

    pattern = None

    if not field or not value or not expression:
        pattern = request.GET.get("pattern", None)

    if pattern:
        skill_list = Skill.objects.filter(
            Q(longLabel__icontains=pattern) | Q(shortLabel__icontains=pattern)
        )
    elif field and expression and value:
        kwargs = {"{0}__{1}".format(field, expression): value}
        skill_list = Skill.objects.filter(**kwargs)
    elif level is not None:
        skill_list = Skill.objects.filter
    else:
        skill_list = Skill.objects.all()

    context = {'skill_list': skill_list}
    return render(request, 'objectives/skills/list.html', context)


@login_required
@require_http_methods(["GET"])
def skill_details(request, skillid):
    """
    Récupère toutes les informations d'un skill.

    :param skillig:     id d'un `skill`
    :type skillid:      int

    :return: skill
    """
    context = {"skill": get_object_or_404(Skill, pk=skillid)}
    return render(request, "objectives/skills/details.html", context)


@login_required
@require_http_methods(["GET"])
def routine_listing(request):
    """
    Récupère la liste des routines (série) suivant un pattern si celui-ci est définit.
    """

    pattern = request.GET.get("pattern", None)
    if pattern:
        routine_list = Routine.objects.filter(
            Q(longLabel__icontains=pattern) | Q(shortLabel__icontains=pattern)
        )
    else:
        routine_list = Routine.objects.all()

    context = {"routine_list": routine_list}
    return render(request, "objectives/routines/list.html", context)


@login_required
@require_http_methods(["GET"])
def routine_lookup(request):
    """
    Récupère la liste des lieux à la volée suivant des caractères de recherche entrés.
    """
    pattern = request.GET.get("pattern", 0)

    if pattern is not None and len(pattern) >= 3:
        results = Routine.objects.filter(
            Q(longLabel__icontains=pattern) | Q(shortLabel__icontains=pattern)
        )
        place_list = [{"id": x.id, "label": str(x)} for x in results]

    json = simplejson.dumps(place_list)
    return HttpResponse(json, content_type="application/json")


@login_required
def routine_details(request, routineid):
    """
    Récupère toutes les informations d'une routine (série).

    :param routineid: id d'une `routine`
    :type routineid: int
    :return: routineid
    """

    routine = get_object_or_404(Routine, pk=routineid)

    rank = 0
    level = 0
    difficulty = 0
    age_boy = 0
    age_girl = 0
    is_competitive = True

    for skill_link in routine.skill_links.all():

        difficulty += skill_link.skill.difficulty

        if skill_link.skill.level > level:
            level = skill_link.skill.level

        if skill_link.skill.rank > rank:
            rank = skill_link.skill.rank + 1

        if not skill_link.skill.is_competitive:
            is_competitive = False

        if skill_link.skill.age_boy is not None and skill_link.skill.age_boy > age_boy:
            age_boy = skill_link.skill.age_boy

        if skill_link.skill.age_girl is not None and skill_link.skill.age_girl > age_girl:
            age_girl = skill_link.skill.age_girl

    if routine.skill_links.all().count() != 10:
        is_competitive = False

    routine.difficulty = difficulty

    if routine.level < level:
        routine.level = level

    if routine.rank is None or routine.rank < rank:
        routine.rank = rank

    if routine.age_boy is None or routine.age_boy < age_boy:
        routine.age_boy = age_boy

    if routine.age_girl is None or routine.age_girl < age_girl:
        routine.age_girl = age_girl

    routine.is_competitive = is_competitive

    routine.save()

    context = {"routine": routine, "skill_link_list": routine.skill_links.all()}
    return render(request, "objectives/routines/details.html", context)


@login_required
@require_http_methods(["GET", "POST"])
def routine_create_or_update(request, routineid=None):
    """ Création d'une série.

    Args:
        routine_id (int): identifiant d'un object de classe <routine>.
    """

    if routineid:
        routine = get_object_or_404(Routine, pk=routineid)
    else:
        routine = None

    if request.method == "POST":
        form = RoutineForm(request.POST, instance=routine)

        if form.is_valid():
            routine = form.save()
            # ici faire un FOR skill in form_skills_list:
            # record.save()  # ca sauve le record dans la table RoutineSkill
            # something like this : http://stackoverflow.com/questions/3074938/django-m2m-form-save-through-table
            # TO_FRED : can you help me ?
            return HttpResponseRedirect(reverse("routine_details", args=(routine.pk,)))
        else:
            print(form.errors)
    else:
        form = RoutineForm(instance=routine)

    context = {"form": form, "routineid": routineid}
    return render(request, "objectives/routines/create.html", context)


@login_required
@require_http_methods(["GET"])
def compose_routine(request, routineid):
    """
    Récupère une routine et les sauts associés.
    """

    routine = get_object_or_404(Routine, pk=routineid)
    number_of_skill = routine.skill_links.all().count()
    context = {
        "routine": routine,
        "skill_link_list": routine.skill_links.all(),
        "number_of_skill": number_of_skill,
    }
    return render(request, "objectives/routines/compose.html", context)


@require_http_methods(["GET"])
def link_skill_to_routine(request, routineid, skillid, order):
    """
    Recoit trois informations permettant de lier complètement un saut à une routine
    """
    routine = get_object_or_404(Routine, pk=routineid)
    skill = get_object_or_404(Skill, pk=skillid)
    link, created = RoutineSkill.objects.get_or_create(
        routine=routine, skill=skill, rank=order
    )
    # context = {'link':link, 'created':created}
    # return render(request, 'compose_routine.html', context)

    return HttpResponse(200, (link, created))
    # except:
    # return False