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 ultron.people.models import Gymnast
from .models import Skill, Routine, RoutineSkill, Plan
from .forms import RoutineForm, PlanForm

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 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")


@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():
        if prerequisite.level >= skill.level:
            skill.level = prerequisite.level + 1

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

        if prerequisite.age_boy > skill.age_boy:
            skill.age_boy = prerequisite.age_boy

        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):
    """
    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(long_label__icontains=pattern) | Q(short_label__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(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")


@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


@login_required
@require_http_methods(["GET", "POST"])
def plan_create_or_update(request, plan_id=None, gymnast_id=None, skill_id=None):
    """Création d'un plan.

    Args:
        plan_id (int):      identifiant d'un plan (classe <Plan>).
        gymnast_id (int):   identifiant d'un gymnaste (classe <Gymnast>).
        skill_id (int):     identifiant d'un skill (classe <Skill>).
    """

    if plan_id:
        plan = get_object_or_404(Plan, pk=plan_id)
        data = {
            "gymnast": plan.gymnast.id,
            "gymnast_related": str(plan.gymnast),
            "skill": plan.skill.id,
            "skill_related": str(plan.skill),
        }
    else:
        plan = None
        data = {}

        if gymnast_id:
            gymnast = get_object_or_404(Gymnast, pk=gymnast_id)
            data["gymnast"] = gymnast_id
            data["gymnast_related"] = str(gymnast)

        if skill_id:
            skill = get_object_or_404(Skill, pk=skill_id)
            data["educative"] = skill_id
            data["educative_related"] = str(skill)

    if request.method == "POST":
        form = PlanForm(request.POST, instance=plan)

        if form.is_valid():
            plan = form.save()
        else:
            print(form.errors)
    else:
        form = PlanForm(instance=plan, initial=data)

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