from django.contrib.auth.decorators import login_required
from django.db.models import Q
from django.http import HttpResponse, HttpResponseRedirect, 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 ultron.people.models import Gymnast

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


@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 2
    if pattern is not None and len(pattern) > 2:
        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")
    return JsonResponse(results, safe=False)


@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(long_label__icontains=pattern) | Q(short_label__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.

    La méthode en profite pour vérifier les champs level, rank, age_boy et age_girl
    par rapport aux pré-requis.

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

    :return: skill
    """
    skill = get_object_or_404(Skill, pk=skillid)

    for prerequisite in skill.prerequisites.all():
        skill.level = max(prerequisite.level + 1, skill.level)
        # if prerequisite.level >= skill.level:
        #     skill.level = prerequisite.level + 1

        skill.rank = max(prerequisite.rank + 1, skill.rank)
        # if prerequisite.rank >= skill.rank:
        #     skill.rank = prerequisite.rank + 1

        skill.age_boy_with_help = max(skill.age_boy_with_help, prerequisite.age_boy_with_help)
        skill.age_boy_without_help = max(
            skill.age_boy_without_help,
            prerequisite.age_boy_without_help
        )
        skill.age_boy_chained = max(skill.age_boy_chained, prerequisite.age_boy_chained)
        skill.age_boy_masterised = max(skill.age_boy_masterised, prerequisite.age_boy_masterised)
        # if prerequisite.age_boy > skill.age_boy:
        #     skill.age_boy = prerequisite.age_boy

        skill.age_girl_with_help = max(skill.age_girl_with_help, prerequisite.age_girl_with_help)
        skill.age_girl_without_help = max(
            skill.age_girl_without_help,
            prerequisite.age_girl_without_help
        )
        skill.age_girl_chained = max(skill.age_girl_chained, prerequisite.age_girl_chained)
        skill.age_girl_masterised = max(skill.age_girl_masterised, prerequisite.age_girl_masterised)
        # if prerequisite.age_girl > skill.age_girl:
        #     skill.age_girl = prerequisite.age_girl

    skill.save()

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


@login_required
@require_http_methods(["GET"])
def routine_listing(request, gymnast_id=None):
    """Récupère la liste des routines suivant un pattern si celui-ci est défini
    """

    gymnast = None
    pattern = request.GET.get("pattern", None)
    if pattern:
        routine_list = Routine.objects.filter(
            Q(long_label__icontains=pattern) | Q(short_label__icontains=pattern)
        )
    else:
        if gymnast_id:
            routine_list = Routine.objects.filter(done_by_gymnast__gymnast=gymnast_id)
            gymnast = Gymnast.objects.get(pk=gymnast_id)
        else:
            routine_list = Routine.objects.all()

    context = {
        "routine_list": routine_list,
        "gymnast_id": gymnast_id,
        "gymnast": gymnast,
    }
    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(long_label__icontains=pattern) | Q(short_label__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")
    return JsonResponse(place_list, safe=False)


@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
    age_boy = 0
    age_girl = 0
    difficulty = 0
    is_competitive = True

    for skill_link in routine.skill_links.all():

        difficulty += skill_link.skill.difficulty
        level = max(skill_link.skill.level, level)
        rank = max(skill_link.skill.rank + 1, rank)

        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
    routine.level = max(routine.level, level)
    routine.rank = max(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  # pylint: disable=line-too-long
            # TO_FRED : can you help me ?
            return HttpResponseRedirect(reverse("routine_details", args=(routine.pk,)))

        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
    )

    return HttpResponse(200, (link, created))