"""Fichier views.py de gestion de la page dashboard de l'application SGL.

Principales fonctionnalités couvertes :
    1- Gestion des stocks des produits (rupture, pré-rupture, normal).
    2- Affichage des commandes en cours et validations des dites commandes
    3- Affichage des demandes en cours et validations des dites demandes.
"""

from django.shortcuts import render, redirect
from django.http import JsonResponse
from gestion_produit.models import Commander, Demander, Produit
# from django.views.decorators.csrf import csrf_exempt
from django.contrib.auth.decorators import login_required

import json

from gestion_produit.views import calcul_stock_produit


def dashboard_quantite_produit():
    """Calculez les quantités des produits en rupture, pré-rupture et normal.

    Returns
    -------
    dict
        Dictionnaire contenant les nombres et les listes des produits par
        catégorie.

    """
    tous_les_produits = Produit.objects.all()

    produit_rupture = []
    produit_pre_rupture = []
    produit_normal = []

    for produit in tous_les_produits:
        stock_actuel = calcul_stock_produit(produit)
        stock_actuel.pop("image")
        if stock_actuel["stockActuel"] == 0:
            produit_rupture.append(stock_actuel)
        elif stock_actuel["stockActuel"] < produit.seuil_pre_rupture:
            produit_pre_rupture.append(stock_actuel)
        else:
            produit_normal.append(stock_actuel)

    return {
        "nombre_rupture": len(produit_rupture),
        "nombre_pre_rupture": len(produit_pre_rupture),
        "nombre_normal": len(produit_normal),
        "produit_rupture": produit_rupture,
        "produit_pre_rupture": produit_pre_rupture,
        "produit_normale": produit_normal,
    }


@login_required(login_url="authentification:login")
def index(request):
    """Retournez la page d'accueil du dashboard.

    Parameters
    ----------
    request : HttpRequest
        La requête HTTP entrante.

    Returns
    -------
    HttpResponse
        La réponse HTTP contenant la page d'accueil du dashboard.

    """
    if request.user.groups.filter(name="Chauffeur").exists():
        return redirect("gestion_vehicule:index")

    if not request.user.groups.filter(name="Administration").exists():
        return redirect("gestion_produit:index")

    commandes_en_cours = Commander.objects.filter(livrer=False)
    demandes_en_cours = Demander.objects.filter(
        valider_par_chef=True, valider_par_logisticien=None
    )

    gestion_quantite_produit = dashboard_quantite_produit()

    nombre_rupture = gestion_quantite_produit["nombre_rupture"]
    nombre_pre_rupture = gestion_quantite_produit["nombre_pre_rupture"]
    nombre_normal = gestion_quantite_produit["nombre_normal"]

    return render(
        request,
        "index.html",
        {
            "nb_commande": len(commandes_en_cours),
            "nb_demande": len(demandes_en_cours),
            "nombre_rupture": nombre_rupture,
            "nombre_pre_rupture": nombre_pre_rupture,
            "nombre_normal": nombre_normal,
        },
    )

@login_required(login_url="login")
def produit_a_rendre(_request):
    """Retournez la liste des équipements à rendre.

    Cette vue est appelée via une requête AJAX et renvoie une liste
    d'équipements qui doivent être rendus.

    Parameters
    ----------
    request : HttpRequest
        La requête HTTP entrante.

    Returns
    -------
    JsonResponse
        Une réponse JSON contenant la liste des équipements à rendre.

    """
    equipement_a_rendre = Demander.objects.filter(a_rendre=True, rendu=False)
    liste_equipement = [
        {
            "id_demande": equipement.id,
            "produit": equipement.produit.libelle,
            "quantite": equipement.quantite,
            "detenteur": (
                f"{equipement.user.user.first_name} "
                f"{equipement.user.user.last_name}"
            ),
            "action": equipement.rendu,
        }
        for equipement in equipement_a_rendre
    ]

    return JsonResponse(liste_equipement, safe=False)

@login_required(login_url="login")
def produit_a_rendre_update(request):
    """Mettez à jour le statut des équipements à rendre.

    Lorsqu'une requête POST est reçue, cette vue met à jour le statut
    des équipements à rendre en fonction des données fournies dans la
    requête.

    Parameters
    ----------
    request : HttpRequest
        request.id_demande : int
            L'identifiant de la demande d'équipement à mettre à jour.
        request.action : bool
            Le nouveau statut de rendu de l'équipement.

    Returns
    -------
    JsonResponse
        Une réponse JSON indiquant le succès de l'opération.

    """
    if request.method == "POST":
        data = json.loads(request.body)
        for d in data:
            demande = Demander.objects.get(id=d["id_demande"])
            demande.rendu = d["action"]
            demande.save()

    return JsonResponse(
        {"status": "success", "message": "Produits mis à jour"}
    )

@login_required(login_url="login")
def liste_produit_rupture(request):
    """Vue pour obtenir la liste des produits en fonction de leur type.

    Cette vue est appelée via une requête AJAX à chaque fois que l'on clique
    sur un cadran (rupture, pré-rupture, en stock normal) et renvoie une liste
    de produits en fonction du type spécifié dans les paramètres de la
    requête.

    Parameters
    ----------
    request : HttpRequest
        request.type : str
            Le statut de produits à récupérer qui sont en "rupture",
            "pre_rupture" ou "normal".

    Returns
    -------
    JsonResponse
        Une réponse JSON contenant la liste des produits correspondant
        au type spécifié.

    """
    type_encadrer = request.GET["type"]
    dashboard_gestion = dashboard_quantite_produit()

    donnees_charger = []

    if type_encadrer == "rupture":
        donnees_charger = dashboard_gestion["produit_rupture"]
    elif type_encadrer == "pre_rupture":
        donnees_charger = dashboard_gestion["produit_pre_rupture"]
    elif type_encadrer == "normal":
        donnees_charger = dashboard_gestion["produit_normale"]

    return JsonResponse(donnees_charger, safe=False)

@login_required(login_url="login")
def liste_produit_commander(request):
    """Listez des produits commandés non encore livrés.

    Parameters
    ----------
    request : HttpRequest
        La requête HTTP entrante.

    Returns
    -------
    JsonResponse
        Une réponse JSON contenant la liste des produits commandés
        non encore livrés.

    """
    commandes_en_cours = Commander.objects.filter(livrer=False)
    ma_liste_commandes = [
        {
            "id_commande": commande.id,
            "produit": commande.produit.libelle,
            "quantite": commande.quantite_commander,
            "date_commande": commande.date_commande,
            "date_livraison": commande.date_livraison,
            "fournisseur": commande.fournisseur.nom_entreprise,
            "is_logisticien": (
                request.user.profile.departement.
                nom_departement == "Logistique"
            ),
        }
        for commande in commandes_en_cours
    ]

    return JsonResponse(ma_liste_commandes, safe=False)


@login_required(login_url="login")
def enregistrer_livraison_produit(request):
    """Enregistrez la livraison d'un produit commandé.

    Lorsqu'une requête POST est reçue, cette vue met à jour le statut
    de livraison du produit commandé en fonction de l'identifiant de la
    commande fourni dans la requête.

    Parameters
    ----------
    request : HttpRequest
        request.id_commande : int
            L'identifiant de la commande dont la livraison doit
            être enregistrée.

    Returns
    -------
    JsonResponse
        Une réponse JSON indiquant le succès ou l'échec de l'opération.

    """
    if request.method == "POST":
        id_commande = request.POST.get("id_commande")
        try:
            commande = Commander.objects.get(id=id_commande)
            commande.livrer = True
            commande.save()
            return JsonResponse(
                {
                    "status": "success",
                    "message": "Livraison enregistrée avec succès."
                }
            )
        except Commander.DoesNotExist:
            return JsonResponse(
                {"status": "error", "message": "Commande non trouvée."}
            )
    return JsonResponse(
        {"status": "error", "message": "Méthode non autorisée."}
    )


@login_required(login_url="login")
def liste_demandes(request):
    """Listez des demandes en cours de validation.

    Parameters
    ----------
    request : HttpRequest
        La requête HTTP entrante.

    Returns
    -------
    JsonResponse
        Une réponse JSON contenant la liste des demandes en cours
        de validation.

    """
    demandes_en_cours = Demander.objects.filter(
        valider_par_chef=True, valider_par_logisticien=None
    )
    is_logisticien = (
        request.user.profile.departement.nom_departement == "Logistique"
    )
    ma_liste_demandes = [
        {
            "id_demande": demande.id,
            "demandeur": (
                f"{demande.user.user.first_name} "
                f"{demande.user.user.last_name}"
            ),
            "produit": demande.produit.libelle,
            "quantite": demande.quantite,
            "motifs": demande.motifs,
            "date_de_mise_a_dispo_souhaite": (
                demande.date_de_mise_a_dispo_souhaite
                .strftime("%Y-%m-%d")
            ),
            "a_rendre": demande.a_rendre,
            "valider_par_chef": demande.valider_par_chef,
            "valider_par_logisticien": demande.valider_par_logisticien,
            "is_logisticien": is_logisticien,
        }
        for demande in demandes_en_cours
    ]

    return JsonResponse(ma_liste_demandes, safe=False)
