from django.shortcuts import render, get_object_or_404
from django.http import HttpResponse, HttpResponseRedirect
from django.db.models import Q, Sum

import os
from django.conf import settings
from django.urls import reverse
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_http_methods
from datetime import date, datetime, timedelta

import simplejson

from .models import (
    Client,
    Contract,
    Prestation,
)

from .forms import (
    ClientForm,
    ContractForm,
    PrestationForm,
)

from tools.pdf_generator import BillPaper


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

    if pattern is not None and len(pattern) >= 3:
        results = Client.objects.filter(
            Q(name__icontains=pattern) | Q(contact__icontains=pattern) | Q(city__icontains=pattern)
        )
        client_list = [{"ID": x.id, "name": str(x)} for x in results]

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


@login_required
@require_http_methods(["GET"])
def client_listing(request):
    """ Récupère la liste de tous les clients. """
    client_list = Client.objects.all()
    context = {"client_list": client_list}
    return render(request, "clients/listing.html", context)


@login_required
@require_http_methods(["GET"])
def client_details(request, client_id=None):
    """ Récupère les informations d'un client.

    Args:
        client_id (int): identifiant d'un client.
    """
    client = get_object_or_404(Client, pk=client_id)
    context = {"client": client}
    return render(request, "clients/details.html", context)


@login_required
@require_http_methods(["GET", "POST"])
def client_create_or_update(request, client_id=None):
    """ Création d'un client.

    Args:
        client_id (int): identifiant d'un client.
    """

    if client_id:
        client = get_object_or_404(Client, pk=client_id)
    else:
        client = None

    if request.method == "POST":
        form = ClientForm(request.POST, instance=client)

        if form.is_valid():
            client = form.save()
            return HttpResponseRedirect(reverse("client_details", args=(client.pk, )))

    else:
        form = ClientForm(instance=client)

    context = {"form": form, "client_id": client_id}
    return render(request, "clients/create.html", context)


@login_required
@require_http_methods(["GET"])
def contract_listing(request):
    """ Récupère la liste de tous les contrats. """
    contract_list = Contract.objects.all()
    context = {"contract_list": contract_list}
    return render(request, "contracts/listing.html", context)


@login_required
@require_http_methods(["GET"])
def contract_detail(request, contract_id):
    """
    Récupère toutes les informations relatives à un contrat et les prestations relatives à
    celui-ci.

    Args:
        contract_id (int): identifiant d'un contract
    """

    contract = Contract.objects.get(pk=contract_id)
    prestation_list = contract.get_prestation.all()
    prestation_count = prestation_list.count()
    total = list(contract.get_prestation.all().aggregate(Sum("total_amount")).values())[
        0
    ]
    context = {
        "contract": contract,
        "prestation_list": prestation_list,
        "prestation_count": prestation_count,
        "total": total,
    }
    return render(request, "contracts/details.html", context)


@login_required
@require_http_methods(["GET", "POST"])
def contract_create_or_update(request, contract_id=None):
    """ Création d'un contract.

    Args:
        contract_id (int): identifiant d'un contract.
    """

    if contract_id:
        contract = get_object_or_404(Contract, pk=contract_id)
    else:
        contract = None

    if request.method == "POST":
        form = ContractForm(request.POST, instance=contract)

        if form.is_valid():
            contract = form.save()
            return HttpResponseRedirect(reverse("contract_details", args=(contract.pk, )))

    else:
        form = ContractForm(instance=contract)

    context = {"form": form, "contract_id": contract_id}
    return render(request, "contracts/create.html", context)


@login_required
@require_http_methods(["GET"])
def contract_export(request, contract_id):
    """ Génere un fichier PDF pour fournir au client.

    Args:
        contract_id (int): identifiant d'un contract.
    """

    contract = Contract.objects.get(pk=contract_id)

    # Create the HttpResponse object with the appropriate PDF headers.
    response = HttpResponse(content_type="application/pdf")
    response["Content-Disposition"] = (
        'attachment; filename="facture_' + str(contract.reference) + '.pdf"'
    )
    document = BillPaper(response)
    document.generate(contract)

    document.download()
    return response


@login_required
@require_http_methods(["GET", "POST"])
def prestation_create_or_update(request, prestation_id=None):
    """ Création d'un contract.

    Args:
        prestation_id (int): identifiant d'un prestation.
    """

    if prestation_id:
        prestation = get_object_or_404(Prestation, pk=prestation_id)
    else:
        prestation = None

    if request.method == "POST":
        form = PrestationForm(request.POST, instance=prestation)

        if form.is_valid():
            prestation = form.save()
            return HttpResponseRedirect(reverse("contract_detail", args=(prestation.contract.id, )))
        else:
            print(form.errors)

    else:
        form = PrestationForm(instance=prestation)

    context = {"form": form, "prestation_id": prestation_id}
    return render(request, "prestations/create.html", context)


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

    if pattern is not None and len(pattern) >= 3:
        results = Contract.objects.filter(Q(name__icontains=pattern))
        contract_list = [{"ID": x.id, "name": str(x)} for x in results]

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