import re

def parse_syntactic(text):
    """
    Analyse le texte d'entrée en sections de textes, cartes mémoire et exercices.

    Args:
        text (str): Le texte d'entrée à analyser en un dictionnaire de listes.

    Returns:
        dict: Un dictionnaire avec les clés 'texts', 'flashcards', et 'exercises' contenant les listes respectives.
    """
    # Initialisation des listes
    texts = []
    flashcards = []
    exercises = []

    sections = re.split(r'#(TX|FL|EX)%', text)

    # Parcourir les sections et les séparer en listes
    for i in range(1, len(sections), 2):
        section_type = sections[i]
        section_content = sections[i + 1].strip()

        if section_type == 'TX':
            texts.extend(section_content.split('#%'))
        elif section_type == 'FL':
            flashcards.extend(section_content.split('#%'))
        elif section_type == 'EX':
            exercises.extend(section_content.split('#%'))

    # Nettoyer les listes pour supprimer les éléments vides
    texts = [text.strip() for text in texts if text.strip()]
    flashcards = [flashcard.strip() for flashcard in flashcards if flashcard.strip()]
    exercises = [exercise.strip() for exercise in exercises if exercise.strip()]

    return {'texts': texts, 'flashcards': flashcards, 'exercises': exercises}


def parse_parts(text):
    """
    Analyse un texte structuré et extrait les différentes sections en une liste de dictionnaires.

    Paramètres:
    text (str): Le texte à analyser.

    Retourne:
    tuple: Un tuple contenant le titre extrait (str) et la liste des éléments (list of dict).
    """
    # Vérification de l'unicité du champ TI
    ti_matches = re.findall(r'#TI%(.*?)(?=#PA%|#TX%|#FL%|#EX%|$)', text, re.DOTALL)
    title = ''
    if len(ti_matches) == 1:
        title = ti_matches[0].strip()
    else:
        title = 'Title Error'
    
    print("Texte reçu en entrée de parse_parts : ", text)

    # Initialisation de la liste de dictionnaires
    elements = []

    # Utilisation de regex pour extraire les sections
    sections = re.split(r'#(TI|PA|TX|FL|EX)%', text)

    # Parcourir les sections et les séparer en listes
    for i in range(1, len(sections), 2):
        type_section = sections[i]
        contenu_section = sections[i + 1].strip()

        if type_section == 'PA':
            elements.append({'type': 'title', 'prompt': contenu_section})
        elif type_section == 'TX':
            elements.append({'type': 'text', 'prompt': contenu_section})
        elif type_section == 'FL':
            elements.append({'type': 'flashcard', 'prompt': contenu_section})
        elif type_section == 'EX':
            elements.append({'type': 'exercise', 'prompt': contenu_section})

    return title, elements


def extract_text(delta, main_only=False):
    text = ""
    if not 'ops' in delta:
        print("[extract_text] Erreur: delta n'a pas de clé 'ops'")
        return ""
    for op in delta['ops']:
        if op['insert']:
            if main_only and (not 'attributes' in op or 'header' not in op['attributes']):
                text += op['insert'] 
            elif not main_only:
                text += op['insert']
        if 'formula' in op:
            text += op['formula']
            # Éliminer les mots courts et retours à la ligne
    text = text.replace('\n', '')
    if main_only:
        text = ''.join([word for word in text.split(' ') if len(word) >= 2])
    return text

# # Exemple d'utilisation
# texte = """
# #TI%Introduction aux Réseaux de Neurones
# #PA%Concepts Fondamentaux
# #TX%Les réseaux de neurones sont un type d'algorithme d'apprentissage automatique qui est inspiré du fonctionnement du cerveau humain.
# #TX%Ils sont utilisés pour résoudre des problèmes complexes tels que la reconnaissance d'images, le traitement du langage naturel et la prédiction de séries temporelles.
# """

# titre, elements = parse_parts(texte)
# print("Titre:", titre)
# print("Éléments:", elements)