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.custom_fonctions import *
from BasicData.templatetags.custom_tag import get_etudiant_by_ue_list, get_ecue_etudiant_session
from BasicData.templatetags.custom_tag_obj import get_ue_by_ufr_simple
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 BasicData.models import User
import datetime


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

    AnUniv = Annee.objects.last()

    AFForm = AnneeFilterForm()
    if request.method == 'POST':
        AFForm = AnneeFilterForm(request.POST)
        if AFForm.is_valid():
            cd = AFForm.cleaned_data
            libelle = cd.get('libelle')
            AnUniv = Annee.objects.get(id=libelle)

        #print(request.POST)

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

    annee_univ = Annee.objects.last()
    UEs = []
    for enst in EnseignantUes:
        # print(enst.ecue.ue.libelle)
        try:
            UEs = Ue.objects.get(id=enst.ecue.ue.id)
        except Ue.DoesNotExist:
            UEs = None

    # # On recupere la deliberation
    # delib = None
    # if UEs and annee_univ:
    #     try:
    #         delib = DeliberationUe.objects.get(ue=UEs, annee=AnUniv, session=Session.objects.get(id=1))
    #     except DeliberationUe.DoesNotExist:
    #         delib = None


    context = {
        'user': user,
        'enseignant': enseignant,
        'EnseignantUes': EnseignantUes,
        'Ue': UEs,
        #'form2': form2,
        #'delib': delib,
        'anneeLast': Annee.objects.last(),
        'annees': Annee.objects.all().order_by('-id'),
        'AnUniv': AnUniv,
        'AFForm': AFForm,
    }
    return render(request, 'enseignant/home.html', context)


@login_required(login_url='BasicData:login')
def enseignant_profile_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}
    return render(request, 'enseignant/change_password.html', context)


@login_required(login_url='BasicData:login')
def enseignant_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}
    return render(request, 'enseignant/infos_perso.html', context)


@login_required(login_url='BasicData:login')
def enseignant_edt(request):
    # ROLE
    user = enseignant = 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=enseignant).last()
    # On recupere l'UFR
    UFR = None
    if user:
        UFR = user.ufr
    ############################################
    # ecues = Ecue.objects.filter(ue__ufr=UFR, active=True).order_by('libelle')
    niveaux = Niveau.objects.all()
    salles = Salle.objects.all()
    # print(niveaux)

    validites = Validite.objects.filter(done=False).order_by('dateDebut')[:5]
    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)

    # 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 = []

    # On recupere les ecue enseignés par l'enseignant
    ensEcu = [ec.ecue for ec in EnseignantUe.objects.filter(annee=annee,enseignant=enseignant)]

    # for niveau in niveaux:
    progByNiveau = EmploiDuTemps2.objects.filter(validite=validite, ecue__in=ensEcu,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, 'enseignant/enseignant_edt.html', context)


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

    # ON RECUPERE LE SYLLABUS
    ecue = Ecue.objects.get(id=id)
    try:
        syllabus = SyllabusEcue.objects.get(ecue=ecue)
    except SyllabusEcue.DoesNotExist:
        syllabus = None

    context = {
        'syllabus': syllabus,
        'ecue': ecue,
        'user': user,
    }
    return render(request, 'enseignant/syllabus_ecue_home.html', context)


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

    # ON RECUPERE LE SYLLABUS
    ecue = Ecue.objects.get(id=ecue)

    try:
        syllbus = SyllabusEcue.objects.get(id=id)
    except SyllabusEcue.DoesNotExist:
        syllbus = None

    show_form = True
    form = SyllabusEcueAddForm(instance=syllbus)
    if request.method == 'POST':
        form = SyllabusEcueAddForm(request.POST, instance=syllbus)
        if form.is_valid():
            form.save()
            messages.success(request, 'Syllabus modifié avec succès!')
            show_form = False
            # return redirect('syllabus_ecue_home/'+str(id)+'/')
        else:
            messages.error(request, 'vérifiez les champs svp!')
            messages.error(request, form.errors)

    context = {
        'form': form,
        'ecue': ecue,
        'user': user,
        'show_form': show_form,
    }

    return render(request, 'enseignant/syllabus_ecue_add.html', context)


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

    # ON RECUPERE L'ECUE
    ecue = Ecue.objects.get(id=id)

    show_form = True
    form = SyllabusEcueAddForm()
    if request.method == 'POST':
        form = SyllabusEcueAddForm(request.POST)
        if form.is_valid():
            form.save()

            messages.success(request, 'Syllabus modifié avec succès!')
            show_form = False
            # return redirect('syllabus_ecue_home/'+str(id)+'/')
        else:
            messages.error(request, 'vérifiez les champs svp!')
            messages.error(request, form.errors)

    context = {
        'form': form,
        'ecue': ecue,
        'user': user,
        'show_form': show_form,
    }
    return render(request, 'enseignant/syllabus_ecue_add.html', context)


@login_required(login_url='BasicData:login')
def seance_cours(request):
    # ROLE
    user = enseignant = Enseignant.objects.get(email=request.user.email)
    annees = Annee.objects.all().order_by('-id')

    ############ 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 ECUEs DE L'ENSEIGNANT
    ecues = [Ecue.objects.get(id=ecue.ecue.id) for ecue in
             EnseignantUe.objects.filter(annee=Annee.objects.last(), enseignant=enseignant)]

    # ON RECUPERE LES SEANCE DE L'ENSEIGNANT
    seances = SeanceCours.objects.filter(annee=Annee.objects.last(), enseignant=enseignant).order_by('-date')

    # FORM FILTER
    annee = None
    ecue = 'tous'
    status = 'tous'
    debutf = '1900-01-01'
    finf = '1900-01-01'
    filter_form = SeanceFilterForm(request.POST)
    add_seance_form = AddSeanceForm(request.POST)
    if request.method == 'POST':
        if 'ecueFilter' in request.POST:
            filter_form = SeanceFilterForm(request.POST)
            if filter_form.is_valid():
                cd = filter_form.cleaned_data
                ecue = cd.get('ecue')
                annee = cd.get('annee')
                debutf = cd.get('debut')
                finf = cd.get('fin')
                status = cd.get('status')
                if debutf > finf:
                    temp = debutf
                    debutf = finf
                    finf = temp

                if ecue == 'tous' and status == 'tous':
                    seances = SeanceCours.objects.filter(enseignant=enseignant, date__gte=debutf,
                                                         date__lte=finf).order_by('-date')

                if ecue == 'tous' and status == 'validé':
                    seances = SeanceCours.objects.filter(enseignant=enseignant, date__gte=debutf, date__lte=finf,
                                                         admin_valid=True).order_by('-date')

                if ecue == 'tous' and status == 'en attente':
                    seances = SeanceCours.objects.filter(enseignant=enseignant, date__gte=debutf, date__lte=finf,
                                                         admin_valid=False).order_by('-date')

                if ecue != 'tous' and status == 'tous':
                    seances = SeanceCours.objects.filter(enseignant=enseignant, ecue__id=ecue, date__gte=debutf,
                                                         date__lte=finf).order_by('-date')

                if ecue != 'tous' and status == 'validé':
                    seances = SeanceCours.objects.filter(enseignant=enseignant,ecue__id=ecue, date__gte=debutf, date__lte=finf,
                                                         admin_valid=True).order_by('-date')

                if ecue != 'tous' and status == 'en attente':
                    seances = SeanceCours.objects.filter(enseignant=enseignant,ecue__id=ecue, date__gte=debutf, date__lte=finf,
                                                         admin_valid=False).order_by('-date')

                else:
                    pass

        if 'addseancepost' in request.POST:
            add_seance_form = AddSeanceForm(request.POST)
            if add_seance_form.is_valid():
                cd = add_seance_form.cleaned_data
                type_cours = cd.get('type_cours')
                adecue = cd.get('adecue')
                anneead = cd.get('annee')
                salle = cd.get('salle')
                date = cd.get('date')
                debut = cd.get('debut')
                fin = cd.get('fin')
                contenu = cd.get('contenu')

                SeanceCours.objects.create(
                    type_cours=type_cours,
                    ecue=Ecue.objects.get(id=adecue),
                    enseignant=enseignant,
                    salle=Salle.objects.get(id=salle.id),
                    annee=Annee.objects.get(id=anneead.id),
                    date=date,
                    debut=debut,
                    fin=fin,
                    contenu=contenu
                )
                messages.success(request, 'Séance ajoutée avec succès!')
                add_seance_form = AddSeanceForm()
                return redirect('/enseignant/seance_cours/')

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

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


    context = {
        'filter_form': filter_form,
        'add_seance_form': add_seance_form,
        'user': user,
        'UFR': UFR,
        'annees': annees,
        'ecues': ecues,
        'seances': seances,
        'enseignant': enseignant,
        'debut': debutf,
        'fin': finf,
        'annee': Annee.objects.filter(id=annee).last(),
        'anneeLast': Annee.objects.last(),
        'ecue': ecue,
        'status': status,
        'ecue_obj': ecue_obj,
    }
    return render(request, 'enseignant/seance_cours.html', context)


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

    # ON RECUPERE LES ECUEs DE L'ENSEIGNANT
    ecues = [Ecue.objects.get(id=ecue.ecue.id) for ecue in
             EnseignantUe.objects.filter(annee=Annee.objects.last(), enseignant=enseignant)]

    form = EditSeanceForm(instance=seance)
    if request.method == 'POST':
        form = EditSeanceForm(request.POST, instance=seance)
        if form.is_valid():
            form.save()
            cd = form.cleaned_data
            messages.success(request, 'Séance modifiée avec succès!')
            return redirect('/enseignant/seance_cours/')

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

    context = {
        'form': form,
        'seance': seance,
        'user': user,
        'ecues': ecues,
        'enseignant': enseignant,
    }
    return render(request, 'enseignant/edit_seance_cours.html', context)


#+++++++++++++++ PERSO ++++++++++++++++++++

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

    # ON RECUPERE LES TYPE DE COURS
    typCours = PsTypeCours.objects.filter(enseignant=enseignant)

    # ADD
    form = TypeCoursAddForm()
    if request.method == 'POST':
        if 'addTypeCoursBtn' in request.POST:
            form = TypeCoursAddForm(request.POST)
            if form.is_valid():
                cd = form.cleaned_data
                libel = cd.get('libelle')
                prereqs = cd.get('prerequis')
                PsTypeCours.objects.create(
                    libelle = libel,
                    prerequis = prereqs,
                    enseignant = enseignant
                )
                messages.success(request, 'Type de cours enregistré avec succès!')
                return redirect('EspaceEnseignant:Type_cours_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    # DELETE
    form2 = ObjIdForm()
    if request.method == 'POST':
        if 'delTypCour' in request.POST:
            form2 = ObjIdForm(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                obj = cd.get('objID')
                typcou = PsTypeCours.objects.get(id=obj).delete()
                messages.success(request, 'Type de cours supprimé avec succès!')
                return redirect('EspaceEnseignant:Type_cours_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'typCours': typCours,
    }
    return render(request, 'enseignant/type_cours_list.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    typCours = PsTypeCours.objects.get(id=id)

    # ADD
    form = TypeCoursAddForm(instance=typCours)
    if request.method == 'POST':
        form = TypeCoursAddForm(request.POST,instance=typCours)
        if form.is_valid():
            form.save()
            messages.success(request, 'Type de cours enregistré avec succès!')
            return redirect('EspaceEnseignant:Type_cours_list')
        else:
            messages.error(request, 'vérifiez les champs svp!')


    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'typCours': typCours,
    }
    return render(request, 'enseignant/type_cours_edit.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    typPub = PsTypePublication.objects.filter(enseignant=enseignant)

    # ADD
    form = TypePubAddForm()
    if request.method == 'POST':
        if 'addTypeCoursBtn' in request.POST:
            form = TypePubAddForm(request.POST)
            if form.is_valid():
                cd = form.cleaned_data
                libel = cd.get('libelle')
                PsTypePublication.objects.create(
                    libelle = libel,
                    enseignant = enseignant
                )
                messages.success(request, 'Type de cours enregistré avec succès!')
                return redirect('EspaceEnseignant:Type_pub_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    # DELETE
    form2 = ObjIdForm()
    if request.method == 'POST':
        if 'delTypCour' in request.POST:
            form2 = ObjIdForm(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                obj = cd.get('objID')
                typcou = PsTypePublication.objects.get(id=obj).delete()
                messages.success(request, 'Type de publication supprimé avec succès!')
                return redirect('EspaceEnseignant:Type_pub_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'typPub': typPub,
    }
    return render(request, 'enseignant/type_pub_list.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    typPub = PsTypePublication.objects.get(id=id)

    # ADD
    form = TypePubAddForm(instance=typPub)
    if request.method == 'POST':
        form = TypePubAddForm(request.POST,instance=typPub)
        if form.is_valid():
            form.save()
            messages.success(request, 'Type de cours enregistré avec succès!')
            return redirect('EspaceEnseignant:Type_pub_list')
        else:
            messages.error(request, 'vérifiez les champs svp!')


    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'typPub': typPub,
    }
    return render(request, 'enseignant/type_pub_edit.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    equipes = PsGroupeRech.objects.filter(enseignant=enseignant)

    # ADD
    form = EquipeAddForm()
    if request.method == 'POST':
        if 'addTypeCoursBtn' in request.POST:
            form = EquipeAddForm(request.POST)
            if form.is_valid():
                cd = form.cleaned_data
                libel = cd.get('libelle')
                instit = cd.get('institut')
                PsGroupeRech.objects.create(
                    libelle = libel,
                    institut = instit,
                    enseignant = enseignant
                )
                messages.success(request, 'Equipe enregistré avec succès!')
                return redirect('EspaceEnseignant:equipe_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    # DELETE
    form2 = ObjIdForm()
    if request.method == 'POST':
        if 'delTypCour' in request.POST:
            form2 = ObjIdForm(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                obj = cd.get('objID')
                typcou = PsGroupeRech.objects.get(id=obj).delete()
                messages.success(request, 'Equipe supprimé avec succès!')
                return redirect('EspaceEnseignant:equipe_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'equipes': equipes,
    }
    return render(request, 'enseignant/equipe_list.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    equipe = PsGroupeRech.objects.get(id=id)

    # ADD
    form = EquipeAddForm(instance=equipe)
    if request.method == 'POST':
        form = EquipeAddForm(request.POST,instance=equipe)
        if form.is_valid():
            form.save()
            messages.success(request, 'Equipe enregistré avec succès!')
            return redirect('EspaceEnseignant:equipe_list')
        else:
            messages.error(request, 'vérifiez les champs svp!')


    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'equipe': equipe,
    }
    return render(request, 'enseignant/equipe_edit.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    cours = PsCours2.objects.filter(enseignant=enseignant).order_by('-id')

    # ADD
    form = PsCourAddForm()
    if request.method == 'POST':
        if 'addTypeCoursBtn' in request.POST:
            form = PsCourAddForm(request.POST)
            if form.is_valid():
                obj = form.save(commit=False)
                obj.enseignant = enseignant
                obj.save()
                messages.success(request, 'Cours enregistré avec succès!')
                return redirect('EspaceEnseignant:ps_cours_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    # DELETE
    form2 = ObjIdForm()
    if request.method == 'POST':
        if 'delTypCour' in request.POST:
            form2 = ObjIdForm(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                obj = cd.get('objID')
                typcou = PsCours2.objects.get(id=obj).delete()
                messages.success(request, 'Cours supprimé avec succès!')
                return redirect('EspaceEnseignant:ps_cours_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    # ADD SUPPORT
    form3 = SupportAddForm()
    if request.method == 'POST':
        if 'addSupportBtn' in request.POST:
            form3 = SupportAddForm(request.POST, request.FILES)
            if form3.is_valid():
                cd = form3.cleaned_data
                obj = cd.get('obj')
                pb_obj = PsCours2.objects.get(id=obj)
                pj = form3.save(commit=False)
                pj.cours = None
                pj.cours2 = pb_obj
                pj.pub = None
                pj.save()
                messages.success(request, 'Support enregistré avec succès!')
                return redirect('EspaceEnseignant:ps_cours_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'form3': form3,
        'cours': cours,
    }
    return render(request, 'enseignant/ps_cours_list.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    cours = PsCours2.objects.get(id=id)

    # ADD
    form = PsCourAddForm(instance=cours)
    if request.method == 'POST':
        form = PsCourAddForm(request.POST,instance=cours)
        if form.is_valid():
            form.save()
            messages.success(request, 'Cours enregistré avec succès!')
            return redirect('EspaceEnseignant:ps_cours_list')
        else:
            messages.error(request, 'vérifiez les champs svp!')


    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'cours': cours,
    }
    return render(request, 'enseignant/ps_cours_edit.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    support = PsPJoint.objects.filter(cours__type_cours__enseignant=enseignant)

    # ON RECUPERE LES TYPE DE COURS ET LES PUBLICATIONS
    cours = PsCours.objects.filter(type_cours__enseignant=enseignant)
    publications = PsPublication.objects.filter(enseignant=enseignant)

    # ADD
    form = SupportAddForm()
    if request.method == 'POST':
        if 'addTypeCoursBtn' in request.POST:
            form = SupportAddForm(request.POST,request.FILES)
            if form.is_valid():
                cd = form.cleaned_data
                crs = cd.get('cours')
                pb = cd.get('pub')

                crs_obj = None
                if crs !='vide':
                    crs_obj = PsCours.objects.get(id=crs)

                pb_obj = None
                if pb !='vide':
                    pb_obj = PsPublication.objects.get(id=pb)

                pj = form.save(commit=False)
                pj.cours = crs_obj
                pj.pub = pb_obj
                pj.save()
                messages.success(request, 'Support enregistré avec succès!')
                return redirect('EspaceEnseignant:support_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')
                messages.error(request, form.errors)

    # DELETE
    form2 = ObjIdForm()
    if request.method == 'POST':
        if 'delTypCour' in request.POST:
            form2 = ObjIdForm(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                obj = cd.get('objID')
                typcou = PsPJoint.objects.get(id=obj).delete()
                messages.success(request, 'Support supprimé avec succès!')
                return redirect('EspaceEnseignant:support_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'support': support,
        'cours': cours,
        'publications': publications,
    }
    return render(request, 'enseignant/support_list.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    support = PsPJoint.objects.get(id=id)
    # ON RECUPERE LES TYPE DE COURS ET LES PUBLICATIONS
    cours = PsCours.objects.filter(type_cours__enseignant=enseignant)
    publications = PsPublication.objects.filter(enseignant=enseignant)

    # ADD
    form = SupportAddForm(instance=support)
    if request.method == 'POST':
        form = SupportAddForm(request.POST,request.FILES,instance=support)
        if form.is_valid():
            cd = form.cleaned_data
            crs = cd.get('cours')
            pb = cd.get('pub')

            crs_obj = None
            if crs != 'vide':
                crs_obj = PsCours.objects.get(id=crs)

            pb_obj = None
            if pb != 'vide':
                pb_obj = PsPublication.objects.get(id=pb)

            pj = form.save(commit=False)
            pj.cours = crs_obj
            pj.pub = pb_obj
            pj.save()
            messages.success(request, 'Support modifié avec succès!')
            return redirect('EspaceEnseignant:support_list')
        else:
            messages.error(request, 'vérifiez les champs svp!')

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'support': support,
        'publications': publications,
        'cours': cours,
    }
    return render(request, 'enseignant/support_edit.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    pub = PsPublication.objects.filter(enseignant=enseignant).order_by('-id')

    # ADD
    form = PubAddForm()
    if request.method == 'POST':
        if 'addTypeCoursBtn' in request.POST:
            form = PubAddForm(request.POST)
            if form.is_valid():
                #form.save()
                cd = form.cleaned_data
                typ = cd.get('typub')
                an = cd.get('annee')
                titr = cd.get('titre')
                ref = cd.get('reference')
                autrs = cd.get('auteurs')
                vol = cd.get('volume')
                PsPublication.objects.create(
                    typub = typ,
                    annee=an,
                    titre = titr,
                    reference = ref,
                    auteurs = autrs,
                    volume = vol,
                    enseignant = enseignant
                )
                messages.success(request, 'Publication enregistré avec succès!')
                return redirect('EspaceEnseignant:pub_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')
                #messages.error(request, form.errors)

    # DELETE
    form2 = ObjIdForm()
    if request.method == 'POST':
        if 'delTypCour' in request.POST:
            form2 = ObjIdForm(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                obj = cd.get('objID')
                typcou = PsPublication.objects.get(id=obj).delete()
                messages.success(request, 'Publication supprimé avec succès!')
                return redirect('EspaceEnseignant:pub_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    # ADD SUPPORT
    form3 = SupportAddForm()
    if request.method == 'POST':
        if 'addSupportBtn' in request.POST:
            form3 = SupportAddForm(request.POST, request.FILES)
            if form3.is_valid():
                cd = form3.cleaned_data
                obj = cd.get('obj')
                pb_obj = PsPublication.objects.get(id=obj)

                pj = form3.save(commit=False)
                pj.cours = None
                pj.cours2 = None
                pj.pub = pb_obj
                pj.save()
                messages.success(request, 'Support enregistré avec succès!')
                return redirect('EspaceEnseignant:pub_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')
                #messages.error(request, form.errors)

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'form2': form2,
        'form3': form3,
        'pub': pub,
    }
    return render(request, 'enseignant/pub_list.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    pub = PsPublication.objects.get(id=id)

    # ADD
    form = PubAddForm(instance=pub)
    if request.method == 'POST':
        form = PubAddForm(request.POST,instance=pub)
        if form.is_valid():
            form.save()
            messages.success(request, 'Publication modifié avec succès!')
            return redirect('EspaceEnseignant:pub_list')
        else:
            messages.error(request, 'vérifiez les champs svp!')

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'pub': pub,
    }
    return render(request, 'enseignant/pub_edit.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    logiciel = PsLogiciel.objects.filter(enseignant=enseignant)

    # ADD
    form = LogicielAddForm()
    if request.method == 'POST':
        if 'addTypeCoursBtn' in request.POST:
            form = LogicielAddForm(request.POST)
            if form.is_valid():
                form.save()
                cd = form.cleaned_data
                fonct = cd.get('fonction')
                descr = cd.get('description')
                partp = cd.get('participant')
                url = cd.get('url')
                PsLogiciel.objects.create(
                    fonction = fonct,
                    description = descr,
                    participant = partp,
                    url = url,
                    enseignant = enseignant
                )
                messages.success(request, 'Logiciel enregistré avec succès!')
                return redirect('EspaceEnseignant:logiciel_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')
                messages.error(request, form.errors)

    # DELETE
    form2 = ObjIdForm()
    if request.method == 'POST':
        if 'delTypCour' in request.POST:
            form2 = ObjIdForm(request.POST)
            if form2.is_valid():
                cd = form2.cleaned_data
                obj = cd.get('objID')
                typcou = PsLogiciel.objects.get(id=obj).delete()
                messages.success(request, 'Logiciel supprimé avec succès!')
                return redirect('EspaceEnseignant:logiciel_list')
            else:
                messages.error(request, 'vérifiez les champs svp!')

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'logiciel': logiciel,
    }
    return render(request, 'enseignant/logiciel_list.html', context)


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

    # ON RECUPERE LES TYPE DE COURS
    logiciel = PsLogiciel.objects.get(id=id)

    # ADD
    form = LogicielAddForm(instance=logiciel)
    if request.method == 'POST':
        form = LogicielAddForm(request.POST,instance=logiciel)
        if form.is_valid():
            form.save()
            messages.success(request, 'Logiciel modifié avec succès!')
            return redirect('EspaceEnseignant:logiciel_list')
        else:
            messages.error(request, 'vérifiez les champs svp!')

    context = {
        'user': user,
        'enseignant': enseignant,
        'form': form,
        'logiciel': logiciel,
    }
    return render(request, 'enseignant/logiciel_edit.html', context)


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

    # ADD
    form = EnseignantEditForm(instance=enseignant)
    if request.method == 'POST':
        form = EnseignantEditForm(request.POST, instance=enseignant)
        if form.is_valid():
            form.save()
            messages.success(request, 'Profil modifié avec succès!')
            return redirect('EspaceEnseignant:infos_personnelles')
        else:
            messages.error(request, 'vérifiez les champs svp!')

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


# Nouvelle vue pour Ajout de note
@login_required(login_url='BasicData:login')
def marquer_absence(request, id,an):
    # 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)

    # ON ORDONNE LA LISTE
    etudiantUes = get_etudiant_by_ue_list([annee,ue])

    date = datetime.date.today()
    if request.method == "POST" and 'Enregistrer' in request.POST:
        absents = request.POST.getlist('absent')
        date = request.POST.get('date')
        debut = request.POST.get('debut')
        fin = request.POST.get('fin')
        nbHeure = request.POST.get('nbHeure')

        selected = [p.etudiant for p in Presence.objects.filter(date=date, ecue=ecue, annee=annee)]
        get_list = Etudiant.objects.filter(id__in=absents)
        print(selected)
        print(get_list)
        print("*****************************")
        for etudiant in get_list:
            # and etd not in list(get_list)
            if etudiant in selected :
                selected.remove(etudiant)
            else:
                Presence.objects.create(
                    etudiant=etudiant,
                    annee=Annee.objects.last(),
                    ecue=ecue,
                    date=date,
                    debut=debut,
                    fin=fin,
                    nombre_heure=nbHeure
                )
        Presence.objects.filter(date=date, ecue=ecue, annee=annee,etudiant__in=selected).delete()
        messages.success(request,"Enregistré avec succès!")
        return redirect("/enseignant/marquer_absence/"+str(id)+"/"+str(an)+"/")


    context = {
        'user': user,
        'ue': ue,
        'ecue': ecue,
        'date': date,
        'etudiantUes': etudiantUes,
        'enseign': enseign,
        'annee':annee,
    }
    return render(request, 'enseignant/marquer_absence.html', context)