Update streamlit_app.py

streamlit_app.py

@@ -1,13 +1,15 @@
-import io 
+import io
 import os
 from datetime import datetime, date
 from typing import Dict, List, Optional, Tuple
+import smtplib
+import ssl
+from email.message import EmailMessage
 
 import pandas as pd
 import plotly.express as px
 import streamlit as st
 
-
 # -----------------------------
 # App Configuration
 # -----------------------------
@@ -18,7 +20,6 @@ st.set_page_config(
     initial_sidebar_state="expanded",
 )
 
-
 # -----------------------------
 # Utilities
 # -----------------------------
@@ -66,6 +67,7 @@ def find_column(df: pd.DataFrame, candidates: List[str]) -> Optional[str]:
             return norm_to_col[n]
     return None
 
+
 def infer_pandas_types(df: pd.DataFrame) -> Dict[str, str]:
     """Return a mapping of column -> inferred logical type: 'categorical' | 'numeric' | 'date' | 'text'."""
     type_map: Dict[str, str] = {}
@@ -166,11 +168,94 @@ def chart_card(title: str, fig):
 
 
 def inject_base_css():
-    with open(os.path.join("", "styles.css"), "r", encoding="utf-8") as f:
+    # Créer le dossier assets s'il n'existe pas
+    if not os.path.exists("assets"):
+        os.makedirs("assets")
+    
+    # Créer le fichier CSS s'il n'existe pas
+    css_file = os.path.join("assets", "styles.css")
+    if not os.path.exists(css_file):
+        with open(css_file, "w", encoding="utf-8") as f:
+            f.write("""
+            .card {
+                background-color: var(--card);
+                border-radius: 0.5rem;
+                padding: 1rem;
+                margin-bottom: 1rem;
+                box-shadow: 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24);
+            }
+            .card-title {
+                font-weight: bold;
+                font-size: 1.2rem;
+                margin-bottom: 0.5rem;
+                color: var(--primary);
+            }
+            .kpi {
+                text-align: center;
+                padding: 1rem;
+            }
+            .card-label {
+                font-size: 1rem;
+                color: var(--muted);
+            }
+            .card-value {
+                font-size: 2rem;
+                font-weight: bold;
+                color: var(--primary);
+            }
+            """)
+    
+    # Lire et injecter le CSS
+    with open(css_file, "r", encoding="utf-8") as f:
         css = f.read()
     st.markdown(f"<style>{css}</style>", unsafe_allow_html=True)
 
 
+def safe_format_template(template: str, row: Dict[str, object]) -> str:
+    class SafeDict(dict):
+        def __missing__(self, key):
+            return ""
+
+    flat = {str(k): ("" if v is None else str(v)) for k, v in row.items()}
+    try:
+        return template.format_map(SafeDict(flat))
+    except Exception:
+        return template
+
+
+def send_email_smtp(
+    smtp_host: str,
+    smtp_port: int,
+    sender_email: str,
+    sender_password: str,
+    use_tls: bool,
+    to_email: str,
+    subject: str,
+    body_text: str,
+    reply_to: Optional[str] = None,
+) -> None:
+    message = EmailMessage()
+    message["From"] = sender_email
+    message["To"] = to_email
+    message["Subject"] = subject
+    if reply_to:
+        message["Reply-To"] = reply_to
+    message.set_content(body_text)
+
+    if use_tls:
+        context = ssl.create_default_context()
+        with smtplib.SMTP(smtp_host, smtp_port) as server:
+            server.starttls(context=context)
+            if sender_password:
+                server.login(sender_email, sender_password)
+            server.send_message(message)
+    else:
+        with smtplib.SMTP_SSL(smtp_host, smtp_port) as server:
+            if sender_password:
+                server.login(sender_email, sender_password)
+            server.send_message(message)
+
+
 def set_theme_variables(mode: str):
     # Adjust CSS variables for light/dark for cards and text; Plotly handled via template
     palette = {
@@ -230,8 +315,16 @@ def sidebar_controls() -> Tuple[Optional[pd.DataFrame], Dict[str, str], str, Dic
             # Ensure unique column names
             if pd.Index(df.columns).has_duplicates:
                 df.columns = make_unique_columns(list(df.columns))
+            
+            # Stocker dans session state pour les autres onglets
+            st.session_state['df'] = df
+            st.session_state['filtered_df'] = df.copy()
         except Exception as e:
             st.sidebar.error(f"Erreur de lecture du fichier: {e}")
+    else:
+        # Récupérer les données du session state si disponible
+        if 'df' in st.session_state:
+            df = st.session_state['df']
 
     logical_types: Dict[str, str] = {}
     coercions: Dict[str, str] = {}
@@ -306,31 +399,22 @@ def sidebar_controls() -> Tuple[Optional[pd.DataFrame], Dict[str, str], str, Dic
         unique_keys = st.sidebar.multiselect(
             "Champs d'unicité (sélection multiple)", options=list(df.columns), default=suggested, help="Sélectionnez les champs qui identifient de façon unique une personne."
         )
+        
+        # Stocker les types et clés dans session state
+        st.session_state['logical_types'] = logical_types
+        st.session_state['unique_keys'] = unique_keys
+        st.session_state['filtered_df'] = df.copy()
 
     return df, logical_types, theme_mode, coercions, unique_keys
 
 
 # -----------------------------
-# Main App
+# Page: Tableau de bord
 # -----------------------------
-def main():
-    inject_base_css()
-
-    # Header
-    col_logo, col_title, col_right = st.columns([1, 3, 1])
-    with col_logo:
-        logo_path = os.path.join("assets", "logo.png")
-        if os.path.exists(logo_path):
-            st.image(logo_path, width=72)
-    with col_title:
-        st.markdown("<h1 style='text-align:center; margin-top: 0;'>Tableau de bord des inscriptions</h1>", unsafe_allow_html=True)
-    with col_right:
-        st.write("")
-
-    df, type_map, theme_mode, _, unique_keys = sidebar_controls()
-    plotly_template = get_plotly_template(theme_mode)
-
-    if df is None or df.empty:
+def page_tableau_de_bord():
+    st.markdown("<h2>📊 Tableau de bord</h2>", unsafe_allow_html=True)
+    
+    if 'df' not in st.session_state or st.session_state['df'] is None:
         st.markdown(
             """
             <div class="card">
@@ -346,14 +430,18 @@ def main():
         )
         return
 
+    df = st.session_state['df']
+    type_map = st.session_state.get('logical_types', {})
+    unique_keys = st.session_state.get('unique_keys', [])
+    theme_mode = "dark" if st.session_state.get('theme_mode') == "dark" else "light"
+    plotly_template = get_plotly_template(theme_mode)
+    
     # Filters (dynamic for all columns)
     st.sidebar.markdown("---")
     filtered_df = dynamic_filters(df, type_map)
 
     # Optional unique-person filtering using selected keys
     st.sidebar.markdown("### 👤 Filtrer par personne unique")
-    if 'unique_keys' not in locals():
-        unique_keys = []
     if unique_keys:
         person_filter = st.sidebar.checkbox("Activer le filtre d'unicité (drop_duplicates)", value=False, key="unique_filter_toggle")
         keep_strategy = st.sidebar.selectbox("Conserver", options=["first", "last"], index=0, key="unique_filter_keep")
@@ -363,6 +451,9 @@ def main():
             except Exception:
                 st.sidebar.warning("Impossible d'appliquer le filtre d'unicité. Vérifiez les champs choisis.")
 
+    # Mettre à jour le dataframe filtré dans session state
+    st.session_state['filtered_df'] = filtered_df
+
     # KPIs
     total_count = len(filtered_df)
     total_columns = filtered_df.shape[1]
@@ -441,7 +532,7 @@ def main():
             chart_card("Répartition (dimension 2)", fig_country)
     st.markdown("</div>", unsafe_allow_html=True)
 
-    # Charts row 2: Status distribution, Time series
+    # Charts row 2: Status distribution
     charts_row_2 = st.columns(2)
     if cat_cols_all and not filtered_df.empty:
         dim3 = st.selectbox("Dimension 3", options=cat_cols_all, key="rep_dim3")
@@ -459,15 +550,50 @@ def main():
         with charts_row_2[0]:
             chart_card("Répartition (dimension 3)", fig_status)
 
-    # date_cols = [c for c in filtered_df.columns if type_map.get(c) == "date"]
-    
+    # Affichage des données
+    search_query = st.text_input("Recherche globale", key="search_dashboard")
+    df_searched = apply_search(filtered_df, search_query)
+    st.dataframe(df_searched, use_container_width=True, hide_index=True)
 
-    # Charts row 3: Numeric histogram (user-selectable)
-    # numeric_cols = [c for c in filtered_df.columns if pd.api.types.is_numeric_dtype(filtered_df[c])]
-    
+    # Downloads
+    csv_bytes = df_searched.to_csv(index=False).encode("utf-8-sig")
+    xlsx_bytes = to_excel_bytes(df_searched)
+    dc1, dc2 = st.columns(2)
+    with dc1:
+        st.download_button(
+            "Télécharger CSV",
+            data=csv_bytes,
+            file_name="inscriptions_filtrees.csv",
+            mime="text/csv",
+            use_container_width=True,
+        )
+    with dc2:
+        st.download_button(
+            "Télécharger Excel",
+            data=xlsx_bytes,
+            file_name="inscriptions_filtrees.xlsx",
+            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            use_container_width=True,
+        )
 
+
+# -----------------------------
+# Page: Zone d'analyse
+# -----------------------------
+def page_analyses():
+    st.markdown("<h2>📋 Analyses avancées</h2>", unsafe_allow_html=True)
+    
+    if 'filtered_df' not in st.session_state or st.session_state['filtered_df'] is None:
+        st.warning("Veuillez d'abord importer et configurer des données dans l'onglet Tableau de bord.")
+        return
+        
+    filtered_df = st.session_state['filtered_df']
+    type_map = st.session_state.get('logical_types', {})
+    theme_mode = "dark" if st.session_state.get('theme_mode') == "dark" else "light"
+    plotly_template = get_plotly_template(theme_mode)
+    
     # Ad-hoc analysis builder
-    st.markdown("<div class=\"card\"><div class=\"card-title\">Zone d’analyse</div>", unsafe_allow_html=True)
+    st.markdown("<div class=\"card\"><div class=\"card-title\">Zone d'analyse</div>", unsafe_allow_html=True)
     cat_cols = [c for c in filtered_df.columns if type_map.get(c) in ("categorical", "text")]
     if cat_cols:
         ac1, ac2, ac3 = st.columns([2,1,1])
@@ -486,45 +612,112 @@ def main():
         st.plotly_chart(fig, use_container_width=True, theme=None)
     st.markdown("</div>", unsafe_allow_html=True)
 
-
     # Drilldown option (simple): filtrer sur une dimension/valeur
+    st.markdown("<div class=\"card\"><div class=\"card-title\">Drilldown</div>", unsafe_allow_html=True)
     dd_cols = cat_cols
     dd1, dd2 = st.columns([1,2])
     with dd1:
         dd_dim = st.selectbox("Drilldown - dimension", options=[None] + dd_cols)
+    
+    drill_df = filtered_df.copy()
     if dd_dim:
         values = [x for x in filtered_df[dd_dim].dropna().astype(str).unique()]
         with dd2:
             dd_val = st.selectbox("Valeur", options=[None] + values)
         if dd_val:
-            filtered_df = filtered_df[filtered_df[dd_dim].astype(str) == dd_val]
-
-    search_query = st.text_input("Recherche globale")
-    df_searched = apply_search(filtered_df, search_query)
+            drill_df = filtered_df[filtered_df[dd_dim].astype(str) == dd_val]
+            
+    search_query = st.text_input("Recherche globale", key="search_analysis")
+    df_searched = apply_search(drill_df, search_query)
     st.dataframe(df_searched, use_container_width=True, hide_index=True)
+    st.markdown("</div>", unsafe_allow_html=True)
 
-    # Downloads
-    csv_bytes = df_searched.to_csv(index=False).encode("utf-8-sig")
-    xlsx_bytes = to_excel_bytes(df_searched)
-    dc1, dc2 = st.columns(2)
-    with dc1:
-        st.download_button(
-            "Télécharger CSV",
-            data=csv_bytes,
-            file_name="inscriptions_filtrees.csv",
-            mime="text/csv",
-            use_container_width=True,
-        )
-    with dc2:
-        st.download_button(
-            "Télécharger Excel",
-            data=xlsx_bytes,
-            file_name="inscriptions_filtrees.xlsx",
-            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-            use_container_width=True,
-        )
+    # Decision Maker View (field-aware, optional)
+    st.markdown("<div class=\"card\"><div class=\"card-title\">Vue Décideur (si champs disponibles)</div>", unsafe_allow_html=True)
+    # Candidate fields based on provided list
+    col_email = find_column(filtered_df, ["Email"]) or find_column(filtered_df, ["E-mail"])
+    col_gender = find_column(filtered_df, ["Genre", "Autre genre (Veuillez préciser) : "])
+    col_nat = find_column(filtered_df, ["Nationalité"])
+    col_country = find_column(filtered_df, ["Pays de résidence"]) or find_column(filtered_df, ["D'où préférez-vous participer à l'événement ?"])
+    col_role = find_column(filtered_df, ["Votre profession / statut", "Autre profession (veuillez préciser)"])
+    col_aff = find_column(filtered_df, ["Affiliation", "Autre affiliation (Veuillez préciser) : "])
+    col_particip = find_column(filtered_df, ["Avez-vous déjà participé à un événement Indaba X Togo ?"])
+    col_mode_formation = find_column(filtered_df, ["Comment voulez-vous participer aux formations ?"])
+    col_what_do = find_column(filtered_df, ["Que voulez-vous faire ?"])
+    col_skills = {
+        "Python": find_column(filtered_df, ["Quel est votre niveau en  [Python]", "Quel est votre niveau en [Python]"]),
+        "Numpy": find_column(filtered_df, ["Quel est votre niveau en  [Numpy]", "Quel est votre niveau en [Numpy]"]),
+        "Pandas": find_column(filtered_df, ["Quel est votre niveau en  [Pandas]", "Quel est votre niveau en [Pandas]"]),
+        "Scikit Learn": find_column(filtered_df, ["Quel est votre niveau en  [Scikit Learn]", "Quel est votre niveau en [Scikit Learn]"]),
+        "Pytorch": find_column(filtered_df, ["Quel est votre niveau en  [Pytorch]", "Quel est votre niveau en [Pytorch]"]),
+        "Deep Learning": find_column(filtered_df, ["Quel est votre niveau en  [Deep Learning]", "Quel est votre niveau en [Deep Learning]"]),
+    }
+
+    # KPIs for decision maker
+    kcols = st.columns(4)
+    with kcols[0]:
+        kpi_card("Inscriptions", f"{len(filtered_df):,}")
+    with kcols[1]:
+        if col_email:
+            uniq_people = filtered_df[col_email].astype(str).str.strip().str.lower().dropna().nunique()
+            kpi_card("Personnes uniques (email)", f"{uniq_people:,}")
+        else:
+            kpi_card("Personnes uniques", "-")
+    with kcols[2]:
+        if col_country and col_country in filtered_df.columns:
+            kpi_card("Pays (distincts)", f"{filtered_df[col_country].astype(str).nunique():,}")
+        else:
+            kpi_card("Pays (distincts)", "-")
+    with kcols[3]:
+        if col_role and col_role in filtered_df.columns:
+            kpi_card("Profils (distincts)", f"{filtered_df[col_role].astype(str).nunique():,}")
+        else:
+            kpi_card("Profils (distincts)", "-")
+
+    # Row 1 charts: Gender, Country
+    dm1 = st.columns(2)
+    if col_gender and col_gender in filtered_df.columns and not filtered_df.empty:
+        gcounts = filtered_df.groupby(col_gender).size().reset_index(name="count").sort_values("count", ascending=False)
+        fig_g = px.pie(gcounts, names=col_gender, values="count", template=get_plotly_template(theme_mode), hole=0.35)
+        with dm1[0]:
+            chart_card("Répartition par genre", fig_g)
+    if col_country and col_country in filtered_df.columns and not filtered_df.empty:
+        ccounts = filtered_df.groupby(col_country).size().reset_index(name="count").sort_values("count", ascending=False).head(15)
+        fig_c = px.bar(ccounts, x=col_country, y="count", template=get_plotly_template(theme_mode))
+        with dm1[1]:
+            chart_card("Top 15 pays de résidence", fig_c)
+
+    # Row 2: Participation history and roles
+    dm2 = st.columns(2)
+    if col_particip and col_particip in filtered_df.columns and not filtered_df.empty:
+        pcounts = filtered_df.groupby(col_particip).size().reset_index(name="count")
+        fig_p = px.bar(pcounts, x=col_particip, y="count", template=get_plotly_template(theme_mode))
+        with dm2[0]:
+            chart_card("A déjà participé ?", fig_p)
+    if col_role and col_role in filtered_df.columns and not filtered_df.empty:
+        rcounts = filtered_df.groupby(col_role).size().reset_index(name="count").sort_values("count", ascending=False).head(15)
+        fig_r = px.bar(rcounts, x=col_role, y="count", template=get_plotly_template(theme_mode))
+        with dm2[1]:
+            chart_card("Professions / Statuts (Top 15)", fig_r)
+    
     st.markdown("</div>", unsafe_allow_html=True)
 
+
+# -----------------------------
+# Page: Constructeur de graphiques
+# -----------------------------
+def page_constructeur_graphiques():
+    st.markdown("<h2>📈 Constructeur de graphiques</h2>", unsafe_allow_html=True)
+    
+    if 'filtered_df' not in st.session_state or st.session_state['filtered_df'] is None:
+        st.warning("Veuillez d'abord importer et configurer des données dans l'onglet Tableau de bord.")
+        return
+    
+    filtered_df = st.session_state['filtered_df']
+    type_map = st.session_state.get('logical_types', {})
+    theme_mode = "dark" if st.session_state.get('theme_mode') == "dark" else "light"
+    plotly_template = get_plotly_template(theme_mode)
+    
     # Universal Chart Builder
     st.markdown("<div class=\"card\"><div class=\"card-title\">Constructeur de graphiques</div>", unsafe_allow_html=True)
     chart_types = [
@@ -624,112 +817,210 @@ def main():
         st.plotly_chart(fig, use_container_width=True, theme=None)
     st.markdown("</div>", unsafe_allow_html=True)
 
-    # Decision Maker View (field-aware, optional)
-    st.markdown("<div class=\"card\"><div class=\"card-title\">Vue Décideur (si champs disponibles)</div>", unsafe_allow_html=True)
-    # Candidate fields based on provided list
-    col_email = find_column(filtered_df, ["Email"]) or find_column(filtered_df, ["E-mail"])
-    col_gender = find_column(filtered_df, ["Genre", "Autre genre (Veuillez préciser) : "])
-    col_nat = find_column(filtered_df, ["Nationalité"])
-    col_country = find_column(filtered_df, ["Pays de résidence"]) or find_column(filtered_df, ["D’où préférez-vous participer à l'événement ?"])
-    col_role = find_column(filtered_df, ["Votre profession / statut", "Autre profession (veuillez préciser)"])
-    col_aff = find_column(filtered_df, ["Affiliation", "Autre affiliation (Veuillez préciser) : "])
-    col_particip = find_column(filtered_df, ["Avez-vous déjà participé à un événement Indaba X Togo ?"])
-    col_mode_formation = find_column(filtered_df, ["Comment voulez-vous participer aux formations ?"])
-    col_what_do = find_column(filtered_df, ["Que voulez-vous faire ?"])
-    col_skills = {
-        "Python": find_column(filtered_df, ["Quel est votre niveau en  [Python]", "Quel est votre niveau en [Python]"]),
-        "Numpy": find_column(filtered_df, ["Quel est votre niveau en  [Numpy]", "Quel est votre niveau en [Numpy]"]),
-        "Pandas": find_column(filtered_df, ["Quel est votre niveau en  [Pandas]", "Quel est votre niveau en [Pandas]"]),
-        "Scikit Learn": find_column(filtered_df, ["Quel est votre niveau en  [Scikit Learn]", "Quel est votre niveau en [Scikit Learn]"]),
-        "Pytorch": find_column(filtered_df, ["Quel est votre niveau en  [Pytorch]", "Quel est votre niveau en [Pytorch]"]),
-        "Deep Learning": find_column(filtered_df, ["Quel est votre niveau en  [Deep Learning]", "Quel est votre niveau en [Deep Learning]"]),
-    }
 
-    # KPIs for decision maker
-    kcols = st.columns(4)
-    with kcols[0]:
-        kpi_card("Inscriptions", f"{len(filtered_df):,}")
-    with kcols[1]:
-        if col_email:
-            uniq_people = filtered_df[col_email].astype(str).str.strip().str.lower().dropna().nunique()
-            kpi_card("Personnes uniques (email)", f"{uniq_people:,}")
-        else:
-            kpi_card("Personnes uniques", "-")
-    with kcols[2]:
-        if col_country and col_country in filtered_df.columns:
-            kpi_card("Pays (distincts)", f"{filtered_df[col_country].astype(str).nunique():,}")
-        else:
-            kpi_card("Pays (distincts)", "-")
-    with kcols[3]:
-        if col_role and col_role in filtered_df.columns:
-            kpi_card("Profils (distincts)", f"{filtered_df[col_role].astype(str).nunique():,}")
-        else:
-            kpi_card("Profils (distincts)", "-")
+# -----------------------------
+# Page: Envoi d'emails
+# -----------------------------
+def page_emails():
+    st.markdown("<h2>✉️ Envoi d'emails</h2>", unsafe_allow_html=True)
+    
+    if 'filtered_df' not in st.session_state or st.session_state['filtered_df'] is None:
+        st.warning("Veuillez d'abord importer et configurer des données dans l'onglet Tableau de bord.")
+        return
+    
+    filtered_df = st.session_state['filtered_df']
+    
+    # Email Sender Section
+    st.markdown("<div class=\"card\"><div class=\"card-title\">✉️ Envoi d'emails (CSV ou données filtrées)</div>", unsafe_allow_html=True)
+    ecols1 = st.columns([1, 1])
+    with ecols1[0]:
+        st.caption("Source des destinataires")
+        use_current = st.radio(
+            "Choisir la source",
+            options=["Données filtrées actuelles", "Importer un CSV/XLSX"],
+            horizontal=False,
+            index=0,
+            key="email_source_choice",
+        )
+    with ecols1[1]:
+        st.caption("Fichier (si import)")
+        upload_mail = st.file_uploader("Importer un fichier", type=["csv", "xlsx"], key="email_upload_file")
+
+    recipients_df: Optional[pd.DataFrame] = None
+    if use_current == "Données filtrées actuelles":
+        recipients_df = filtered_df.copy()
+    else:
+        if upload_mail is not None:
+            try:
+                if upload_mail.name.lower().endswith(".csv"):
+                    recipients_df = pd.read_csv(upload_mail)
+                else:
+                    recipients_df = pd.read_excel(upload_mail)
+                recipients_df.columns = [str(c).strip() for c in recipients_df.columns]
+            except Exception as e:
+                st.error(f"Erreur de lecture du fichier: {e}")
+
+    if recipients_df is None or recipients_df.empty:
+        st.info("Importez un fichier ou utilisez les données filtrées pour continuer.")
+        st.markdown("</div>", unsafe_allow_html=True)
+        return
 
-    # Row 1 charts: Gender, Country
-    dm1 = st.columns(2)
-    if col_gender and col_gender in filtered_df.columns and not filtered_df.empty:
-        gcounts = filtered_df.groupby(col_gender).size().reset_index(name="count").sort_values("count", ascending=False)
-        fig_g = px.pie(gcounts, names=col_gender, values="count", template=get_plotly_template(theme_mode), hole=0.35)
-        with dm1[0]:
-            chart_card("Répartition par genre", fig_g)
-    if col_country and col_country in filtered_df.columns and not filtered_df.empty:
-        ccounts = filtered_df.groupby(col_country).size().reset_index(name="count").sort_values("count", ascending=False).head(15)
-        fig_c = px.bar(ccounts, x=col_country, y="count", template=get_plotly_template(theme_mode))
-        with dm1[1]:
-            chart_card("Top 15 pays de résidence", fig_c)
+    # Mapping email column
+    email_col_guess = find_column(recipients_df, ["email", "e-mail", "mail"]) or ("Email" if "Email" in recipients_df.columns else None)
+    email_col = st.selectbox(
+        "Colonne email",
+        options=list(recipients_df.columns),
+        index=(list(recipients_df.columns).index(email_col_guess) if email_col_guess in recipients_df.columns else 0),
+        help="Sélectionnez la colonne contenant les adresses email",
+        key="email_col_select",
+    )
 
-    # Row 2: Participation history and roles
-    dm2 = st.columns(2)
-    if col_particip and col_particip in filtered_df.columns and not filtered_df.empty:
-        pcounts = filtered_df.groupby(col_particip).size().reset_index(name="count")
-        fig_p = px.bar(pcounts, x=col_particip, y="count", template=get_plotly_template(theme_mode))
-        with dm2[0]:
-            chart_card("A déjà participé ?", fig_p)
-    if col_role and col_role in filtered_df.columns and not filtered_df.empty:
-        rcounts = filtered_df.groupby(col_role).size().reset_index(name="count").sort_values("count", ascending=False).head(15)
-        fig_r = px.bar(rcounts, x=col_role, y="count", template=get_plotly_template(theme_mode))
-        with dm2[1]:
-            chart_card("Professions / Statuts (Top 15)", fig_r)
+    # SMTP settings
+    st.markdown("<div class=\"card\" style=\"margin-top: 0.75rem;\"><div class=\"card-title\">Paramètres SMTP</div>", unsafe_allow_html=True)
+    s1, s2, s3, s4 = st.columns([1.2, 0.8, 1, 1])
+    with s1:
+        smtp_host = st.text_input("Hôte SMTP", value=os.environ.get("SMTP_HOST", "smtp.gmail.com"))
+    with s2:
+        smtp_port = st.number_input("Port", min_value=1, max_value=65535, value=int(os.environ.get("SMTP_PORT", 587)))
+    with s3:
+        use_tls = st.selectbox("Sécurité", options=["STARTTLS", "SSL"], index=0) == "STARTTLS"
+    with s4:
+        reply_to = st.text_input("Reply-To (optionnel)", value=os.environ.get("SMTP_REPLY_TO", ""))
+    s5, s6 = st.columns([1, 1])
+    with s5:
+        sender_email = st.text_input("Adresse expéditrice", value=os.environ.get("SMTP_SENDER", ""))
+    with s6:
+        sender_password = st.text_input("Mot de passe/clé appli", type="password", value=os.environ.get("SMTP_PASSWORD", ""))
+    st.markdown("</div>", unsafe_allow_html=True)
 
-    # Row 2b: Formations participation mode and intentions
-    dm2b = st.columns(2)
-    if col_mode_formation and col_mode_formation in filtered_df.columns and not filtered_df.empty:
-        mcounts = (
-            filtered_df.groupby(col_mode_formation).size().reset_index(name="count").sort_values("count", ascending=False)
-        )
-        fig_m = px.bar(mcounts, x=col_mode_formation, y="count", template=get_plotly_template(theme_mode))
-        with dm2b[0]:
-            chart_card("Mode de participation aux formations", fig_m)
-    if col_what_do and col_what_do in filtered_df.columns and not filtered_df.empty:
-        wcounts = (
-            filtered_df.groupby(col_what_do).size().reset_index(name="count").sort_values("count", ascending=False).head(15)
-        )
-        fig_w = px.bar(wcounts, x=col_what_do, y="count", template=get_plotly_template(theme_mode))
-        with dm2b[1]:
-            chart_card("Intentions: Que voulez-vous faire ? (Top 15)", fig_w)
-
-    # Row 3: Skills radar-like bars
-    skill_pairs = [(name, col) for name, col in col_skills.items() if col]
-    if skill_pairs:
-        sm = []
-        for name, col in skill_pairs:
-            # Map text levels to ordered scale if needed
-            s = filtered_df[col].astype(str).str.strip().str.lower()
-            order = ["débutant", "intermédiaire", "avancé", "expert"]
-            s = s.where(s.isin(order), s)
-            d = s.value_counts().reindex(order).fillna(0).rename_axis("niveau").reset_index(name="count")
-            d["skill"] = name
-            sm.append(d)
-        if sm:
-            skill_df = pd.concat(sm, ignore_index=True)
-            fig_skill = px.bar(skill_df, x="skill", y="count", color="niveau", barmode="group", template=get_plotly_template(theme_mode))
-            chart_card("Niveaux par compétence", fig_skill)
+    # Composition
+    st.markdown("<div class=\"card\" style=\"margin-top: 0.75rem;\"><div class=\"card-title\">Composer le message</div>", unsafe_allow_html=True)
+    placeholders = ", ".join([f"{{{c}}}" for c in recipients_df.columns])
+    subj = st.text_input("Objet", placeholder="Objet de l'email. Vous pouvez utiliser des variables comme {Nom}")
+    body = st.text_area(
+        "Corps (texte)",
+        height=180,
+        placeholder="Bonjour {Prenom} {Nom},\n\nVotre statut: {Statut}\n...",
+        help=f"Variables disponibles: {placeholders}",
+    )
+    st.caption("Astuce: utilisez {NomColonne} pour insérer des champs du CSV.")
+
+    # Preview first recipient
+    pv1, pv2 = st.columns([1, 1])
+    with pv1:
+        st.subheader("Aperçu des données (5)")
+        st.dataframe(recipients_df.head(5), use_container_width=True, hide_index=True)
+    with pv2:
+        st.subheader("Aperçu email (1er destinataire)")
+        try:
+            if not recipients_df.empty:
+                row0 = recipients_df.iloc[0].to_dict()
+                st.write("À:", recipients_df[email_col].iloc[0])
+                st.write("Objet:", safe_format_template(subj, row0))
+                st.code(safe_format_template(body, row0))
+        except Exception:
+            st.caption("Impossible de générer l'aperçu.")
+    st.markdown("</div>", unsafe_allow_html=True)
 
+    # Sending controls
+    st.markdown("<div class=\"card\" style=\"margin-top: 0.75rem;\"><div class=\"card-title\">Envoi</div>", unsafe_allow_html=True)
+    c_left, c_mid, c_right = st.columns([1, 1, 1])
+    with c_left:
+        limit_send = st.number_input("Limiter (0 = tout)", min_value=0, value=0, help="Pour tester, limiter le nombre d'emails envoyés")
+    with c_mid:
+        start_at = st.number_input("Début à l'index", min_value=0, value=0)
+    with c_right:
+        confirm = st.checkbox("Je confirme vouloir envoyer ces emails", value=False)
+
+    do_send = st.button("Envoyer", type="primary", use_container_width=True, disabled=not confirm)
+
+    if do_send:
+        if not sender_email or not smtp_host or not subj or not body:
+            st.error("Veuillez remplir l'hôte SMTP, l'adresse expéditrice, l'objet et le corps.")
+        else:
+            total = len(recipients_df)
+            indices = list(range(start_at, total))
+            if limit_send and limit_send > 0:
+                indices = indices[: int(limit_send)]
+            progress = st.progress(0)
+            sent_ok = 0
+            log_container = st.container()
+            for idx_i, i in enumerate(indices, start=1):
+                try:
+                    row = recipients_df.iloc[i]
+                    to_addr = str(row[email_col]).strip()
+                    if not to_addr or "@" not in to_addr:
+                        raise ValueError("Adresse email invalide")
+                    row_dict = row.to_dict()
+                    subject_i = safe_format_template(subj, row_dict)
+                    body_i = safe_format_template(body, row_dict)
+                    send_email_smtp(
+                        smtp_host=smtp_host,
+                        smtp_port=int(smtp_port),
+                        sender_email=sender_email,
+                        sender_password=sender_password,
+                        use_tls=use_tls,
+                        to_email=to_addr,
+                        subject=subject_i,
+                        body_text=body_i,
+                        reply_to=(reply_to or None),
+                    )
+                    sent_ok += 1
+                    log_container.success(f"Envoyé à {to_addr}")
+                except Exception as e:
+                    log_container.error(f"Échec pour index {i}: {e}")
+                progress.progress(int(idx_i * 100 / max(1, len(indices))))
+            st.info(f"Terminé. Succès: {sent_ok}/{len(indices)}")
     st.markdown("</div>", unsafe_allow_html=True)
 
 
-if __name__ == "__main__":
-    main()
+# -----------------------------
+# Main App
+# -----------------------------
+def main():
+    inject_base_css()
 
+    # Header
+    col_logo, col_title, col_right = st.columns([1, 3, 1])
+    with col_logo:
+        logo_path = os.path.join("assets", "logo.png")
+        if os.path.exists(logo_path):
+            st.image(logo_path, width=72)
+    with col_title:
+        st.markdown("<h1 style='text-align:center; margin-top: 0;'>Tableau de bord des inscriptions</h1>", unsafe_allow_html=True)
+    with col_right:
+        st.write("")
+
+    # Charger les contrôles de la barre latérale
+    # (ces contrôles sont partagés entre tous les onglets)
+    df, type_map, theme_mode, _, unique_keys = sidebar_controls()
+    
+    # Stocker les types dans session_state pour les autres onglets
+    if df is not None:
+        st.session_state['logical_types'] = type_map
+        st.session_state['unique_keys'] = unique_keys
+        st.session_state['theme_mode'] = theme_mode
+    
+    # Onglets de l'application
+    tab1, tab2, tab3, tab4 = st.tabs([
+        "📊 Tableau de bord", 
+        "📋 Analyses avancées", 
+        "📈 Constructeur graphiques", 
+        "✉️ Envoi emails"
+    ])
+    
+    with tab1:
+        page_tableau_de_bord()
+    
+    with tab2:
+        page_analyses()
+    
+    with tab3:
+        page_constructeur_graphiques()
+        
+    with tab4:
+        page_emails()
 
+
+if __name__ == "__main__":
+    main()