import csv

from django.contrib.auth.hashers import make_password
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from BasicData.models import *
from BasicData.templatetags.custom_tag_obj import get_ecue_etudiant, get_ue_by_ufr_simple, get_ue_by_ufr_set_all, \
    get_etudiant_list, get_ecue_by_ufr_simple, get_ue_by_ufr_simple2
from EspaceEtudiant.forms import EtudiantSeanceForm
from .forms import *
from django.contrib.auth import update_session_auth_hash
from django.contrib.auth.forms import PasswordChangeForm
from django.contrib import messages
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from BasicData.custom_fonctions import *
from BasicData.templatetags.custom_tag import get_new_reclamation, get_ecue_etudiant_session, \
    get_moyenne_annuelle_etudiant, taux_credit_valide_annuel, get_etudiant_by_ue_list


@login_required(login_url='BasicData:login')
def dr_urf_profile(request):
    # ROLE
    user = enseignant = Enseignant.objects.get(email=request.user.email)

    # On recupere les infos du DR
    annee = Annee.objects.last()
    #drUfr = EnseignantUfr.objects.filter(annee=annee, enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr

    # On recupere tout les enseignant de l'UFR
    enseignantsUfr = [ens.enseignant for ens in EnseignantUfr.objects.filter(annee=annee, ufr=UFR).order_by('enseignant__nom')]

    Pobject = enseignantsUfr


    context = {
        'enseignant': enseignant,
        'annee': annee,
        'user': user,
        'UFR': UFR,
        #'drUfr': drUfr,
        'page_obj': Pobject,
        'UfrAn': [UFR,annee],
        'group_check': group_check(request),
    }
    return render(request, 'dg_ufr/home.html', context)


@login_required(login_url='BasicData:login')
def dr_ufr_classe_list(request):
    # ROLE
    user = enseignant = Enseignant.objects.get(email=request.user.email)

    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr

    Pobject = Niveau.objects.all().order_by('id')


    context = {
        'enseignant': enseignant,
        'user': user,
        'UFR': UFR,
        'page_obj': Pobject,
    }
    return render(request, 'dg_ufr/classe_list.html', context)


@login_required(login_url='BasicData:login')
def dr_ufr_ue(request,id):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    niveau = Niveau.objects.get(id=id)

    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    anUniv = Annee.objects.last()

    UFR = None
    if user:
        UFR = user.ufr

    # ON RECUPERE LES ANNEES ET LES NIVEAUX
    annees = Annee.objects.all().order_by('-id')
    niveaux = Niveau.objects.all()

    # FILTRE FORM
    formFil = PvFilterForm()
    if request.method == 'POST':
        if 'AnneeFilter' in request.POST:
            formFil = PvFilterForm(request.POST)
            if formFil.is_valid():
                cd = formFil.cleaned_data
                anUniv = Annee.objects.get(id=cd.get('annee'))

    #UES = Ue.objects.filter(ufr=UFR, active=True).order_by('libelle')
    UES = get_ue_by_ufr_simple2(UFR.id,[anUniv.id,niveau.id])
    semestres = Semestre.objects.filter(niveau=niveau).order_by('libelle')

    context = {
        'user': user,
        'anUniv': anUniv,
        'UfrAn': [UFR,anUniv],
        'UfrAnId': [UFR.id,anUniv.id],
        'niveau': niveau,
        'UFR': UFR,
        # 'page_obj': Pobject,
        #'form2': form2,
        'UES': UES,
        'group_check': group_check(request),
        'annees': annees,
        'niveaux': niveaux,
        'formFil': formFil,
        'semestres': semestres,
    }
    return render(request, 'dg_ufr/liste_ue.html', context)


@login_required(login_url='BasicData:login')
def dr_ufr_ecue(request,id):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)
    niveau = Niveau.objects.get(id=id)
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################
    ECUE = Ecue.objects.filter(ue__ufr=UFR,active=True,ue__niveau=niveau).order_by('libelle')
    semsestres = Semestre.objects.filter(niveau=niveau).order_by('libelle')


    context = {
        'user': user,
        'UFR': UFR,
        'ECUE': ECUE,
        'semsestres': semsestres,
        'group_check': group_check(request),

    }
    return render(request, 'dg_ufr/liste_ecue.html', context)


@login_required(login_url='BasicData:login')
def dr_ufr_manage_password(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    show_form = 'show'
    if request.method == 'POST':
        form = PasswordChangeForm(request.user, request.POST)
        if form.is_valid():
            user = form.save()
            cd = form.cleaned_data
            an = cd.get('old_password')
            update_session_auth_hash(request, user)  # Important!
            messages.success(request, 'Votre mot de passe a bien été modifié!')
            show_form = 'hide'
        else:
            messages.error(request, 'Verifiez les champs')
    else:
        form = PasswordChangeForm(request.user)
    context = {'user':user,'form': form, 'show_form': show_form,'group_check':group_check(request),}
    return render(request, 'dg_ufr/change_password.html', context)


@login_required(login_url='login')
def dr_ufr_profile_infos(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    enseignant = Enseignant.objects.get(email=request.user.email)
    context = {'user':user,'enseignant': enseignant,'group_check':group_check(request),}
    return render(request, 'dg_ufr/infos_perso.html', context)


@login_required(login_url='BasicData:login')
def add_ecue(request, id):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    annee = Annee.objects.last()
    #drUfr = EnseignantUfr.objects.filter(annee=annee, enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################

    # On recupere les infos de l'enseignant
    enseignant = Enseignant.objects.get(id=id)
    # On recupere les Ecue de l'UFR et les Années
    #Ecues = Ecue.objects.filter(ue__ufr=UFR,active=True).order_by('libelle')
    Ecues = get_ecue_by_ufr_simple(UFR.id,annee.id)
    annees = Annee.objects.all().order_by('-id')

    # Traitement du formulaire
    show_form = 'show'
    form = AddEcueForm()
    if request.method == 'POST':
        form = AddEcueForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            ecue = cd.get('ecue')
            annee = cd.get('annee')

            if ecue == 'choose':
                messages.error(request, "Choisissez une ECUE valide svp!")
            else:
                is_ensEcue = EnseignantUe.objects.filter(enseignant=Enseignant.objects.get(id=id),
                                                         ecue=Ecue.objects.get(id=ecue),
                                                         annee=Annee.objects.get(id=annee))

                if is_ensEcue:
                    messages.error(request, "Cet Ecue est déja attribué à cet enseignant en " + str(
                        Annee.objects.get(id=annee).libelle))
                else:
                    # Attribution de l'ECUE à l'enseignant
                    EnseignantUe.objects.create(
                        enseignant=Enseignant.objects.get(id=id),
                        ecue=Ecue.objects.get(id=ecue),
                        annee=Annee.objects.get(id=annee)
                    )
                    show_form = 'hide'
                    messages.success(request, "L'ECUE: << " + str(
                        Ecue.objects.get(id=ecue).libelle.upper()) + " >> a bien été attribué cet Enseignant")
    else:
        form = AddEcueForm()

    context = {
        'user': user,
        'enseignant': enseignant,
        'Ecues': Ecues,
        'annees': annees,
        'show_form': show_form,
        'form': form,
        'group_check': group_check(request),
    }
    return render(request, 'dg_ufr/add_ecue.html', context)


@login_required(login_url='BasicData:login')
def dr_ufr_enseignant_infos(request, id):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    # On recupere tout les infos de l'enseignant
    enseignant = Enseignant.objects.get(id=id)

    # ECUEs = Ecue.objects.filter(ue__ufr=UFR)
    EnseignantUes = EnseignantUe.objects.filter(enseignant=enseignant,annee=Annee.objects.last()).order_by('-annee')

    # pagination
    page = request.GET.get('page', 1)
    paginator = Paginator(EnseignantUes, 15)
    try:
        Pobject = paginator.page(page)
    except PageNotAnInteger:
        Pobject = paginator.page(1)
    except EmptyPage:
        Pobject = paginator.page(paginator.num_pages)

    context = {
        'user': user,
        'enseignant': enseignant,
        'page_obj': Pobject,
        'group_check': group_check(request),

    }
    return render(request, 'dg_ufr/enseignant_infos.html', context)


@login_required(login_url='BasicData:login')
def emploi_du_temps_list(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    ############ new Enseignant Ufr ############
   # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################
    niveaux = Niveau.objects.all()
    salles = Salle.objects.all()

    validites = Validite.objects.filter(done=False).order_by('dateDebut')
    validite = Validite.objects.filter(done=False).order_by('dateDebut').first()

    SDM1 = []
    TES2 = []
    ARHAI3 = []
    MPSI4 = []
    CPGE5 = []
    for ufrec in Ufr.objects.all():
        ecues_ufr = Ecue.objects.filter(ue__ufr=ufrec, active=True)
        #ecues_ufr = get_ue_by_ufr_simple(ufrec.id, annee.id)

        for ecu in ecues_ufr:
            if ufrec.id == 1:
                SDM1.append(ecu.code)
            elif ufrec.id == 2:
                TES2.append(ecu.code)
            elif ufrec.id == 3:
                ARHAI3.append(ecu.code)
            elif ufrec.id == 4:
                MPSI4.append(ecu.code)
            else:
                pass

    # FORMULAIRE POUR RECUPERER LA PERIODE SELECTIONNEE
    niveau_data_zip = []
    form = ChoosePeriodeForm()
    if request.method == 'POST' and 'FilterBtn' in request.POST:
        form = ChoosePeriodeForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            periode = cd.get('periode')

            if 'aucun' == periode:
                messages.error(request, 'Veuilliez sélectionner une période valide')
            else:
                validite = Validite.objects.get(id=periode)

    # ADD SALLE
    form2 = AddSalleForm2()
    if request.method == 'POST':
        if 'addSalleBtn' in request.POST:
            form2 = AddSalleForm2(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                salle = cd.get('salle')
                PJour = cd.get('jour')
                PrID = cd.get('Progid')
                prog = EmploiDuTemps2.objects.get(id=PrID)
                Sal = Salle.objects.get(id=salle)
                if PJour == 'lun':
                    prog.salle_lun = Sal
                elif PJour == 'mar':
                    prog.salle_mar = Sal
                elif PJour == 'mer':
                    prog.salle_mer = Sal
                elif PJour == 'jeu':
                    prog.salle_jeu = Sal
                elif PJour == 'ven':
                    prog.salle_ven = Sal
                elif PJour == 'sam':
                    prog.salle_sam = Sal
                else:
                    pass
                prog.save()

                messages.success(request, 'Salle attribuée avec succès')
                return redirect('/enseignant/rp_programme/')

            else:
                messages.error(request, 'Vérifiez les champs')

    # on rcupere les programme par niveaux
    progNivx = []
    progNivx2 = []
    p_lundi_m = []
    p_lundi_s = []
    p_mardi_m = []
    p_mardi_s = []
    p_mercredi_m = []
    p_mercredi_s = []
    p_jeudi_m = []
    p_jeudi_s = []
    p_vendredi_m = []
    p_vendredi_s = []
    p_samedi_m = []
    p_samedi_s = []
    # for niveau in niveaux:
    progByNiveau = EmploiDuTemps2.objects.filter(validite=validite,ecue__ue__ufr=UFR,activated=True)
    # print(progByNiveau)
    if progByNiveau:
        # progNivx.append(niveau)
        # progNivx2.append(progByNiveau)
        for pro in progByNiveau:

            if pro.lundi != '':
                debut_cours = get_horaire_split(pro.lundi, 'debut')
                if debut_cours <= 12:
                    p_lundi_m.append(pro)
                else:
                    p_lundi_s.append(pro)

            if pro.mardi != '':
                debut_cours = get_horaire_split(pro.mardi, 'debut')
                if debut_cours <= 12:
                    p_mardi_m.append(pro)
                else:
                    p_mardi_s.append(pro)

            if pro.mercredi != '':
                debut_cours = get_horaire_split(pro.mercredi, 'debut')
                if debut_cours <= 12:
                    p_mercredi_m.append(pro)
                else:
                    p_mercredi_s.append(pro)

            if pro.jeudi != '':
                debut_cours = get_horaire_split(pro.jeudi, 'debut')
                if debut_cours <= 12:
                    p_jeudi_m.append(pro)
                else:
                    p_jeudi_s.append(pro)

            if pro.vendredi != '':
                debut_cours = get_horaire_split(pro.vendredi, 'debut')
                if debut_cours <= 12:
                    p_vendredi_m.append(pro)
                else:
                    p_vendredi_s.append(pro)

            if pro.samedi != '':
                debut_cours = get_horaire_split(pro.samedi, 'debut')
                if debut_cours <= 12:
                    p_samedi_m.append(pro)
                else:
                    p_samedi_s.append(pro)
    else:
        pass

    # niveau_data_zip = zip(progNivx, progNivx2)

    context = {
        'user': user,
        'group_check': group_check(request),
        # 'ecues': ecues,
        'niveaux': niveaux,
        'salles': salles,
        'form2': form2,
        # 'ecue_data': ecue_data,
        'ndzip': niveau_data_zip,
        'validite': validite,
        'validites': validites,
        'form': form,
        'p_lundi_m': p_lundi_m, 'p_lundi_s': p_lundi_s,
        'p_mardi_m': p_mardi_m, 'p_mardi_s': p_mardi_s,
        'p_mercredi_m': p_mercredi_m, 'p_mercredi_s': p_mercredi_s,
        'p_jeudi_m': p_jeudi_m, 'p_jeudi_s': p_jeudi_s,
        'p_vendredi_m': p_vendredi_m, 'p_vendredi_s': p_vendredi_s,
        'p_samedi_m': p_samedi_m, 'p_samedi_s': p_samedi_s,
        'SDM1': SDM1, 'TES2': TES2, 'ARHAI3': ARHAI3, 'MPSI4': MPSI4,
    }
    return render(request, 'dg_ufr/emploi_du_temps_list.html', context)


@login_required(login_url='BasicData:login')
def emploi_du_temps_add(request, id):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    show_form = 'show'
    validite = None
    # ON RECUPERE L'ECUE
    ecue1 = Ecue.objects.get(id=id)
    annee = Annee.objects.last()
    annees = Annee.objects.all().order_by('-id')
    niveaux = Niveau.objects.all().order_by('id')

    # ON RECUPERE L'UFR
    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    annee = Annee.objects.last()
    #drUfr = EnseignantUfr.objects.filter(annee=annee, enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################

    # ON RECUPERE L'ENSEIGNANT QUI GERE CETTE ECUE CETTE ANNEE
    EnseignantEcue = EnseignantUe.objects.filter(ecue=ecue1, annee=annee).last()

    # ON RECUPERE LA VALIDITE EN COURS
    validites = Validite.objects.filter(done=False).order_by('-id')


    # TRAITEMENT DU FORMULAIRE
    form = ProgramEcueForm()
    if request.method == 'POST':
        form = ProgramEcueForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            ecue = cd.get('ecue')
            niveau = cd.get('niveau')
            #enseignant = cd.get('enseignant')
            annee = cd.get('annee')
            periode = cd.get('periode')

            lundi = cd.get('lundi')
            mardi = cd.get('mardi')
            mercredi = cd.get('mercredi')
            jeudi = cd.get('jeudi')
            vendredi = cd.get('vendredi')
            samedi = cd.get('samedi')

            type_lun = cd.get('type_lun')
            type_mar = cd.get('type_mar')
            type_mer = cd.get('type_mer')
            type_jeu = cd.get('type_jeu')
            type_ven = cd.get('type_ven')
            type_sam = cd.get('type_sam')


            mode_lun = cd.get('mode_lun')
            mode_mar = cd.get('mode_mar')
            mode_mer = cd.get('mode_mer')
            mode_jeu = cd.get('mode_jeu')
            mode_ven = cd.get('mode_ven')
            mode_sam = cd.get('mode_sam')

            url_lun = cd.get('url_lun')
            url_mar = cd.get('url_mar')
            url_mer = cd.get('url_mer')
            url_jeu = cd.get('url_jeu')
            url_ven = cd.get('url_ven')
            url_sam = cd.get('url_sam')


            EmploiDuTemps2.objects.create(
                ecue=Ecue.objects.get(id=ecue),
                niveau=Niveau.objects.get(id=niveau),
                enseignants=Enseignant.objects.get(email=request.user.email),
                annee=Annee.objects.last(),
                validite=Validite.objects.get(id=periode),
                lundi=lundi,
                mardi=mardi,
                mercredi=mercredi,
                jeudi=jeudi,
                vendredi=vendredi,
                samedi=samedi,
                type_lun=type_lun,
                type_mar=type_mar,
                type_mer=type_mer,
                type_jeu=type_jeu,
                type_ven=type_ven,
                type_sam=type_sam,
                mode_lun=mode_lun,
                mode_mar=mode_mar,
                mode_mer=mode_mer,
                mode_jeu=mode_jeu,
                mode_ven=mode_ven,
                mode_sam=mode_sam,
                url_lun=url_lun,
                url_mar=url_mar,
                url_mer=url_mer,
                url_jeu=url_jeu,
                url_ven=url_ven,
                url_sam=url_sam,

                salle=Salle.objects.get(id=1)

            )
            #show_form = 'hide'
            messages.success(request, 'Ecue programmée avec succès')

        else:
            messages.error(request, 'Vérifiez les champs svp!')
            messages.error(request, form.errors)


    context = {
        'user': user,
        'show_form': show_form,
        'EnseignantEcue': EnseignantEcue,
        #'Enseignants': Enseignants,
        'ecue': ecue1,
        'annees': annees,
        'niveaux': niveaux,
        'form': form,
        'validites': validites,
        'group_check': group_check(request),
    }
    return render(request, 'dg_ufr/programme_ecue.html', context)


@login_required(login_url='BasicData:login')
def stop_programme(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)
    # ON RECUPERE TOUTE LES UFR ET LES NIVEAUX
    UFRS = Ufr.objects.all()
    niveaux = Niveau.objects.all()
    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    annee = Annee.objects.last()
    #drUfr = EnseignantUfr.objects.filter(annee=annee, enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################
    user_ufr = UFR

    # ON RECUPERE LA VALIDITE EN COURS
    validites = Validite.objects.filter(done=False)
    validite = None

    ufr = None
    niveau = None
    programmes_ufr = None
    form = ValiditeUFRFilterForm()
    if request.method == 'POST':
        form = ValiditeUFRFilterForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            ufr = cd.get('ufr')
            niveau = cd.get('niveau')
            periode = cd.get('periode')

            if 'aucun' == periode:
                messages.error(request,'Veuilliez sélectionner une période valide')
            else:
                validite = Validite.objects.get(id=periode)

            # ON RECUPERE LE PROGRAMME EN COURS DE L'UFR PAR NIVEAU
            if niveau != '0000':
                programmes_ufr = EmploiDuTemps2.objects.filter(validite=validite, ecue__ue__ufr=user_ufr,
                                                               niveau=Niveau.objects.get(id=niveau),activated=True)

    context = {
        'form': form,
        'user': user,
        'UFRS': UFRS,
        'niveaux': niveaux,
        'validite': validite,
        'validites': validites,
        'programmes': programmes_ufr,
        'ufr': user_ufr,
        'niveau': Niveau.objects.filter(id=niveau).last(),
        'group_check': group_check(request),
    }
    return render(request, 'dg_ufr/stop_programme.html', context)


@login_required(login_url='BasicData:login')
def stop(request, id):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)
    try:
        programme = EmploiDuTemps2.objects.get(id=id)
    except EmploiDuTemps2.DoesNotExist:
        programme = None

    if programme:
        programme.activated = False
        programme.save()
        messages.success(request, 'Ce programme a bien été arrêté')
    else:
        pass

    context = {
        'programme': programme,
        'user': user,
        'group_check': group_check(request),
    }
    return render(request, 'dg_ufr/stop_success.html', context)


@login_required(login_url='BasicData:login')
def edit_programme(request, id):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    show_form = 'show'
    validite = None
    # ON RECUPERE L'ECUE
    ecue1 = EmploiDuTemps2.objects.get(id=id).ecue
    programs = EmploiDuTemps2.objects.get(id=id)
    annee = Annee.objects.last()
    annees = Annee.objects.all().order_by('-id')
    jours = Jour.objects.all().order_by('id')
    niveaux = Niveau.objects.all().order_by('id')

    # ON RECUPERE L'UFR
    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    annee = Annee.objects.last()
    drUfr = EnseignantUfr.objects.filter(annee=annee, enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################

    # ON RECUPERE L'ENSEIGNANT QUI GERE CETTE ECUE CETTE ANNEE
    EnseignantEcue = EnseignantUe.objects.filter(ecue=ecue1, annee=annee).last()

    # ON RECUPERE LES ENSEIGNANTS DE L'UFR
    Enseignants = Enseignant.objects.filter(ufr=UFR)

    # ON RECUPERE LA VALIDITE EN COURS
    validites = Validite.objects.filter(done=False).order_by('-id')

    # TRAITEMENT DU FORMULAIRE
    form = ProgramEcueForm()
    if request.method == 'POST':
        form = ProgramEcueForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            ecue = cd.get('ecue')
            niveau = cd.get('niveau')
            #enseignant = cd.get('enseignant')
            annee = cd.get('annee')
            periode = cd.get('periode')

            lundi = cd.get('lundi')
            mardi = cd.get('mardi')
            mercredi = cd.get('mercredi')
            jeudi = cd.get('jeudi')
            vendredi = cd.get('vendredi')
            samedi = cd.get('samedi')

            type_lun = cd.get('type_lun')
            type_mar = cd.get('type_mar')
            type_mer = cd.get('type_mer')
            type_jeu = cd.get('type_jeu')
            type_ven = cd.get('type_ven')
            type_sam = cd.get('type_sam')

            mode_lun = cd.get('mode_lun')
            mode_mar = cd.get('mode_mar')
            mode_mer = cd.get('mode_mer')
            mode_jeu = cd.get('mode_jeu')
            mode_ven = cd.get('mode_ven')
            mode_sam = cd.get('mode_sam')

            url_lun = cd.get('url_lun')
            url_mar = cd.get('url_mar')
            url_mer = cd.get('url_mer')
            url_jeu = cd.get('url_jeu')
            url_ven = cd.get('url_ven')
            url_sam = cd.get('url_sam')

            # ENREGISTREMENT DE L'EMPLOI DU TEMPS


            programs.niveau = Niveau.objects.get(id=niveau)
            #programs.enseignant = Enseignant.objects.get(email=request.user.email)
            programs.lundi = lundi
            programs.mardi = mardi
            programs.mercredi = mercredi
            programs.jeudi = jeudi
            programs.vendredi = vendredi
            programs.samedi = samedi

            programs.type_lun = type_lun
            programs.type_mar = type_mar
            programs.type_mer = type_mer
            programs.type_jeu = type_jeu
            programs.type_ven = type_ven
            programs.type_sam = type_sam

            programs.mode_lun = mode_lun
            programs.mode_mar = mode_mar
            programs.mode_mer = mode_mer
            programs.mode_jeu = mode_jeu
            programs.mode_ven = mode_ven
            programs.mode_sam = mode_sam


            programs.save()

            show_form = 'hide'
            messages.success(request, 'Programme modifié  avec succès')
            return redirect('/enseignant/stop_programme/')
        else:
            messages.error(request, 'Vérifiez les champs svp!')
            messages.error(request, form.errors)

    context = {
        'user': user,
        'show_form': show_form,
        'EnseignantEcue': EnseignantEcue,
        'Enseignants': Enseignants,
        'ecue': ecue1,
        'annees': annees,
        'jours': jours,
        'niveaux': niveaux,
        'form': form,
        'validites': validites,
        'programs': programs,
        'group_check': group_check(request),
    }
    return render(request, 'dg_ufr/programme_ecue_edit.html', context)


@login_required(login_url='BasicData:login')
def periode_list(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)
    # LISTE DES PERIODES
    periodes = Validite.objects.filter(done=False).order_by('-id')

    form = AddPeriodeForm()
    if request.method == 'POST':
        form = AddPeriodeForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            debut = cd.get('dateDebut')
            fin = cd.get('dateFin')

            # ON S'ASSURE QUE dateDebut < dateFin
            if debut > fin:
                temp = debut
                debut = fin
                fin = temp
            else:
                pass

            # ON ENREGISTRE LA PERIODE DE VALIDITE
            form.save()
            messages.success(request,'Période enregistrée avec succès')
        else:
            messages.error(request,'Vérifiez les champs svp!')

    context={
        'periodes':periodes,
        'form':form,
        'user':user,
        'group_check': group_check(request),
    }
    return render(request, 'dg_ufr/periode_list.html', context)


@login_required(login_url='BasicData:login')
def dr_ufr_etudiant_ecue_note(request, id):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    ecue = Ecue.objects.get(id=id)
    enseignant = Enseignant.objects.get(email=request.user.email)
    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    annee = Annee.objects.last()
    drUfr = EnseignantUfr.objects.filter(annee=annee, enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################
    etud_nce_ufr = []
    etuds_ufr = []
    etuds_notes = []
    evaluations = []
    etudiants = EtudiantUe.objects.filter(parcoursSemestreUe__ue__ufr=UFR)
    for etudiant in etudiants:
        if etudiant.etudiant.nce in etud_nce_ufr:
            pass
        else:
            etud_nce_ufr.append(etudiant.etudiant.nce)

    for etud in etud_nce_ufr:
        etuds_ufr.append(Etudiant.objects.get(nce=etud))
        notes = Note.objects.filter(annee=Annee.objects.last(),etudiant__nce=etud,ecue=ecue)
        etuds_notes.append(notes)
        for note in notes:
            if note.evaluation.libelle in evaluations:
                pass
            else:
                evaluations.append(note.evaluation.libelle)

    zip_datas = zip(etuds_ufr,etuds_notes)

    context = {
        'user': user,
        'etudiants_notes_zip': zip_datas,
        'evaluations': evaluations,
    }
    return render(request, 'dg_ufr/etudiant_ecue_note.html', context)


@login_required(login_url='BasicData:login')
def dr_ufr_ue_home(request,id,an,niveau,ufr):
    # ON RECUPERE LES PARAMETRES
    get_annee = Annee.objects.get(id=an)
    get_niveau = Niveau.objects.get(id=niveau)
    get_ufr = Ufr.objects.get(id=ufr)

    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    # ON RECUPERE L'UE
    UE = Ue.objects.get(id=id)

    # ON RECUPERE LES ECUES DE L'UE
    ECUES = Ecue.objects.filter(ue=UE)

    # On recupere l'enseignant
    enseignant = Enseignant.objects.get(email=request.user.email)
    # On recupere les UE de l'Enseignant
    EnseignantUes = EnseignantUe.objects.filter(enseignant=enseignant)

    annee_univ = Annee.objects.last()

    try:
        delib = DeliberationUe.objects.get(ue=UE,annee=get_annee,session=Session.objects.get(id=1))
    except DeliberationUe.DoesNotExist:
        delib =None


    # =================== DELIBERATION =================
    form2 = DeliberationsUeForm()
    if request.method == 'POST':
        if 'deliberationue' in request.POST:
            form2 = DeliberationsUeForm(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                session = cd.get('session')
                note = cd.get('note')
                anUniv = cd.get('annee')

                #ON CREE LA DELIBERATION
                DeliberationUe.objects.create(
                    annee=get_annee,
                    ue=UE,
                    session=session,
                    note=note,
                    user = Enseignant.objects.get(email=request.user.email)
                )
                form2 = DeliberationsUeForm()
                messages.success(request, "La délibération pour l'UE (" + UE.code + ") a été créée avec succès")
                return redirect('/enseignant/ue_home/' + str(id) + '/' + str(an) + '/' + str(niveau) + '/' + str(ufr) + '/')
            else:
                messages.error(request, 'Veuillez verifier les champs svp!')
    else:
        form2 = DeliberationsUeForm()

    # =================== DELIBERATION ECUE  =================
    formEc = DeliberationsForm()
    if request.method == 'POST':
        if 'deliberationecue' in request.POST:
            formEc = DeliberationsForm(request.POST)
            if formEc.is_valid():
                cd = formEc.cleaned_data
                session = cd.get('session')
                note = cd.get('note')
                del_ecue = cd.get('ecue')
                del_annee = cd.get('annee')

                # ON CREE LA DELIBERATION
                Deliberation.objects.create(
                    annee=get_annee,
                    ecue=del_ecue,
                    session=session,
                    note=note,
                    user=Enseignant.objects.get(email=request.user.email)
                )
                formEc = DeliberationsForm()
                messages.success(request, "La délibération Ecue (" + '' + ") réussie")
                return redirect('/enseignant/ue_home/'+str(id)+'/'+str(an)+'/'+str(niveau)+'/'+str(ufr)+'/')
            else:
                messages.error(request, 'Veuillez verifier les champs svp!')
                messages.error(request, formEc.errors)

    else:
        formEc = DeliberationsForm()

    context={
        'user': user,
        'enseignant':enseignant,
        'EnseignantUes':EnseignantUes,
        'Ue':UE,
        'Ecues':ECUES,
        'form2':form2,
        'formEc':formEc,
        'delib':delib,
        'get_annee':get_annee,
        'get_niveau':get_niveau,
        'get_ufr':get_ufr,
        'annees':Annee.objects.all().order_by('-id')
    }
    return render(request,'dg_ufr/ue_home.html',context)


@login_required(login_url='BasicData:login')
def ecue_note_views(request, id,an,niveau,ufr):
    # ON RECUPERE LES PARAMETRES
    get_annee = Annee.objects.get(id=an)
    get_niveau = Niveau.objects.get(id=niveau)
    get_ufr = Ufr.objects.get(id=ufr)

    # ROLE
    user = enseign = Enseignant.objects.get(email=request.user.email)
    annee = Annee.objects.get(id=an)

    # On recupere les infos UE de l'Ecue
    ue = Ecue.objects.get(id=id).ue
    ecue = Ecue.objects.get(id=id)

    # PARAMETRE POUR LE FILTRE
    args = [annee.id, ue.ufr.id, ue.niveau.id, ecue.id]

    # PAR DEFAUT
    etudiantUes = get_etudiant_by_ue_list([annee,ue])
    session_ini = session = Session.objects.get(id=1)

    SFForm = AnneeFilterForm(request.POST)
    if request.method == 'POST':
        if 'sessionFilter' in request.POST:
            SFForm = AnneeFilterForm(request.POST)
            if SFForm.is_valid():
                cd = SFForm.cleaned_data
                SF = int(cd.get('libelle'))

                if SF == 1:
                    etudiantUes = get_etudiant_by_ue_list([annee, ue])
                else:
                    etudiantUes = get_ecue_etudiant_session(args)

                session_ini = session = Session.objects.get(id=SF)

    # ON recupere la derniere Année
    annee_univ = Annee.objects.last()

    # On recupere les types d'évaluation et les Sessions
    TypeEvaluations = TypeEvaluation.objects.all()
    Sessions = Session.objects.all()

    # On recupere toute les Evaluation de l'Ecue
    Evaluation_enseignant = Evaluation.objects.filter(ecue=ecue, annee=annee, session=session_ini)
    EvalAnZip = list(zip(Evaluation_enseignant, [annee for EV in Evaluation_enseignant],
                         [session_ini for EV in Evaluation_enseignant]))


    # ON RECUPERE LA DELIBERATION DE L'ECUE
    # On initialise la session a 1
    try:
        delib_ecue = Deliberation.objects.filter(annee=annee, ecue=ecue, session=session_ini).last()
    except Deliberation.DoesNotExist:
        delib_ecue = None

    # =================== DELIBERATION =================
    form2 = DeliberationsForm()
    if request.method == 'POST':
        if 'deliberation' in request.POST:
            form2 = DeliberationsForm(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                session = cd.get('session')
                note = cd.get('note')
                anUniv = cd.get('annee')

                # ON CREE LA DELIBERATION
                Deliberation.objects.create(
                    annee=Annee.objects.get(id=anUniv.id),
                    ecue=ecue,
                    session=session,
                    note=note,
                    user=Enseignant.objects.get(email=request.user.email)
                )
                form2 = DeliberationsForm()
                messages.success(request, "La délibération pour l'ECUE (" + ecue.code + ") pour "+str(session)+" a été créée avec succès")
                return redirect('/enseignant/ecue_note_views/'+str(id)+'/'+str(an)+'/'+str(niveau)+'/'+str(ufr)+'/')
            else:
                messages.error(request, 'Veuillez verifier les champs svp!')
    else:
        form2 = DeliberationsForm()

    context = {
        'user': user,
        'ue': ue,
        'args': args,
        #'parcourSemestreUe': parcourSemestreUe,
        'etudiantUes': etudiantUes,
        'TypeEvaluations': TypeEvaluations,
        'Sessions': Sessions,
        'form2': form2,
        'EvalEns': Evaluation_enseignant,
        'enseign': enseign,
        'enseignant': Enseignant.objects.get(email=request.user.email),
        'id_ecue': id,
        'id_ecue2': [id, annee, session_ini],
        'ecue': ecue,
        'delib_ecue': delib_ecue,
        'get_annee': get_annee,
        'get_niveau': get_niveau,
        'get_ufr': get_ufr,
        'EvalAnZip': EvalAnZip,
        'session_ini': session_ini,
        #'id_ecue2': [id, get_annee],

    }
    return render(request, 'dg_ufr/ecue_note_view.html', context)


@login_required(login_url='BasicData:login')
def pv_home(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    # On recupere l'enseignant
    enseignant = Enseignant.objects.get(email=request.user.email)

    # ON RECUPERE L'UFR
    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    annee = Annee.objects.last()
    #drUfr = EnseignantUfr.objects.filter(annee=annee, enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################

    # ON RECUPERE LES ANNEES/NIVEAUX/SEMESTRES
    annees = Annee.objects.all().order_by('-id')
    niveaux = Niveau.objects.all()
    semestres = Semestre.objects.all()

    # ON RECUPERE LES DONNEES DU FORMULAIRE
    get_annee = []
    get_niveau = []
    get_semestre = []
    form = PvFilterForm()
    if request.method == 'POST':
        form = PvFilterForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            annee = cd.get('annee')
            niveau = cd.get('niveau')
            semestre = cd.get('semestre')

            # ON RECUPERE LES INFOS
            get_annee = Annee.objects.get(id=annee)
            get_niveau = Niveau.objects.get(id=niveau)
            get_semestre = Semestre.objects.get(id=semestre)

    context = {
        'user': user,
        'form':form,
        'annees':annees,
        'UFR':UFR,
        'niveaux':niveaux,
        'semestres':semestres,
        'get_annee':get_annee,
        'get_niveau':get_niveau,
        'get_semestre':get_semestre,
    }
    return render(request,'dg_ufr/pv_home.html',context)


@login_required(login_url='BasicData:login')
def dr_reclamation_list(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    # ON RECUPERE LES RECLAMATIONS GRACE A LA FONCTION QUI PERMET DE LES COMPTER
    # ON RECUPERE LES UFRS
    ufrList = []
    for ufr in EnseignantUfr.objects.filter(enseignant=user):
        ufrList.append(ufr.ufr)
    form = DecArchiveForm()
    if request.method == 'POST':
        form = DecArchiveForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            idr = cd.get('idr')
            reclamation = Reclamations.objects.get(id=idr)
            reclamation.archive = True
            reclamation.save()
            messages.success(request,'La réclamation à bien été archivée!')

    # ON RECUPERE LES RECLAMATIONS DE L'UFR
    reclamations = Reclamations.objects.filter(ufr__in=ufrList, archive=False).order_by('-id')

    #print(reclamations)
    context={
        'reclamations':reclamations,
        'user':user,
    }
    return render(request,'dg_ufr/reclamations_list.html',context)


@login_required(login_url='BasicData:login')
def dr_reclamation_detail(request,id):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    # ON RECUPERE LA RECLAMATION
    reclamation = Reclamations.objects.get(id=id)
    reclamation.reception = True
    reclamation.save()

    try:
        topic = Ue.objects.get(code=reclamation.code_discipline)
    except Ue.DoesNotExist:
        try:
            topic = Ecue.objects.get(code=reclamation.code_discipline)
        except Ecue.DoesNotExist:
            topic = 'UE ou Ecue inconnu'

    if request.method == 'POST':
        if 'rec' in request.POST: # RECEVABLE
            reclamation.status = 'Recevable'
            reclamation.save()
            messages.success(request,'Réclamation évaluée Recevable')
            return redirect('EspaceEnseignant:dr_reclamation_list')
        elif 'nrec' in request.POST:
            reclamation.status = 'Non-recevable'
            reclamation.save()
            messages.success(request, 'Réclamation évaluée Non-recevable')
            return redirect('EspaceEnseignant:dr_reclamation_list')

    context={
        'user':user,
        'reclamation':reclamation,
        'topic':topic,
    }
    return render(request,'dg_ufr/reclamations_detail.html',context)


@login_required(login_url='BasicData:login')
def stats_semestre_home(request, annee, niveau, semestre, ufr):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    # ON RECUPERE LES INFOS DES PARAMETRES
    UFR = Ufr.objects.get(id=ufr)
    get_annee = Annee.objects.get(id=annee)
    get_semestre = Semestre.objects.get(id=semestre)
    get_niveau = Niveau.objects.get(id=niveau)

    # GESTION DU NIVEAU
    niveauLib =  get_niveau.libelle.split(' ')[0]

    ues_semestre = []
    ues_semestre = Ue.objects.filter(niveau=get_niveau,semestre=get_semestre,ufr=UFR,active=True).order_by('libelle')

    ues = Ue.objects.filter(ufr=UFR,semestre=get_semestre,niveau=get_niveau,active=True).order_by('libelle')


    form = StatUeFilter()
    ue = None
    ecues =None
    deliberation =None
    if request.method == 'POST':
        form = StatUeFilter(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            ueval = cd.get('ueval')
            ue = Ue.objects.get(id=ueval)

        ecues = Ecue.objects.filter(ue=ue)

        # ON RECUPERE LA DELIBERATION
        deliberation = DeliberationUe.objects.filter(annee=get_annee, ue=ue, session__id=1).last()

    context = {
        'form': form,
        'user': user,
        'ues': ues,
        'get_niveau': get_niveau,
        'get_annee': get_annee,
        'get_semestre': get_semestre,
        'ues_semestre': ues_semestre,
        'UFR': UFR,
        'ue': ue,
        'ecues': ecues,
        'deliberation': deliberation,
    }
    return  render(request,'dg_ufr/stats_semestre_home.html',context)


@login_required(login_url='BasicData:login')
def new_year_update(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    # On recupere les infos du DR
    annee = Annee.objects.last()
    annee_precedente = Annee.objects.all().order_by('-id')[:2]
    if len(annee_precedente) > 1:
        an_prec = annee_precedente[1]
    else:
        an_prec = annee_precedente[0]

    #drUfr = EnseignantUfr.objects.filter(annee=an_prec, enseignant=user).first()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    # On recupere tout les enseignant de l'UFR
    enseignantsUfr = []

    if user:
        UFR = user.ufr

        # ON RECONDUIT LES MEMES ENSEIGNANTS
        enseignantsUfr_prec = EnseignantUfr.objects.filter(annee=an_prec, ufr=UFR).order_by('enseignant__nom')
        for ensUfrprec in enseignantsUfr_prec:
            # On verifie si l'enseignant appartient deja à l'ufr cette année
            if_enseignantsUfr = EnseignantUfr.objects.filter(annee=annee, ufr=UFR, enseignant=ensUfrprec.enseignant).order_by('enseignant__nom')
            if if_enseignantsUfr:
                pass
            else:
                EnseignantUfr.objects.create(annee=annee, enseignant=ensUfrprec.enseignant, ufr=UFR)

            # ON RECUPERE PUIS RECONDUIT LES DE L'ANNEE PRECEDENTE DE L'ENSEIGNANT
            enseignantsUe_prec = EnseignantUe.objects.filter(annee=an_prec, enseignant=ensUfrprec.enseignant).order_by(
                'enseignant__nom')
            for enUe in enseignantsUe_prec:
                if_enseignantsUe_prec = EnseignantUe.objects.filter(annee=annee, enseignant=ensUfrprec.enseignant, ecue=enUe.ecue)
                if if_enseignantsUe_prec:
                    pass
                else:
                    EnseignantUe.objects.create(annee=annee, enseignant=ensUfrprec.enseignant, ecue=enUe.ecue)

        # On recupere tout les enseignant de l'UFR
        enseignantsUfr1 = EnseignantUfr.objects.filter(annee=annee, ufr=UFR).order_by('enseignant__nom')
        for ens in enseignantsUfr1:
            enseignantsUfr.append(ens.enseignant)

        messages.success(request,'La liste des enseignants à bien été mise à jour')
    else:
        UFR = None

    context = {}
    return redirect('/enseignant/ufr_home/')


@login_required(login_url='BasicData:login')
def dr_ufr_seance_home(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    # ON RECUPERE L'UFR/ SES ECUES/ LES NIVEAUX/ LE PROGRAMME
    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    annee = Annee.objects.last()
    #drUfr = EnseignantUfr.objects.filter(annee=annee, enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################

    ufrs = Ufr.objects.all().order_by('code')

    # ON RECUPERE LES ENSEIGNANTS DE L'UFR
    annees = Annee.objects.all().order_by('-id')


    anfil = None
    debut = '1900-01-01'
    fin = '1900-01-01'
    ecue = 'tous'
    ens = 'tous'
    status = 'tous'
    ufr = None
    if user.is_ufr_dg == True:
        seances = SeanceCours.objects.filter(annee=Annee.objects.last(),ecue__ue__ufr=UFR).order_by('-date')
        ecues = Ecue.objects.filter(ue__ufr=UFR, active=True).order_by('ue__semestre__libelle')
        ufrEns = [ens.enseignant for ens in
                  EnseignantUfr.objects.filter(annee=Annee.objects.last(), ufr=UFR).order_by('enseignant__nom')]
    else:
        seances = SeanceCours.objects.filter(annee=Annee.objects.last()).order_by('-date')[:100]
        ecues = Ecue.objects.filter(active=True).order_by('ue__ufr__code')
        ufrEns = [ens.enseignant for ens in
                  EnseignantUfr.objects.filter(annee=Annee.objects.last()).order_by('enseignant__nom')]

    form = EtudiantSeanceForm(request.POST)
    formF = SeanceFilterForm2(request.POST)
    if request.method == 'POST':
        if 'seancefilter' in request.POST:
            formF = SeanceFilterForm2(request.POST)
            if formF.is_valid():
                cd = formF.cleaned_data
                anfil = Annee.objects.get(id=cd.get('annee'))
                ens = cd.get('enseignant')
                debut = cd.get('debut')
                fin = cd.get('fin')
                ecue = cd.get('ecue')
                ufr = cd.get('ufr')
                status = cd.get('status')
                if debut > fin:
                    temp = debut
                    debut = fin
                    fin = temp

                # SI C'EST UN DIRENCTEUR D'UFR
                if user.is_ufr_dg == True:
                    ufr = UFR
                    ens = ens
                else:
                    ufr = Ufr.objects.get(id=ufr)

                    # ON RECUPERE L'ENSEIGNANT PAR LE CODE ENTRE
                    ens_get = Enseignant.objects.filter(email=ens).last()
                    if ens_get:
                        ens = ens_get.id
                    else:
                        ens = 'tous'

                # ON RECUPERE L'ECUE PAR LE CODE ENTRE
                ecue_get = Ecue.objects.filter(code=ecue).last()
                if ecue_get:
                    ecue = ecue_get.id
                else:
                    ecue = 'tous'



                if ecue == 'tous' and ens == 'tous' and status == 'tous':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr, date__gte=debut,
                                                         date__lte=fin).order_by('-date')

                elif ecue == 'tous' and ens != 'tous' and status == 'tous':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr,
                                                         enseignant=Enseignant.objects.get(id=ens), date__gte=debut,
                                                         date__lte=fin).order_by('-date')

                elif ecue != 'tous' and ens == 'tous' and status == 'tous':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr, ecue=Ecue.objects.get(id=ecue),
                                                         date__gte=debut,
                                                         date__lte=fin).order_by('-date')

                elif ecue == 'tous' and ens == 'tous' and status == 'en attente':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr, date__gte=debut, date__lte=fin,
                                                         admin_valid=False).order_by(
                        '-date')

                elif ecue == 'tous' and ens == 'tous' and status == 'validé':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr, date__gte=debut, date__lte=fin,
                                                         admin_valid=True).order_by(
                        '-date')

                elif ecue == 'tous' and ens != 'tous' and status == 'en attente':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr,
                                                         enseignant=Enseignant.objects.get(id=ens), date__gte=debut,
                                                         date__lte=fin, admin_valid=False).order_by('-date')

                elif ecue == 'tous' and ens != 'tous' and status == 'validé':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr,
                                                         enseignant=Enseignant.objects.get(id=ens), date__gte=debut,
                                                         date__lte=fin, admin_valid=True).order_by('-date')

                elif ecue != 'tous' and ens == 'tous' and status == 'en attente':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr, ecue=Ecue.objects.get(id=ecue),
                                                         date__gte=debut, date__lte=fin,
                                                         admin_valid=False).order_by('-date')

                elif ecue != 'tous' and ens == 'tous' and status == 'validé':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr, ecue=Ecue.objects.get(id=ecue),
                                                         date__gte=debut, date__lte=fin,
                                                         admin_valid=True).order_by('-date')

                elif ecue != 'tous' and ens != 'tous' and status == 'tous':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr, ecue=Ecue.objects.get(id=ecue),
                                                         enseignant=Enseignant.objects.get(id=ens), date__gte=debut,
                                                         date__lte=fin).order_by('-date')

                elif ecue != 'tous' and ens != 'tous' and status == 'en attente':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr, ecue=Ecue.objects.get(id=ecue),
                                                         enseignant=Enseignant.objects.get(id=ens), date__gte=debut,
                                                         date__lte=fin, admin_valid=False).order_by('-date')

                elif ecue != 'tous' and ens != 'tous' and status == 'validé':
                    seances = SeanceCours.objects.filter(ecue__ue__ufr=ufr, ecue=Ecue.objects.get(id=ecue),
                                                         enseignant=Enseignant.objects.get(id=ens), date__gte=debut,
                                                         date__lte=fin, admin_valid=True).order_by('-date')
                else:
                    pass


        if 'agreeseance' in request.POST:
            form = EtudiantSeanceForm(request.POST)
            if form.is_valid():
                cd = form.cleaned_data
                sean = cd.get('seance')
                seance = SeanceCours.objects.get(id=sean)
                seance.admin_valid = True
                seance.save()
                messages.success(request, "Vous avez confimer la séance du "+str(seance.date)+" de l'Ecue: "+str(seance.ecue.code))
                return redirect('/enseignant/dr_ufr_seance_home/')
            else:
                messages.error(request, 'Vérifiez les champs svp')


    ens_obj = None
    if ens != 'tous':
        ens_obj = Enseignant.objects.get(id=ens)
    ecue_obj = None
    if ecue != 'tous':
        ecue_obj = Ecue.objects.get(id=ecue)

    context={
        'ufr':ufr,
        'user':user,
        'ufrs':ufrs,
        'ecues':ecues,
        'debut':debut,
        'fin':fin,
        'ufrEns':ufrEns,
        'annees':annees,
        'form':form,
        'formF':formF,
        'anfil':anfil,
        'ens':ens,'ens_obj':ens_obj,
        'ecue':ecue,'ecue_obj':ecue_obj,
        'status':status,
        'seances':seances,
        'UFR':UFR,
        'args':[ens,debut,fin,ecue,ufr,status]
    }
    return render(request,'dg_ufr/seance_cours.html',context)


@login_required(login_url='BasicData:login')
def dr_ufr_inactive_ue_home(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    #anUniv = Annee.objects.last()
    anUniv = 'tout'
    getue = 'tout'
    #drUfr = EnseignantUfr.objects.filter(annee=Annee.objects.last(), enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr

    # ON RECUPERE LES ANNEES ET LES NIVEAUX
    annees = Annee.objects.all().order_by('-id')
    niveaux = Niveau.objects.all()

    # FILTRE FORM
    niveau = 1
    formFil = PvFilterForm()
    if request.method == 'POST':
        if 'AnneeFilter' in request.POST:
            formFil = PvFilterForm(request.POST)
            if formFil.is_valid():
                cd = formFil.cleaned_data
                anUniv = cd.get('annee')
                getue = cd.get('niveau')

                if anUniv !='tout':
                    anUniv = Annee.objects.get(id=anUniv)

                if getue !='tout':
                    getue = Ue.objects.get(id=getue)

    #UES = Ue.objects.filter(ufr=UFR, active=True).order_by('libelle')
    UESUFR = [Ue.objects.get(id=ue['ue__id']) for ue in
            InactiveUe.objects.filter(ue__ufr__id=UFR.id).order_by('ue__libelle').values('ue__id').distinct()]
    UES=[]
    if anUniv =='tout' and getue =='tout':
        UES = InactiveUe.objects.filter(ue__ufr__id=UFR.id).order_by('-annee')
    elif anUniv =='tout' and getue !='tout':
        UES = InactiveUe.objects.filter(ue__ufr__id=UFR.id,ue=getue).order_by('-annee')
    elif anUniv !='tout' and getue =='tout':
        UES = InactiveUe.objects.filter(ue__ufr__id=UFR.id,annee=anUniv).order_by('-annee')
    elif anUniv !='tout' and getue !='tout':
        UES = InactiveUe.objects.filter(ue__ufr__id=UFR.id,annee=anUniv,ue=getue).order_by('-annee')
    else:pass

    # ACTIVER OU DESACTIVER L'UE
    addForm = AddInactiveUeForm()
    if request.method == 'POST':
        if 'addForm' in request.POST:
            addForm = AddInactiveUeForm(request.POST)
            if addForm.is_valid():
                addForm.save()
                messages.success(request,'UE désactivée avec succés!')
                return redirect('/enseignant/dr_ufr_inactive_ue_home/')
            else:
                messages.error(request,'Vérifiez les champs svp!')
                return redirect('/enseignant/dr_ufr_inactive_ue_home/')

        # ACTIVER OU DESACTIVER L'UE
        dForm = AnneeFilterForm()
        if request.method == 'POST':
            if 'deleteForm' in request.POST:
                dForm = AnneeFilterForm(request.POST)
                if dForm.is_valid():
                    cd = dForm.cleaned_data
                    InUe = InactiveUe.objects.get(id=cd.get('libelle'))
                    print(InUe)
                    InUe.delete()
                    #InUe.save()
                    messages.success(request, 'UE activée avec succés!')
                    return redirect('/enseignant/dr_ufr_inactive_ue_home/')
                else:
                    messages.error(request, 'Vérifiez les champs svp!')
                    return redirect('/enseignant/dr_ufr_inactive_ue_home/')

    #semestres = Semestre.objects.all().order_by('libelle')

    context = {
        'user': user,
        'anUniv': anUniv,
        'UfrAn': [UFR,anUniv],
        #'UfrAnId': [UFR.id,anUniv.id],
        #'niveau': Niveau.objects.get(id=niveau),
        'getue': getue,
        'UFR': UFR,
        'UES': UES,
        'UEALL': get_ue_by_ufr_set_all(UFR.id),
        'UESUFR': UESUFR,
        'group_check': group_check(request),
        'annees': annees,
        'niveaux': niveaux,
        'formFil': formFil,
        #'semestres': semestres,
    }
    return render(request, 'dg_ufr/liste_inactive_ue.html', context)


@login_required(login_url='BasicData:login')
def compensation_home(request):
    # ROLE
    user = Enseignant.objects.get(email=request.user.email)

    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    #drUfr = EnseignantUfr.objects.filter(annee=Annee.objects.last(), enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr

    # ON RECUPERE LES ANNEES/NIVEAUX/SEMESTRE
    annees = Annee.objects.all().order_by('-id')
    niveaux = Niveau.objects.all().order_by('id')

    an = None
    niv = None
    moy = 10
    taux = 80
    symb ='<'

    form = CompensationFilterForm()
    if request.method == 'POST':
        if 'compFilter' in request.POST:
            form = CompensationFilterForm(request.POST)
            if form.is_valid():
                cd = form.cleaned_data
                an = cd.get('annee')
                niv = cd.get('niveau')
                taux = cd.get('taux')
                moy = cd.get('moyenne')
                symb = cd.get('symbole')

    an1 = None
    if an is not None:
        an1 = Annee.objects.get(id=an)

    niveau = None
    if niv is not None:
        niveau = Niveau.objects.get(id=niv)

    etudiants =None
    if symb =='<':
        etudiants = [etud for etud in get_etudiant_list([an,niv,UFR.id]) if get_moyenne_annuelle_etudiant([etud,an1])>=float(moy) and taux_credit_valide_annuel([etud,an1])< float(taux) ]
    elif symb =='>':
        etudiants = [etud for etud in get_etudiant_list([an,niv,UFR.id]) if get_moyenne_annuelle_etudiant([etud,an1])>=float(moy) and taux_credit_valide_annuel([etud,an1]) > float(taux) ]
    else:pass



    context ={
        'user':user,
        'UFR':UFR,
        'niveaux':niveaux,
        'annees':annees,
        'etudiants':etudiants,
        'an1':an1,
        'niveau':niveau,
        'taux':taux,
        'symb':symb,
        'moy':moy,
        'form':form,

    }
    return render(request, 'dg_ufr/compensation_home.html', context)


@login_required(login_url='BasicData:login')
def compens_etudiant(request,id,an):

    etudiant = Etudiant.objects.get(id=id)
    AnUniv = Annee.objects.get(id=an)

    user = enseignant = Enseignant.objects.filter(email=request.user.email).last()

    # ON RECUPERE LE NIVEAU DE L'ETUDIANT
    nivEtud = NiveauEtudiant.objects.filter(annee=AnUniv, etudiant=etudiant).last()
    semestres = None
    if nivEtud:
        semestres = Semestre.objects.filter(niveau=nivEtud.niveau).order_by('libelle')

    # MODAL ADD COMPENS NOTE
    form = AddCompNoteForm()
    if request.method == 'POST':
        if 'addCompBtn' in request.POST:
            form = AddCompNoteForm(request.POST)
            if form.is_valid():
                cd = form.cleaned_data
                getue = cd.get('ue')
                getnote = cd.get('note')

                ue_obj = Ue.objects.get(id=getue)

                Compensation.objects.create(
                    annee =AnUniv,
                    etudiant=etudiant,
                    ue = ue_obj,
                    note = getnote
                )
                messages.success(request,"Note de Compensation ajoutée pour l'UE ("+str(ue_obj.code)+")")
                return redirect('/enseignant/compens_etudiant/'+str(id)+'/'+str(an)+'/')
            else:
                messages.error(request,'Vérifiez les champs svp!')

    # MODAL EDIT COMPENS NOTE
    form = AddCompNoteForm()
    if request.method == 'POST':
        if 'editCompBtn' in request.POST:
            form = AddCompNoteForm(request.POST)
            if form.is_valid():
                cd = form.cleaned_data
                getue = cd.get('ue')
                getnote = cd.get('note')

                ue_obj = Ue.objects.get(id=getue)

                comp = Compensation.objects.filter(
                    annee=AnUniv,
                    etudiant=etudiant,
                    ue=ue_obj,
                ).last()
                comp.note = getnote
                comp.save()
                messages.success(request, "Note de Compensation modifiée pour l'UE (" + str(ue_obj.code) + ")")
                return redirect('/enseignant/compens_etudiant/' + str(id) + '/' + str(an) + '/')
            else:
                messages.error(request, 'Vérifiez les champs svp!')


    context = {
        'user': user,
        'etudiant': etudiant,
        'semestres': semestres,
        'EtudAn': [etudiant,AnUniv],
        'UFR': etudiant.ufr,
        'UfrAn':[etudiant.ufr.id,AnUniv.id],
        'AnUniv': AnUniv,
        'annee': AnUniv,
        'form': form,
    }
    return render(request, 'dg_ufr/compens_etudiant.html', context)


@login_required(login_url='BasicData:login')
def groupe_etude_list(request):
    user = enseignant = Enseignant.objects.filter(email=request.user.email).last()

    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    #drUfr = EnseignantUfr.objects.filter(annee=Annee.objects.last(), enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr

    # ON RECUPERE LES GROUPES DE L'UFR
    groupes = GroupTravail.objects.filter(ufr=UFR).order_by('ufr__code')

    # ADD GROUPE
    form = AddGroupForm()
    if request.method == 'POST' and 'addGroupBtn' in request.POST:
        form = AddGroupForm(request.POST)
        if form.is_valid():
            form.save()
            messages.success(request,'Groupe Enregistré avec succès')
            return redirect('/enseignant/groupe_etude_list/')
        else:
            messages.error(request,'Vérifiez les champs svp')

    # DELETE GROUP
    form2 = ObjIdForm()
    if request.method == 'POST' and 'delGroupBtn' in request.POST:
        form2 = ObjIdForm(request.POST)
        if form2.is_valid():
            cd = form2.cleaned_data
            objID = cd.get('objID')
            groupe = GroupTravail.objects.get(id=objID)
            groupe.delete()
            messages.success(request,'Groupe Supprimé avec succès')
            return redirect('/enseignant/groupe_etude_list/')
        else:
            messages.error(request,'Vérifiez les champs svp')

    context = {
        'user':user,
        'groupes':groupes,
        'form':form,
        'form2':form2,
    }
    return render(request, 'dg_ufr/groupe_etude_list.html', context)


@login_required(login_url='BasicData:login')
def groupe_etude_edit(request,id):
    user = enseignant = Enseignant.objects.filter(email=request.user.email).last()

    # ON RECUPERE LES GROUPES DE L'UFR
    groupe = GroupTravail.objects.get(id=id)

    # ADD GROUPE
    form = AddGroupForm(instance=groupe)
    if request.method == 'POST' and 'addGroupBtn' in request.POST:
        form = AddGroupForm(request.POST,instance=groupe)
        if form.is_valid():
            form.save()
            messages.success(request,'Groupe modifié avec succès')
            return redirect('/enseignant/groupe_etude_list/')
        else:
            messages.error(request,'Vérifiez les champs svp')


    context = {
        'user':user,
        'groupe':groupe,
        'form':form,
    }
    return render(request, 'dg_ufr/groupe_etude_edit.html', context)


@login_required(login_url='BasicData:login')
def groupe_enseignant_list(request,id):
    user = enseignant = Enseignant.objects.filter(email=request.user.email).last()

    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    #drUfr = EnseignantUfr.objects.filter(annee=Annee.objects.last(), enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr

    # ON RECUPERE LE GROUPE
    groupe =  GroupTravail.objects.get(id=id)

    # ENSEIGNANT DU GROUPE
    GrEns = [ens for ens in GroupEnseignant.objects.filter(groupe=groupe)]

    # ENSEIGNANTS DE L'UFR
    enseignants = [ens.enseignant for ens in EnseignantUfr.objects.filter(ufr=UFR,annee=groupe.annee)]

    # ADD GROUPE ENSEIGNANT
    form = addGroupEnsForm()
    if request.method == 'POST' and 'addGroupEnsBtn' in request.POST:
        form = addGroupEnsForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            ensID = cd.get('enseignant')
            GroupEnseignant.objects.create(
                enseignant = Enseignant.objects.get(id=ensID),
                annee = groupe.annee,
                groupe = groupe
            )
            messages.success(request, 'Enseignant Ajouté avec succès')
            return redirect('/enseignant/groupe_enseignant_list/'+str(id)+'/')
        else:
            messages.error(request, 'Vérifiez les champs svp')

    # DELETE GROUPE ENSEIGNANT
    form2 = ObjIdForm()
    if request.method == 'POST' and 'delGroupEnsBtn' in request.POST:
        form2 = ObjIdForm(request.POST)
        if form2.is_valid():
            cd = form2.cleaned_data
            objID = cd.get('objID')
            groupEns = GroupEnseignant.objects.get(id=objID)
            groupEns.delete()
            messages.success(request, 'Enseignant rétiré du groupe avec succès')
            return redirect('/enseignant/groupe_enseignant_list/'+str(id)+'/')
        else:
            messages.error(request, 'Vérifiez les champs svp')

    context = {
        'user': user,
        'GrEns': GrEns,
        'groupe': groupe,
        'enseignants': enseignants,
    }
    return render(request, 'dg_ufr/groupe_enseignant_list.html', context)


@login_required(login_url='BasicData:login')
def groupe_etudiant_list(request,id):
    user = enseignant = Enseignant.objects.filter(email=request.user.email).last()

    ############ new Enseignant Ufr ############
    # On recupere les infos du DR
    #drUfr = EnseignantUfr.objects.filter(annee=Annee.objects.last(), enseignant=user).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr

    # ON RECUPERE LE GROUPE
    groupe =  GroupTravail.objects.get(id=id)

    # ENSEIGNANT DU GROUPE
    GrEtu = [etu for etu in GroupEtudiant.objects.filter(groupe=groupe)]

    # ENSEIGNANTS DE L'UFR
    enseignants = [ens.enseignant for ens in EnseignantUfr.objects.filter(ufr=UFR,annee=groupe.annee)]

    # DELETE GROUPE ENSEIGNANT
    form2 = ObjIdForm()
    if request.method == 'POST' and 'delGroupEnsBtn' in request.POST:
        form2 = ObjIdForm(request.POST)
        if form2.is_valid():
            cd = form2.cleaned_data
            objID = cd.get('objID')
            groupEns = GroupEtudiant.objects.get(id=objID)
            groupEns.delete()
            messages.success(request, 'Etudiant rétiré du groupe avec succès')
            return redirect('/enseignant/groupe_etudiant_list/'+str(id)+'/')
        else:
            messages.error(request, 'Vérifiez les champs svp')

    # IMPORT GROUP ETUDIANT
    form3 = GroupEtudImportForm(request.POST or None, request.FILES or None)
    if 'importer' in request.POST:
        if form3.is_valid():
            form3.save()
            #form3 = CsvModelForm()
            obj = Csv.objects.get(activated=False)
            obj.activated = True
            obj.save()
            with open(obj.file_name.path, 'r') as f:
                reader = csv.reader(f)
                for i, row in enumerate(reader):
                    if i == 0:
                        pass
                    else:
                        row = "".join(row)
                        # on remplace les espaces avec par des " _ "
                        row = row.replace(" ", "_")
                        # on repmlace " ; " par des espaces
                        row = row.replace(";", " ")
                        row = row.split()
                        # ON RECUPERE LES DONNEES

                        # On recupere l'objet etudiant
                        etudiant = Etudiant.objects.get(nce=row[0])
                        #print(etudiant)
                        is_added = GroupEtudiant.objects.filter(groupe=groupe,etudiant=etudiant)
                        if is_added:
                            pass
                        else:
                            GroupEtudiant.objects.create(groupe=groupe, etudiant=etudiant, annee=groupe.annee)
            messages.success(request,'liste importée avec succès')
            return redirect('/enseignant/groupe_etudiant_list/' + str(id) + '/')
        else:
            messages.error(request,form3.errors)
            return redirect('/enseignant/groupe_etudiant_list/' + str(id) + '/')

    context = {
        'user': user,
        'GrEtu': GrEtu,
        'groupe': groupe,
        'enseignants': enseignants,
        'form3': form3,
    }
    return render(request, 'dg_ufr/groupe_etudiant_list.html', context)


@login_required(login_url='BasicData:login')
def flash_info_list(request):
    user = enseignant = Enseignant.objects.filter(email=request.user.email).last()

    ############ new Enseignant Ufr ############
    UFR = None
    if user:
        UFR = user.ufr

    # ON RECUPERE LES INFOS GENERALES ET DE L'UFR
    infos = FlashInfo.objects.filter(ufr__in=['Tout',UFR.code.upper()]).order_by('-id')
    print(infos)

    # ADD INFO FORM
    form = FlashInfoAddForm()
    if request.method == 'POST':
        if 'addInfoBtn' in request.POST:
            form = FlashInfoAddForm(request.POST)
            if form.is_valid():
                form.save()
                messages.success(request,'Flash Info ajouté avec succès!')
                return redirect('EspaceEnseignant:flash_info_list')
            else:
                messages.error(request,'Vérifiez les champs svp!')

    # DELETE INFO
    form2 = ObjIdForm()
    if request.method == 'POST' and 'delGroupBtn' in request.POST:
        form2 = ObjIdForm(request.POST)
        if form2.is_valid():
            cd = form2.cleaned_data
            objID = cd.get('objID')
            Inf = FlashInfo.objects.get(id=objID)
            Inf.delete()
            messages.success(request, 'Etudiant rétiré du groupe avec succès')
            return redirect('EspaceEnseignant:flash_info_list')
        else:
            messages.error(request, 'Vérifiez les champs svp')

    context = {
        'user':user,
        'infos':infos,
        'form':form,
        'form2':form2,
        'UFR':UFR,
    }
    return render(request, 'dg_ufr/fladh_info_list.html', context)


@login_required(login_url='BasicData:login')
def flash_info_edit(request,id):
    user = enseignant = Enseignant.objects.filter(email=request.user.email).last()

    ############ new Enseignant Ufr ############
    UFR = None
    if user:
        UFR = user.ufr

    # ON RECUPERE LE FLASH INFO
    infos = FlashInfo.objects.get(id=id)

    # EDIT INFO
    form = FlashInfoAddForm(instance=infos)
    if request.method == 'POST':
        form = FlashInfoAddForm(request.POST,instance=infos)
        if form.is_valid():
            form.save()
            messages.success(request, 'Flash Info modifié avec succès!')
            return redirect('EspaceEnseignant:flash_info_list')
        else:
            messages.error(request, 'Vérifiez les champs svp!')


    context = {
        'enseignant': enseignant,
        'user': user,
        'infos': infos,
        'form': form,
    }
    return render(request, 'dg_ufr/flash_info_edit.html', context)