Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,685 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import numpy as np
+import matplotlib
+matplotlib.use('Agg') # Mode non-interactif pour matplotlib
+import matplotlib.pyplot as plt
+import seaborn as sns
+from collections import Counter
+import re
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from matplotlib.backends.backend_pdf import PdfPages
+from datetime import datetime
+import io
+import requests
+# from wordcloud import WordCloud # Si utilisé
+# from sklearn.feature_extraction.text import TfidfVectorizer # Si utilisé
+# from sklearn.cluster import KMeans # Si utilisé
+
+# --- Configuration de la Page Streamlit ---
+st.set_page_config(
+    page_title="Analyseur Sécurité Alimentaire IFS",
+    page_icon="🛡️",
+    layout="wide", # Utilise toute la largeur de la page
+    initial_sidebar_state="expanded" # Sidebar ouverte par défaut
+)
+
+# --- Styles CSS Personnalisés (Optionnel, pour un look plus moderne) ---
+# Vous pouvez ajouter du CSS ici pour personnaliser davantage l'apparence.
+# Exemple : st.markdown("<style>...</style>", unsafe_allow_html=True)
+# Pour l'instant, nous allons nous concentrer sur la structure.
+
+# --- Classe IFSAnalyzer (copiez-collez votre classe ici) ---
+# Assurez-vous que les méthodes de la classe sont adaptées pour Streamlit :
+# - Elles devraient retourner des données (DataFrames, dicts, figures Plotly/Matplotlib)
+# - La génération PDF devrait enregistrer le fichier et retourner son chemin.
+class IFSAnalyzer:
+    def __init__(self, locked_file_io, checklist_file_io=None):
+        self.locked_df = None
+        self.checklist_df = None
+        self.themes_keywords_definition = {
+            'HYGIENE_PERSONNEL': ['hygien', 'personnel', 'clothing', 'hand', 'wash', 'uniform', 'gmp', 'locker', 'changing room', 'work clothing', 'protective clothes'],
+            'HACCP_CCP_OPRP': ['haccp', 'ccp', 'oprp', 'critical', 'control', 'point', 'monitoring', 'hazard analysis', 'validation haccp', '2.3.9.1'],
+            'TRACEABILITY': ['traceability', 'trace', 'record', 'batch', 'lot', 'identification', 'tracking', '4.18.1'],
+            'ALLERGEN_MANAGEMENT': ['allergen', 'allergy', 'cross-contamination', 'gluten', 'lactose', 'celery', 'mustard', 'wheat', 'egg', '4.19.2'],
+            'PEST_CONTROL': ['pest', 'rodent', 'insect', 'trap', 'bait', 'infestation', 'fly', 'mouse', 'rat', 'moth', 'weevil', 'spider', 'cobweb', '4.13.1', '4.13.2'],
+            'CLEANING_SANITATION': ['clean', 'sanitation', 'disinfect', 'chemical', 'cleaning plan', 'dirt', 'residue', '4.10.1', '4.10.2'],
+            'TEMPERATURE_CONTROL': ['temperature', 'cold', 'heat', 'refrigerat', 'freez', 'thaw', 'cooling'],
+            'MAINTENANCE_EQUIPMENT': ['maintenance', 'equipment', 'calibrat', 'repair', 'infrastructure', 'facility', 'structure', 'conveyor', '4.9.1.1', '4.16.5', '4.17.2', '4.17.4'],
+            'DOCUMENTATION_RECORDS': ['document', 'procedure', 'record', 'manual', 'specification', 'not documented', '5.1.1', '5.1.2', '5.3.2'],
+            'FOREIGN_BODY_CONTAMINATION': ['foreign body', 'foreign material', 'glass', 'metal', 'detect', 'x-ray', 'contaminat', 'wood', 'plastic', '4.12.1', '4.12.2', '4.12.3'],
+            'STORAGE_WAREHOUSING': ['storage', 'warehouse', 'stock', 'segregat', 'pallet', 'raw material storage', '4.14.3', '4.14.5'],
+            'SUPPLIER_RAW_MATERIAL_CONTROL': ['supplier', 'vendor', 'purchase', 'raw material', 'ingredient', 'packaging material', 'declaration of conformity', 'doc', '4.5.1', '4.5.2'],
+            'LABELLING': ['label', 'labelling', 'declaration', 'ingredient list', 'mrl', 'allergen labelling', 'nutritional information', '4.3.1', '4.3.2'],
+            'QUANTITY_CONTROL_WEIGHT': ['quantity control', 'weight', 'fill', 'scale', 'metrological', 'underfilling', '5.5.1', '5.5.2', '5.4.1', '5.4.2'],
+            'MANAGEMENT_RESPONSIBILITY_CULTURE': ['management', 'responsibilit', 'food safety culture', 'internal audit', 'corrective action', 'training', '1.1.1', '1.1.2', '1.2.1', '5.11.1', '5.11.2', '5.11.3', '5.11.4'],
+            'NON_PAYMENT_ADMINISTRATIVE': ['payment', 'invoice', 'pay', 'closure', 'discontinued', 'bankrupt', 'denies access', 'ceased operation', 'fire', 'merged'],
+            'INTEGRITY_PROGRAM_ISSUES': ['integrity', 'on-site check', 'ioc', 'unannounced audit', 'integrity on-site check', 'integrity on site check']
+        }
+        self.load_data(locked_file_io, checklist_file_io)
+        if self.locked_df is not None:
+            self.clean_lock_reasons()
+
+    def load_data(self, locked_file_io, checklist_file_io=None):
+        try:
+            self.locked_df = pd.read_csv(locked_file_io, encoding='utf-8')
+            # print(f"✅ Données de suspension chargées: {len(self.locked_df)} lignes initiales.")
+            if 'Standard' in self.locked_df.columns:
+                self.locked_df = self.locked_df[self.locked_df['Standard'].str.contains('IFS Food', na=False, case=False)]
+                # print(f"📋 Après filtrage IFS Food: {len(self.locked_df)} lignes.")
+            if checklist_file_io:
+                try:
+                    self.checklist_df = pd.read_csv(checklist_file_io, encoding='utf-8')
+                    # print(f"✅ Checklist IFS chargée: {len(self.checklist_df)} exigences.")
+                    if 'Requirement Number' not in self.checklist_df.columns or \
+                       'Requirement text (English)' not in self.checklist_df.columns:
+                        st.warning("Colonnes 'Requirement Number' ou 'Requirement text (English)' manquantes dans la checklist. L'analyse des exigences sera limitée.")
+                        self.checklist_df = None
+                except Exception as e_checklist:
+                    st.error(f"Erreur lors du chargement du fichier checklist : {e_checklist}")
+                    self.checklist_df = None
+            # else:
+                # print("ℹ️ Fichier checklist non fourni. L'analyse des exigences sera basée sur les numéros de chapitre uniquement.")
+        except Exception as e:
+            st.error(f"❌ Erreur lors du chargement du fichier des suspensions : {e}")
+            self.locked_df = None
+
+    def clean_lock_reasons(self):
+        if self.locked_df is None or 'Lock reason' not in self.locked_df.columns: return
+        self.locked_df['lock_reason_clean'] = self.locked_df['Lock reason'].astype(str).fillna('') \
+            .str.lower() \
+            .str.replace(r'[\n\r\t]', ' ', regex=True) \
+            .str.replace(r'[^\w\s\.\-\/\%]', ' ', regex=True) \
+            .str.replace(r'\s+', ' ', regex=True).str.strip()
+
+    def extract_ifs_chapters(self, text):
+        if pd.isna(text) or not isinstance(text, str) or text.strip() == '': return []
+        patterns = [
+            r'(?:ko|major|cl\.|req\.|requirement(?: item)?|chapter|section|point|§|cl\s+|clause)?\s*(\d\.\d{1,2}(?:\.\d{1,2})?)', # X.Y ou X.Y.Z avec préfixes
+            r'(\d\.\d{1,2}(?:\.\d{1,2})?)\s*(?:ko|major|:|-|\(ko\)|\(major\))', # X.Y ou X.Y.Z suivi de KO/Major
+            r'(\d{1,2})\s*-\s*ko', # Ex: 5.11.3 - KO (capture le numéro seul)
+            r'requirement\s+(\d\.\d\.\d)',
+            r'cl\s+(\d\.\d+(?:\.\d+)?)', # Ex: cl 4.12.1
+            r'§\s*(\d\.\d+(?:\.\d+)?)'   # Ex: § 4.13.1
+        ]
+        chapters_found = []
+        normalized_text = text.lower().replace('\n', ' ').replace('\r', ' ')
+        for pattern in patterns:
+            matches = re.findall(pattern, normalized_text)
+            for match in matches:
+                chapter_num = match if isinstance(match, str) else (match[-1] if isinstance(match, tuple) and match[-1] else match[0] if isinstance(match, tuple) and match[0] else None)
+                if chapter_num:
+                    chapter_num = chapter_num.strip().rstrip('.').strip()
+                    if re.fullmatch(r'\d(\.\d+){1,2}', chapter_num) or re.fullmatch(r'\d\.\d+', chapter_num) :
+                        main_chapter_part = chapter_num.split('.')[0]
+                        if main_chapter_part.isdigit() and 1 <= int(main_chapter_part) <= 6:
+                             chapters_found.append(chapter_num)
+        return sorted(list(set(chapters_found)))
+
+    def analyze_themes(self):
+        if self.locked_df is None or 'lock_reason_clean' not in self.locked_df.columns: return {}, {}
+        theme_counts = {theme: 0 for theme in self.themes_keywords_definition}
+        theme_details = {theme: [] for theme in self.themes_keywords_definition}
+        for index, row in self.locked_df.iterrows():
+            reason_text = row['lock_reason_clean']
+            original_reason = row['Lock reason']
+            supplier = row['Supplier']
+            country = row.get('Country/Region', 'N/A')
+            for theme, keywords in self.themes_keywords_definition.items():
+                if any(keyword in reason_text for keyword in keywords):
+                    theme_counts[theme] += 1
+                    theme_details[theme].append({
+                        "reason": original_reason,
+                        "supplier": supplier,
+                        "country": country
+                    })
+        return theme_counts, theme_details
+
+    def geographic_analysis(self):
+        if self.locked_df is None or 'Country/Region' not in self.locked_df.columns: return None
+        return self.locked_df.groupby('Country/Region').size().sort_values(ascending=False).reset_index(name='total_suspensions')
+
+    def clean_product_scopes(self, scope_text):
+        if pd.isna(scope_text): return []
+        scope_text = str(scope_text)
+        raw_scopes = re.split(r'[,;\s"\'’`]|et|\/|&|\.\s', scope_text) # Ajout de guillemets et point suivi d'espace
+        cleaned_scopes = []
+        for scope in raw_scopes:
+            scope = scope.strip().replace('"', '').replace("'", "")
+            if not scope or not scope.isdigit(): continue # Ignorer si vide ou non numérique après nettoyage
+            num = int(scope)
+            if 1 <= num <= 11:
+                cleaned_scopes.append(str(num))
+            elif num > 1000: # ex: 2005, 2007, 2009, 2010
+                potential_scope_2 = str(num % 100) # Pour 10, 11
+                potential_scope_1 = str(num % 10)  # Pour 1-9
+                if potential_scope_2 in ['10', '11']:
+                     cleaned_scopes.append(potential_scope_2)
+                elif potential_scope_1 in [str(i) for i in range(1,10)]:
+                     cleaned_scopes.append(potential_scope_1)
+        return list(set(cleaned_scopes))
+
+
+    def product_scope_analysis(self):
+        if self.locked_df is None or 'Product scopes' not in self.locked_df.columns: return None
+        all_scopes = []
+        for scopes_text in self.locked_df['Product scopes'].dropna():
+            cleaned = self.clean_product_scopes(scopes_text)
+            all_scopes.extend(cleaned)
+        return Counter(all_scopes)
+
+    def chapter_frequency_analysis(self):
+        if self.locked_df is None or 'Lock reason' not in self.locked_df.columns: return Counter()
+        all_chapters = []
+        for reason in self.locked_df['Lock reason'].dropna():
+            all_chapters.extend(self.extract_ifs_chapters(reason))
+        return Counter(all_chapters)
+
+    def analyze_audit_types(self):
+        if self.locked_df is None: return {}, {}
+        audit_keywords = {
+            'INTEGRITY_PROGRAM_IP': ['integrity program', 'integrity', 'programme intégrité', 'programme integrity','onsite check', 'on site check', 'on-site check', 'on-site integrity check', 'ioc', 'i.o.c', 'ip audit', 'integrity audit', 'spot check', 'unannounced audit', 'audit inopiné', 'control inopiné', 'ifs integrity'],
+            'SURVEILLANCE_FOLLOW_UP': ['surveillance', 'surveillance audit', 'follow up audit', 'follow-up', 'suivi', 'corrective action'],
+            'COMPLAINT_WITHDRAWAL': ['complaint', 'réclamation', 'plainte', 'customer complaint', 'withdrawal', 'retrait', 'recall'],
+            'RECERTIFICATION_RENEWAL': ['recertification', 'renewal', 'renouvellement', 're-certification', 'renewal audit']
+        }
+        audit_analysis = {audit_type: 0 for audit_type in audit_keywords}
+        audit_examples = {audit_type: {'examples': [], 'countries': Counter()} for audit_type in audit_keywords}
+        for index, row in self.locked_df.iterrows():
+            text_to_search = (str(row.get('Lock reason', '')) + " " + str(row.get('Lock history', ''))).lower()
+            for audit_type, keywords in audit_keywords.items():
+                if any(keyword in text_to_search for keyword in keywords):
+                    audit_analysis[audit_type] += 1
+                    if len(audit_examples[audit_type]['examples']) < 5: # Plus d'exemples
+                        audit_examples[audit_type]['examples'].append({
+                            'Supplier': row.get('Supplier', 'N/A'),
+                            'Country/Region': row.get('Country/Region', 'N/A'),
+                            'Lock reason': row.get('Lock reason', 'N/A')
+                        })
+                    audit_examples[audit_type]['countries'][row.get('Country/Region', 'N/A')] += 1
+        for audit_type in audit_examples:
+            audit_examples[audit_type]['countries'] = dict(audit_examples[audit_type]['countries'].most_common(5))
+        return audit_analysis, audit_examples
+
+    def generate_ifs_recommendations_analysis(self):
+        if self.locked_df is None or self.checklist_df is None: return None
+        chapter_counts = self.chapter_frequency_analysis()
+        if not chapter_counts: return None
+        recommendations = []
+        for chapter, count in chapter_counts.most_common():
+            norm_chapter = chapter.replace("KO ", "").strip()
+            req_text_series = self.checklist_df[self.checklist_df['Requirement Number'].astype(str).str.strip() == norm_chapter]['Requirement text (English)']
+            req_text = req_text_series.iloc[0] if not req_text_series.empty else "Texte de l'exigence non trouvé."
+            # if len(req_text) > 250: req_text = req_text[:247] + "..." # Tronquer pour affichage résumé
+            recommendations.append({'chapter': chapter, 'count': count, 'requirement_text': req_text})
+        return recommendations
+
+    def cross_analysis_scope_themes(self):
+        if self.locked_df is None or 'Product scopes' not in self.locked_df.columns or 'lock_reason_clean' not in self.locked_df.columns: return None
+        themes_for_cross = {
+            'HYGIENE': self.themes_keywords_definition['HYGIENE_PERSONNEL'], 'HACCP': self.themes_keywords_definition['HACCP_CCP_OPRP'],
+            'TRACE': self.themes_keywords_definition['TRACEABILITY'], 'ALLERGEN': self.themes_keywords_definition['ALLERGEN_MANAGEMENT'],
+            'CLEAN': self.themes_keywords_definition['CLEANING_SANITATION'], 'MAINT': self.themes_keywords_definition['MAINTENANCE_EQUIPMENT'],
+            'LABEL': self.themes_keywords_definition['LABELLING'], 'PEST': self.themes_keywords_definition['PEST_CONTROL']
+        }
+        scope_theme_data = []
+        for idx, row in self.locked_df.iterrows():
+            scopes_text, reason_text = row['Product scopes'], row['lock_reason_clean']
+            if pd.notna(scopes_text) and pd.notna(reason_text) and reason_text:
+                for scope in self.clean_product_scopes(scopes_text):
+                    for theme, keywords in themes_for_cross.items():
+                        if any(kw in reason_text for kw in keywords):
+                            scope_theme_data.append({'scope': f"Scope {scope}", 'theme': theme})
+        if not scope_theme_data: return None
+        return pd.DataFrame(scope_theme_data).pivot_table(index='scope', columns='theme', aggfunc='size', fill_value=0)
+
+    def _create_plotly_bar_chart(self, data_dict, title, orientation='v', xaxis_title="", yaxis_title="", color='royalblue', height=400):
+        if not data_dict : return go.Figure()
+        if orientation == 'h':
+            y_data = list(data_dict.keys())
+            x_data = list(data_dict.values())
+        else:
+            x_data = list(data_dict.keys())
+            y_data = list(data_dict.values())
+
+        fig = go.Figure(go.Bar(x=x_data, y=y_data, orientation=orientation, marker_color=color, text=x_data if orientation=='h' else y_data, textposition='auto'))
+        fig.update_layout(
+            title={'text': title, 'x':0.5, 'font': {'size': 16}},
+            xaxis_title=xaxis_title,
+            yaxis_title=yaxis_title,
+            height=height,
+            margin=dict(l=10, r=10, t=50, b=10),
+            yaxis=dict(autorange="reversed") if orientation == 'h' else {},
+            plot_bgcolor='rgba(0,0,0,0)', paper_bgcolor='rgba(0,0,0,0)'
+        )
+        return fig
+
+    def _create_plotly_choropleth_map(self, geo_data_df, title, height=500):
+        if geo_data_df is None or geo_data_df.empty: return go.Figure()
+        fig = px.choropleth(geo_data_df, locations="Country/Region",
+                            locationmode='country names', # S'assurer que les noms de pays sont compatibles
+                            color="total_suspensions",
+                            hover_name="Country/Region",
+                            color_continuous_scale=px.colors.sequential.Plasma,
+                            title=title,
+                            height=height)
+        fig.update_layout(
+            title={'x':0.5, 'font': {'size': 16}},
+            geo=dict(showframe=False, showcoastlines=False, projection_type='equirectangular'),
+            margin=dict(l=10, r=10, t=50, b=10),
+             plot_bgcolor='rgba(0,0,0,0)', paper_bgcolor='rgba(0,0,0,0)'
+        )
+        return fig
+
+    def _create_plotly_heatmap(self, pivot_matrix, title, height=500):
+        if pivot_matrix is None or pivot_matrix.empty: return go.Figure()
+        fig = px.imshow(pivot_matrix, text_auto=True, aspect="auto", color_continuous_scale='YlGnBu', title=title, height=height)
+        fig.update_layout(
+            title={'x':0.5, 'font': {'size': 16}},
+            margin=dict(l=10, r=10, t=50, b=10),
+            xaxis=dict(tickangle=45),
+             plot_bgcolor='rgba(0,0,0,0)', paper_bgcolor='rgba(0,0,0,0)'
+        )
+        return fig
+
+    # --- Méthodes pour le rapport PDF (utilisant Matplotlib) ---
+    def _add_text_to_pdf_page(self, fig, text_lines, start_y=0.95, line_height=0.035, font_size=9, title="", title_font_size=14, max_chars_per_line=100):
+        ax = fig.gca()
+        ax.clear()
+        ax.axis('off')
+        if title:
+            ax.text(0.5, start_y, title, ha='center', va='top', fontsize=title_font_size, fontweight='bold')
+            start_y -= (line_height * 2.5)
+        current_y = start_y
+        for line in text_lines:
+            wrapped_lines = [line[i:i+max_chars_per_line] for i in range(0, len(line), max_chars_per_line)]
+            for wrapped_line in wrapped_lines:
+                if current_y < 0.05: return False # Page pleine
+                fw = 'bold' if line.startswith(tuple(["🎯","📊","🌍","🏭","📋","🔍"])) else 'normal'
+                fs = font_size + 1 if fw == 'bold' else font_size
+                ax.text(0.03, current_y, wrapped_line, ha='left', va='top', fontsize=fs, fontweight=fw)
+                current_y -= line_height
+            if not line.strip(): current_y -= (line_height * 0.5)
+        return True
+
+    def _create_matplotlib_figure_for_pdf(self, data_dict_or_df, title, x_label="", y_label="", chart_type='barh', top_n=10, color='skyblue', xtick_rotation=0, ytick_fontsize=8):
+        if not data_dict_or_df and not isinstance(data_dict_or_df, pd.DataFrame) : return None
+        fig, ax = plt.subplots(figsize=(10, 6.5))
+        items, values = [], []
+
+        if isinstance(data_dict_or_df, (Counter, dict)):
+            sorted_data = dict(sorted(data_dict_or_df.items(), key=lambda item: item[1], reverse=True)[:top_n])
+            items = [str(k).replace('_',' ').replace('MANAGEMENT','MGMT').replace('RESPONSIBILITY','RESP.')[:30] for k in sorted_data.keys()] # Tronquer labels longs
+            values = list(sorted_data.values())
+        elif isinstance(data_dict_or_df, pd.DataFrame):
+            df_top = data_dict_or_df.head(top_n)
+            if 'Country/Region' in df_top.columns and 'total_suspensions' in df_top.columns:
+                items = df_top['Country/Region'].tolist()
+                values = df_top['total_suspensions'].tolist()
+                chart_type = 'bar'
+            elif 'chapter' in df_top.columns and 'count' in df_top.columns and 'requirement_text' in df_top.columns:
+                 items = [f"{row['chapter']}\n({row['requirement_text'][:35]}...)" if row['requirement_text'] != "Texte de l'exigence non trouvé." else row['chapter'] for index, row in df_top.iterrows()]
+                 values = df_top['count'].tolist()
+                 chart_type = 'bar'
+            else: # Cas générique
+                if not df_top.empty:
+                    items = df_top.index.astype(str).tolist() if len(df_top.columns) == 1 else df_top.iloc[:,0].astype(str).tolist()
+                    values = df_top.iloc[:,0].tolist() if len(df_top.columns) == 1 else df_top.iloc[:,1].tolist()
+
+        if not items or not values or all(v == 0 for v in values): return None
+
+        if chart_type == 'barh':
+            ax.barh(items, values, color=color, edgecolor='grey')
+            ax.set_yticklabels(items, fontsize=ytick_fontsize)
+            ax.invert_yaxis()
+            ax.set_xlabel(x_label if x_label else 'Nombre de cas', fontsize=10)
+            for i, v_ in enumerate(values): ax.text(v_ + (max(values)*0.01), i, str(v_), va='center', fontsize=8)
+            ax.set_xlim(0, max(values) * 1.12 if values else 1)
+        elif chart_type == 'bar':
+            bars = ax.bar(items, values, color=color, edgecolor='grey')
+            ax.set_xticklabels(items, rotation=xtick_rotation, ha='right' if xtick_rotation > 0 else 'center', fontsize=ytick_fontsize)
+            ax.set_ylabel(y_label if y_label else 'Nombre de cas', fontsize=10)
+            for bar in bars:
+                yval = bar.get_height()
+                ax.text(bar.get_x() + bar.get_width()/2.0, yval + (max(values)*0.01), int(yval), ha='center', va='bottom', fontsize=8)
+            ax.set_ylim(0, max(values) * 1.12 if values else 1)
+
+        ax.set_title(title, fontsize=13, fontweight='bold', pad=15)
+        ax.grid(axis='x' if chart_type == 'barh' else 'y', linestyle='--', alpha=0.7)
+        sns.despine(left=True, bottom=True)
+        plt.tight_layout(pad=1.5)
+        return fig
+
+    def export_report_to_pdf(self, filename='IFS_Analysis_Report.pdf'):
+        if self.locked_df is None: return None
+        try:
+            with PdfPages(filename) as pdf:
+                # print(f"📄 Génération du rapport PDF: {filename}")
+                total_suspensions = len(self.locked_df)
+                if total_suspensions == 0:
+                    fig = plt.figure(figsize=(8.5, 11)); self._add_text_to_pdf_page(fig, ["Aucune donnée."], title="Rapport"); pdf.savefig(fig); plt.close(fig); return filename
+
+                # Page 1: Couverture
+                fig = plt.figure(figsize=(8.5, 11))
+                title_page_text = [ f"Date: {datetime.now().strftime('%d/%m/%Y %H:%M')}", "",
+                                    f"Source Suspensions: {st.session_state.get('locked_file_name_original', 'N/A')}",
+                                    f"Source Checklist: {st.session_state.get('checklist_file_name_original', 'Non fournie')}", "",
+                                    "📊 VUE D'ENSEMBLE",
+                                    f"   • Total suspensions IFS Food: {total_suspensions}",
+                                    f"   • Avec motifs: {self.locked_df['Lock reason'].notna().sum()} ({self.locked_df['Lock reason'].notna().sum()/total_suspensions*100:.1f}%)" ]
+                audit_s, _ = self.analyze_audit_types(); total_as = sum(audit_s.values())
+                title_page_text.append(f"   • Liées à audits spécifiques: {total_as} ({total_as/total_suspensions*100:.1f}%)")
+                self._add_text_to_pdf_page(fig, title_page_text, title="Rapport d'Analyse IFS Food Safety"); pdf.savefig(fig, bbox_inches='tight'); plt.close(fig)
+
+                # Graphiques
+                tc, _ = self.analyze_themes(); fig_t = self._create_matplotlib_figure_for_pdf(tc, 'Top 10 Thèmes NC', color='indianred', ytick_fontsize=7);
+                if fig_t: pdf.savefig(fig_t, bbox_inches='tight'); plt.close(fig_t)
+
+                gs = self.geographic_analysis(); fig_g = self._create_matplotlib_figure_for_pdf(gs, 'Top 10 Pays', chart_type='bar', color='lightseagreen', xtick_rotation=30, ytick_fontsize=7);
+                if fig_g: pdf.savefig(fig_g, bbox_inches='tight'); plt.close(fig_g)
+
+                sc = self.product_scope_analysis(); sc_plot = {f"Sc {k}": v for k,v in sc.items()}; fig_s = self._create_matplotlib_figure_for_pdf(sc_plot, 'Top 10 Product Scopes', color='cornflowerblue', ytick_fontsize=7);
+                if fig_s: pdf.savefig(fig_s, bbox_inches='tight'); plt.close(fig_s)
+
+                reco = self.generate_ifs_recommendations_analysis()
+                if reco:
+                    df_reco = pd.DataFrame(reco)
+                    fig_c = self._create_matplotlib_figure_for_pdf(df_reco, 'Top 10 Exigences IFS', chart_type='bar', color='gold', xtick_rotation=30, ytick_fontsize=6);
+                else:
+                    cc_direct = self.chapter_frequency_analysis()
+                    fig_c = self._create_matplotlib_figure_for_pdf(cc_direct, 'Top 10 Chapitres IFS (Numéros)', chart_type='bar', color='gold', xtick_rotation=30, ytick_fontsize=7);
+                if fig_c: pdf.savefig(fig_c, bbox_inches='tight'); plt.close(fig_c)
+
+                # Heatmap
+                cpm = self.cross_analysis_scope_themes()
+                if cpm is not None and not cpm.empty:
+                    top_n = min(8, len(cpm.index)); scope_tots = cpm.sum(axis=1).sort_values(ascending=False)
+                    cpm_f = cpm.loc[scope_tots.head(top_n).index] if len(cpm.index) > top_n else cpm
+                    if not cpm_f.empty:
+                        fig_h, ax_h = plt.subplots(figsize=(10, max(5, len(cpm_f.index)*0.6)))
+                        sns.heatmap(cpm_f, annot=True, cmap="YlGnBu", fmt='d', ax=ax_h, annot_kws={"size":7});
+                        ax_h.set_title('Corrélations: Thèmes vs Scopes (Top)', fontsize=13, pad=15)
+                        ax_h.tick_params(axis='x', labelsize=8, rotation=30, ha='right'); ax_h.tick_params(axis='y', labelsize=8)
+                        plt.tight_layout(pad=1.5); pdf.savefig(fig_h, bbox_inches='tight'); plt.close(fig_h)
+
+                # Pages Texte Détaillées
+                for gen_func, title_str, lh, fs, mcpl in [
+                    (self.generate_detailed_theme_analysis, "Analyse Thématique Détaillée", 0.03, 8, 110),
+                    (self.generate_audit_analysis_report, "Analyse des Types d'Audits", 0.03, 8, 110)
+                ]:
+                    fig = plt.figure(figsize=(8.5, 11)); s_io = io.StringIO(); gen_func(stream=s_io)
+                    self._add_text_to_pdf_page(fig, s_io.getvalue().splitlines(), title=title_str, line_height=lh, font_size=fs, max_chars_per_line=mcpl)
+                    pdf.savefig(fig, bbox_inches='tight'); plt.close(fig)
+
+                if reco:
+                    fig = plt.figure(figsize=(8.5, 11))
+                    req_tl = ["Note: Texte de l'exigence de la checklist IFS Food v8 (si fournie).\n"]
+                    for r_ in sorted(reco, key=lambda x: x['count'], reverse=True)[:20]:
+                        req_tl.extend([f"📋 Chap {r_['chapter']} ({r_['count']} mentions)", f"   Txt: {r_['requirement_text']}", ""])
+                    self._add_text_to_pdf_page(fig, req_tl, title="Détail Exigences IFS", line_height=0.028, font_size=7, max_chars_per_line=120)
+                    pdf.savefig(fig, bbox_inches='tight'); plt.close(fig)
+
+            # print(f"✅ Rapport PDF complet généré: {filename}")
+            return filename
+        except Exception as e:
+            st.error(f"❌ Erreur majeure PDF: {e}")
+            return None # Pas de fallback txt dans Streamlit, l'erreur est affichée
+
+# --- Fonctions Utilitaires pour Streamlit ---
+@st.cache_data # Mise en cache des données téléchargées pour éviter de recharger
+def load_csv_data(uploaded_file):
+    if uploaded_file is not None:
+        try:
+            return pd.read_csv(uploaded_file)
+        except Exception as e:
+            st.error(f"Erreur lors de la lecture du fichier CSV : {e}")
+            return None
+    return None
+
+@st.cache_resource # Mise en cache de l'objet analyseur
+def get_analyzer(locked_data_io, checklist_data_io):
+    return IFSAnalyzer(locked_data_io, checklist_data_io)
+
+def download_checklist_from_github_st(url="https://raw.githubusercontent.com/M00N69/Action-plan/main/Guide%20Checklist_IFS%20Food%20V%208%20-%20CHECKLIST.csv"):
+    try:
+        response = requests.get(url, timeout=10) # Ajout d'un timeout
+        response.raise_for_status()
+        return io.StringIO(response.text)
+    except requests.exceptions.RequestException as e:
+        st.warning(f"Impossible de télécharger la checklist depuis GitHub ({e}). L'analyse des exigences sera limitée.")
+        return None
+
+# --- Interface Streamlit ---
+def main():
+    st.title("🛡️ Analyseur de Sécurité Alimentaire IFS")
+    st.markdown("Téléversez votre fichier de suspensions IFS pour générer une analyse détaillée et des visualisations.")
+
+    # --- Sidebar pour les options ---
+    with st.sidebar:
+        st.header("⚙️ Options d'Analyse")
+        locked_file_uploaded = st.file_uploader("1. Fichier des suspensions IFS (.csv)", type="csv", key="locked_uploader")
+
+        st.markdown("---")
+        checklist_source = st.radio(
+            "2. Source de la Checklist IFS Food V8:",
+            ("Utiliser celle de GitHub (Recommandé)", "Téléverser ma checklist", "Ne pas utiliser de checklist"),
+            key="checklist_source_radio"
+        )
+        checklist_file_uploaded = None
+        if checklist_source == "Téléverser ma checklist":
+            checklist_file_uploaded = st.file_uploader("Téléversez votre fichier checklist (.csv)", type="csv", key="checklist_uploader")
+
+    # --- Logique principale ---
+    if locked_file_uploaded is not None:
+        # Stocker les noms de fichiers originaux pour le rapport PDF
+        st.session_state.locked_file_name_original = locked_file_uploaded.name
+        if checklist_file_uploaded:
+            st.session_state.checklist_file_name_original = checklist_file_uploaded.name
+        elif checklist_source == "Utiliser celle de GitHub (Recommandé)":
+            st.session_state.checklist_file_name_original = "Checklist IFS Food V8 (GitHub)"
+        else:
+            st.session_state.checklist_file_name_original = "Non fournie"
+
+
+        locked_data_io = io.BytesIO(locked_file_uploaded.getvalue()) # Convertir en BytesIO pour l'analyseur
+        checklist_data_io = None
+
+        if checklist_source == "Téléverser ma checklist" and checklist_file_uploaded is not None:
+            checklist_data_io = io.BytesIO(checklist_file_uploaded.getvalue())
+        elif checklist_source == "Utiliser celle de GitHub (Recommandé)":
+            # Ne pas mettre en cache le téléchargement lui-même, mais le résultat si nécessaire
+            checklist_data_io = download_checklist_from_github_st()
+
+
+        # Utiliser BytesIO pour l'analyseur
+        analyzer = get_analyzer(locked_data_io, checklist_data_io)
+
+
+        if analyzer.locked_df is not None and not analyzer.locked_df.empty:
+            st.success(f"Fichier '{locked_file_uploaded.name}' chargé et analysé. {len(analyzer.locked_df)} suspensions IFS Food trouvées.")
+            display_dashboard_tabs(analyzer) # Afficher les onglets avec les résultats
+
+            # Bouton pour générer le rapport PDF
+            st.sidebar.markdown("---")
+            if st.sidebar.button("📄 Générer le Rapport PDF Complet", key="pdf_button"):
+                with st.spinner("Génération du rapport PDF en cours... Veuillez patienter."):
+                    pdf_path = analyzer.export_report_to_pdf() # La méthode gère l'enregistrement
+                    if pdf_path:
+                        with open(pdf_path, "rb") as pdf_file:
+                            st.sidebar.download_button(
+                                label="📥 Télécharger le Rapport PDF",
+                                data=pdf_file,
+                                file_name="Analyse_IFS_Suspensions_Report.pdf",
+                                mime="application/pdf"
+                            )
+                        st.sidebar.success("Rapport PDF généré !")
+                    else:
+                        st.sidebar.error("Erreur lors de la création du rapport PDF.")
+        else:
+            st.error("Aucune donnée IFS Food n'a été trouvée dans le fichier ou après filtrage. Veuillez vérifier votre fichier.")
+    else:
+        st.info("Veuillez téléverser un fichier CSV des suspensions IFS pour commencer l'analyse.")
+
+    st.sidebar.markdown("---")
+    st.sidebar.markdown("Développé avec ❤️ par IA")
+
+
+def display_dashboard_tabs(analyzer):
+    tab_titles = [
+        "📊 Vue d'Ensemble", "🌍 Géographie", "🏷️ Thèmes Détaillés",
+        "📋 Exigences IFS", "🕵️ Types d'Audits", "🔗 Analyse Croisée"
+    ]
+    tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs(tab_titles)
+
+    with tab1: # Vue d'Ensemble
+        st.header("📊 Vue d'Ensemble des Suspensions")
+        col1, col2 = st.columns(2)
+        total_suspensions = len(analyzer.locked_df)
+        with_reasons_count = analyzer.locked_df['Lock reason'].notna().sum()
+        audit_analysis_summary, _ = analyzer.analyze_audit_types()
+        total_audit_special = sum(audit_analysis_summary.values())
+
+        with col1:
+            st.metric("Total Suspensions IFS Food", total_suspensions)
+            st.metric("Avec Motifs Documentés", f"{with_reasons_count} ({with_reasons_count/total_suspensions*100:.1f}%)" if total_suspensions > 0 else "0")
+        with col2:
+            st.metric("Liées à Audits Spécifiques (IP, etc.)", f"{total_audit_special} ({total_audit_special/total_suspensions*100:.1f}%)" if total_suspensions > 0 else "0")
+            # Vous pouvez ajouter d'autres métriques ici
+
+        st.markdown("---")
+        st.subheader("Visualisations Clés")
+        # Thèmes
+        theme_counts, _ = analyzer.analyze_themes()
+        if theme_counts:
+            top_themes = dict(sorted(theme_counts.items(), key=lambda x:x[1], reverse=True)[:10])
+            top_themes_clean = {k.replace('_',' ').replace('MANAGEMENT','MGMT').replace('RESPONSIBILITY','RESP.'):v for k,v in top_themes.items() if v > 0}
+            if top_themes_clean: st.plotly_chart(analyzer._create_plotly_bar_chart(top_themes_clean, "Top 10 Thèmes de Non-Conformités", orientation='h', color='indianred', height=450), use_container_width=True)
+
+        # Product Scopes
+        scope_counts = analyzer.product_scope_analysis()
+        if scope_counts:
+            top_scopes = dict(scope_counts.most_common(10))
+            top_scopes_clean = {f"Scope {k}": v for k, v in top_scopes.items() if v > 0}
+            if top_scopes_clean: st.plotly_chart(analyzer._create_plotly_bar_chart(top_scopes_clean, "Top 10 Product Scopes Impactés", orientation='h', color='cornflowerblue', height=450), use_container_width=True)
+
+    with tab2: # Géographie
+        st.header("🌍 Analyse Géographique")
+        geo_stats_df = analyzer.geographic_analysis()
+        if geo_stats_df is not None and not geo_stats_df.empty:
+            st.plotly_chart(analyzer._create_plotly_choropleth_map(geo_stats_df, "Suspensions par Pays"), use_container_width=True)
+            st.markdown("---")
+            st.subheader("Tableau des Suspensions par Pays (Top 15)")
+            st.dataframe(geo_stats_df.head(15), use_container_width=True)
+        else:
+            st.info("Données géographiques non disponibles.")
+
+    with tab3: # Thèmes Détaillés
+        st.header("🏷️ Analyse Thématique Détaillée")
+        theme_counts, theme_details = analyzer.analyze_themes()
+        for theme, count in sorted(theme_counts.items(), key=lambda x: x[1], reverse=True):
+            if count > 0:
+                with st.expander(f"{theme.replace('_', ' ')} ({count} cas)", expanded=False):
+                    st.markdown(f"**Exemples de motifs (jusqu'à 3) pour le thème : {theme.replace('_', ' ')}**")
+                    for i, detail in enumerate(theme_details[theme][:3]):
+                        st.markdown(f"**Cas {i+1} (Fournisseur: {detail['supplier']}, Pays: {detail['country']})**")
+                        st.caption(f"{detail['reason'][:500]}...") # Afficher une partie du motif
+                        st.markdown("---")
+                    # Ajouter les pays les plus touchés pour ce thème
+                    theme_keywords_current_theme = analyzer.themes_keywords_definition.get(theme, [])
+                    if theme_keywords_current_theme:
+                        theme_mask = analyzer.locked_df['lock_reason_clean'].str.contains('|'.join(theme_keywords_current_theme), case=False, na=False, regex=True)
+                        if theme_mask.sum() > 0:
+                            theme_countries_df = analyzer.locked_df[theme_mask]['Country/Region'].value_counts().reset_index()
+                            theme_countries_df.columns = ['Pays', 'Nombre de cas']
+                            if not theme_countries_df.empty:
+                                st.markdown("**Pays les plus affectés par ce thème :**")
+                                st.dataframe(theme_countries_df.head(5), use_container_width=True)
+
+
+    with tab4: # Exigences IFS
+        st.header("📋 Analyse des Exigences IFS")
+        recommendations = analyzer.generate_ifs_recommendations_analysis()
+        if recommendations and analyzer.checklist_df is not None:
+            st.info("Les textes des exigences proviennent de la checklist IFS Food V8. Les numéros sont extraits des motifs de suspension.")
+            df_reco = pd.DataFrame(recommendations)
+            df_reco_sorted = df_reco.sort_values(by='count', ascending=False)
+
+            # Graphique des exigences les plus citées
+            top_reco_chart = df_reco_sorted.head(10).copy() # Pour le graphique
+            # Raccourcir les labels pour le graphique
+            top_reco_chart['display_label'] = top_reco_chart.apply(lambda row: f"{row['chapter']} ({row['requirement_text'][:25]}...)", axis=1)
+            reco_chart_data = pd.Series(top_reco_chart['count'].values, index=top_reco_chart['display_label']).to_dict()
+            st.plotly_chart(analyzer._create_plotly_bar_chart(reco_chart_data, "Top 10 Exigences IFS Citées", orientation='v', color='gold', height=500), use_container_width=True)
+
+
+            st.markdown("---")
+            st.subheader("Détail des Exigences Citées")
+            for index, row in df_reco_sorted.iterrows():
+                with st.expander(f"Exigence {row['chapter']} ({row['count']} mentions)", expanded=False):
+                    st.markdown(f"**Texte de l'exigence :**")
+                    st.markdown(f"> {row['requirement_text']}")
+        elif recommendations: # Pas de checklist mais des chapitres extraits
+             st.warning("Checklist non chargée. Affichage des numéros de chapitres uniquement.")
+             df_reco = pd.DataFrame(recommendations)
+             df_reco_sorted = df_reco.sort_values(by='count', ascending=False)
+             chapter_counts_dict = pd.Series(df_reco_sorted['count'].values, index=df_reco_sorted['chapter']).to_dict()
+             st.plotly_chart(analyzer._create_plotly_bar_chart(chapter_counts_dict, "Top Chapitres IFS Cités (Numéros)", orientation='v', color='gold', height=500), use_container_width=True)
+             st.dataframe(df_reco_sorted, use_container_width=True)
+        else:
+            st.info("Aucune exigence IFS spécifique n'a pu être extraite des motifs ou la checklist n'est pas disponible.")
+
+
+    with tab5: # Types d'Audits
+        st.header("🕵️ Analyse par Types d'Audits")
+        audit_analysis, audit_examples = analyzer.analyze_audit_types()
+        if audit_analysis:
+            # Graphique
+            audit_analysis_clean = {k.replace('_', ' '):v for k,v in audit_analysis.items() if v > 0}
+            if audit_analysis_clean: st.plotly_chart(analyzer._create_plotly_bar_chart(audit_analysis_clean, "Répartition par Type d'Audit Spécifique", color='darkorange', height=400), use_container_width=True)
+
+            st.markdown("---")
+            st.subheader("Détails et Exemples par Type d'Audit")
+            for audit_type, count in sorted(audit_analysis.items(), key=lambda x: x[1], reverse=True):
+                if count > 0:
+                    with st.expander(f"{audit_type.replace('_', ' ')} ({count} cas)", expanded=False):
+                        st.markdown(f"**Exemples (jusqu'à 3) pour : {audit_type.replace('_', ' ')}**")
+                        for i, ex_data in enumerate(audit_examples[audit_type]['examples'][:3]):
+                            st.markdown(f"**Cas {i+1} (Fournisseur: {ex_data.get('Supplier', 'N/A')}, Pays: {ex_data.get('Country/Region', 'N/A')})**")
+                            st.caption(f"{ex_data.get('Lock reason', 'N/A')[:500]}...")
+                            st.markdown("---")
+                        countries_data = audit_examples[audit_type]['countries']
+                        if countries_data:
+                            st.markdown(f"**Répartition géographique (Top 5 pays) pour ce type d'audit :** {', '.join([f'{c} ({n})' for c, n in countries_data.items()])}")
+        else:
+            st.info("Aucune donnée sur les types d'audits disponible.")
+
+    with tab6: # Analyse Croisée
+        st.header("🔗 Analyse Croisée : Thèmes vs Product Scopes")
+        cross_pivot_matrix = analyzer.cross_analysis_scope_themes()
+        if cross_pivot_matrix is not None and not cross_pivot_matrix.empty:
+            # Pour la lisibilité, on peut filtrer les scopes avec peu de données ou transposer
+            # Limiter le nombre de scopes affichés dans la heatmap pour la lisibilité
+            top_n_scopes_for_heatmap = min(15, len(cross_pivot_matrix.index))
+            if len(cross_pivot_matrix.index) > top_n_scopes_for_heatmap:
+                scope_totals = cross_pivot_matrix.sum(axis=1).sort_values(ascending=False)
+                top_scopes_names = scope_totals.head(top_n_scopes_for_heatmap).index
+                cross_pivot_matrix_filtered = cross_pivot_matrix.loc[top_scopes_names]
+            else:
+                cross_pivot_matrix_filtered = cross_pivot_matrix
+
+            if not cross_pivot_matrix_filtered.empty:
+                 st.plotly_chart(analyzer._create_plotly_heatmap(cross_pivot_matrix_filtered, "Fréquence des Thèmes de NC par Product Scope (Top Scopes)", height=max(500, len(cross_pivot_matrix_filtered.index) * 40)), use_container_width=True)
+                 st.markdown("---")
+                 st.subheader("Tableau de Corrélation Complet (Scopes vs Thèmes)")
+                 st.dataframe(cross_pivot_matrix.style.background_gradient(cmap='YlGnBu', axis=None), use_container_width=True) # axis=None pour colorer toute la cellule
+            else:
+                st.info("Pas assez de données pour afficher la heatmap après filtrage.")
+        else:
+            st.info("Données insuffisantes pour l'analyse croisée Thèmes vs Product Scopes.")
+
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# --- Exécution de l'application ---
+if __name__ == "__main__":
+    main()