Update app.py

app.py

@@ -1,21 +1,16 @@
 import streamlit as st
 import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import time
-import json
-import os
-import uuid
-import zipfile
 import io
+import zipfile
 import base64
+import uuid
+import os
 from datetime import datetime
-from typing import Dict, List, Any, Tuple
 
 # Configuration de la page
 st.set_page_config(
-    page_title="VisiPilot IFS Food 8",
-    page_icon="🔍",
+    page_title="Plan d'Actions IFS Food 8",
+    page_icon="📋",
     layout="wide",
     initial_sidebar_state="expanded"
 )
@@ -23,29 +18,21 @@ st.set_page_config(
 # Styles CSS
 st.markdown("""
 <style>
-    .main-header {
-        font-size: 28px;
+    .header {
+        font-size: 24px;
         font-weight: bold;
-        color: #0066cc;
+        color: #1E3D59;
         text-align: center;
         margin-bottom: 20px;
         padding: 10px 0;
         border-bottom: 2px solid #e0f7fa;
     }
-    .banner {
-        background-image: url('https://github.com/M00N69/BUSCAR/blob/main/logo%2002%20copie.jpg?raw=true');
-        background-size: cover;
-        height: 150px;
-        background-position: center;
-        margin-bottom: 20px;
-        border-radius: 10px;
-    }
     .card {
         padding: 15px;
-        border-radius: 10px;
+        border-radius: 5px;
         background-color: #f9f9f9;
         margin-bottom: 15px;
-        border-left: 5px solid #0066cc;
+        border-left: 3px solid #1E3D59;
     }
     .status-badge {
         display: inline-block;
@@ -67,65 +54,37 @@ st.markdown("""
         background-color: #dc3545;
         color: white;
     }
-    .button-container {
-        display: flex;
-        gap: 10px;
-    }
-
-    /* Style personnalisé pour les expanders de recommandation */
-    .recommendation-expander {
-        background-color: #e6f2ff !important;
-        border-radius: 8px !important;
-        border: 1px solid #b3d9ff !important;
-        margin-top: 10px !important;
-    }
-
-    /* Modification du style des éléments d'expander de Streamlit */
-    .st-emotion-cache-1abe2ax, .st-emotion-cache-ue6h4q, .st-emotion-cache-1y4p8pa {
-        background-color: #e6f2ff !important;
-    }
-    /* Modification pour le header d'expander */
-    .st-emotion-cache-19rxjzo {
-        background-color: #cce5ff !important;
-    }
-
-    /* Style pour les onglets de rôle */
-    .role-tab {
-        padding: 15px;
-        border-radius: 10px;
-        text-align: center;
-        cursor: pointer;
-        transition: all 0.3s;
+    .attachment {
+        padding: 5px;
+        margin: 5px;
+        border: 1px solid #ddd;
+        border-radius: 4px;
+        display: inline-block;
     }
-    .role-tab:hover {
-        transform: translateY(-3px);
-        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+    .section-title {
+        color: #1E3D59;
+        font-weight: bold;
+        margin-top: 10px;
+        margin-bottom: 5px;
     }
-    .role-tab-active {
-        border: 2px solid #0066cc;
-        background-color: #e6f2ff;
+    .section-content {
+        padding: 10px;
+        background-color: #f5f5f5;
+        border-radius: 5px;
+        margin-bottom: 10px;
     }
-    .role-tab-inactive {
-        border: 1px solid #cccccc;
-        background-color: #f9f9f9;
+    .info-text {
+        font-style: italic;
+        color: #666;
     }
-
-    /* Style pour les vignettes de pièces jointes */
-    .attachment-thumbnail {
-        border: 1px solid #ddd;
-        border-radius: 5px;
-        padding: 5px;
-        margin: 5px;
-        display: inline-block;
-        max-width: 150px;
+    .requirement-text {
+        font-weight: bold;
     }
-    .attachment-name {
-        font-size: 12px;
-        overflow: hidden;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-        max-width: 140px;
-        text-align: center;
+    .finding-text {
+        font-style: italic;
+        border-left: 2px solid #ffc107;
+        padding-left: 10px;
+        margin: 10px 0;
     }
 </style>
 """, unsafe_allow_html=True)
@@ -133,16 +92,12 @@ st.markdown("""
 # Initialiser les états de session
 if 'role' not in st.session_state:
     st.session_state['role'] = "site"  # site, auditor, reviewer
-if 'action_plan_df' not in st.session_state:
-    st.session_state['action_plan_df'] = None
-if 'recommendations' not in st.session_state:
-    st.session_state['recommendations'] = {}
-if 'responses' not in st.session_state:
-    st.session_state['responses'] = {}
-if 'attachments' not in st.session_state:
-    st.session_state['attachments'] = {}
+if 'audit_data' not in st.session_state:
+    st.session_state['audit_data'] = None
 if 'comments' not in st.session_state:
     st.session_state['comments'] = {}
+if 'attachments' not in st.session_state:
+    st.session_state['attachments'] = {}
 if 'audit_metadata' not in st.session_state:
     st.session_state['audit_metadata'] = {
         "audit_id": str(uuid.uuid4()),
@@ -150,1041 +105,773 @@ if 'audit_metadata' not in st.session_state:
         "site_name": "",
         "auditor_name": "",
         "reviewer_name": "",
-        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        "last_modified": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        "validation": {
-            "site": False,
-            "auditor": False,
-            "reviewer": False
-        }
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     }
-if 'history' not in st.session_state:
-    st.session_state['history'] = []
 if 'active_item' not in st.session_state:
     st.session_state['active_item'] = None
-if 'ask_questions' not in st.session_state:
-    st.session_state['ask_questions'] = {}
-if 'api_key' not in st.session_state:
-    st.session_state['api_key'] = ""
-
-# Fonctions pour gérer le fichier .auditpack
-
-def create_auditpack() -> bytes:
-    """Crée un fichier .auditpack contenant toutes les données actuelles"""
-    # Préparer les données pour le JSON principal
-    audit_data = {
-        "metadata": st.session_state['audit_metadata'],
-        "plan_action": st.session_state['action_plan_df'].to_dict() if st.session_state['action_plan_df'] is not None else {},
-        "recommendations": st.session_state['recommendations'],
-        "responses": st.session_state['responses'],
-        "comments": st.session_state['comments'],
-        "history": st.session_state['history']
-    }
+if 'excel_metadata' not in st.session_state:
+    st.session_state['excel_metadata'] = {}
 
-    # Mettre à jour la date de dernière modification
-    audit_data["metadata"]["last_modified"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-    # Créer un fichier ZIP en mémoire
-    zip_buffer = io.BytesIO()
-
-    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as audit_zip:
-        # Ajouter le JSON principal
-        audit_zip.writestr("audit_data.json", json.dumps(audit_data, indent=2))
-
-        # Ajouter les pièces jointes
-        for idx, attachments in st.session_state['attachments'].items():
-            for file_name, file_data in attachments.items():
-                file_path = f"attachments/{idx}/{file_name}"
-                audit_zip.writestr(file_path, file_data)
-
-    zip_buffer.seek(0)
-    return zip_buffer.getvalue()
-
-def load_auditpack(file_data: bytes) -> bool:
-    """Charge les données d'un fichier .auditpack"""
+# Fonction pour extraire les métadonnées du fichier Excel
+def extract_excel_metadata(uploaded_file):
     try:
-        # Créer un buffer en mémoire avec les données du fichier
-        zip_buffer = io.BytesIO(file_data)
-
-        with zipfile.ZipFile(zip_buffer, "r") as audit_zip:
-            # Extraire et charger le JSON principal
-            with audit_zip.open("audit_data.json") as f:
-                audit_data = json.loads(f.read())
-
-            # Mettre à jour les données de session
-            st.session_state['audit_metadata'] = audit_data["metadata"]
-
-            # Charger le plan d'action
-            if "plan_action" in audit_data and audit_data["plan_action"]:
-                st.session_state['action_plan_df'] = pd.DataFrame.from_dict(audit_data["plan_action"])
-
-            st.session_state['recommendations'] = audit_data.get("recommendations", {})
-            st.session_state['responses'] = audit_data.get("responses", {})
-            st.session_state['comments'] = audit_data.get("comments", {})
-            st.session_state['history'] = audit_data.get("history", [])
-
-            # Extraire les pièces jointes
-            attachments = {}
-            for file_info in audit_zip.namelist():
-                if file_info.startswith("attachments/"):
-                    # Format expected: attachments/item_id/filename
-                    parts = file_info.split("/")
-                    if len(parts) == 3:
-                        item_id = parts[1]
-                        filename = parts[2]
-
-                        if item_id not in attachments:
-                            attachments[item_id] = {}
-
-                        attachments[item_id][filename] = audit_zip.read(file_info)
-
-            st.session_state['attachments'] = attachments
-
-            # Ajouter une entrée d'historique
-            history_entry = {
-                "action": "load_auditpack",
-                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "role": st.session_state['role'],
-                "details": f"Chargement du fichier audit par {st.session_state['role']}"
-            }
-            st.session_state['history'].append(history_entry)
-
-            return True
+        # Lire les premières lignes pour extraire les métadonnées
+        metadata_df = pd.read_excel(uploaded_file, header=None, nrows=10)
+        
+        # Créer un dictionnaire pour stocker les métadonnées
+        metadata = {}
+        
+        # Extraire les informations pertinentes (adapter selon la structure exacte)
+        if len(metadata_df) >= 1 and len(metadata_df.columns) >= 2:
+            # Ligne 1: Entreprise et adresse
+            enterprise_info = metadata_df.iloc[0, 0] if not pd.isna(metadata_df.iloc[0, 0]) else ""
+            metadata["enterprise"] = enterprise_info
+            
+            # Ligne 2: Référentiel
+            if len(metadata_df) >= 2:
+                standard_info = metadata_df.iloc[1, 0] if not pd.isna(metadata_df.iloc[1, 0]) else ""
+                metadata["standard"] = standard_info
+            
+            # Ligne 3: Type d'audit
+            if len(metadata_df) >= 3:
+                audit_type = metadata_df.iloc[2, 0] if not pd.isna(metadata_df.iloc[2, 0]) else ""
+                metadata["audit_type"] = audit_type
+            
+            # Ligne 4: Date d'audit
+            if len(metadata_df) >= 4:
+                audit_date = metadata_df.iloc[3, 0] if not pd.isna(metadata_df.iloc[3, 0]) else ""
+                metadata["audit_date"] = audit_date
+        
+        return metadata
     except Exception as e:
-        error_message = f"⚠️ Erreur lors du chargement du fichier : {str(e)}"
-        st.error(error_message)
-        return False
+        st.error(f"Erreur lors de l'extraction des métadonnées: {str(e)}")
+        return {}
 
-# Charger le fichier Excel avec le plan d'action
-def load_action_plan(uploaded_file):
+# Fonction pour charger les données d'audit
+def load_audit_data(uploaded_file):
     try:
-        # Utiliser header=11 pour sauter les lignes d'en-tête
-        action_plan_df = pd.read_excel(uploaded_file, header=11)
-        action_plan_df = action_plan_df[["requirementNo", "requirementText", "requirementExplanation"]]
-        action_plan_df.columns = ["Numéro d'exigence", "Exigence IFS Food 8", "Explication (par l'auditeur/l'évaluateur)"]
-
-        # Ajouter une colonne de statut
-        action_plan_df["Statut"] = "Non traité"
-
-        # Supprimer les lignes vides (où le numéro d'exigence est NaN ou vide)
-        action_plan_df = action_plan_df.dropna(subset=["Numéro d'exigence"])
-        action_plan_df = action_plan_df[action_plan_df["Numéro d'exigence"].astype(str).str.strip() != ""]
-
-        # Ajouter à l'historique
-        history_entry = {
-            "action": "load_excel",
-            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "role": st.session_state['role'],
-            "details": f"Chargement du plan d'action Excel par {st.session_state['role']}"
+        # Extraire d'abord les métadonnées
+        metadata = extract_excel_metadata(uploaded_file)
+        st.session_state['excel_metadata'] = metadata
+        
+        # Charger les données d'Excel - en sautant les lignes d'en-tête (les 11 premières lignes)
+        df = pd.read_excel(uploaded_file, header=11)
+        
+        # Sélectionner uniquement les colonnes pertinentes
+        columns_to_use = [
+            "requirementNo", "requirementText", "requirementScore", "requirementExplanation",
+            "correctionDescription", "correctionResponsibility", "correctionDueDate", "correctionStatus",
+            "correctionEvidence", "correctiveActionDescription", "correctiveActionResponsibility",
+            "correctiveActionDueDate", "correctiveActionStatus", "releaseResponsibility", "releaseDate"
+        ]
+        
+        # Vérifier que toutes les colonnes existent
+        existing_columns = [col for col in columns_to_use if col in df.columns]
+        df = df[existing_columns]
+        
+        # Création du mapping de colonnes
+        column_mapping = {
+            "requirementNo": "reference",
+            "requirementText": "requirement",
+            "requirementScore": "score",
+            "requirementExplanation": "finding",
+            "correctionDescription": "correction",
+            "correctionResponsibility": "correction_responsibility",
+            "correctionDueDate": "correction_due_date",
+            "correctionStatus": "correction_status",
+            "correctionEvidence": "evidence_type",
+            "correctiveActionDescription": "corrective_action",
+            "correctiveActionResponsibility": "corrective_action_responsibility",
+            "correctiveActionDueDate": "corrective_action_due_date",
+            "correctiveActionStatus": "corrective_action_status",
+            "releaseResponsibility": "release_responsibility",
+            "releaseDate": "release_date"
         }
-        st.session_state['history'].append(history_entry)
-
-        return action_plan_df
+        
+        # Renommer les colonnes
+        df = df.rename(columns=column_mapping)
+        
+        # Ajouter un statut global pour notre application
+        if "status" not in df.columns:
+            # Initialiser le statut à "Non traité"
+            df["status"] = "Non traité"
+            
+            # Si les valeurs pour correction ou action corrective sont remplies, statut "En cours"
+            in_progress_mask = df["correction"].notna() | df["corrective_action"].notna()
+            df.loc[in_progress_mask, "status"] = "En cours"
+            
+            # Si les deux ont un statut "Completed", alors le statut global est "Complété"
+            completed_mask = (df["correction_status"] == "Completed") & (df["corrective_action_status"] == "Completed")
+            df.loc[completed_mask, "status"] = "Complété"
+            
+            # Si une date de validation est présente, alors le statut est "Validé"
+            validated_mask = df["release_date"].notna()
+            df.loc[validated_mask, "status"] = "Validé"
+        
+        # Ajouter une colonne pour l'analyse de cause racine si elle n'existe pas
+        if "root_cause" not in df.columns:
+            df["root_cause"] = ""
+        
+        # Ajouter une colonne pour la méthode de vérification si elle n'existe pas
+        if "verification_method" not in df.columns:
+            df["verification_method"] = ""
+        
+        # Supprimer les lignes vides (où le numéro d'exigence est vide)
+        df = df.dropna(subset=["reference"])
+        
+        return df
     except Exception as e:
-        error_message = f"⚠️ Erreur lors de la lecture du fichier: {str(e)}"
-        st.error(error_message)
+        st.error(f"Erreur lors du chargement des données: {str(e)}")
         return None
 
-# Détecter la langue du texte
-def detect_language(text):
-    # Liste de mots français courants pour détection simple
-    french_words = ["et", "les", "des", "dans", "pour", "avec", "par", "sur", "en", "au", "aux",
-                   "de", "la", "le", "du", "un", "une", "cette", "est", "sont", "ont", "qui",
-                   "non", "conformité", "exigence", "auditeur"]
-
-    # Compter les mots français
-    text_lower = text.lower()
-    french_count = sum(1 for word in french_words if f" {word} " in f" {text_lower} ")
-
-    # Si au moins 3 mots français sont détectés, considérer comme français
-    return "fr" if french_count >= 3 else "en"
-
-# Générer des questions adaptées à la non-conformité
-def generate_questions(non_conformity):
-    req_text = non_conformity["Exigence IFS Food 8"]
-    audit_comment = non_conformity["Explication (par l'auditeur/l'évaluateur)"]
-
-    # Détecter les mots-clés pour personnaliser les questions
-    keywords = {
-        "formation": ["formation", "compétence", "qualification", "personnel"],
-        "documentation": ["document", "procédure", "enregistrement", "contrôle"],
-        "équipement": ["équipement", "matériel", "maintenance", "installation"],
-        "hygiène": ["hygiène", "nettoyage", "désinfection", "contamination"],
-        "traçabilité": ["traçabilité", "lot", "identification", "rappel"]
+# Fonction pour créer un package d'export
+def create_export_package():
+    # Préparer les données pour l'export
+    export_data = {
+        "metadata": st.session_state['audit_metadata'],
+        "excel_metadata": st.session_state['excel_metadata'],
+        "audit_data": st.session_state['audit_data'].to_dict('records') if st.session_state['audit_data'] is not None else [],
+        "comments": st.session_state['comments']
     }
-
-    # Questions de base
-    questions = [
-        {
-            "id": "context",
-            "question": "Décrivez brièvement le contexte actuel lié à cette exigence dans votre entreprise."
-        },
-        {
-            "id": "cause",
-            "question": "Selon vous, quelle est la cause principale de cette non-conformité ?"
-        }
-    ]
-
-    # Ajouter des questions spécifiques en fonction des mots-clés
-    for category, terms in keywords.items():
-        for term in terms:
-            if term.lower() in req_text.lower() or term.lower() in audit_comment.lower():
-                if category == "formation":
-                    questions.append({
-                        "id": "training",
-                        "question": "Le personnel a-t-il reçu une formation spécifique sur ce sujet ? Si oui, quand était la dernière formation ?"
-                    })
-                    break
-                elif category == "documentation":
-                    questions.append({
-                        "id": "documentation",
-                        "question": "Disposez-vous d'une procédure ou d'instructions pour ce processus ? Est-elle à jour ?"
-                    })
-                    break
-                elif category == "équipement":
-                    questions.append({
-                        "id": "equipment",
-                        "question": "Les équipements concernés sont-ils adaptés et correctement entretenus ?"
-                    })
-                    break
-                elif category == "hygiène":
-                    questions.append({
-                        "id": "hygiene",
-                        "question": "Quelles sont vos pratiques actuelles de nettoyage/désinfection dans cette zone ?"
-                    })
-                    break
-                elif category == "traçabilité":
-                    questions.append({
-                        "id": "traceability",
-                        "question": "Comment assurez-vous actuellement la traçabilité dans ce processus ?"
-                    })
-                    break
-
-    # Limiter à 3 questions maximum
-    return questions[:3]
-
-# Fonction pour vérifier si l'API est disponible
-def is_groq_api_available():
-    return st.session_state.get('api_key', "") != ""
-
-# Générer une recommandation (version hybride API/locale) - CORRIGÉ
-def generate_recommendation(non_conformity, responses=None, direct=False):
-    # Vérifier si l'API Groq est disponible
-    use_api = is_groq_api_available()
-
-    # Détection de la langue
-    combined_text = f"{non_conformity['Exigence IFS Food 8']} {non_conformity['Explication (par l'auditeur/l'évaluateur)']}"
-    language = detect_language(combined_text)
-
-    if use_api:
-        try:
-            # Tentative d'utilisation de l'API
-            from pocketgroq import GroqProvider
-            groq = GroqProvider(api_key=st.session_state['api_key'])
-
-            # Construire le prompt selon la langue détectée
-            if language == "fr":
-                if direct:
-                    prompt = (
-                        f"En tant qu'expert en IFS Food 8 et en sécurité alimentaire, "
-                        f"analysez cette non-conformité et proposez un plan d'action complet.\n\n"
-                        f"# NON-CONFORMITÉ\n"
-                        f"- Exigence N°: {non_conformity['Numéro d\'exigence']}\n"
-                        f"- Exigence IFS Food 8: {non_conformity['Exigence IFS Food 8']}\n"
-                        f"- Constat de l'auditeur: {non_conformity['Explication (par l\'auditeur/l\'évaluateur)']}\n\n"
-                        f"# VOTRE MISSION\n"
-                        "Fournir une analyse et un plan d'action structuré avec les sections suivantes:\n\n"
-                        "1. ANALYSE DE LA NON-CONFORMITÉ\n"
-                        "Analysez la situation et identifiez clairement le problème.\n\n"
-                        "2. ANALYSE DES CAUSES\n"
-                        "Identifiez et détaillez les causes racines probables.\n\n"
-                        "3. PLAN D'ACTION\n"
-                        "   a) Actions immédiates (corrections)\n"
-                        "   b) Type de preuves à fournir\n"
-                        "   c) Actions correctives à long terme\n\n"
-                        "4. MÉTHODES DE VALIDATION DE L'EFFICACITÉ\n"
-                        "Comment vérifier que les actions mises en place sont efficaces.\n\n"
-                        "5. RECOMMANDATIONS COMPLÉMENTAIRES\n\n"
-                        "Rédigez l'ensemble de l'analyse en français et fournissez des recommandations spécifiques, réalistes et conformes à l'IFS Food 8."
-                    )
-                else:
-                    prompt = (
-                        f"En tant qu'expert en IFS Food 8 et en sécurité alimentaire, "
-                        f"analysez cette non-conformité et les informations fournies pour proposer un plan d'action adapté.\n\n"
-                        f"# NON-CONFORMITÉ\n"
-                        f"- Exigence N°: {non_conformity['Numéro d\'exigence']}\n"
-                        f"- Exigence IFS Food 8: {non_conformity['Exigence IFS Food 8']}\n"
-                        f"- Constat de l'auditeur: {non_conformity['Explication (par l\'auditeur/l\'évaluateur)']}\n\n"
-                        f"# INFORMATIONS FOURNIES PAR L'UTILISATEUR\n"
-                        f"{json.dumps(responses, indent=2)}\n\n"
-                        f"# VOTRE MISSION\n"
-                        "Fournir une analyse et un plan d'action structuré avec les sections suivantes:\n\n"
-                        "1. ANALYSE DE LA NON-CONFORMITÉ\n"
-                        "Analysez la situation et identifiez clairement le problème en tenant compte des informations fournies.\n\n"
-                        "2. ANALYSE DES CAUSES\n"
-                        "Identifiez et détaillez les causes racines probables.\n\n"
-                        "3. PLAN D'ACTION\n"
-                        "   a) Actions immédiates (corrections)\n"
-                        "   b) Type de preuves à fournir\n"
-                        "   c) Actions correctives à long terme\n\n"
-                        "4. MÉTHODES DE VALIDATION DE L'EFFICACITÉ\n"
-                        "Comment vérifier que les actions mises en place sont efficaces.\n\n"
-                        "5. RECOMMANDATIONS COMPLÉMENTAIRES\n\n"
-                        "Rédigez l'ensemble de l'analyse en français et fournissez des recommandations spécifiques, réalistes et conformes à l'IFS Food 8."
-                    )
-            else:
-                # En anglais
-                if direct:
-                    prompt = (
-                        f"As an IFS Food 8 and food safety expert, analyze this non-conformity and provide a comprehensive action plan.\n\n"
-                        f"# NON-CONFORMITY\n"
-                        f"- Requirement No.: {non_conformity['Numéro d\'exigence']}\n"
-                        f"- IFS Food 8 Requirement: {non_conformity['Exigence IFS Food 8']}\n"
-                        f"- Auditor's finding: {non_conformity['Explication (par l\'auditeur/l\'évaluateur)']}\n\n"
-                        f"# YOUR MISSION\n"
-                        "Provide an analysis and structured action plan with the following sections:\n\n"
-                        "1. ANALYSIS OF THE NON-CONFORMITY\n"
-                        "Analyze the situation and clearly identify the problem.\n\n"
-                        "2. ROOT CAUSE ANALYSIS\n"
-                        "Identify and detail the probable root causes.\n\n"
-                        "3. ACTION PLAN\n"
-                        "   a) Immediate actions (corrections)\n"
-                        "   b) Type of evidence to be provided\n"
-                        "   c) Long-term corrective actions\n\n"
-                        "4. METHODS FOR VALIDATING EFFECTIVENESS\n"
-                        "How to verify that the implemented actions are effective.\n\n"
-                        "5. ADDITIONAL RECOMMENDATIONS\n\n"
-                        "Write the entire analysis in English and provide specific, realistic recommendations that comply with IFS Food 8."
-                    )
-                else:
-                    prompt = (
-                        f"As an IFS Food 8 and food safety expert, analyze this non-conformity and the information provided to propose an adapted action plan.\n\n"
-                        f"# NON-CONFORMITY\n"
-                        f"- Requirement No.: {non_conformity['Numéro d\'exigence']}\n"
-                        f"- IFS Food 8 Requirement: {non_conformity['Exigence IFS Food 8']}\n"
-                        f"- Auditor's finding: {non_conformity['Explication (par l\'auditeur/l\'évaluateur)']}\n\n"
-                        f"# INFORMATION PROVIDED BY THE USER\n"
-                        f"{json.dumps(responses, indent=2)}\n\n"
-                        f"# YOUR MISSION\n"
-                        "Provide an analysis and structured action plan with the following sections:\n\n"
-                        "1. ANALYSIS OF THE NON-CONFORMITY\n"
-                        "Analyze the situation and clearly identify the problem, taking into account the information provided.\n\n"
-                        "2. ROOT CAUSE ANALYSIS\n"
-                        "Identify and detail the probable root causes.\n\n"
-                        "3. ACTION PLAN\n"
-                        "   a) Immediate actions (corrections)\n"
-                        "   b) Type of evidence to be provided\n"
-                        "   c) Long-term corrective actions\n\n"
-                        "4. METHODS FOR VALIDATING EFFECTIVENESS\n"
-                        "How to verify that the implemented actions are effective.\n\n"
-                        "5. ADDITIONAL RECOMMENDATIONS\n\n"
-                        "Write the entire analysis in English and provide specific, realistic recommendations that comply with IFS Food 8."
-                    )
-
-            # Envoi de la requête à l'API
-            api_result = groq.generate(prompt, max_tokens=1500, temperature=0.2, use_cot=True)
-
-            # Ajouter une note indiquant que la recommandation vient de l'API
-            api_note = "\n\n> *Cette recommandation a été générée par l'API Groq pour une meilleure personnalisation.*" if language == "fr" else "\n\n> *This recommendation was generated by the Groq API for better personalization.*"
-            recommendation = f"{api_result}{api_note}"
-
-            # Ajouter à l'historique
-            history_entry = {
-                "action": "generate_recommendation_api",
-                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "role": st.session_state['role'],
-                "details": f"Génération de recommandation via API pour l'exigence {non_conformity['Numéro d\'exigence']}"
-            }
-            st.session_state['history'].append(history_entry)
-
-            return recommendation
-
-        except Exception as e:
-            # En cas d'erreur, afficher un message et utiliser la version locale
-            warning_message = f"Erreur lors de l'utilisation de l'API Groq: {str(e)}. Utilisation de la recommandation locale à la place."
-            st.warning(warning_message)
-            use_api = False
-
-    # Si pas d'API disponible ou en cas d'erreur, utiliser la version locale
-    if not use_api:
-        # Extraction des valeurs pour les f-strings
-        requirement_num = non_conformity["Numéro d'exigence"]
-        requirement_text = non_conformity["Exigence IFS Food 8"]
-        auditor_explanation = non_conformity["Explication (par l'auditeur/l'évaluateur)"]
-
-        # Version simplifiée qui renvoie un template de recommandation
-        if language == "fr":
-            # Template en français
-            recommendation = f"""
-## ANALYSE DE LA NON-CONFORMITÉ
-La non-conformité concerne l'exigence {requirement_num} qui stipule: "{requirement_text}".
-Le constat de l'auditeur indique: "{auditor_explanation}"
-
-## ANALYSE DES CAUSES
-Les causes probables de cette non-conformité incluent:
-- Manque de procédures documentées
-- Formation insuffisante du personnel
-- Ressources inadéquates allouées à ce processus
-
-## PLAN D'ACTION
-### Actions immédiates (corrections)
-1. Réaliser un état des lieux complet
-2. Mettre en place une solution temporaire immédiate
-3. Informer et former rapidement le personnel concerné
-
-### Type de preuves à fournir
-- Photos de la mise en conformité
-- Procédures mises à jour
-- Feuilles d'émargement des formations
-- Rapports de vérification
-
-### Actions correctives à long terme
-1. Réviser la procédure complète
-2. Mettre en place un plan de formation régulier
-3. Établir des contrôles périodiques
-4. Intégrer ce point dans les audits internes
-
-## MÉTHODES DE VALIDATION DE L'EFFICACITÉ
-- Audits internes ciblés
-- Indicateurs de performance à suivre mensuellement
-- Revue de direction trimestrielle sur ce sujet
-
-## RECOMMANDATIONS COMPLÉMENTAIRES
-- Envisager une approche plus globale de ce processus
-- Évaluer l'impact sur d'autres exigences liées
-- Prévoir une revue systématique annuelle
-"""
-        else:
-            # Template en anglais
-            recommendation = f"""
-## ANALYSIS OF THE NON-CONFORMITY
-The non-conformity relates to requirement {requirement_num} which states: "{requirement_text}".
-The auditor's finding indicates: "{auditor_explanation}"
-
-## ROOT CAUSE ANALYSIS
-The probable causes of this non-conformity include:
-- Lack of documented procedures
-- Insufficient staff training
-- Inadequate resources allocated to this process
-
-## ACTION PLAN
-### Immediate actions (corrections)
-1. Conduct a complete assessment
-2. Implement immediate temporary solution
-3. Rapidly inform and train relevant staff
-
-### Type of evidence to be provided
-- Photos of compliance implementation
-- Updated procedures
-- Training attendance records
-- Verification reports
-
-### Long-term corrective actions
-1. Revise the complete procedure
-2. Establish a regular training program
-3. Set up periodic controls
-4. Integrate this point into internal audits
-
-## METHODS FOR VALIDATING EFFECTIVENESS
-- Targeted internal audits
-- Performance indicators to be monitored monthly
-- Quarterly management review on this topic
-
-## ADDITIONAL RECOMMENDATIONS
-- Consider a more comprehensive approach to this process
-- Evaluate the impact on other related requirements
-- Plan for a systematic annual review
-"""
-
-        # Ajouter à l'historique
-        history_entry = {
-            "action": "generate_recommendation_local",
-            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "role": st.session_state['role'],
-            "details": f"Génération de recommandation locale pour l'exigence {requirement_num}"
+    
+    # Créer un fichier ZIP en mémoire
+    buffer = io.BytesIO()
+    
+    with zipfile.ZipFile(buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        # Créer un DataFrame pour l'export
+        export_df = st.session_state['audit_data'].copy()
+        
+        # Renommer les colonnes pour correspondre au format d'origine
+        reverse_mapping = {
+            "reference": "requirementNo",
+            "requirement": "requirementText",
+            "score": "requirementScore",
+            "finding": "requirementExplanation",
+            "correction": "correctionDescription",
+            "correction_responsibility": "correctionResponsibility",
+            "correction_due_date": "correctionDueDate",
+            "correction_status": "correctionStatus",
+            "evidence_type": "correctionEvidence",
+            "corrective_action": "correctiveActionDescription",
+            "corrective_action_responsibility": "correctiveActionResponsibility",
+            "corrective_action_due_date": "correctiveActionDueDate",
+            "corrective_action_status": "correctiveActionStatus",
+            "release_responsibility": "releaseResponsibility",
+            "release_date": "releaseDate"
         }
-        st.session_state['history'].append(history_entry)
-
-    return recommendation
-
-# Fonction pour afficher l'historique - CORRIGÉ
-def display_history():
-    if st.session_state['history']:
-        with st.expander("📜 Historique des actions", expanded=False):
-            for entry in sorted(st.session_state['history'], key=lambda x: x["timestamp"], reverse=True):
-                timestamp = entry['timestamp']
-                details = entry['details']
-                role = entry['role']
-                history_entry = f"**{timestamp}** - {details} (par {role})"
-                st.markdown(history_entry)
-
-# Afficher les pièces jointes - CORRIGÉ
-def display_attachments(index, readonly=False):
-    if index in st.session_state['attachments'] and st.session_state['attachments'][index]:
-        st.markdown("#### 📎 Pièces jointes")
-
-        attachments = st.session_state['attachments'][index]
+        
+        export_df = export_df.rename(columns=reverse_mapping)
+        
+        # Ajouter l'en-tête (à adapter selon le format exact)
+        header_df = pd.DataFrame({
+            "Action plan": [st.session_state['excel_metadata'].get("enterprise", "")],
+            "": [""],
+            "Référentiel / Programme / Check": [st.session_state['excel_metadata'].get("standard", "IFS Food 8")],
+            "Type d'audit/d'évaluation": [st.session_state['excel_metadata'].get("audit_type", "")],
+            "Date de début d'audit / d'évaluation": [st.session_state['excel_metadata'].get("audit_date", "")]
+        })
+        
+        # Créer un DataFrame avec les titres des colonnes en français et anglais
+        column_titles = pd.DataFrame({
+            "requirementNo": ["Numéro d'exigence"],
+            "requirementText": ["Exigence IFS Food 8"],
+            "requirementScore": ["Notation"],
+            "requirementExplanation": ["Explication (par l'auditeur/l'évaluateur)"],
+            "correctionDescription": ["Correction (par l'entreprise)"],
+            "correctionResponsibility": ["Responsabilité (par l'entreprise)"],
+            "correctionDueDate": ["Date (par l'entreprise)"],
+            "correctionStatus": ["Statut de la mise en œuvre (par l'entreprise)"],
+            "correctionEvidence": ["Type de preuve(s) et nom du/des document(s)"],
+            "correctiveActionDescription": ["Action corrective (par l'entreprise)"],
+            "correctiveActionResponsibility": ["Responsabilité (par l'entreprise)"],
+            "correctiveActionDueDate": ["Date (par l'entreprise)"],
+            "correctiveActionStatus": ["Statut de la mise en œuvre (par l'entreprise)"],
+            "releaseResponsibility": ["Effectué par (l'auditeur/l'évaluateur)"],
+            "releaseDate": ["Date de transmission"]
+        })
+        
+        # Créer un fichier Excel en mémoire
+        excel_buffer = io.BytesIO()
+        with pd.ExcelWriter(excel_buffer, engine='openpyxl') as writer:
+            header_df.to_excel(writer, sheet_name='Plan d\'action', index=False)
+            # Laisser des lignes vides
+            column_titles.to_excel(writer, sheet_name='Plan d\'action', startrow=11, index=False)
+            export_df.to_excel(writer, sheet_name='Plan d\'action', startrow=13, index=False)
+        
+        excel_buffer.seek(0)
+        zip_file.writestr('action_plan_updated.xlsx', excel_buffer.getvalue())
+        
+        # Ajouter les pièces jointes
+        for ref, attachments in st.session_state['attachments'].items():
+            for filename, file_data in attachments.items():
+                zip_file.writestr(f'attachments/{ref}/{filename}', file_data)
+        
+        # Ajouter un fichier de commentaires au format texte
+        if st.session_state['comments']:
+            comments_text = "COMMENTAIRES DU PLAN D'ACTION\n\n"
+            for ref, comments_list in st.session_state['comments'].items():
+                comments_text += f"Exigence {ref}:\n"
+                for comment in comments_list:
+                    comments_text += f"- {comment['timestamp']} ({comment['role']}): {comment['text']}\n"
+                comments_text += "\n"
+            
+            zip_file.writestr('comments.txt', comments_text)
+    
+    buffer.seek(0)
+    return buffer.getvalue()
+
+# Fonction pour afficher les pièces jointes
+def display_attachments(reference, readonly=False):
+    if reference in st.session_state['attachments'] and st.session_state['attachments'][reference]:
+        st.markdown("<div class='section-title'>Pièces jointes</div>", unsafe_allow_html=True)
+        
         cols = st.columns(4)
-
-        for i, (filename, file_data) in enumerate(attachments.items()):
+        
+        for i, (filename, file_data) in enumerate(st.session_state['attachments'][reference].items()):
             col = cols[i % 4]
-
-            # Détecter le type de fichier
-            file_extension = os.path.splitext(filename)[1].lower()
-
-            if file_extension in ['.jpg', '.jpeg', '.png', '.gif']:
-                # Pour les images - f-string HTML corrigé
-                b64_data = base64.b64encode(file_data).decode()
-                html_content = f"""
-                <div class="attachment-thumbnail">
-                    <img src="data:image/{file_extension[1:]};base64,{b64_data}" width="100%">
-                    <div class="attachment-name">{filename}</div>
-                </div>
-                """
-                st.markdown(html_content, unsafe_allow_html=True)
-
-                # Bouton de téléchargement
-                st.download_button(
-                    "📥",
-                    file_data,
-                    file_name=filename,
-                    mime=f"image/{file_extension[1:]}"
-                )
-            elif file_extension == '.pdf':
-                # Pour les PDF - f-string HTML corrigé
-                html_content = f"""
-                <div class="attachment-thumbnail">
-                    <div style="text-align: center; font-size: 40px;">📄</div>
-                    <div class="attachment-name">{filename}</div>
-                </div>
-                """
-                st.markdown(html_content, unsafe_allow_html=True)
-
-                # Bouton de téléchargement
-                st.download_button(
-                    "📥",
-                    file_data,
-                    file_name=filename,
-                    mime="application/pdf"
-                )
-            else:
-                # Pour les autres fichiers - f-string HTML corrigé
-                html_content = f"""
-                <div class="attachment-thumbnail">
-                    <div style="text-align: center; font-size: 40px;">📎</div>
-                    <div class="attachment-name">{filename}</div>
-                </div>
-                """
-                st.markdown(html_content, unsafe_allow_html=True)
-
+            
+            with col:
+                # Déterminer le type de fichier
+                file_extension = os.path.splitext(filename)[1].lower()
+                
+                # Afficher une icône différente selon le type de fichier
+                icon = "📄"  # Par défaut
+                if file_extension in ['.jpg', '.jpeg', '.png', '.gif']:
+                    icon = "🖼️"
+                elif file_extension == '.pdf':
+                    icon = "📑"
+                elif file_extension in ['.doc', '.docx']:
+                    icon = "📝"
+                elif file_extension in ['.xls', '.xlsx']:
+                    icon = "📊"
+                
+                # Afficher le nom du fichier
+                st.markdown(f"<div class='attachment'>{icon} {filename}</div>", unsafe_allow_html=True)
+                
                 # Bouton de téléchargement
                 st.download_button(
-                    "📥",
+                    "Télécharger",
                     file_data,
                     file_name=filename
                 )
+                
+                # Bouton de suppression (si non readonly)
+                if not readonly and st.session_state['role'] == "site":
+                    if st.button("Supprimer", key=f"delete_{reference}_{filename}"):
+                        del st.session_state['attachments'][reference][filename]
+                        st.rerun()
 
-            # Bouton de suppression (si non readonly)
-            if not readonly:
-                delete_button_key = f"delete_{index}_{filename}"
-                if st.button("🗑️", key=delete_button_key):
-                    del st.session_state['attachments'][index][filename]
-                    # Ajouter à l'historique
-                    history_entry = {
-                        "action": "delete_attachment",
-                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                        "role": st.session_state['role'],
-                        "details": f"Suppression de la pièce jointe {filename} pour l'exigence {index}"
-                    }
-                    st.session_state['history'].append(history_entry)
-                    st.rerun()
+# Fonction pour afficher les commentaires
+def display_comments(reference):
+    if reference in st.session_state['comments'] and st.session_state['comments'][reference]:
+        st.markdown("<div class='section-title'>Commentaires</div>", unsafe_allow_html=True)
+        
+        for comment in st.session_state['comments'][reference]:
+            # Définir la couleur du rôle
+            role_colors = {
+                "site": "#28a745",
+                "auditor": "#0066cc",
+                "reviewer": "#6f42c1"
+            }
+            role_color = role_colors.get(comment["role"], "#6c757d")
+            
+            # Afficher le commentaire
+            st.markdown(f"""
+            <div style="background-color: #f8f9fa; padding: 10px; border-radius: 5px; margin-bottom: 10px; border-left: 3px solid {role_color};">
+                <div style="display: flex; justify-content: space-between;">
+                    <span style="font-weight: bold; color: {role_color};">{comment["role"].capitalize()}</span>
+                    <span style="font-size: 0.8em; color: #6c757d;">{comment["timestamp"]}</span>
+                </div>
+                <div style="margin-top: 5px;">{comment["text"]}</div>
+            </div>
+            """, unsafe_allow_html=True)
 
 # Interface principale
 def main():
-    # Sidebar pour la configuration
+    # Sidebar pour configuration
     with st.sidebar:
-        st.markdown("### 👤 Rôle utilisateur")
-
+        st.markdown("### Configuration")
+        
         # Sélection du rôle
-        col1, col2, col3 = st.columns(3)
-
-        with col1:
-            site_class = "role-tab-active" if st.session_state['role'] == "site" else "role-tab-inactive"
-            # F-string HTML corrigé
-            site_html = f"""
-            <div class="role-tab {site_class}" id="role-site">
-                <div style="font-size: 24px;">🏭</div>
-                <div>Site Audité</div>
-            </div>
-            """
-            st.markdown(site_html, unsafe_allow_html=True)
-            if st.button("Site Audité", key="btn_site"):
-                st.session_state['role'] = "site"
-                st.rerun()
-
-        with col2:
-            auditor_class = "role-tab-active" if st.session_state['role'] == "auditor" else "role-tab-inactive"
-            # F-string HTML corrigé
-            auditor_html = f"""
-            <div class="role-tab {auditor_class}" id="role-auditor">
-                <div style="font-size: 24px;">🔍</div>
-                <div>Auditeur</div>
-            </div>
-            """
-            st.markdown(auditor_html, unsafe_allow_html=True)
-            if st.button("Auditeur", key="btn_auditor"):
-                st.session_state['role'] = "auditor"
-                st.rerun()
-
-        with col3:
-            reviewer_class = "role-tab-active" if st.session_state['role'] == "reviewer" else "role-tab-inactive"
-            # F-string HTML corrigé
-            reviewer_html = f"""
-            <div class="role-tab {reviewer_class}" id="role-reviewer">
-                <div style="font-size: 24px;">✅</div>
-                <div>Reviewer</div>
-            </div>
-            """
-            st.markdown(reviewer_html, unsafe_allow_html=True)
-            if st.button("Reviewer", key="btn_reviewer"):
-                st.session_state['role'] = "reviewer"
-                st.rerun()
-
-        st.markdown("---")
-
-        # API Key Groq (optionnelle)
-        st.session_state['api_key'] = st.text_input(
-            "Clé API Groq (optionnelle) :",
-            type="password",
-            value=st.session_state.get('api_key', '')
+        role_options = {
+            "site": "Site Audité", 
+            "auditor": "Auditeur", 
+            "reviewer": "Reviewer"
+        }
+        
+        selected_role = st.selectbox(
+            "Rôle:",
+            options=list(role_options.keys()),
+            format_func=lambda x: role_options[x],
+            index=list(role_options.keys()).index(st.session_state['role'])
         )
-
-        # Metadata form en fonction du rôle
-        st.markdown("### 📋 Informations d'audit")
-
+        
+        if selected_role != st.session_state['role']:
+            st.session_state['role'] = selected_role
+            st.rerun()
+        
+        # Formulaire pour les métadonnées de l'audit
         with st.form(key="metadata_form"):
+            st.markdown("### Informations d'audit")
+            
             if st.session_state['role'] == "site":
                 st.session_state['audit_metadata']["site_name"] = st.text_input(
-                    "Nom du site :",
+                    "Nom du site:",
                     value=st.session_state['audit_metadata'].get("site_name", "")
                 )
-                audit_date_value = datetime.strptime(
-                    st.session_state['audit_metadata'].get("audit_date", datetime.now().strftime("%Y-%m-%d")),
-                    "%Y-%m-%d"
-                )
-                st.session_state['audit_metadata']["audit_date"] = st.date_input(
-                    "Date de l'audit :",
-                    value=audit_date_value
-                ).strftime("%Y-%m-%d")
-
-            elif st.session_state['role'] == "auditor":
+            
+            if st.session_state['role'] == "auditor":
                 st.session_state['audit_metadata']["auditor_name"] = st.text_input(
-                    "Nom de l'auditeur :",
+                    "Nom de l'auditeur:",
                     value=st.session_state['audit_metadata'].get("auditor_name", "")
                 )
-
-            elif st.session_state['role'] == "reviewer":
+            
+            if st.session_state['role'] == "reviewer":
                 st.session_state['audit_metadata']["reviewer_name"] = st.text_input(
-                    "Nom du reviewer :",
+                    "Nom du reviewer:",
                     value=st.session_state['audit_metadata'].get("reviewer_name", "")
                 )
-
+                
             st.form_submit_button("Enregistrer")
-
-        st.markdown("---")
-
-        # Actions spécifiques au rôle
+        
+        # Upload du fichier d'audit (pour le rôle site uniquement)
         if st.session_state['role'] == "site":
-            st.markdown("### 📤 Plan d'Action")
-            uploaded_file = st.file_uploader("Fichier Excel du plan d'action :", type=["xlsx"])
-
+            st.markdown("### Charger les données d'audit")
+            uploaded_file = st.file_uploader("Fichier d'audit IFS Food 8:", type=["xlsx", "xls"])
+            
             if uploaded_file:
-                action_plan_df = load_action_plan(uploaded_file)
-                if action_plan_df is not None:
-                    st.session_state['action_plan_df'] = action_plan_df
-                    st.success("✅ Plan d'action chargé avec succès")
-
-        # Sauvegarde/Chargement de session pour tous les rôles
-        st.markdown("### 💾 Gestion du dossier")
-
+                audit_data = load_audit_data(uploaded_file)
+                if audit_data is not None:
+                    st.session_state['audit_data'] = audit_data
+                    st.success("Données d'audit chargées avec succès")
+                    st.rerun()
+        
+        # Export du rapport
+        if st.session_state['audit_data'] is not None:
+            st.markdown("### Export du plan d'actions")
+            
+            if st.button("Exporter le rapport"):
+                export_data = create_export_package()
+                
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                site_name = st.session_state['audit_metadata']["site_name"].replace(" ", "_") or "audit"
+                
+                st.download_button(
+                    "Télécharger le rapport",
+                    export_data,
+                    file_name=f"plan_actions_{site_name}_{timestamp}.zip",
+                    mime="application/zip"
+                )
+    
+    # Contenu principal
+    st.markdown('<div class="header">Plan d\'Actions IFS Food 8</div>', unsafe_allow_html=True)
+    
+    # Afficher les informations d'audit
+    if st.session_state['excel_metadata']:
+        enterprise = st.session_state['excel_metadata'].get("enterprise", "")
+        standard = st.session_state['excel_metadata'].get("standard", "")
+        audit_type = st.session_state['excel_metadata'].get("audit_type", "")
+        audit_date = st.session_state['excel_metadata'].get("audit_date", "")
+        
         col1, col2 = st.columns(2)
-
         with col1:
-            if st.button("💾 Exporter .auditpack"):
-                if 'action_plan_df' in st.session_state and st.session_state['action_plan_df'] is not None:
-                    # Mettre à jour le statut de validation selon le rôle
-                    st.session_state['audit_metadata']["validation"][st.session_state['role']] = True
-
-                    # Créer l'auditpack
-                    auditpack_data = create_auditpack()
-
-                    # Créer un lien de téléchargement
-                    timestamp = time.strftime("%Y%m%d-%H%M%S")
-                    site_name = st.session_state['audit_metadata']["site_name"].replace(" ", "_") or "audit"
-                    file_name = f"{site_name}_audit_{timestamp}.auditpack"
-
-                    st.download_button(
-                        label="📥 Télécharger le fichier",
-                        data=auditpack_data,
-                        file_name=file_name,
-                        mime="application/zip"
-                    )
-
-                    # Ajouter à l'historique
-                    history_entry = {
-                        "action": "export_auditpack",
-                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                        "role": st.session_state['role'],
-                        "details": f"Export du fichier auditpack par {st.session_state['role']}"
-                    }
-                    st.session_state['history'].append(history_entry)
-                else:
-                    st.warning("Chargez d'abord un plan d'action.")
-
+            st.markdown(f"**Entreprise:** {enterprise}")
+            st.markdown(f"**Référentiel:** {standard}")
         with col2:
-            uploaded_auditpack = st.file_uploader("📂 Importer .auditpack", type=["auditpack", "zip"])
-            if uploaded_auditpack is not None:
-                file_content = uploaded_auditpack.getvalue()
-                if load_auditpack(file_content):
-                    st.success("✅ Dossier d'audit chargé avec succès")
-                    st.rerun()
-
-        st.markdown("---")
-
-        # Statistiques
-        if 'action_plan_df' in st.session_state and st.session_state['action_plan_df'] is not None:
-            st.markdown("### 📈 Progression")
-
-            total = len(st.session_state['action_plan_df'])
-            completed = sum(st.session_state['action_plan_df']["Statut"] == "Complété")
-            in_progress = sum(st.session_state['action_plan_df']["Statut"] == "En cours")
-
-            st.progress(completed / total if total > 0 else 0)
-
-            # Calcul du pourcentage avec sécurité
-            completed_percent = int((completed/total)*100) if total > 0 else 0
-            progress_text = f"**{completed}/{total}** complétées ({completed_percent}%)"
-            st.markdown(progress_text)
-
-            # Afficher les statuts de validation
-            st.markdown("### ✅ Validation")
-
-            validation = st.session_state['audit_metadata']["validation"]
-
-            site_status = "✓" if validation.get("site", False) else "✗"
-            auditor_status = "✓" if validation.get("auditor", False) else "✗"
-            reviewer_status = "✓" if validation.get("reviewer", False) else "✗"
-
-            validation_text = f"""
-            - Site: {site_status}
-            - Auditeur: {auditor_status}
-            - Reviewer: {reviewer_status}
-            """
-            st.markdown(validation_text)
-
-    # Afficher la bannière dans la page principale
-    st.markdown('<div class="banner"></div>', unsafe_allow_html=True)
-
-    # Afficher le titre avec indication du rôle - CORRIG��
-    role_dict = {
-        "site": "Site Audité",
-        "auditor": "Auditeur",
-        "reviewer": "Reviewer"
-    }
-    role_name = role_dict.get(st.session_state['role'], "")
-    title_html = f'<div class="main-header">📊 VisiPilot - Plan d\'Actions IFS Food 8 [{role_name}]</div>'
-    st.markdown(title_html, unsafe_allow_html=True)
-
-    # Afficher l'historique
-    display_history()
-
-    # Section principale - contenu spécifique au rôle
-    if 'action_plan_df' not in st.session_state or st.session_state['action_plan_df'] is None:
-        st.info("👈 Commencez par configurer les informations d'audit et charger un plan d'action dans la barre latérale.")
-    else:
+            st.markdown(f"**Type d'audit:** {audit_type}")
+            st.markdown(f"**Date d'audit:** {audit_date}")
+    
+    # Afficher les non-conformités si les données sont chargées
+    if st.session_state['audit_data'] is not None:
         # Filtres
+        st.markdown("### Filtrer les non-conformités")
         col1, col2 = st.columns([1, 2])
+        
         with col1:
-            status_filter = st.multiselect("Filtrer par statut",
-                                         options=["Tous", "Non traité", "En cours", "Complété"],
-                                         default=["Tous"])
+            status_options = ["Tous", "Non traité", "En cours", "Complété", "Validé"]
+            status_filter = st.multiselect(
+                "Statut:",
+                options=status_options,
+                default=["Tous"]
+            )
+        
         with col2:
-            search_term = st.text_input("Rechercher une exigence", "")
-
+            search_term = st.text_input("Rechercher:", "")
+        
         # Appliquer les filtres
-        filtered_df = st.session_state['action_plan_df'].copy()
-
+        filtered_data = st.session_state['audit_data'].copy()
+        
         if "Tous" not in status_filter:
-            filtered_df = filtered_df[filtered_df["Statut"].isin(status_filter)]
-
+            filtered_data = filtered_data[filtered_data["status"].isin(status_filter)]
+        
         if search_term:
-            filtered_df = filtered_df[
-                filtered_df["Exigence IFS Food 8"].str.contains(search_term, case=False) |
-                filtered_df["Numéro d'exigence"].astype(str).str.contains(search_term, case=False)
-            ]
-
+            # Recherche dans toutes les colonnes textuelles
+            text_columns = filtered_data.select_dtypes(include='object').columns
+            
+            mask = False
+            for column in text_columns:
+                mask = mask | filtered_data[column].str.contains(search_term, case=False, na=False)
+            
+            filtered_data = filtered_data[mask]
+        
+        # Afficher les statistiques
+        if len(filtered_data) > 0:
+            st.markdown("### Statistiques")
+            
+            total = len(st.session_state['audit_data'])
+            completed = sum(st.session_state['audit_data']["status"] == "Complété")
+            in_progress = sum(st.session_state['audit_data']["status"] == "En cours")
+            validated = sum(st.session_state['audit_data']["status"] == "Validé")
+            
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("Total", str(total))
+            
+            with col2:
+                st.metric("En cours", str(in_progress))
+            
+            with col3:
+                st.metric("Complétés", str(completed))
+                
+            with col4:
+                st.metric("Validés", str(validated))
+            
+            progress = (completed + validated) / total if total > 0 else 0
+            st.progress(progress)
+        
         # Afficher les non-conformités
-        for index, row in filtered_df.iterrows():
+        st.markdown("### Non-conformités")
+        
+        for index, row in filtered_data.iterrows():
             # Déterminer la classe du badge de statut
-            status_class_dict = {
-                "Complété": "status-completed",
+            status_class = {
+                "Non traité": "status-pending",
                 "En cours": "status-progress",
-                "Non traité": "status-pending"
-            }
-            status_class = status_class_dict.get(row["Statut"], "status-pending")
-
-            # Afficher la carte de non-conformité - CORRIGÉ
-            requirement_num = row["Numéro d'exigence"]
-            requirement_text = row["Exigence IFS Food 8"]
-            auditor_explanation = row["Explication (par l'auditeur/l'évaluateur)"]
-            status = row["Statut"]
-
-            card_html = f"""
+                "Complété": "status-completed",
+                "Validé": "status-completed"
+            }.get(row["status"], "status-pending")
+            
+            # Créer la carte de non-conformité
+            reference = str(row["reference"]) if "reference" in row else str(index)
+            requirement = row.get("requirement", "")
+            finding = row.get("finding", "")
+            score = row.get("score", "")
+            
+            st.markdown(f"""
             <div class="card">
-                <div>
-                    <strong>Exigence {requirement_num}</strong>
-                    <span class="status-badge {status_class}">{status}</span>
-                </div>
-                <div style="margin-top: 5px;">
-                    {requirement_text}
-                </div>
-                <div style="font-style: italic; margin-top: 5px; color: #666;">
-                    <strong>Constat de l'auditeur:</strong> {auditor_explanation}
+                <div style="display: flex; justify-content: space-between;">
+                    <div>
+                        <strong>Exigence {reference}</strong>
+                        <span class="status-badge {status_class}">{row["status"]}</span>
+                    </div>
+                    <div>
+                        <strong>Notation: {score}</strong>
+                    </div>
                 </div>
+                <div class="requirement-text" style="margin-top: 10px;">{requirement}</div>
+                <div class="finding-text">{finding}</div>
             </div>
-            """
-            st.markdown(card_html, unsafe_allow_html=True)
-
-            # Options d'action selon le rôle
+            """, unsafe_allow_html=True)
+            
+            # Options selon le rôle
             if st.session_state['role'] == "site":
-                # Boutons pour le site
-                col1, col2, col3 = st.columns([1, 1, 1])
-
-                with col1:
-                    button_key = f"questions_{index}"
-                    if st.button("💡 Questions ciblées", key=button_key):
-                        st.session_state['active_item'] = index
-                        st.session_state['ask_questions'][index] = True
-
-                with col2:
-                    button_key = f"direct_{index}"
-                    if st.button("🤖 Recommandation directe", key=button_key):
-                        with st.spinner("Génération en cours..."):
-                            recommendation = generate_recommendation(row, direct=True)
-                            if recommendation:
-                                st.session_state['recommendations'][str(index)] = recommendation
-                                st.session_state['active_item'] = index
-                                # Mettre à jour le statut
-                                st.session_state['action_plan_df'].loc[index, "Statut"] = "En cours"
-                                st.rerun()
-
-                with col3:
-                    # Téléchargement de pièces jointes
-                    upload_key = f"upload_{index}"
+                # Le site peut ajouter des actions correctives et des pièces jointes
+                with st.expander("Répondre à cette non-conformité", expanded=st.session_state.get('active_item') == index):
+                    with st.form(key=f"form_{index}"):
+                        # Analyse de cause racine
+                        root_cause = st.text_area(
+                            "Analyse de cause racine:",
+                            value=row.get("root_cause", ""),
+                            height=80
+                        )
+                        
+                        # Correction immédiate
+                        correction = st.text_area(
+                            "Correction immédiate:",
+                            value=row.get("correction", ""),
+                            height=80
+                        )
+                        
+                        # Responsable de la correction
+                        correction_responsibility = st.text_input(
+                            "Responsable de la correction:",
+                            value=row.get("correction_responsibility", "")
+                        )
+                        
+                        # Date prévue pour la correction
+                        correction_due_date = st.date_input(
+                            "Date prévue pour la correction:",
+                            value=datetime.now()
+                        )
+                        
+                        # Statut de la correction
+                        correction_status = st.selectbox(
+                            "Statut de la correction:",
+                            options=["Non démarré", "En cours", "Completed"],
+                            index=0 if pd.isna(row.get("correction_status")) else ["Non démarré", "En cours", "Completed"].index(row.get("correction_status", "Non démarré"))
+                        )
+                        
+                        # Action corrective à long terme
+                        corrective_action = st.text_area(
+                            "Action corrective (prévention de la récurrence):",
+                            value=row.get("corrective_action", ""),
+                            height=80
+                        )
+                        
+                        # Responsable de l'action corrective
+                        corrective_action_responsibility = st.text_input(
+                            "Responsable de l'action corrective:",
+                            value=row.get("corrective_action_responsibility", "")
+                        )
+                        
+                        # Date prévue pour l'action corrective
+                        corrective_action_due_date = st.date_input(
+                            "Date prévue pour l'action corrective:",
+                            value=datetime.now()
+                        )
+                        
+                        # Statut de l'action corrective
+                        corrective_action_status = st.selectbox(
+                            "Statut de l'action corrective:",
+                            options=["Non démarré", "En cours", "Completed"],
+                            index=0 if pd.isna(row.get("corrective_action_status")) else ["Non démarré", "En cours", "Completed"].index(row.get("corrective_action_status", "Non démarré"))
+                        )
+                        
+                        # Méthode de vérification
+                        verification_method = st.text_area(
+                            "Méthode de vérification de l'efficacité:",
+                            value=row.get("verification_method", ""),
+                            height=60
+                        )
+                        
+                        # Type de preuves
+                        evidence_type = st.text_input(
+                            "Type de preuves et nom des documents:",
+                            value=row.get("evidence_type", "")
+                        )
+                        
+                        submitted = st.form_submit_button("Enregistrer les actions")
+                        
+                        if submitted:
+                            st.session_state['audit_data'].at[index, "root_cause"] = root_cause
+                            st.session_state['audit_data'].at[index, "correction"] = correction
+                            st.session_state['audit_data'].at[index, "correction_responsibility"] = correction_responsibility
+                            st.session_state['audit_data'].at[index, "correction_due_date"] = correction_due_date.strftime("%Y-%m-%d")
+                            st.session_state['audit_data'].at[index, "correction_status"] = correction_status
+                            st.session_state['audit_data'].at[index, "corrective_action"] = corrective_action
+                            st.session_state['audit_data'].at[index, "corrective_action_responsibility"] = corrective_action_responsibility
+                            st.session_state['audit_data'].at[index, "corrective_action_due_date"] = corrective_action_due_date.strftime("%Y-%m-%d")
+                            st.session_state['audit_data'].at[index, "corrective_action_status"] = corrective_action_status
+                            st.session_state['audit_data'].at[index, "verification_method"] = verification_method
+                            st.session_state['audit_data'].at[index, "evidence_type"] = evidence_type
+                            
+                            # Déterminer le statut global
+                            if correction_status == "Completed" and corrective_action_status == "Completed":
+                                st.session_state['audit_data'].at[index, "status"] = "Complété"
+                            elif correction != "" or corrective_action != "":
+                                st.session_state['audit_data'].at[index, "status"] = "En cours"
+                            
+                            st.success("Actions enregistrées avec succès")
+                            st.rerun()
+                    
+                    # Upload de pièces jointes
                     uploaded_files = st.file_uploader(
-                        "📎 Ajouter des preuves",
-                        type=["pdf", "jpg", "jpeg", "png", "docx", "xlsx"],
+                        "Ajouter des pièces justificatives:",
                         accept_multiple_files=True,
-                        key=upload_key
+                        key=f"files_{index}"
                     )
-
+                    
                     if uploaded_files:
-                        # Initialiser le dictionnaire pour l'index si nécessaire
-                        if str(index) not in st.session_state['attachments']:
-                            st.session_state['attachments'][str(index)] = {}
-
-                        for uploaded_file in uploaded_files:
-                            file_data = uploaded_file.read()  # Lire les données binaires
-                            file_name = uploaded_file.name    # Récupérer le nom de fichier
-
-                            # Stocker le fichier
-                            st.session_state['attachments'][str(index)][file_name] = file_data
-
-                            # Ajouter à l'historique
-                            history_entry = {
-                                "action": "upload_attachment",
-                                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                                "role": st.session_state['role'],
-                                "details": f"Ajout de la pièce jointe {file_name} pour l'exigence {index}"
-                            }
-                            st.session_state['history'].append(history_entry)
-
-                        success_message = f"{len(uploaded_files)} fichiers ajoutés"
-                        st.success(success_message)
-
-            elif st.session_state['role'] == "auditor":
-                # Boutons pour l'auditeur
-                col1, col2 = st.columns(2)
-
-                with col1:
-                    # Ajouter commentaire
-                    button_key = f"comment_{index}"
-                    if st.button("💬 Ajouter commentaire", key=button_key):
-                        st.session_state['active_item'] = index
-
-                with col2:
-                    # Valider action
-                    button_key = f"validate_{index}"
-                    if st.button("✅ Valider action", key=button_key):
-                        # Ajouter à l'historique
-                        history_entry = {
-                            "action": "validate_item",
-                            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                            "role": st.session_state['role'],
-                            "details": f"Validation de l'action pour l'exigence {index} par l'auditeur"
-                        }
-                        st.session_state['history'].append(history_entry)
-                        # Mettre à jour le statut
-                        st.session_state['action_plan_df'].loc[index, "Statut"] = "Complété"
+                        if reference not in st.session_state['attachments']:
+                            st.session_state['attachments'][reference] = {}
+                        
+                        for file in uploaded_files:
+                            file_data = file.read()
+                            filename = file.name
+                            
+                            st.session_state['attachments'][reference][filename] = file_data
+                        
+                        st.success(f"{len(uploaded_files)} fichier(s) ajouté(s)")
                         st.rerun()
-
-            elif st.session_state['role'] == "reviewer":
-                # Boutons pour le reviewer
-                col1, col2 = st.columns(2)
-
-                with col1:
-                    # Ajouter commentaire
-                    button_key = f"review_comment_{index}"
-                    if st.button("💬 Ajouter commentaire", key=button_key):
-                        st.session_state['active_item'] = index
-
-                with col2:
-                    # Approuver final
-                    button_key = f"approve_{index}"
-                    if st.button("✅ Approuver final", key=button_key):
-                        # Ajouter à l'historique
-                        history_entry = {
-                            "action": "approve_final",
-                            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                            "role": st.session_state['role'],
-                            "details": f"Approbation finale pour l'exigence {index} par le reviewer"
-                        }
-                        st.session_state['history'].append(history_entry)
+            
+            elif st.session_state['role'] == "auditor":
+                # L'auditeur peut ajouter des commentaires et changer le statut
+                with st.expander("Évaluer cette action", expanded=st.session_state.get('active_item') == index):
+                    # Afficher les informations sur les actions proposées
+                    if row.get("root_cause", ""):
+                        st.markdown("<div class='section-title'>Analyse de cause racine</div>", unsafe_allow_html=True)
+                        st.markdown(f"<div class='section-content'>{row.get('root_cause', '')}</div>", unsafe_allow_html=True)
+                    
+                    if row.get("correction", ""):
+                        st.markdown("<div class='section-title'>Correction immédiate</div>", unsafe_allow_html=True)
+                        st.markdown(f"<div class='section-content'>{row.get('correction', '')}</div>", unsafe_allow_html=True)
+                        
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.markdown(f"**Responsable:** {row.get('correction_responsibility', 'Non spécifié')}")
+                        with col2:
+                            st.markdown(f"**Date prévue:** {row.get('correction_due_date', 'Non spécifié')}")
+                        
+                        st.markdown(f"**Statut:** {row.get('correction_status', 'Non spécifié')}")
+                    
+                    if row.get("corrective_action", ""):
+                        st.markdown("<div class='section-title'>Action corrective</div>", unsafe_allow_html=True)
+                        st.markdown(f"<div class='section-content'>{row.get('corrective_action', '')}</div>", unsafe_allow_html=True)
+                        
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.markdown(f"**Responsable:** {row.get('corrective_action_responsibility', 'Non spécifié')}")
+                        with col2:
+                            st.markdown(f"**Date prévue:** {row.get('corrective_action_due_date', 'Non spécifié')}")
+                        
+                        st.markdown(f"**Statut:** {row.get('corrective_action_status', 'Non spécifié')}")
+                    
+                    if row.get("verification_method", ""):
+                        st.markdown("<div class='section-title'>Méthode de vérification</div>", unsafe_allow_html=True)
+                        st.markdown(f"<div class='section-content'>{row.get('verification_method', '')}</div>", unsafe_allow_html=True)
+                    
+                    # Changer le statut
+                    new_status = st.selectbox(
+                        "Statut:",
+                        options=["Non traité", "En cours", "Complété", "Validé"],
+                        index=["Non traité", "En cours", "Complété", "Validé"].index(row["status"]) if row["status"] in ["Non traité", "En cours", "Complété", "Validé"] else 0,
+                        key=f"status_{index}"
+                    )
+                    
+                    if new_status != row["status"]:
+                        st.session_state['audit_data'].at[index, "status"] = new_status
+                        
+                        # Si le statut est "Validé", ajouter la date et le responsable de validation
+                        if new_status == "Validé":
+                            st.session_state['audit_data'].at[index, "release_responsibility"] = st.session_state['audit_metadata']["auditor_name"]
+                            st.session_state['audit_data'].at[index, "release_date"] = datetime.now().strftime("%Y-%m-%d")
+                        
                         st.rerun()
-
-            # Options de statut visibles pour tous les rôles
-            status_options = ["Non traité", "En cours", "Complété"]
-            select_key = f"status_{index}"
-            new_status = st.selectbox(
-                "Statut",
-                options=status_options,
-                index=status_options.index(row["Statut"]),
-                key=select_key
-            )
-
-            if new_status != row["Statut"]:
-                st.session_state['action_plan_df'].loc[index, "Statut"] = new_status
-                # Ajouter à l'historique
-                history_entry = {
-                    "action": "change_status",
-                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                    "role": st.session_state['role'],
-                    "details": f"Changement de statut pour l'exigence {index} : {row['Statut']} -> {new_status}"
-                }
-                st.session_state['history'].append(history_entry)
-
-            # Si cet élément est actif pour les questions (site uniquement)
-            if st.session_state['role'] == "site" and index == st.session_state.get('active_item') and st.session_state['ask_questions'].get(index, False):
-                with st.container():
-                    st.markdown("#### Questions pour analyse ciblée")
-
-                    # Générer des questions adaptées
-                    questions = generate_questions(row)
-
-                    form_key = f"questions_form_{index}"
-                    with st.form(key=form_key):
-                        responses = {}
-                        for q in questions:
-                            question_key = f"q_{index}_{q['id']}"
-                            responses[q["id"]] = st.text_area(q["question"], key=question_key)
-
-                        submit_btn = st.form_submit_button("Générer recommandation")
-                        if submit_btn:
-                            with st.spinner("Génération en cours..."):
-                                recommendation = generate_recommendation(row, responses)
-                                if recommendation:
-                                    st.session_state['recommendations'][str(index)] = recommendation
-                                    st.session_state['responses'][str(index)] = responses
-                                    # Mettre à jour le statut
-                                    st.session_state['action_plan_df'].loc[index, "Statut"] = "En cours"
-                                    st.rerun()
-
-            # Si cet élément est actif pour ajouter un commentaire (auditeur ou reviewer)
-            if index == st.session_state.get('active_item') and st.session_state['role'] in ["auditor", "reviewer"]:
-                with st.container():
-                    st.markdown("#### Ajouter un commentaire")
-
-                    form_key = f"comment_form_{index}"
-                    with st.form(key=form_key):
-                        comment_key = f"comment_{index}_text"
-                        comment_text = st.text_area("Votre commentaire:", key=comment_key)
-
-                        submit_btn = st.form_submit_button("Enregistrer le commentaire")
-                        if submit_btn and comment_text:
-                            # Initialiser la liste de commentaires pour cet index si nécessaire
-                            if str(index) not in st.session_state['comments']:
-                                st.session_state['comments'][str(index)] = []
-
-                            # Ajouter le commentaire
-                            comment_data = {
+                    
+                    # Ajouter un commentaire
+                    with st.form(key=f"comment_{index}"):
+                        comment_text = st.text_area("Ajouter un commentaire:", key=f"comment_text_{index}")
+                        
+                        submitted = st.form_submit_button("Enregistrer le commentaire")
+                        
+                        if submitted and comment_text:
+                            if reference not in st.session_state['comments']:
+                                st.session_state['comments'][reference] = []
+                            
+                            st.session_state['comments'][reference].append({
                                 "role": st.session_state['role'],
                                 "text": comment_text,
                                 "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                            }
-                            st.session_state['comments'][str(index)].append(comment_data)
-
-                            # Ajouter à l'historique
-                            history_entry = {
-                                "action": "add_comment",
-                                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                            })
+                            
+                            st.success("Commentaire ajouté")
+                            st.rerun()
+            
+            elif st.session_state['role'] == "reviewer":
+                # Le reviewer peut valider ou rejeter l'action
+                with st.expander("Valider cette action", expanded=st.session_state.get('active_item') == index):
+                    # Afficher les informations sur les actions proposées
+                    if row.get("root_cause", ""):
+                        st.markdown("<div class='section-title'>Analyse de cause racine</div>", unsafe_allow_html=True)
+                        st.markdown(f"<div class='section-content'>{row.get('root_cause', '')}</div>", unsafe_allow_html=True)
+                    
+                    if row.get("correction", ""):
+                        st.markdown("<div class='section-title'>Correction immédiate</div>", unsafe_allow_html=True)
+                        st.markdown(f"<div class='section-content'>{row.get('correction', '')}</div>", unsafe_allow_html=True)
+                        
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.markdown(f"**Responsable:** {row.get('correction_responsibility', 'Non spécifié')}")
+                        with col2:
+                            st.markdown(f"**Date prévue:** {row.get('correction_due_date', 'Non spécifié')}")
+                        
+                        st.markdown(f"**Statut:** {row.get('correction_status', 'Non spécifié')}")
+                    
+                    if row.get("corrective_action", ""):
+                        st.markdown("<div class='section-title'>Action corrective</div>", unsafe_allow_html=True)
+                        st.markdown(f"<div class='section-content'>{row.get('corrective_action', '')}</div>", unsafe_allow_html=True)
+                        
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.markdown(f"**Responsable:** {row.get('corrective_action_responsibility', 'Non spécifié')}")
+                        with col2:
+                            st.markdown(f"**Date prévue:** {row.get('corrective_action_due_date', 'Non spécifié')}")
+                        
+                        st.markdown(f"**Statut:** {row.get('corrective_action_status', 'Non spécifié')}")
+                    
+                    if row.get("verification_method", ""):
+                        st.markdown("<div class='section-title'>Méthode de vérification</div>", unsafe_allow_html=True)
+                        st.markdown(f"<div class='section-content'>{row.get('verification_method', '')}</div>", unsafe_allow_html=True)
+                    
+                    # Afficher l'évaluation de l'auditeur
+                    st.markdown("<div class='section-title'>Évaluation de l'auditeur</div>", unsafe_allow_html=True)
+                    st.markdown(f"**Statut actuel:** {row['status']}")
+                    
+                    if row.get("release_responsibility", ""):
+                        st.markdown(f"**Validé par:** {row.get('release_responsibility', '')}")
+                    
+                    if row.get("release_date", ""):
+                        st.markdown(f"**Date de validation:** {row.get('release_date', '')}")
+                    
+                    # Ajouter un commentaire et valider/rejeter
+                    with st.form(key=f"review_{index}"):
+                        review_text = st.text_area("Commentaire final:", key=f"review_text_{index}")
+                        
+                        col1, col2 = st.columns(2)
+                        
+                        with col1:
+                            approve = st.form_submit_button("Approuver")
+                        
+                        with col2:
+                            reject = st.form_submit_button("Rejeter")
+                        
+                        if approve:
+                            if reference not in st.session_state['comments']:
+                                st.session_state['comments'][reference] = []
+                            
+                            st.session_state['comments'][reference].append({
                                 "role": st.session_state['role'],
-                                "details": f"Ajout d'un commentaire pour l'exigence {index}"
-                            }
-                            st.session_state['history'].append(history_entry)
-
-                            st.success("Commentaire ajouté avec succès")
-                            st.session_state['active_item'] = None
+                                "text": review_text + " [APPROUVÉ]",
+                                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                            })
+                            
+                            st.session_state['audit_data'].at[index, "status"] = "Validé"
+                            st.session_state['audit_data'].at[index, "release_responsibility"] = st.session_state['audit_metadata']["reviewer_name"]
+                            st.session_state['audit_data'].at[index, "release_date"] = datetime.now().strftime("%Y-%m-%d")
+                            
+                            st.success("Action approuvée")
                             st.rerun()
-
-            # Afficher les pièces jointes
-            if str(index) in st.session_state['attachments']:
-                display_attachments(str(index), readonly=(st.session_state['role'] != "site"))
-
-            # Afficher les commentaires s'il y en a
-            if str(index) in st.session_state['comments'] and st.session_state['comments'][str(index)]:
-                st.markdown("#### 💬 Commentaires")
-
-                for comment in st.session_state['comments'][str(index)]:
-                    role_colors = {
-                        "site": "#28a745",
-                        "auditor": "#0066cc",
-                        "reviewer": "#6f42c1"
-                    }
-                    role_color = role_colors.get(comment["role"], "#6c757d")
-
-                    # f-string HTML corrigé
-                    comment_html = f"""
-                    <div style="background-color: #f8f9fa; padding: 10px; border-radius: 5px; margin-bottom: 10px; border-left: 3px solid {role_color};">
-                        <div style="display: flex; justify-content: space-between;">
-                            <span style="font-weight: bold; color: {role_color};">{comment["role"].capitalize()}</span>
-                            <span style="font-size: 0.8em; color: #6c757d;">{comment["timestamp"]}</span>
-                        </div>
-                        <div style="margin-top: 5px;">{comment["text"]}</div>
-                    </div>
-                    """
-                    st.markdown(comment_html, unsafe_allow_html=True)
-
-            # Afficher la recommandation si elle existe
-            if str(index) in st.session_state.get('recommendations', {}):
-                is_expanded = index == st.session_state.get('active_item')
-                with st.expander("📋 Recommandation IA", expanded=is_expanded):
-                    # Appliquer la classe personnalisée à l'expander via HTML
-                    st.markdown('<div class="recommendation-expander">', unsafe_allow_html=True)
-                    st.markdown(st.session_state['recommendations'][str(index)])
-                    st.markdown('</div>', unsafe_allow_html=True)
-
+                        
+                        if reject:
+                            if reference not in st.session_state['comments']:
+                                st.session_state['comments'][reference] = []
+                            
+                            st.session_state['comments'][reference].append({
+                                "role": st.session_state['role'],
+                                "text": review_text + " [REJETÉ]",
+                                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                            })
+                            
+                            st.session_state['audit_data'].at[index, "status"] = "En cours"
+                            # Effacer les données de validation si elles existent
+                            st.session_state['audit_data'].at[index, "release_responsibility"] = None
+                            st.session_state['audit_data'].at[index, "release_date"] = None
+                            
+                            st.error("Action rejetée")
+                            st.rerun()
+            
+            # Afficher les pièces jointes pour tous les rôles
+            display_attachments(reference, readonly=(st.session_state['role'] != "site"))
+            
+            # Afficher les commentaires pour tous les rôles
+            display_comments(reference)
+            
             st.markdown("---")
+    else:
+        # Message si aucune donnée n'est chargée
+        st.info("Aucune donnée d'audit chargée. Veuillez charger un fichier d'audit depuis le panneau latéral.")
 
+# Lancer l'application
 if __name__ == "__main__":
-    main()
-    
+    main()