reformulation

import pyexcel
from Levenshtein import ratio as levenshtein_ratio


def verif_langue(entree_actuelle, entree_suivante, lexiqueFR, lexiqueEN):
    # Calculer le nombre de mots dans chaque entrée
    nb_mots_actuelle = len(entree_actuelle)
    nb_mots_suivante = len(entree_suivante)

    # Calculer le nombre de mots en français ou en anglais pour chaque entrée
    nb_fr_actuelle = sum(1 for mot in entree_actuelle if mot in lexiqueFR)
    nb_en_actuelle = sum(1 for mot in entree_actuelle if mot in lexiqueEN)
    nb_fr_suivante = sum(1 for mot in entree_suivante if mot in lexiqueFR)
    nb_en_suivante = sum(1 for mot in entree_suivante if mot in lexiqueEN)

    # Vérifier si 60% des mots dans entree_actuelle et entree_suivante sont en français
    if nb_fr_actuelle/nb_mots_actuelle >= 0.6 and nb_fr_suivante/nb_mots_suivante >= 0.6:
        return "fr"
    
    # Vérifier si 60% des mots dans entree_actuelle et entree_suivante sont en anglais
    elif nb_en_actuelle/nb_mots_actuelle >= 0.6 and nb_en_suivante/nb_mots_suivante >= 0.6:
        return "en"
    
    else:
        return "mixte"

def classer_requete(requete, stop_words):
    mots = [mot for mot in ' '.join(requete).split() if mot.lower() not in stop_words]
    nb_mots = len(mots)
    if nb_mots <= 2:
        return "courte"
    elif nb_mots <= 4:
        return "moyenne"
    else:
        return "longue"

def position_modification(mot_modifie, entree_actuelle):
    mots_entree_actuelle = list(entree_actuelle)
    #print(mot_modifie, "-->", mots_entree_actuelle)
    if mot_modifie == mots_entree_actuelle[0]:
        return "au début"
    elif mot_modifie == mots_entree_actuelle[-1]:
        return "à la fin"
    else:
        return "au milieu"



fichier_lexiqueFR = open ("/usr/share/dict/french", mode="r")
lexiqueFR=set()
for mot in fichier_lexiqueFR:
    mot=mot.rstrip("\n")
    lexiqueFR.add(mot)
fichier_lexiqueFR.close()

fichier_lexique_uk = open("/usr/share/dict/british-english", mode="r")
fichier_lexique_us = open("/usr/share/dict/american-english", mode="r")

lexiqueEN = set()

for mot in fichier_lexique_uk:
    mot = mot.rstrip("\n")
    lexiqueEN.add(mot)

for mot in fichier_lexique_us:
    mot = mot.rstrip("\n")
    lexiqueEN.add(mot)

fichier_lexique_uk.close()
fichier_lexique_us.close()


with open('stoplist.txt', 'r') as stop_file:
    stop_words = set([line.strip() for line in stop_file])

# Récupérer les données depuis le fichier ods
donnees = pyexcel.get_sheet(file_name='CoSTQueries.ods')

# Ouvrir le fichier de sortie en mode écriture
fichier = open('output.tsv', 'w')

# Parcourir les lignes de données
for ligne in range(1, donnees.number_of_rows() - 1):
    # Récupérer l'entrée actuelle et l'entrée suivante
    entree_actuelle = set(donnees[ligne, 2].split())
    entree_suivante = set(donnees[ligne+1, 2].split())
    # Convertir les entrées en minuscule
    entree_actuelle = set([mot.lower() for mot in entree_actuelle])
    entree_suivante = set([mot.lower() for mot in entree_suivante])
    # Récupérer la tâche
    tache = donnees[ligne, 3]
    # Vérifier si la tâche ne contient pas "Med"
    if "Med" not in tache:
        # Vérifier si l'entrée actuelle et l'entrée suivante ont chacune au moins deux mots
        if len(entree_actuelle) >= 2 and len(entree_suivante) >= 2:
            # Initialiser les variables de différence de mots
            nombre_diff = 0
            mots_ajoutes = ""
            mots_supprimes = ""
            mots_modifies = []



            
            # Parcourir les mots de l'entrée actuelle
            for mot in entree_actuelle:
                # Ignorer stop words
                if mot in stop_words:
                    continue
                # Vérifier si le mot est présent dans l'entrée suivante
                if mot not in entree_suivante:
                    # Levenshtein ratio
                    ratio_max = 0
                    for suivant_mot in entree_suivante:
                        ratio = levenshtein_ratio(mot, suivant_mot)
                        if ratio > ratio_max:
                            ratio_max = ratio
                    if ratio_max < 0.75:
                        # Incrémenter le nombre de différences
                        nombre_diff += 1
                        # Vérifier si le nombre de différences est supérieur à 2
                        if nombre_diff > 2:
                            break
                        # Ajouter les mots modifiés, ajoutés et supprimés dans les variables correspondantes
                        mots_supprimes += (mot + " ")
                        mots_modifies.append(mot + " ")
                        
            # Parcourir les mots de l'entrée suivante pour chercher les mots ajoutés
            for mot in entree_suivante:
                # Ignorer stop words
                if mot in stop_words:
                    continue
                # Vérifier si le mot est présent dans l'entrée actuelle
                if mot not in entree_actuelle:
                    # Levenshtein ratio
                    ratio_max = 0
                    for actuel_mot in entree_actuelle:
                        ratio = levenshtein_ratio(mot, actuel_mot)
                        if ratio > ratio_max:
                            ratio_max = ratio
                    if ratio_max < 0.75:
                        # Incrémenter le nombre de différences
                        nombre_diff += 1
                        # Vérifier si le nombre de différences est supérieur à 2
                        if nombre_diff > 2:
                            break
                        # Ajouter les mots ajoutés et modifiés dans les variables correspondantes
                        mots_ajoutes += (mot + " ")
                        mots_modifies.append(mot + " ")



            # Vérifier si le nombre de différences est égal à 1
            if nombre_diff == 1:
                # Vérifier si l'entrée actuelle a plus de mots que l'entrée suivante
                if len(entree_actuelle) > len(entree_suivante):
                    # Écrire les entrées dans le fichier de sortie
                    fichier.write(donnees[ligne, 2] + '\t' + donnees[ligne+1, 2] + '\t')
                    fichier.write('supprimé\t' + mots_supprimes.strip()+ '\t' + verif_langue(entree_actuelle, entree_suivante, lexiqueFR, lexiqueEN)+ \
                     '\t' + classer_requete(entree_actuelle, stop_words) + '\t' + position_modification(mots_supprimes.strip(), entree_actuelle) + '\n')

                    

                # Vérifier si l'entrée actuelle a moins de mots que l'entrée suivante
                elif len(entree_actuelle) < len(entree_suivante):
                    fichier.write(donnees[ligne, 2] + '\t' + donnees[ligne+1, 2] + '\t')
                    fichier.write('ajouté\t' + mots_ajoutes.strip()+ '\t' + verif_langue(entree_actuelle, entree_suivante, lexiqueFR, lexiqueEN)+ \
                        '\t'+ classer_requete(entree_actuelle, stop_words) + '\t' + position_modification(mots_ajoutes.strip(), entree_suivante) +'\n')
                    
            
            # Vérifier s'il y a des mots modifiés
            elif nombre_diff == 2 and len(entree_actuelle.difference(entree_suivante)) == 1 and len(entree_suivante.difference(entree_actuelle)) == 1:
                fichier.write(donnees[ligne, 2] + '\t' + donnees[ligne+1, 2] + '\t')
                fichier.write('modifié\t' + entree_actuelle.difference(entree_suivante).pop() + ' --> ' + entree_suivante.difference(entree_actuelle).pop()+ '\t' + \
                    verif_langue(entree_actuelle, entree_suivante, lexiqueFR, lexiqueEN)+ '\t' + classer_requete(entree_actuelle, stop_words) + \
                    '\t' + position_modification(entree_suivante.difference(entree_actuelle).pop(), entree_suivante) +'\n')
             





fichier.close()
print("Traitement terminé !")