comment enlever les adhérents ajoutées du sous menu car ce n'est pas logique de les voir comme si je pouvais tout de même les rajouter : import datetime

from sqlalchemy import func
from .app import db, login_manager
from flask_login import UserMixin

# Modèle pour représenter le lieu
class Lieu(db.Model):
    __tablename__ = 'LIEU'
    idLieu = db.Column(db.Integer, primary_key=True, autoincrement=True)
    nomLieu = db.Column(db.String(50), nullable=False)
    villeLieu = db.Column(db.String(50), nullable=False)
    codePostalLieu = db.Column(db.Integer, nullable=False)
    adresseLieu = db.Column(db.String(50), nullable=False)
    
    def __init__(self, nom_lieu, ville_lieu, code_postal_lieu, adresse_lieu):
        self.nomLieu = nom_lieu
        self.villeLieu = ville_lieu
        self.codePostalLieu = code_postal_lieu
        self.adresseLieu = adresse_lieu

# Modèle pour représenter l'arme
class Arme(db.Model):
    __tablename__ = 'ARME'
    idArme = db.Column(db.Integer, primary_key=True, autoincrement=True)
    nomArme = db.Column(db.String(50), nullable=False, unique = True)

    def __init__(self, nom_arme):
        self.nomArme = nom_arme

# Modèle pour représenter la saison
class Saison(db.Model):
    __tablename__ = 'SAISON'
    idSaison = db.Column(db.Integer, primary_key=True, autoincrement=True)
    nomSaison = db.Column(db.String(50), nullable=False)
    dateDebutSaison = db.Column(db.Date, nullable=False)
    dateFinSaison = db.Column(db.Date, nullable=False)
    
    def __init__(self, nom_saison, date_debut_saison, date_fin_saison):
        self.nomSaison = nom_saison
        self.dateDebutSaison = date_debut_saison
        self.dateFinSaison = date_fin_saison

# Modèle pour représenter la catégorie
class Categorie(db.Model):
    __tablename__ = 'CATEGORIE'
    idCat = db.Column(db.Integer, primary_key=True, autoincrement=True)
    nomCategorie = db.Column(db.String(50), nullable=False, unique=True)
    
    def __init__(self, nom_categorie):
        self.nomCategorie = nom_categorie

# Modèle pour représenter le club
class Club(db.Model):
    __tablename__ = 'CLUB'
    idClub = db.Column(db.Integer, primary_key=True, autoincrement=True)
    nomClub = db.Column(db.String(50), nullable=False, unique = True)
    regionClub = db.Column(db.String(50), nullable=False)
    
    def __init__(self, nom_club, region_club):
        self.nomClub = nom_club
        self.regionClub = region_club

# Modèle pour représenter la compétition
class Competition(db.Model):
    __tablename__ = 'COMPETITION'
    idComp = db.Column(db.Integer, primary_key=True, autoincrement=True)
    idLieu = db.Column(db.Integer, db.ForeignKey('LIEU.idLieu'), nullable=False)
    lieu = db.relationship('Lieu', backref='Lieu.idLieu')
    idSaison = db.Column(db.Integer, db.ForeignKey('SAISON.idSaison'), nullable=False)
    saison = db.relationship('Saison', backref='Saison.idSaison')
    idCat = db.Column(db.Integer, db.ForeignKey('CATEGORIE.idCat'), nullable=False)
    categorie = db.relationship('Categorie', backref='Categorie.idCat')
    idArme = db.Column(db.Integer, db.ForeignKey('ARME.idArme'), nullable=False)
    arme = db.relationship('Arme', backref='Arme.idArme')
    nomComp = db.Column(db.String(50), nullable=False)
    descComp = db.Column(db.String(50), nullable=False)
    dateComp = db.Column(db.Date, nullable=False)
    heureComp = db.Column(db.Time, nullable=False)
    sexeComp = db.Column(db.String(1), nullable=False)
    estIndividuelle = db.Column(db.Boolean, nullable=False)
    
    def __init__(self, idLieu, idSaison, idCat, idArme, nomComp, descComp, dateComp, heureComp, sexeComp, estIndividuelle):
        self.idLieu = idLieu
        self.idSaison = idSaison
        self.idCat = idCat
        self.idArme = idArme
        self.nomComp = nomComp
        self.descComp = descComp
        self.dateComp = dateComp
        self.heureComp = heureComp
        self.sexeComp = sexeComp
        self.estIndividuelle = estIndividuelle

# Modèle pour représenter la piste
class Piste(db.Model):
    __tablename__ = 'PISTE'
    idPiste = db.Column(db.Integer, primary_key=True, autoincrement=True)
    idComp = db.Column(db.Integer, db.ForeignKey('COMPETITION.idComp'), nullable=False)
    nomPiste = db.Column(db.String(50), nullable=False)
    estDispo = db.Column(db.Boolean, nullable=False)

    competition = db.relationship('Competition', backref='Competition.idComp')
    
    def __init__(self, competition, nom_piste, est_dispo):
        self.idComp = competition
        self.nomPiste = nom_piste
        self.estDispo = est_dispo

# Modèle pour représenter le type de match
class TypeMatch(db.Model):
    __tablename__ = 'TYPE_MATCH'
    idTypeMatch = db.Column(db.Integer, primary_key=True, autoincrement=True)
    nomTypeMatch = db.Column(db.String(50), nullable=False)
    nbTouches = db.Column(db.Integer, nullable=False)
    
    def __init__(self, nom_type_match, nb_touches):
        self.nomTypeMatch = nom_type_match
        self.nbTouches = nb_touches

# Modèle pour représenter l'escrimeur
class Escrimeur(db.Model):
    __tablename__ = 'ESCRIMEUR'
    numeroLicenceE = db.Column(db.Integer, nullable=False, primary_key=True)
    idCat = db.Column(db.Integer, db.ForeignKey('CATEGORIE.idCat'), nullable=False)
    prenomE = db.Column(db.String(50), nullable=False)
    nomE = db.Column(db.String(50), nullable=False)
    dateNaissanceE = db.Column(db.Date, nullable=False)
    sexeE = db.Column(db.String(50), nullable=False)
    numTelE = db.Column(db.Integer, nullable=True)

    categorie = db.relationship('Categorie', backref='categorie')

    def __init__(self, categorie, prenom_e, nom_e, date_naissance_e, numero_licence_e, sexe_e, num_tel_e):
        self.idCat = categorie
        self.numeroLicenceE = numero_licence_e
        self.idCat = categorie
        self.prenomE = prenom_e
        self.nomE = nom_e
        self.dateNaissanceE = date_naissance_e
        self.sexeE = sexe_e
        self.numTelE = num_tel_e
        
    def to_dict(self):
        return {
            'idCat': self.idCat,
            'prenomE': self.prenomE,
            'nomE': self.nomE,
            'dateNaissanceE': self.dateNaissanceE.isoformat() if self.dateNaissanceE else None,
            'numeroLicenceE': self.numeroLicenceE,
            'sexeE': self.sexeE,
            'numTelE': self.numTelE
        }

    
# Modèle pour représenter les tireurs
class Tireur(db.Model):
    __tablename__ = 'TIREUR'
    numeroLicenceE = db.Column(db.Integer, db.ForeignKey('ESCRIMEUR.numeroLicenceE'), primary_key=True)
    idClub = db.Column(db.Integer, db.ForeignKey('CLUB.idClub'), nullable=False)
    classement = db.Column(db.Integer, nullable=False)

    club = db.relationship('Club', backref='Club.idClub')
    escrimeur = db.relationship('Escrimeur', backref='Escrimeur.tireur')

    def __init__(self, num_licence, club, classement):
        self.numeroLicenceE = num_licence
        self.idClub = club
        self.classement = classement
    
    def to_dict(self):
        dic_tireur = self.escrimeur.to_dict()
        dic_tireur['idClub'] = self.idClub
        dic_tireur['nomClub'] = self.club.nomClub
        dic_tireur['classement'] = self.classement
        return dic_tireur
        
# Modèle pour représenter les arbitres
class Arbitre(db.Model):
    __tablename__ = 'ARBITRE'
    idArbitre = db.Column(db.Integer, primary_key=True, autoincrement=True)    
    numeroLicenceE = db.Column(db.Integer, db.ForeignKey('ESCRIMEUR.numeroLicenceE'))
    
    arbitre = db.relationship('Escrimeur', backref='Arbitre.numeroLicenceE')

    def __init__(self, numeroLicenceE):
        self.numeroLicenceE = numeroLicenceE
        

# Modèle pour représenter les participants aux compétitions
class ParticipantsCompetition(db.Model):
    __tablename__ = 'PARTICIPANTS_COMPETITION'
    numeroLicenceE = db.Column(db.Integer, db.ForeignKey('ESCRIMEUR.numeroLicenceE'), primary_key=True)
    idComp = db.Column(db.Integer, db.ForeignKey('COMPETITION.idComp'), primary_key=True)

    tireur = db.relationship('Escrimeur', backref='PartEscrimeur', foreign_keys=[numeroLicenceE])
    competition = db.relationship('Competition', backref='PartCompetition.idComp')
    
    def __init__(self, numeroLicenceE, idComp):
        self.numeroLicenceE = numeroLicenceE
        self.idComp = idComp

       
# Modèle pour représenter la relation entre les escrimeurs et les armes qu'ils pratiquent
class PratiquerArme(db.Model):
    __tablename__ = 'PRATIQUER_ARME'
    numero_licence_e_fk = db.Column(db.Integer, db.ForeignKey('ESCRIMEUR.numeroLicenceE'), primary_key=True)
    id_arme_fk = db.Column(db.Integer, db.ForeignKey('ARME.idArme'), primary_key=True)

    escrimeur = db.relationship('Escrimeur', backref='armes_pratiquees')
    arme = db.relationship('Arme', backref='pratiquee_par')
    
    def __init__(self, numero_licence_e_fk, id_arme_fk):
        self.numero_licence_e_fk = numero_licence_e_fk
        self.id_arme_fk = id_arme_fk

# Modèle pour représenter le classement final
class ClassementFinal(db.Model):
    __tablename__ = 'CLASSEMENT_FINAL'
    idClassementFinal = db.Column(db.Integer, primary_key=True, autoincrement=True)
    idComp = db.Column(db.Integer, db.ForeignKey('COMPETITION.idComp'), nullable=False)
    numeroLicenceE = db.Column(db.Integer, db.ForeignKey('TIREUR.numeroLicenceE'), nullable=False)
    position = db.Column(db.Integer, nullable=False)

    competition = db.relationship('Competition', backref='competition')
    tireur = db.relationship('Tireur', backref='Tireur.numeroLicenceE')
    
    def __init__(self, comp, tireur, position):
        self.idComp = comp
        self.numeroLicenceE = tireur
        self.position = position

# Modèle pour représenter les poules
class Poule(db.Model):
    __tablename__ = 'POULE'
    idPoule = db.Column(db.Integer, primary_key=True, autoincrement=True)
    idComp = db.Column(db.Integer, db.ForeignKey('COMPETITION.idComp'), nullable=False)
    idPiste = db.Column(db.Integer, db.ForeignKey('PISTE.idPiste'), nullable=False)
    idArbitre = db.Column(db.Integer, db.ForeignKey('ARBITRE.idArbitre'), nullable=False)
    nomPoule = db.Column(db.String(50), nullable=False)

    competition = db.relationship('Competition', backref='poules')
    piste = db.relationship('Piste', backref='Piste.idPiste')
    arbitre = db.relationship('Arbitre', backref='Arbitre.idArbitre')
    
    def __init__(self, competition, piste, arbitre, nom_poule):
        self.idComp = competition
        self.idPiste = piste
        self.idArbitre = arbitre
        self.nomPoule = nom_poule

# Modèle pour représenter les participants aux poules
class ParticipantsPoule(db.Model):
    __tablename__ = 'PARTICIPANTS_POULE'
    idPoule = db.Column(db.Integer, db.ForeignKey('POULE.idPoule'), primary_key=True)
    numeroLicenceE = db.Column(db.Integer, db.ForeignKey('TIREUR.numeroLicenceE'), primary_key=True)

    poule = db.relationship('Poule', backref='Poule.idPoule')
    tireur = db.relationship('Tireur', backref='poule_participants')
    
    def __init__(self, poule, tireur):
        self.idPoule = poule
        self.numeroLicenceE = tireur

# Modèle pour représenter les matchs de poule
class MatchPoule(db.Model):
    __tablename__ = 'MATCH_POULE'
    idMatch = db.Column(db.Integer, primary_key=True, autoincrement=True)
    idTypeMatch = db.Column(db.Integer, db.ForeignKey('TYPE_MATCH.idTypeMatch'), nullable=False)
    idPoule = db.Column(db.Integer, db.ForeignKey('POULE.idPoule'), nullable=False)
    idPiste = db.Column(db.Integer, db.ForeignKey('PISTE.idPiste'), nullable=False)
    idArbitre = db.Column(db.Integer, db.ForeignKey('ARBITRE.idArbitre'), nullable=False)
    numeroLicenceE1 = db.Column(db.Integer, db.ForeignKey('TIREUR.numeroLicenceE'), nullable=False)
    numeroLicenceE2 = db.Column(db.Integer, db.ForeignKey('TIREUR.numeroLicenceE'), nullable=False)
    dateMatch = db.Column(db.Date, nullable=False)
    heureMatch = db.Column(db.Time, nullable=False)
    touchesRecuesTireur1 = db.Column(db.Integer)
    touchesDonneesTireur1 = db.Column(db.Integer)
    touchesRecuesTireur2 = db.Column(db.Integer)
    touchesDonneesTireur2 = db.Column(db.Integer)

    type_match = db.relationship('TypeMatch', backref='TypeMatch.idTypeMatch')
    poule = db.relationship('Poule', backref='matches')
    piste = db.relationship('Piste', backref='matches')
    arbitre = db.relationship('Arbitre', backref='matches')
    tireur1 = db.relationship('Tireur', foreign_keys=[numeroLicenceE1], backref='Tireur.numeroLicenceE1')
    tireur2 = db.relationship('Tireur', foreign_keys=[numeroLicenceE2], backref='Tireur.numeroLicenceE2')
    
    def __init__(self, type_match, poule, piste, arbitre, tireur1, tireur2, date_match, heure_match, touches_recues_tireur1, touches_donnees_tireur1, touches_recues_tireur2, touches_donnees_tireur2):
        self.idTypeMatch = type_match
        self.idPoule = poule
        self.idPiste = piste
        self.idArbitre = arbitre
        self.numeroLicenceE1 = tireur1
        self.numeroLicenceE2 = tireur2
        self.dateMatch = date_match
        self.heureMatch = heure_match
        self.touchesRecuesTireur1 = touches_recues_tireur1
        self.touchesDonneesTireur1 = touches_donnees_tireur1
        self.touchesRecuesTireur2 = touches_recues_tireur2
        self.touchesDonneesTireur2 = touches_donnees_tireur2

# Modèle pour représenter les feuilles de match
class FeuilleMatch(db.Model):
    __tablename__ = 'FEUILLE_MATCH'
    idFeuille = db.Column(db.Integer, primary_key=True, autoincrement=True)
    idPoule = db.Column(db.Integer, db.ForeignKey('POULE.idPoule'), nullable=False)
    idComp = db.Column(db.Integer, db.ForeignKey('COMPETITION.idComp'), nullable=False)
    numeroLicenceE1 = db.Column(db.Integer, db.ForeignKey('TIREUR.numeroLicenceE'), nullable=False)
    numeroLicenceE2 = db.Column(db.Integer, db.ForeignKey('TIREUR.numeroLicenceE'), nullable=False)
    scoreTireur1 = db.Column(db.Integer)
    scoreTireur2 = db.Column(db.Integer)
    
    poule = db.relationship('Poule', backref='feuille_matches')
    competition = db.relationship('Competition', backref='feuille_matches')
    tireur1 = db.relationship('Tireur', foreign_keys=[numeroLicenceE1], backref='matches_as_tireur1')
    tireur2 = db.relationship('Tireur', foreign_keys=[numeroLicenceE2], backref='matches_as_tireur2')

    def __init__(self, poule, competition, tireur1, tireur2, score_tireur1, score_tireur2):
        self.idPoule = poule
        self.idComp = competition
        self.numeroLicenceE1 = tireur1
        self.numeroLicenceE2 = tireur2
        self.scoreTireur1 = score_tireur1
        self.scoreTireur2 = score_tireur2
        
class User(db.Model, UserMixin):
    __tablename__ = 'USER'
    idUser = db.Column(db.Integer, primary_key=True)
    pseudoUser = db.Column(db.String (50), unique=True, nullable=False)
    mdpUser = db.Column(db.String (64), nullable=False)
    emailUser = db.Column(db.String (50), unique=True)
    statutUser = db.Column(db.String(50), nullable=False)
    def get_id(self):
        return self.idUser

@login_manager.user_loader
def load_user(username):
    return User.query.get(username)

def get_sample():
    return Competition.query.order_by(Competition.dateComp.desc()).all()

def get_competition_by_id(id_comp):
    return Competition.query.filter_by(idComp=id_comp).first()

def get_categories():
    categories = Categorie.query.all()
    return [categorie.nomCategorie for categorie in categories]


def get_saisons():
    saisons = Saison.query.all()
    return [saison.nomSaison for saison in saisons]

def get_lieux():
    lieux = Lieu.query.all()
    return [lieu.nomLieu for lieu in lieux]

def get_armes():
    armes = Arme.query.all()
    return [arme.nomArme for arme in armes]

def get_type_match():
    type_match = TypeMatch.query.all()
    return [type_match.nomTypeMatch for type_match in type_match]

def get_nb_participants(id_tournoi):
    participants_count = ParticipantsCompetition.query.join(Competition).filter(Competition.idComp == id_tournoi).count()
    return participants_count

def filtrer_competitions(competitions, categorie, arme, sexe, statut):
    comp_filtrer = competitions
    if categorie:
        comp_filtrer = [comp for comp in comp_filtrer if comp.categorie.nomCategorie == categorie]
    if arme:
        comp_filtrer = [comp for comp in comp_filtrer if comp.arme.nomArme == arme]
    if sexe:
        comp_filtrer = [comp for comp in comp_filtrer if comp.sexeComp == sexe]
    if statut:
        if statut == "A venir":
            comp_filtrer = [comp for comp in comp_filtrer if comp.dateComp > datetime.date.today()]
        elif statut == "Terminé":
            comp_filtrer = [comp for comp in comp_filtrer if comp.dateComp <= datetime.date.today()]
    return comp_filtrer

def filtrer_adherent(adherents, categorie, sexeE):
    adherents_filtrer = adherents 
    if categorie:
        adherents_filtrer = [adherent for adherent in adherents_filtrer if adherent.Categorie.nomCategorie == categorie]
    if sexeE:
        adherents_filtrer = [adherent for adherent in adherents_filtrer if adherent.Escrimeur.sexeE == sexeE]
    # if role == 'tireur':
    #     adherents_filtrer = [adherent for adherent in adherents_filtrer if adherent.Arbitre is None]
    # elif role == 'arbitre':
    #     adherents_filtrer = [adherent for adherent in adherents_filtrer if adherent.Arbitre is not None]
    return adherents_filtrer

def get_id_lieu(nom_lieu):
    lieu = Lieu.query.filter_by(nomLieu=nom_lieu).first()
    return lieu.idLieu if lieu else None

def get_id_saison(nom_saison):
    saison = Saison.query.filter_by(nomSaison=nom_saison).first()
    return saison.idSaison if saison else None

def get_liste_participants_competitions_tireurs(id_comp):
    return ParticipantsCompetition.query.join(Tireur, ParticipantsCompetition.numeroLicenceE == Tireur.numeroLicenceE).filter(ParticipantsCompetition.idComp == id_comp).all()

def get_liste_participants_competitions_arbitres(id_comp):
    return ParticipantsCompetition.query.join(Arbitre, ParticipantsCompetition.numeroLicenceE == Arbitre.numeroLicenceE).filter(ParticipantsCompetition.idComp == id_comp).all()

def get_classement_tireur(num_licence):
    return Tireur.query.filter_by(numeroLicenceE=num_licence).first().classement

def get_id_club_tireur(num_licence):
    return Tireur.query.filter_by(numeroLicenceE=num_licence).first().idClub

def get_id_arbitre_from_escrimeur(numero_licence):
    arbitre = Arbitre.query.filter_by(numeroLicenceE=numero_licence).first()
    if arbitre:
        return arbitre.idArbitre
    
def get_nom_club_by_id(id_club):
    return Club.query.filter_by(idClub=id_club).first().nomClub

def classer_tireurs(tireurs):
    return sorted(tireurs, key=lambda tireur : get_classement_tireur(tireur.numeroLicenceE), reverse=True)

def poules_fabriquables(tireurs, arbitres):
    return True if 3 <= len(tireurs) // len(arbitres) <= 7 and len(tireurs) > 3 else False

def nb_poules_fabriquables(arbitres):
    return [[] for _ in range(len(arbitres))]

def get_nb_arbitres(id_comp):
    return ParticipantsCompetition.query.join(Arbitre, ParticipantsCompetition.numeroLicenceE == Arbitre.numeroLicenceE).filter(ParticipantsCompetition.idComp == id_comp).count()

def get_nb_tireurs(id_comp):
    return ParticipantsCompetition.query.filter_by(idComp=id_comp).count() - get_nb_arbitres(id_comp)

def get_liste_pistes_selon_nb_arbitres(id_comp, nb_arbitres):
    return Piste.query.filter_by(idComp=id_comp).limit(nb_arbitres).all()

def fabriquer_poules_selon_classement(tireurs, arbitres, pistes):
    if not poules_fabriquables(tireurs, arbitres):
        return "Les poules ne sont pas fabriquables"
    
    liste_triee = classer_tireurs(tireurs)
    liste_poules = nb_poules_fabriquables(arbitres)
    tireurs_dans_poule = set()
    arbitres_dans_poule = set()
    pistes_associees = set()
    for i in range(len(liste_triee)):
        if arbitres[i % len(arbitres)] not in arbitres_dans_poule and pistes[i % len(arbitres)] not in pistes_associees:
            escrimeur = Escrimeur.query.filter_by(numeroLicenceE=arbitres[i].numeroLicenceE).first()
            piste = Piste.query.filter_by(idPiste=pistes[i].idPiste).first()
            nom_complet = f"{escrimeur.prenomE} {escrimeur.nomE}, {piste.nomPiste}"
            liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
            arbitres_dans_poule.add(arbitres[i])
            pistes_associees.add(pistes[i])
        if liste_triee[i] not in tireurs_dans_poule:
            if len(liste_poules[i % len(arbitres)]) < 7:
                escrimeur = Escrimeur.query.filter_by(numeroLicenceE=liste_triee[i].numeroLicenceE).first()
                nom_complet = f"{escrimeur.prenomE} {escrimeur.nomE}, Classement : {get_classement_tireur(escrimeur.numeroLicenceE)}"
                liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
                tireurs_dans_poule.add(liste_triee[i])
        
        if liste_triee[-i-1] not in tireurs_dans_poule:
            if len(liste_poules[i % len(arbitres)]) < 7:
                escrimeur = Escrimeur.query.filter_by(numeroLicenceE=liste_triee[-i-1].numeroLicenceE).first()
                nom_complet = f"{escrimeur.prenomE} {escrimeur.nomE}, Classement : {get_classement_tireur(escrimeur.numeroLicenceE)}"
                liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
                tireurs_dans_poule.add(liste_triee[-i-1])
    mal_trie = False
    indice_mal_trie = None
    for i in range(len(liste_poules)):
        if len(liste_poules[i]) - 1 < 3:
            mal_trie = True
            indice_mal_trie = i
            break
    if mal_trie:
        for i in range(len(liste_poules)):
            if len(liste_poules[i]) - 1 > 3:
                liste_poules[indice_mal_trie].append(liste_poules[i].pop())
                break
    return liste_poules 

def fabriquer_poules_decalage_club(tireurs, arbitres, pistes):
    if not poules_fabriquables(tireurs, arbitres):
        return "Les poules ne sont pas fabriquables"

    liste_triee = classer_tireurs(tireurs)
    liste_poules = nb_poules_fabriquables(arbitres)
    num_poule = 0
    arbitres_dans_poule = set()
    pistes_associees = set()
    for i in range(len(liste_triee)):
        if arbitres[i % len(arbitres)] not in arbitres_dans_poule and pistes[i % len(arbitres)] not in pistes_associees:
            escrimeur = Escrimeur.query.filter_by(numeroLicenceE=arbitres[i].numeroLicenceE).first()
            piste = Piste.query.filter_by(idPiste=pistes[i].idPiste).first()
            nom_complet = f"{escrimeur.prenomE} {escrimeur.nomE}, {piste.nomPiste}"
            liste_poules[i].append((escrimeur, nom_complet))
            arbitres_dans_poule.add(arbitres[i])
            pistes_associees.add(pistes[i])
        if len(liste_poules[i % len(arbitres)]) < 7:
            escrimeur = Escrimeur.query.filter_by(numeroLicenceE=liste_triee[i].numeroLicenceE).first()
            id_club_tireur = get_id_club_tireur(escrimeur.numeroLicenceE)
            nom_club_tireur = get_nom_club_by_id(id_club_tireur)
            nom_complet = f"{escrimeur.prenomE} {escrimeur.nomE}, Club : {nom_club_tireur}"
            if (escrimeur, nom_complet) not in liste_poules[i % len(arbitres)]:
                liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
            else:
                num_poule += 1
                if num_poule % len(arbitres) == 0:
                    liste_poules[i % len(arbitres)].append((escrimeur, nom_complet))
                    num_poule = 0
                else:
                    liste_poules[i % len(arbitres) + num_poule].append((escrimeur, nom_complet))
    mal_trie = False
    indice_mal_trie = None
    for i in range(len(liste_poules)):
        if len(liste_poules[i]) - 1 < 3:
            mal_trie = True
            indice_mal_trie = i
            break
    if mal_trie:
        for i in range(len(liste_poules)):
            if len(liste_poules[i]) - 1 > 3:
                liste_poules[indice_mal_trie].append(liste_poules[i].pop())
                break
    return liste_poules


def fabriquer_poules(tireurs, arbitres, pistes, type_poule):
    if not poules_fabriquables(tireurs, arbitres):
        return "Les poules ne sont pas fabriquables"
    match type_poule:
        case "Classement":
            liste_poules = fabriquer_poules_selon_classement(tireurs, arbitres, pistes)
        case "Club":
            liste_poules = fabriquer_poules_decalage_club(tireurs, arbitres, pistes)
    return liste_poules

def get_adherents():
    res =  db.session.query(Tireur, Escrimeur, Categorie) \
        .join(Escrimeur, Escrimeur.numeroLicenceE == Tireur.numeroLicenceE) \
        .join(Club, Club.idClub == Tireur.idClub) \
        .join(Categorie, Escrimeur.idCat == Categorie.idCat) \
        .filter(Club.nomClub == "BLOIS CE") \
        .add_columns(
            Tireur.idClub,
            Escrimeur.prenomE,
            Escrimeur.nomE,
            Escrimeur.dateNaissanceE,
            Escrimeur.numeroLicenceE,
            Escrimeur.sexeE,
            Escrimeur.numTelE,
            Categorie.nomCategoriea
        ) \
        .all()
    return res

def get_adherents_adapte_json():
    res = db.session.query(Escrimeur) \
        .join(Tireur, Escrimeur.numeroLicenceE == Tireur.numeroLicenceE) \
        .join(Club, Club.idClub == Tireur.idClub) \
        .join(Categorie, Escrimeur.idCat == Categorie.idCat) \
        .filter(Club.nomClub == "BLOIS CE") \
        .all()
    return res

def dernier_escrimeur_id():
    last_escrimeur = db.session.query(Escrimeur).order_by(Escrimeur.numeroLicenceE.desc()).first()
    if last_escrimeur:
        return last_escrimeur.numeroLicenceE
    else:
        return 0

def get_participants(id_comp, club=None):
    res = (
        db.session.query(ParticipantsCompetition, Escrimeur, Categorie)
        .join(Escrimeur, ParticipantsCompetition.numeroLicenceE == Escrimeur.numeroLicenceE)
        .join(Categorie, Escrimeur.idCat == Categorie.idCat)
        .join(Tireur, Tireur.numeroLicenceE == Escrimeur.numeroLicenceE)
        .join(Club, Club.idClub == Tireur.idClub)
        .outerjoin(Arbitre, Arbitre.numeroLicenceE == Escrimeur.numeroLicenceE)
        .filter(ParticipantsCompetition.idComp == id_comp)
        .filter(Arbitre.idArbitre == None)
    )
    if club is not None:
        if club == "!":
            res = res.filter(Club.nomClub != "BLOIS CE")
        else:
            res = res.filter(Club.nomClub == club)
    return res.add_columns(Escrimeur.prenomE, Escrimeur.nomE, Categorie.nomCategorie).all()

def get_liste_participants_competitions(id_comp):
    return ParticipantsCompetition.query.filter_by(idComp=id_comp).all()

def get_informations_escrimeur(numero_licence):
    return Escrimeur.query.filter_by(numeroLicenceE=numero_licence).first()

def get_id_poule(id_comp, id_piste, id_arbitre, nom_poule):
    return Poule.query.filter_by(idComp=id_comp, idPiste=id_piste, idArbitre=id_arbitre, nomPoule=nom_poule).first().idPoule

def get_arbitres(idcomp):
    arbitres = db.session.query(Arbitre, Escrimeur, Categorie).join(Escrimeur, Arbitre.numeroLicenceE == Escrimeur.numeroLicenceE).join(
        Categorie, Escrimeur.idCat == Categorie.idCat
    ).join(
        ParticipantsCompetition,
        ParticipantsCompetition.numeroLicenceE == Escrimeur.numeroLicenceE
    ).filter(ParticipantsCompetition.idComp == idcomp).all()
    return arbitres

def get_competition_statut(competition):
    participants = ParticipantsCompetition.query.filter_by(idComp=competition.idComp).first()
    if participants:
        # verifie si les poules ont été créées pour la compétition
        poules = Poule.query.filter_by(idComp=competition.idComp).first()
        if poules:
            # verifie si l’appel a été fait donc sil ya des scores entrés pour des matchs de poules)
            match_poule = MatchPoule.query.filter_by(idComp=competition.idComp).first()
            if match_poule and (match_poule.touchesRecuesTireur1 is not None or match_poule.touchesDonneesTireur1 is not None
                                or match_poule.touchesRecuesTireur2 is not None or match_poule.touchesDonneesTireur2 is not None):
                return 'score'
            else:
                return 'appel'
        else:
            return 'participants'
    else:
        return 'participants'
{% extends 'base.html' %} {% block content %}
<link
  rel="stylesheet"
  href="{{ url_for('static', filename='gestion_participants.css') }}"
/>
<script>
  var nbParticipantsBlois = {{ nb_participants_blois }};
  var nbParticipantsOther = {{ nb_participants_other }};
  var nbParticipantsArb = {{ participants_arb|length }};
  var competitionId = {{ competition.idComp }};
  var competitionGender = "{{ competition.sexeComp }}";   
</script>
<script src="{{ url_for('static', filename='js/condCompetValide.js') }}"></script>
<script src="{{ url_for('static', filename='js/gestionParticipant.js') }}"></script>
<script src="{{ url_for('static', filename='js/editField.js') }}"></script>
{% include 'progress-bar.html' %}
<section class="content">
  <section class="section-infopr">
    <div class="infotitre">
      <h2>INFORMATIONS PRINCIPALE</h2>
    </div>
    <section class="infopr">
      <div class="labelp">
        <p>Titre :</p>
        <p>Organisateur :</p>
        <p>Lieu :</p>
        <p>Date :</p>
        <p>Heure :</p> 
      </div>
      <div class="valeurp">
        <p id="nomComp">{{ competition.nomComp }}</p>
        <p id="descComp">{{ competition.descComp }}</p>
        <p id="lieu">{{ competition.lieu.nomLieu }}</p>
        <p id="dateComp">{{ competition.dateComp }}</p>
        <p id="heureComp">{{ competition.heureComp }}</p> <!-- Nouvelle ligne pour l'heure -->
      </div>
      <div class="actionsp">
        <img src="{{ url_for('static', filename='../static/img/edit.png') }}" onclick="editField('nomComp')" />
        <img src="{{ url_for('static', filename='../static/img/edit.png') }}" onclick="editField('descComp')" />
        <img src="{{ url_for('static', filename='../static/img/edit.png') }}" onclick="editField('lieu')" />
        <img src="{{ url_for('static', filename='../static/img/edit.png') }}" onclick="editField('dateComp')" />
        <img src="{{ url_for('static', filename='../static/img/edit.png') }}" onclick="editField('heureComp')" /> <!-- Nouvelle ligne pour l'heure -->
      </div>
    </section>
  </section>
  <section class="gestion-participants">
    <div class="infotitre">
      <h2>GESTION PARTICIPANTS</h2>
    </div>
    <section class="container-section-participants">
      <section class="escrimeblois">
        <div class="subtitreparticipant">
          <h3>Tireurs du Club de l’Escrime de Blois</h3>
          <p class="nb">{{ nb_participants_blois }}</p>
        </div>
        <div class="gestion-participants-list">
          {% if participants_blois %} 
          {% for participant in participants_blois %}
          <div class="gestionp">
            <div class="participant">
              <p>{{ participant.Escrimeur.prenomE }}</p>
              <p>{{ participant.Escrimeur.nomE }}</p>
              <p>|</p>
              <p>{{ participant.Categorie.nomCategorie }}</p>
            </div>
            <div class="suppd">
              <form action="{{ url_for('delete_participant', id_comp = competition.idComp,id=participant.Escrimeur.numeroLicenceE) }}" method="post">
                <button style="font-size: 30px" type="submit">-</button>
              </form>
            </div>
          </div>
          {% endfor %} {% else %}
          <p class="nullparticipant">Aucun participant de l'escrime de Blois</p>
          {% endif %}
          <div class="addp">
            <button style="font-size: 30px">+</button>
            <div class="submenu" style="display: none;">
                <input type="text" class="search" placeholder="Rechercher…">
                <ul class="escrimeurs-list"></ul>
            </div>
            </div>
          </div>
        </div>
      </section>

      <section class="escrime-other">
        <div class="subtitreparticipant">
          <h3>Tireurs d’autres club</h3>
          <p class="nb">{{ nb_participants_other }}</p>
        </div>
        <div class="gestion-participants-list">
          {% if participants_other %} 
          {% for participant in participants_other %}
          <div class="gestionp">
            <div class="participant">
              <p>{{ participant.Escrimeur.prenomE }}</p>
              <p>{{ participant.Escrimeur.nomE }}</p>
              <p>|</p>
              <p>{{ participant.Categorie.nomCategorie }}</p>
            </div>
            <div class="suppd">
              <form action="{{ url_for('delete_participant', id_comp = competition.idComp,id=participant.Escrimeur.numeroLicenceE) }}" method="post">
                <button style="font-size: 30px" type="submit">-</button>
              </form>
            </div>
          </div>
          {% endfor %}{% else %}
          <p class="nullparticipant">Aucun participant d'autres clubs</p>
          {% endif %}
          <div class="addp">
            <button style="font-size: 30px">+</button>
            <div class="submenu" style="display: none;">
                <input type="text" class="search" placeholder="Rechercher…">
                <ul class="escrimeurs-list"></ul>
            </div>
        </div>
      </section>
      <section class="escrime-arb">
        <div class="subtitreparticipant">
          <h3>Arbitres</h3>
          <p class="nb">{{ nb_participants_arb }}</p>
        </div>
        <div class="gestion-participants-list">
          {% if participants_arb %}
          {% for arbitre, escrimeur, categorie in participants_arb %}            <div class ="gestionp">
            <div class="participant">
              <p>{{ escrimeur.prenomE }}</p>
              <p>{{ escrimeur.nomE }}</p>
              <p>|</p>
              <p>{{ escrimeur.categorie.nomCategorie }}</p>
            </div>
            <div class="suppd">
              <form
                action="{{ url_for('delete_participant', id_comp = competition.idComp,id=escrimeur.numeroLicenceE) }}"
                method="post"
              >
                <button style="font-size: 30px" type="submit">-</button>
              </form>
            </div>
            </div>
            {% endfor %}
          {% else %}
            <p class = "nullparticipant">Aucun arbitres pour le moment</p>
          {% endif %}
          <div class="addp">
            <button style="font-size: 30px">+</button>
            <div class="submenu" style="display: none;">
                <input type="text" class="search" placeholder="Rechercher…">
                <ul class="escrimeurs-list"></ul>
            </div>
        </div>
      </section>
    </section>
  </section>
  <div class="center">
    <div class="btndiv">
      <a href="{{ url_for('home_default') }}" class="btn-annuler">ANNULER</a>
      <a href="{{ url_for('gestion_poules', id_comp = competition.idComp) }}" class="btn-publier"
        >CREER LES POULES</a
      >
    </div>
  </div>

  {% endblock %}
</section>
import random
from .app import app, db, mail
import logging
import math
from .ajout_bd import *
from flask import jsonify, render_template, session, url_for, redirect, request, flash
from .models import *
from flask_wtf import FlaskForm
from wtforms.validators import DataRequired
from wtforms import StringField, PasswordField
from hashlib import sha256
from flask_login import login_user, logout_user, current_user
from flask_mail import Message
from flask import make_response
from weasyprint import HTML

def send_verification_email(user_email, code):
    with app.app_context():
        msg = Message("Votre code de vérification", recipients=[user_email])
        msg.body = f"Votre code de vérification est : {code}"
        mail.send(msg)

logging.basicConfig(filename='debug.log', level=logging.DEBUG)
class LoginForm(FlaskForm):
    email_username = StringField('email_username', validators=[DataRequired()])
    password = PasswordField('password', validators=[DataRequired()])

    def get_authenticated_user(self):
        user = User.query.filter_by(emailUser=self.email_username.data).first()
        if user is None:
            user = User.query.filter_by(pseudoUser=self.email_username.data).first()
            if user is None:
                return None
        m = sha256 ()
        m.update(self.password.data.encode ())
        passwd = m. hexdigest ()
        return user if passwd == user.mdpUser else None
    
class InscriptionForm(FlaskForm):
    pseudo = StringField('pseudo', validators=[DataRequired()])
    email = StringField('email', validators=[DataRequired()])
    password = PasswordField('password', validators=[DataRequired()])
    comfirm_password = PasswordField('comfirm_password', validators=[DataRequired()])

class EditUserForm(FlaskForm):
    newpsswd = PasswordField("Nouveau mot de passe")
    confirm = PasswordField("Confirmez le nouveau mot de passe")
    username = StringField("Pseudonyme actuelle")
    password = PasswordField("Mot de passe actuelle")

@app.context_processor
def inject_user_status():
    if current_user.is_authenticated:
        return {"user_status": current_user.statutUser}
    return {"user_status": None}
    
@app.route("/gestion_score/")
def gestion_score():
    if request.method == "POST":
        pass
    rows_data = [
        {'Nom': 'Doe', 'Prenom': 'John', 'Club': 'Club A'},
        {'Nom': 'Smith', 'Prenom': 'Alice', 'Club': 'Club A'},
        {'Nom': 'Johnson', 'Prenom': 'Bob', 'Club': 'Club A'},
        {'Nom': 'Williams', 'Prenom': 'Emma', 'Club': 'Club A'}
    ]

    # Définir le nombre de lignes et de colonnes dans le tableau
    rows = len(rows_data)
    cols = len(rows_data)

    # Générer les données pour le tableau
    table_data = [[f'input_{i}_{j}' for j in range(cols)] for i in range(rows)]

    # Rendre le modèle HTML avec Flask
    return render_template('Score.html', table_data=table_data, rows_data=rows_data, rows=rows, cols=cols)

@app.route("/afficher-score-poule/<int:id_comp>/")
def afficher_score_poule(id_comp):
    competition = Competition.query.get_or_404(id_comp)
    scores = get_scores_for_competition(id_comp)
    return render_template('Affichage-score.html', data=scores, competition=competition)

def get_scores_for_competition(id_comp):
    classements = db.session.query(ClassementFinal, Escrimeur, Club).join(
        Tireur, ClassementFinal.numeroLicenceE == Tireur.numeroLicenceE
    ).join(
        Escrimeur, Tireur.numeroLicenceE == Escrimeur.numeroLicenceE
    ).join(
        Club, Tireur.idClub == Club.idClub
    ).filter(
        ClassementFinal.idComp == id_comp
    ).order_by(
        ClassementFinal.position
    ).all()
    
    scores = []
    for classement, escrimeur, club in classements:
        poules = Poule.query.filter_by(idComp=id_comp).subquery()

        victoires = db.session.query(MatchPoule).join(poules, MatchPoule.idPoule == poules.c.idPoule).filter(
            db.or_(
                db.and_(MatchPoule.numeroLicenceE1 == escrimeur.numeroLicenceE,
                        MatchPoule.touchesDonneesTireur1 > MatchPoule.touchesRecuesTireur1),
                db.and_(MatchPoule.numeroLicenceE2 == escrimeur.numeroLicenceE,
                        MatchPoule.touchesDonneesTireur2 > MatchPoule.touchesRecuesTireur2)
            )
        ).count()
        
        total_matchs = db.session.query(MatchPoule).join(poules, MatchPoule.idPoule == poules.c.idPoule).filter(
            db.or_(
                MatchPoule.numeroLicenceE1 == escrimeur.numeroLicenceE,
                MatchPoule.numeroLicenceE2 == escrimeur.numeroLicenceE
            )
        ).count()
        print(victoires, total_matchs)
        vm_ratio = (victoires / total_matchs) if total_matchs > 0 else "N/A"
        scores.append({
            'Classement': classement.position,
            'Prenom': escrimeur.prenomE,
            'Nom': escrimeur.nomE,
            'VM': vm_ratio,
            'Club': club.nomClub
        })
    
    return scores

@app.route("/telecharger-pdf/<int:id_comp>/")
def telecharger_pdf(id_comp):
    scores = get_scores_for_competition(id_comp)
    competition = Competition.query.get_or_404(id_comp)
    rendered = render_template('score_table_pdf.html', data=scores)
    pdf = HTML(string=rendered).write_pdf()
    response = make_response(pdf)
    response.headers['Content-Type'] = 'application/pdf'
    response.headers['Content-Disposition'] = f'attachment; filename=tableau_scores_{competition.nomComp}.pdf'
    return response

@app.route("/inscription-form/")
def inscription_page():
    return render_template("Inscription.html", form = InscriptionForm())

@app.route("/inscription/", methods=["GET", "POST"])
def inscription():
    f = InscriptionForm()
    if(User.query.filter_by(pseudoUser=f.pseudo.data).first() is not None or User.query.filter_by(emailUser=f.email.data).first() is not None or f.password.data != f.comfirm_password.data):
        if(User.query.filter_by(pseudoUser=f.pseudo.data).first() is not None):
            flash("Pseudo déjà utilisé", "error")
        if(User.query.filter_by(emailUser=f.email.data).first() is not None):
            flash("Email déjà utilisé", "error")
        if(f.password.data != f.comfirm_password.data):
            flash("Les mots de passe ne correspondent pas", "error")
        return render_template("Inscription.html", form=f)
    else:
        m = sha256()
        m.update(f.password.data.encode())
        u = User(pseudoUser=f.pseudo.data , mdpUser=m.hexdigest(), emailUser=f.email.data, statutUser="Utilisateur")
        db.session.add(u)
        db.session.commit()
        return redirect(url_for("home"))

@app.route("/login/", methods=["GET", "POST"])
def login():
    f = LoginForm()
    user = f.get_authenticated_user()
    if user:
        login_user(user)
        return redirect(url_for("home_default"))
    else:
        flash("Mot de passe incorrect", "error")
    return render_template("Login.html", form=f)

@app.route("/logout/")
def logout ():
    logout_user ()
    return redirect(url_for("home"))

@app.route('/home/<int:items>', methods=("GET","POST",))
def home_def(items):
    total_pages = 0
    if request.method == "POST":
        page = int(request.form.get('page', 1))
        if 'next' in request.form:
            page += 1
        elif 'prev' in request.form:
            page -= 1
        # récupere les selection du from
        session['categorie'] = request.form.get('categorie')
        session['arme'] = request.form.get('arme')
        session['sexe'] = request.form.get('sexe')
        session['statut'] = request.form.get('statut')
    else:
        page = request.args.get('page', 1, type=int)
        session['categorie'] = request.args.get('categorie', session.get('categorie'))
        session['arme'] = request.args.get('arme', session.get('arme'))
        session['sexe'] = request.args.get('sexe', session.get('sexe'))
        session['statut'] = request.args.get('statut', session.get('statut'))
    competitions = get_sample()
    categories = get_categories()
    armes = get_armes()
    nb_participants = {comp.idComp: get_nb_participants(comp.idComp) for comp in competitions}
    # filtre pour les compet
    compet_filtre = filtrer_competitions(competitions, session.get('categorie'), session.get('arme'), session.get('sexe'), session.get('statut'))
    if len(compet_filtre) !=0:
        total_pages = math.ceil(len(compet_filtre) / items)
        competitions = compet_filtre[(page - 1) * items:page * items]
    else:
        competitions = []
    return render_template(
        "competition.html",
        title="Compétitions ESCRIME",
        competitions=competitions, 
        categories=categories,
        armes=armes,
        nb_participants=nb_participants,
        items=items,
        selec_arme=session.get('arme'),
        selec_categorie=session.get('categorie'),
        selec_sexe=session.get('sexe'),
        selec_statut=session.get('statut'),
        page=page,
        compet_filtre = compet_filtre,
        total_pages=total_pages
    )
    
@app.route('/liste-adherent/<int:items>', methods=["GET", "POST"])
def liste_adherents(items):
    total_pages = 0
    if request.method == "POST":
        page = int(request.form.get('page', 1))
        if 'next' in request.form:
            page += 1
        elif 'prev' in request.form:
            page -= 1
    else:
        page = request.args.get('page', 1, type=int)
    adherents = get_adherents()
    categories = get_categories()
    role = request.form.get('statut', session.get('statuta', ''))
    categorie = request.form.get('categorie', session.get('categoriea', ''))
    sexe = request.form.get('sexe', session.get('sexea', ''))
    
    adherents = filtrer_adherent(adherents, categorie, sexe)
    if request.method == "POST":
        search_query = request.form.get('search')
        # recherche les adhérents en fonction du nom ou prénom
        if search_query:
            adherents = [adherent for adherent in adherents if search_query.lower() in adherent.Escrimeur.prenomE.lower() or search_query.lower() in adherent.Escrimeur.nomE.lower() or search_query.lower() in str(adherent.Escrimeur.numeroLicenceE)]            
    session['statuta'] = role
    session['categoriea'] = categorie
    session['sexea'] = sexe 
    if len(adherents) !=0:
        total_pages = math.ceil(len(adherents) / items)
        adherents = adherents[(page - 1) * items:page * items]
    else:
        adherents = []

    
    return render_template(
        "liste-adherents.html",
        title="Compétitions ESCRIME",
        categories=categories,
        selec_categorie=categorie,
        selec_sexe=sexe,
        selec_statut=role,
        adherents=adherents,
        items=items,
        page=page,
        total_pages=total_pages)

@app.route('/home/')
def home_default():
    return home_def(5)

    
@app.route('/annuler_comp', methods=['POST'])
def annuler_comp():
    # Rediriger vers l'URL d'origine
    return redirect(request.referrer or url_for('home_default'))

@app.route("/test_popup/")
def test_popup():
    return render_template(
        "test_popup.html",
        title="Test")

@app.route("/edit-user/<name>", methods=("GET","POST",))
def edit_user(name):
    form = EditUserForm()
    if not current_user.is_authenticated:
        next = "edit_user"
        return redirect(url_for("login", next=next))

    if form.validate_on_submit():
        print("Formulaire valide")
        user = current_user
        if user.pseudoUser != form.username.data:
            form.username.errors.append("Pseudonyme erreur")
            return render_template("edit-user.html", form=form, name=name, show_verification_popup=False)

        if form.newpsswd.data != form.confirm.data:
            form.confirm.errors.append("Les mots de passe ne correspondent pas")
            return render_template("edit-user.html", form=form, name=name, show_verification_popup=False)
        
        code = str(random.randint(1000, 9999))
        print(code)
        print(user.emailUser)
        send_verification_email(user.emailUser, code)
        print("Email envoyé")
        session['verification_code'] = code  # Stocker le code temporairement
        session['user_id'] = user.idUser
        session['new_password'] = form.newpsswd.data  # Stocker le nouveau mot de passe temporairement
        print("affichage popup")
        return render_template("edit-user.html", form=form, name=name, show_verification_popup=True)

    return render_template("edit-user.html", form=form, name=name, show_verification_popup=False)

@app.route("/verify-code/<name>", methods=["GET", "POST"])
def verify_code(name):
    if request.method == "POST":
        user_code = request.form['code']
        print(user_code)
        if user_code == session.get('verification_code'):
            # Récupérer l'utilisateur et les informations nécessaires
            user = User.query.get(session.get('user_id'))
            if not user:
                return "Utilisateur non trouvé", 404

            # Procéder à la mise à jour du mot de passe
            new_password = session.get('new_password')
            new_password_hash = sha256()
            new_password_hash.update(new_password.encode())

            user.mdpUser = new_password_hash.hexdigest()
            db.session.commit()

            # Nettoyer la session
            del session['verification_code']
            del session['user_id']
            del session['new_password']

            return redirect(url_for("home")) # "Mot de passe mis à jour avec succès!"
        else:
            flash("Code de vérification incorrect", "error")

    return render_template("edit-user.html", name=name, form=EditUserForm(), show_verification_popup=True)

@app.route('/ajouter_escrimeur/', methods=['GET', 'POST'])
def ajouter_escrimeur():
    if request.method == 'POST':
        id = dernier_escrimeur_id() + 1
        print(id)

        #recup donnees du formulaire
        nom = request.form['nom_e']
        print(nom)
        prenom = request.form['prenom_e']
        print(prenom)
        date_naissance = request.form['date_naissance_e']
        print(date_naissance)
        numero_licence = request.form['numero_licence_e']
        numero_licence = int(numero_licence)
        print(numero_licence)

        # sexe = request.form['sexe_e']
        sexe = 'H'
        print(sexe)
        # num_tel = request.form['num_tel_e']
        num_tel = '0648572519'
        print(num_tel)
        default_cat = 1
        
        # creez un nouvel enregistrement d'adherent
        nouvel_adherent = Escrimeur(categorie=default_cat, prenom_e=prenom, nom_e=nom, date_naissance_e=date_naissance, numero_licence_e=numero_licence, sexe_e=sexe, num_tel_e=num_tel)
        db.session.add(nouvel_adherent)
        db.session.commit()
        id_club_blois = 169 
        classement_tireur = 0 
        nouveau_tireur = Tireur(num_licence=numero_licence, club=id_club_blois, classement=classement_tireur)
        db.session.add(nouveau_tireur)
        db.session.commit()

        return redirect(url_for('liste_adherents_def'))
      
@app.route('/')
def home():
    return render_template('Login.html')

from flask import session

@app.route('/gestion_poules/<int:id_comp>', methods=["GET", "POST"])
def gestion_poules(id_comp):
    liste_poules = []
    nb_tireurs = get_nb_tireurs(id_comp)
    nb_arbitres = get_nb_arbitres(id_comp)
    nb_tireurs_par_poule = nb_tireurs // nb_arbitres

    if request.method == "POST":
        classement_checked = 'classement' in request.form
        club_checked = 'club' in request.form
        equilibrer_checked = 'equilibrer' in request.form
        nb_poules = int(request.form.get('nb_poules'))
        nb_tireurs_poules_str = request.form.get('nb_tireurs/poules')
        if nb_tireurs_poules_str and nb_tireurs_poules_str.isdigit():
            nb_tireurs_poules = int(nb_tireurs_poules_str)
        liste_tireurs = get_liste_participants_competitions_tireurs(id_comp)
        liste_arbitres = get_liste_participants_competitions_arbitres(id_comp)
        liste_pistes = get_liste_pistes_selon_nb_arbitres(id_comp, nb_arbitres)
        nb_tireurs_par_poule = nb_tireurs // nb_arbitres
        numero_licence_arbitre = request.form.get('numero_licence_arbitre')
        id_arbitre = get_id_arbitre_from_escrimeur(numero_licence_arbitre)
        if classement_checked:
            liste_tireurs = classer_tireurs(liste_tireurs)
            if poules_fabriquables(liste_tireurs, liste_arbitres):
                liste_poules = fabriquer_poules(liste_tireurs, liste_arbitres, liste_pistes, "Classement")
        elif club_checked:
            if poules_fabriquables(liste_tireurs, liste_arbitres):
                liste_poules = fabriquer_poules(liste_tireurs, liste_arbitres, liste_pistes, "Club")
        session["liste_poules"] = [ [escrimeur[0].numeroLicenceE for escrimeur in poule] for poule in liste_poules]
        session["liste_arbitres"] = [arbitre.numeroLicenceE for arbitre in liste_arbitres]
        session["liste_pistes"] = [piste.idPiste for piste in liste_pistes]
        return render_template('gestion_poules.html', id_comp=id_comp, nb_tireurs=get_nb_tireurs(id_comp), 
                               nb_arbitres=get_nb_arbitres(id_comp), liste_tireurs=liste_tireurs, liste_arbitres=liste_arbitres, 
                               liste_poules=liste_poules, nb_tireurs_par_poule=nb_tireurs_par_poule, liste_pistes=liste_pistes) 

    liste_tireurs = get_liste_participants_competitions_tireurs(id_comp)
    liste_arbitres = get_liste_participants_competitions_arbitres(id_comp)
    liste_pistes = get_liste_pistes_selon_nb_arbitres(id_comp, nb_arbitres)
    competition = Competition.query.get(id_comp)    
    if competition is not None:
        return render_template('gestion_poules.html', id_comp=id_comp, nb_tireurs=nb_tireurs, nb_arbitres=nb_arbitres, 
                               liste_tireurs=liste_tireurs, liste_arbitres=liste_arbitres, 
                               liste_poules=liste_poules, nb_tireurs_par_poule=nb_tireurs_par_poule, liste_pistes=liste_pistes)
        

@app.route("/appel/<int:id_comp>", methods=["GET", "POST"])
def appel(id_comp):
    rows_data = []
    participants_present = []
    if request.method == "POST":
        pistes = session.get("liste_pistes")
        arbitres = session.get("liste_arbitres")
        liste_poules = session.get("liste_poules")
        try:
            for i in range(len(liste_poules)):
                num_licence_arbitre = arbitres[i]
                id_arbitre = get_id_arbitre_from_escrimeur(num_licence_arbitre)
                nom_poule = f"Poule {i+1}"
                id_piste = pistes[i]
                ajouter_poule(id_comp, id_piste, id_arbitre, nom_poule)
                id_poule = get_id_poule(id_comp, id_piste, id_arbitre, nom_poule)
                for j in range(1, len(liste_poules[i])):
                    ajouter_participant_poule(id_poule, liste_poules[i][j])
                    tireur = Tireur.query.get(liste_poules[i][j])
                    rows_data.append(tireur.to_dict())
            redirect(url_for('appel', id_comp=id_comp))
            competition = Competition.query.get(id_comp) 
            return render_template('appel.html', competition = competition, rows_data=rows_data, participants_present=participants_present)
        except Exception as e:
            print(e)
    competition = Competition.query.get(id_comp)  
    if competition is not None:
        rows_data = []
        participants_comp = get_liste_participants_competitions(id_comp)
        participants_comp = get_liste_participants_competitions(id_comp)
        for participant in participants_comp:
            dict_tireur = participant.tireur.to_dict()
            rows_data.append(dict_tireur)
        participants_present = []
        print(rows_data)
        return render_template('appel.html', competition = competition, rows_data=rows_data, participants_present=participants_present)
    
@app.route('/adherent/')
def liste_adherents_def():
    return liste_adherents(5)
  

@app.route("/ajout-comp")
def ajout_comp_page():
    armes = get_armes()
    categories = get_categories()
    lieux = get_lieux()
    types = ["Individuelle", "Equipe"]
    return render_template("ajout-comp.html", listeArmes=armes, listeCategories=categories, listeTypeMatch=types, lieux=lieux)

@app.route('/ajout-comp/', methods=['POST'])
def ajout_comp():
    # Récupérez les données du formulaire
    nomLieu = request.form.get('nomLieu')
    adresseLieu = request.form.get('adresseLieu')
    villeLieu = request.form.get('villeLieu')
    cpLieu = request.form.get('codePostalLieu')
    nomSaison = "Saison 2023"  # Supposons que c'est fixe pour cet exemple
    nomCat = request.form.get('categorie')  # Assurez-vous que le nom correspond au champ dans le HTML
    nomArme = request.form.get('arme')  # Idem
    nomComp = request.form.get('titre')
    nomOrga = request.form.get('organisateur')
    descComp = f"Competition {nomComp} organisée par {nomOrga}" # Ajoutez un champ pour la description si nécessaire
    dateComp = request.form.get('date-deroulement')
    heureComp = request.form.get('appt')
    sexeComp = request.form.get('sexe')[:1].upper()
    estIndividuelle = request.form.get('type') == 'Individuelle'
    print(nomLieu,adresseLieu,villeLieu,cpLieu, nomSaison, nomCat, nomArme, nomComp, nomOrga, descComp, dateComp, heureComp, sexeComp, estIndividuelle)

    resultat = creer_competition(nomLieu,adresseLieu,villeLieu,cpLieu, nomSaison, nomCat, nomArme, nomComp, descComp, dateComp, heureComp, sexeComp, estIndividuelle)
    if isinstance(resultat, Competition):
        return redirect(url_for('gestion_participants', id_comp=resultat.idComp))
    else:
        return redirect(url_for('ajout_comp_page'))

# @app.route('/annuler_comp', methods=['POST'])
# def annuler_comp():
#     if lieu is None:
#         lieu = Lieu(nom_lieu=form.lieu.data, ville_lieu="", code_postal_lieu=0, adresse_lieu="")
#         db.session.add(lieu)
#         db.session.commit()
#         competition = Competition(idLieu=lieu.idLieu, 
#                                   idSaison=Saison.query.get(1).idSaison,
#                                   idCat=getattr(Categorie.query.filter_by(nomCategorie=form.categorie.data).first(), 'idCat', None),
#                                   idArme=getattr(Arme.query.filter_by(nomArme=form.arme.data).first(), 'idArme', None),
#                                   nomComp=form.titre.data,
#                                   descComp=f"Competition organisée par {form.organisateur.data}", 
#                                   dateComp=form.date_deroulement.data,
#                                   heureComp=form.heure_debut.data,
#                                   sexeComp=form.sexe.data[:1],
#                                   estIndividuelle=form.type_comp.data == 'individuel')
#         db.session.add(competition)
#         db.session.commit()
#         flash('La compétition a été ajoutée') # à changer avec une popup
#         return redirect(url_for('home'))

#     # Rediriger vers l'URL d'origine
#     return redirect(request.referrer or url_for('home_default'))

@app.route("/gestion_participants/<int:id_comp>", methods=("GET", "POST"))
def gestion_participants(id_comp):
    competition = Competition.query.get(id_comp)
    participants_blois = get_participants(id_comp, club="BLOIS CE")
    participants_other = get_participants(id_comp, club="!")
    participants_arb = get_arbitres(id_comp)
    nb_participants_blois = len(participants_blois)
    nb_participants_other = len(participants_other)
    nb_participants_arb = len(participants_arb)
    
    return render_template(
      "gestion-participants.html",
      title="Gestion des participants",
      participants_blois=participants_blois,
      nb_participants_blois=nb_participants_blois,
      participants_other=participants_other,
      nb_participants_other=nb_participants_other,
      competition=competition,
      participants_arb=participants_arb,
      nb_participants_arb=nb_participants_arb
  )

@app.route('/ajouter_arbitre_competition/<int:id_comp>', methods=['POST'])
def ajouter_arbitre_competition(id_comp):
        data = request.get_json()
        numeroLicenceE = data.get('numeroLicenceE')
        logging.debug(numeroLicenceE)
        arbitre = Arbitre(numeroLicenceE)
        db.session.add(arbitre)
        participant = ParticipantsCompetition(numeroLicenceE, id_comp)
        db.session.add(participant)

        db.session.commit()
        logging.debug("ça passe commit participant compet")

        return jsonify({'success': True, 'message': 'Arbitre ajouté avec succès'})

@app.route('/get_escrimeurs/<gender>')
def get_escrimeurs_json(gender):
    escrimeurs = None
    if gender == 'M': 
        escrimeurs = Escrimeur.query.all()
    elif gender == "H":
        gender = "Homme"
        escrimeurs = Escrimeur.query.filter_by(sexeE=gender).all()
    elif gender == "F":
        gender = "Femme"
        escrimeurs = Escrimeur.query.filter_by(sexeE=gender).all()
    return jsonify([escrimeur.to_dict() for escrimeur in escrimeurs])

@app.route('/get_adherents')
def get_adherents_json():
    escrimeurs = get_adherents_adapte_json()
    return jsonify([escrimeur.to_dict() for escrimeur in escrimeurs])


@app.route('/delete_participant/<int:id_comp>/<int:id>/', methods=['POST'])
def delete_participant(id, id_comp):
    participant = ParticipantsCompetition.query.filter_by(numeroLicenceE=id).first()

    if participant:
        db.session.delete(participant)
        db.session.commit()
    return redirect(url_for('gestion_participants', id_comp=id_comp))

import logging

logging.basicConfig(filename='debug.log', level=logging.DEBUG)

@app.route('/ajouter_escrimeur_competition/<int:id_comp>/', methods=['POST'])
def add_participant(id_comp):
    if request.method == 'POST':
        tireur = request.get_json().get('numeroLicenceE')
        logging.debug(f'numerolicence_tireur: {tireur}')
        
        tireur = Tireur.query.get(tireur)
        
        logging.debug(f'tireur: {tireur}')

        competition = Competition.query.get(id_comp)
        logging.debug(f'competition: {competition}')
        getattr(competition, "idComp", None)
        if tireur and competition:
            participant = ParticipantsCompetition(numeroLicenceE=getattr(tireur, "numeroLicenceE", None), idComp=getattr(competition, "idComp", None))
            logging.debug('creation participant')
            db.session.add(participant)
            logging.debug('crash ?')
            try:
                db.session.commit()
                logging.debug('Commit successful')
            except Exception as e:
                db.session.rollback()
                logging.error(f'Error during commit: {str(e)}')
            logging.debug('Participant added successfully')
        else:
            logging.debug('Failed to add participant')
    return redirect(url_for('gestion_participants', id_comp=id_comp))

@app.route('/update_database', methods=['POST'])
def update_database():
    data = request.get_json()
    field = data.get('field')
    value = data.get('value')
    competition_id = data.get('competitionId')
    competition = Competition.query.get(competition_id)
    setattr(competition, field, value)
    db.session.commit()
    return 'OK'

@app.route('/competition/<int:id_comp>')
def actu_stat_comp(id_comp):
    competition = Competition.query.get_or_404(id_comp)
    state = get_competition_statut(competition)
    if state == 'participants':
        return redirect(url_for('gestion_participants', id_comp=id_comp))
    elif state == 'poule':
        return redirect(url_for('gestion_poules', id_comp=id_comp))
    elif state == 'appel':
        return redirect(url_for('appel', id_comp=id_comp))
    elif state == 'score':
        return redirect(url_for('gestion_score', id_comp=id_comp))
    else:
        return "les problèmes"