diff --git a/app/app.py b/app/app.py
index ea8a252..9b4048f 100644
--- a/app/app.py
+++ b/app/app.py
@@ -3,6 +3,13 @@ import streamlit as st
 from views.label_views import video_filter_sidebar, video_list_view
 from playlists import playlist_page
 
+import argparse
+
+# --- Parse arguments (avant tout Streamlit UI) ---
+parser = argparse.ArgumentParser(add_help=False)
+parser.add_argument("--unlabeled", action="store_true", help="Afficher uniquement les vidéos sans labels")
+args, _ = parser.parse_known_args()
+
 # ==========================
 # 🧭 Configuration
 # ==========================
@@ -20,7 +27,7 @@ page = st.sidebar.radio(
 # ==========================
 if page == "Vidéos":
     st.title("🎬 Gestion et annotation des vidéos")
-    filters = video_filter_sidebar()
+    filters = video_filter_sidebar(unlabeled=args.unlabeled)
     video_list_view(filters)
 
 # ==========================
diff --git a/app/cache/video_summary.py b/app/cache/video_summary.py
index 28ce6d8..9357ac0 100644
--- a/app/cache/video_summary.py
+++ b/app/cache/video_summary.py
@@ -1,26 +1,9 @@
 # cache/video_summary.py
 import db
+from playlists import playlist_db
 
 def rebuild_video_summary():
     with db.get_conn() as conn:
-        conn.execute("DROP TABLE IF EXISTS video_summary")
-        conn.execute("""
-            CREATE TABLE video_summary AS
-            SELECT
-                v.file_name,
-                v.raw_file,
-                v.mp4_file,
-                v.record_datetime,
-                v.day_of_week,
-                v.difficulty_level,
-                v.address,
-                GROUP_CONCAT(DISTINCT l.name) AS labels,
-                GROUP_CONCAT(DISTINCT p.name) AS playlists
-            FROM videos v
-            LEFT JOIN video_labels vl ON vl.video_file_name = v.file_name
-            LEFT JOIN labels l ON l.id = vl.label_id
-            LEFT JOIN video_playlists vp ON vp.video_file_name = v.file_name
-            LEFT JOIN playlists p ON p.id = vp.playlist_id
-            GROUP BY v.file_name
-        """)
+        conn.execute("DELETE FROM video_summary_materialized;")
+        conn.execute("CREATE TABLE IF NOT EXISTS video_summary_materialized AS SELECT * FROM video_summary;")
         conn.commit()
diff --git a/app/db.py b/app/db.py
index b8b975d..57b5af5 100644
--- a/app/db.py
+++ b/app/db.py
@@ -104,12 +104,19 @@ def search_videos(
     end_date=None,
     difficulty=None,
     label_logic="OR",
+    include_playlists=None,
+    exclude_playlists=None,
+    logic="OR",  # logique entre playlists incluses
+    **kwargs,
 ):
     """
     Retourne une DataFrame filtrée selon les critères fournis.
-    label_logic: "OR" (au moins un label) ou "AND" (tous les labels).
+    label_logic: "OR" (au moins un label) ou "AND" (tous les labels)
+    logic: "OR" ou "AND" pour la combinaison de playlists incluses
     """
     label_names = label_names or []
+    include_playlists = include_playlists or []
+    exclude_playlists = exclude_playlists or []
     params = []
 
     base_query = """
@@ -121,7 +128,6 @@ def search_videos(
     # 🔖 Filtres par label
     if label_names:
         if label_logic == "AND":
-            # Toutes les étiquettes doivent être présentes
             placeholders = ",".join("?" * len(label_names))
             base_query += f"""
                 AND v.file_name IN (
@@ -135,7 +141,6 @@ def search_videos(
             """
             params.extend(label_names)
         else:
-            # OR : au moins une étiquette correspond
             placeholders = ",".join("?" * len(label_names))
             base_query += f"""
                 AND v.file_name IN (
@@ -147,6 +152,47 @@ def search_videos(
             """
             params.extend(label_names)
 
+    # 🎵 Filtres par playlists incluses
+    if include_playlists:
+        placeholders = ",".join("?" * len(include_playlists))
+        if logic == "AND":
+            # Vidéos présentes dans TOUTES les playlists
+            base_query += f"""
+                AND v.file_name IN (
+                    SELECT vp.video_file_name
+                    FROM video_playlists vp
+                    JOIN playlists p ON p.id = vp.playlist_id
+                    WHERE p.id IN ({placeholders})
+                    GROUP BY vp.video_file_name
+                    HAVING COUNT(DISTINCT p.id) = {len(include_playlists)}
+                )
+            """
+            params.extend(include_playlists)
+        else:
+            # Vidéos présentes dans AU MOINS une playlist
+            base_query += f"""
+                AND v.file_name IN (
+                    SELECT vp.video_file_name
+                    FROM video_playlists vp
+                    JOIN playlists p ON p.id = vp.playlist_id
+                    WHERE p.id IN ({placeholders})
+                )
+            """
+            params.extend(include_playlists)
+
+    # ❌ Filtres par playlists exclues
+    if exclude_playlists:
+        placeholders = ",".join("?" * len(exclude_playlists))
+        base_query += f"""
+            AND v.file_name NOT IN (
+                SELECT vp.video_file_name
+                FROM video_playlists vp
+                JOIN playlists p ON p.id = vp.playlist_id
+                WHERE p.id IN ({placeholders})
+            )
+        """
+        params.extend(exclude_playlists)
+
     # 📆 Jour de la semaine
     if day_of_week:
         base_query += " AND v.day_of_week = ?"
@@ -177,6 +223,7 @@ def search_videos(
         return pd.read_sql_query(base_query, conn, params=params)
 
 
+
 def get_video_playlists(file_name):
     with get_conn() as conn:
         query = """
@@ -187,18 +234,41 @@ def get_video_playlists(file_name):
         """
         return [row[0] for row in conn.execute(query, (file_name,))]
 
-def get_videos_in_playlist(playlist_id):
+def get_video_file_names_in_playlist(playlist_id):
+    """Retourne un set de file_name pour une playlist donnée."""
     with get_conn() as conn:
-        query = """
+        rows = conn.execute(
+            # "SELECT video_file_name FROM video_playlists WHERE playlist_id = ?",
+            "SELECT video_file_name FROM playlist_videos WHERE playlist_id = ?",
+            (playlist_id,)
+        ).fetchall()
+        names = []
+        for r in rows:
+            if hasattr(r, "keys"):
+                names.append(r["video_file_name"])
+            else:
+                names.append(r[0])
+        return set(names)
+
+
+def get_videos_in_playlist(playlist_id):
+    """Retourne une liste d'objets Video complets pour une playlist donnée."""
+    import pandas as pd
+    from models import Video
+
+    with get_conn() as conn:
+        df = pd.read_sql_query("""
             SELECT v.*
             FROM videos v
             JOIN video_playlists vp ON vp.video_file_name = v.file_name
             WHERE vp.playlist_id = ?
-            ORDER BY vp.position
-        """
-        return conn.execute(query, (playlist_id,)).fetchall()
+            ORDER BY vp.position ASC
+        """, conn, params=(playlist_id,))
+    return [Video(**row) for _, row in df.iterrows()]
+
 
 def add_video_to_playlist(playlist_id, file_name):
+    print(dict(playlist_id=playlist_id, video_file_name=file_name),flush=True,)
     with get_conn() as conn:
         conn.execute("""
             INSERT OR IGNORE INTO video_playlists (video_file_name, playlist_id, position)
@@ -209,4 +279,4 @@ def add_video_to_playlist(playlist_id, file_name):
 def remove_video_from_playlist(playlist_id, file_name):
     with get_conn() as conn:
         conn.execute("DELETE FROM video_playlists WHERE playlist_id=? AND video_file_name=?", (playlist_id, file_name))
-        conn.commit()
+        conn.commit()
\ No newline at end of file
diff --git a/app/playlists/playlist_controller.py b/app/playlists/playlist_controller.py
index 382bb94..e33b575 100644
--- a/app/playlists/playlist_controller.py
+++ b/app/playlists/playlist_controller.py
@@ -4,28 +4,57 @@ import db
 from playlists.playlist_model import Playlist, RuleSet
 from playlists import playlist_db
 from views.label_views import video_filter_sidebar, video_list_view
+from views.video_views import show_video_row
 from models import Video
 
+
 def playlist_manual_editor(playlist: Playlist):
     """Permet de gérer les vidéos d'une playlist manuelle."""
     st.subheader(f"🎞️ Édition manuelle : {playlist.name}")
+
+    # Filtres standard pour explorer les vidéos
     filters = video_filter_sidebar()
-    videos = video_list_view(filters, editable_labels=False, editable_difficulty=False)
 
-    existing_videos = db.get_videos_in_playlist(playlist.id)
-    existing_names = [v["file_name"] for v in existing_videos]
+    # Précharge les vidéos déjà incluses dans la playlist
+    playlist_video_ids = db.get_video_file_names_in_playlist(playlist.id)
 
-    for video in videos:
-        in_playlist = video.file_name in existing_names
-        button_label = "➕ Ajouter" if not in_playlist else "❌ Retirer"
-        if st.button(button_label, key=f"toggle_{playlist.id}_{video.file_name}"):
-            if in_playlist:
-                db.remove_video_from_playlist(playlist.id, video.file_name)
-                st.success(f"Supprimée de {playlist.name}")
-            else:
-                db.add_video_to_playlist(playlist.id, video.file_name)
-                st.success(f"Ajoutée à {playlist.name}")
-            st.rerun()
+    # Récupère les vidéos filtrées
+    df_videos = db.search_videos(
+        label_names=filters["selected_labels"],
+        day_of_week=filters["day_filter"],
+        difficulty=filters["difficulty_filter"],
+        **filters
+    )
+    if df_videos.empty:
+        st.info("Aucune vidéo trouvée avec ces filtres.")
+        return
+
+    videos = [Video(**row) for _, row in df_videos.iterrows()]
+
+    st.write(f"🎬 {len(videos)} vidéo(s) disponibles.")
+
+    # Affiche les vidéos avec boutons d’ajout/retrait à droite
+    summary_map = summary_map = get_video_summary_cached()
+    for video in videos[:50]:  # limite de sécurité
+        summary = summary_map.get(video.file_name, {"labels": [], "playlists": []})
+        preselected = summary["labels"]
+        playlists = summary["playlists"]
+        show_video_row(
+            video,
+            preselected_labels=preselected,
+            editable_labels=False,
+            editable_difficulty=False,
+            playlist=playlist,
+            playlist_video_ids=playlist_video_ids,
+            video_playlists=playlists
+        )
+    if st.button("📦 Charger plus"):
+        st.session_state.video_page += 1
+        st.rerun()
+
+@st.cache_data(ttl=30)
+def get_video_summary_cached():
+    return playlist_db.load_video_summary_map()
 
 def playlist_dynamic_editor(playlist: Playlist):
     """Édite les règles d'une playlist dynamique et affiche le rendu en temps réel."""
@@ -33,36 +62,77 @@ def playlist_dynamic_editor(playlist: Playlist):
 
     rules = playlist.rules or RuleSet()
     labels = db.load_labels()
-    playlists = [p.name for p in playlist_db.load_all_playlists()]
 
     rules.include_labels = st.multiselect("Inclure labels", labels, default=rules.include_labels)
     rules.exclude_labels = st.multiselect("Exclure labels", labels, default=rules.exclude_labels)
-    rules.include_playlists = st.multiselect("Inclure playlists", playlists, default=rules.include_playlists)
-    rules.exclude_playlists = st.multiselect("Exclure playlists", playlists, default=rules.exclude_playlists)
+
+    all_playlists = playlist_db.load_all_playlists()
+    name_to_id = {p.name: p.id for p in all_playlists}
+    id_to_name = {p.id: p.name for p in all_playlists}
+
+    default_include = [id_to_name.get(pid) for pid in rules.include_playlists if pid in id_to_name]
+    default_exclude = [id_to_name.get(pid) for pid in rules.exclude_playlists if pid in id_to_name]
+
+    selected_includes = st.multiselect("Inclure playlists", id_to_name.values(), default=default_include)
+    selected_excludes = st.multiselect("Exclure playlists", id_to_name.values(), default=default_exclude)
+
+    rules.include_playlists = [name_to_id[name] for name in selected_includes]
+    rules.exclude_playlists = [name_to_id[name] for name in selected_excludes]
+
 
     col1, col2 = st.columns(2)
     with col1:
-        rules.date_after = st.date_input("📅 Après le", value=rules.date_after or None)
+        use_delta = st.checkbox("⏱️ Utiliser un delta de jours", value=bool(rules.date_delta_days))
+        if use_delta:
+            rules.date_delta_days = st.number_input(
+                "Nombre de jours depuis aujourd’hui (négatif pour passé)",
+                value=rules.date_delta_days or -15
+            )
+            rules.date_after = None
+            rules.date_before = None
+        else:
+            rules.date_after = st.date_input("📅 Après le", value=rules.date_after or None)
+            rules.date_before = st.date_input("📅 Avant le", value=rules.date_before or None)
+            rules.date_delta_days = None
+
     with col2:
-        rules.date_before = st.date_input("📅 Avant le", value=rules.date_before or None)
-
-    rules.logic = st.radio("Logique de combinaison", ["AND", "OR"], index=0 if rules.logic == "AND" else 1)
+        rules.logic = st.radio("Logique de combinaison", ["AND", "OR"], index=0 if rules.logic == "AND" else 1)
+        rules.label_logic = st.radio("Logique de combinaison entre labels", ["AND", "OR"], index=0 if rules.label_logic == "AND" else 1)
 
+    # --- Enregistrement ---
     if st.button("💾 Enregistrer les règles"):
         playlist.rules = rules
         playlist.save()
         st.success("Règles mises à jour ✅")
-        st.rerun()
+        (st.rerun if hasattr(st, "rerun") else st.experimental_rerun)()
 
     st.markdown("---")
     st.subheader("🧩 Rendu de la playlist")
+
     rows = playlist_db.get_videos_for_playlist(playlist)
     if not rows:
         st.info("Aucune vidéo ne correspond aux règles actuelles.")
         return
 
     videos = [Video(**row) for row in rows]
-    st.write(f"{len(videos)} vidéo(s) trouvée(s).")
-    from views.video_views import show_video_row
-    for v in videos[:30]:
-        show_video_row(v, db.load_video_labels(v.file_name), editable_labels=False, editable_difficulty=False)
+    st.write(f"🎬 {len(videos)} vidéo(s) trouvée(s).")
+
+    playlist_video_ids = db.get_video_file_names_in_playlist(playlist.id)
+
+    summary_map = summary_map = get_video_summary_cached()
+    for v in videos[:50]:
+        summary = summary_map.get(v.file_name, {"labels": [], "playlists": []})
+        preselected = summary["labels"]
+        playlists = summary["playlists"]
+        show_video_row(
+            v,
+            preselected_labels=preselected,
+            editable_labels=False,
+            editable_difficulty=False,
+            playlist=playlist,
+            playlist_video_ids=playlist_video_ids,
+            video_playlists=playlists
+        )
+    if st.button("📦 Charger plus"):
+        st.session_state.video_page += 1
+        st.rerun()
diff --git a/app/playlists/playlist_db.py b/app/playlists/playlist_db.py
index 9f42425..2830c09 100644
--- a/app/playlists/playlist_db.py
+++ b/app/playlists/playlist_db.py
@@ -1,7 +1,9 @@
 # playlists/playlist_db.py
 import db
 import json
+import pandas as pd
 from playlists.playlist_model import Playlist, RuleSet
+from playlists.sql_builder import build_sql_from_rules
 
 def load_all_playlists():
     """Retourne une liste de Playlist (Pydantic) — tolérant aux rules_json nuls / vides."""
@@ -28,12 +30,16 @@ def load_all_playlists():
                 row_dict = dict(zip(cols, row))
 
             try:
+                created_at = str(row["created_at"]) if row["created_at"] is not None else None
+                updated_at = str(row["updated_at"]) if row["updated_at"] is not None else None
                 pl = Playlist(
-                    id=row_dict.get("id"),
-                    name=row_dict.get("name") or "",
-                    description=row_dict.get("description") or "",
-                    type=row_dict.get("type") or "manual",
-                    rules=row_dict.get("rules_json")
+                    id=row["id"],
+                    name=row["name"],
+                    description=row["description"],
+                    type=row["type"],
+                    rules=row["rules_json"],
+                    created_at=created_at,
+                    updated_at=updated_at
                 )
                 playlists.append(pl)
             except Exception as e:
@@ -47,50 +53,31 @@ def delete_playlist(playlist_id: int):
         conn.execute("DELETE FROM video_playlists WHERE playlist_id = ?", (playlist_id,))
         conn.commit()
 
-def get_videos_for_playlist(playlist: Playlist):
-    """Retourne les vidéos selon le type"""
-    with db.get_conn() as conn:
-        if playlist.type == "manual":
-            q = """
+def get_videos_for_playlist(playlist):
+    """Retourne les vidéos correspondant aux règles d'une playlist dynamique."""
+    if playlist.type == "manual":
+        with db.get_conn() as conn:
+            query = """
                 SELECT v.*
                 FROM videos v
                 JOIN video_playlists vp ON vp.video_file_name = v.file_name
                 WHERE vp.playlist_id = ?
                 ORDER BY vp.position
             """
-            return conn.execute(q, (playlist.id,)).fetchall()
-        else:
-            rules = playlist.rules
-            clauses = []
-            params = []
+            return conn.execute(query, (playlist.id,)).fetchall()
+    else:
+        sql, params = build_sql_from_rules(playlist.rules)
+        with db.get_conn() as conn:
+            return conn.execute(sql, params).fetchall()
 
-            if rules.include_labels:
-                placeholders = ",".join("?" * len(rules.include_labels))
-                clauses.append(f"v.file_name IN (SELECT vl.video_file_name FROM video_labels vl JOIN labels l ON l.id=vl.label_id WHERE l.name IN ({placeholders}))")
-                params += rules.include_labels
-
-            if rules.exclude_labels:
-                placeholders = ",".join("?" * len(rules.exclude_labels))
-                clauses.append(f"v.file_name NOT IN (SELECT vl.video_file_name FROM video_labels vl JOIN labels l ON l.id=vl.label_id WHERE l.name IN ({placeholders}))")
-                params += rules.exclude_labels
-
-            if rules.include_playlists:
-                placeholders = ",".join("?" * len(rules.include_playlists))
-                clauses.append(f"v.file_name IN (SELECT vp.video_file_name FROM video_playlists vp JOIN playlists p ON vp.playlist_id=p.id WHERE p.name IN ({placeholders}))")
-                params += rules.include_playlists
-
-            if rules.exclude_playlists:
-                placeholders = ",".join("?" * len(rules.exclude_playlists))
-                clauses.append(f"v.file_name NOT IN (SELECT vp.video_file_name FROM video_playlists vp JOIN playlists p ON vp.playlist_id=p.id WHERE p.name IN ({placeholders}))")
-                params += rules.exclude_playlists
-
-            if rules.date_after:
-                clauses.append("v.record_datetime >= ?")
-                params.append(rules.date_after)
-            if rules.date_before:
-                clauses.append("v.record_datetime <= ?")
-                params.append(rules.date_before)
-
-            where_clause = f" {' AND ' if rules.logic == 'AND' else ' OR '} ".join(clauses) if clauses else "1=1"
-            q = f"SELECT v.* FROM videos v WHERE {where_clause} ORDER BY v.record_datetime DESC"
-            return conn.execute(q, params).fetchall()
+def load_video_summary_map():
+    """Retourne un dict {file_name: {'labels': [...], 'playlists': [...]}} depuis la vue video_summary."""
+    with db.get_conn() as conn:
+        df = pd.read_sql_query("SELECT file_name, labels, playlists FROM video_summary", conn)
+    summary = {}
+    for _, row in df.iterrows():
+        summary[row["file_name"]] = {
+            "labels": row["labels"].split(",") if row["labels"] else [],
+            "playlists": row["playlists"].split(",") if row["playlists"] else [],
+        }
+    return summary
\ No newline at end of file
diff --git a/app/playlists/playlist_model.py b/app/playlists/playlist_model.py
index 0874af5..825ff31 100644
--- a/app/playlists/playlist_model.py
+++ b/app/playlists/playlist_model.py
@@ -1,25 +1,67 @@
 # playlists/playlist_model.py
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, validator, field_validator
 from typing import List, Optional, Literal
+from datetime import date, datetime
 import json
 import db
 
 
+from typing import Optional, List, Literal
+from pydantic import BaseModel, Field
+import json
+
 class RuleSet(BaseModel):
     include_labels: List[str] = []
     exclude_labels: List[str] = []
-    include_playlists: List[str] = []
-    exclude_playlists: List[str] = []
+    include_playlists: List[int] = []
+    exclude_playlists: List[int] = []
     date_after: Optional[str] = None
     date_before: Optional[str] = None
+    date_delta_days: Optional[int] = None
+    difficulty: Optional[str] = None
+    day_of_week: Optional[str] = None
+    address_keyword: Optional[str] = None
+    label_logic: Literal["AND", "OR"] = "AND"
     logic: Literal["AND", "OR"] = "AND"
 
+    # --- Normalisation des dates (entrée) ---
+    @field_validator("date_after", "date_before", mode="before")
+    def normalize_date(cls, v):
+        """Convertit automatiquement date/datetime en str ISO avant stockage."""
+        if isinstance(v, (date, datetime)):
+            return v.isoformat()
+        return v
+
+    def model_dump(self, *args, **kwargs):
+        """Force la sortie JSON-safe (dates converties en str)."""
+        data = super().model_dump(*args, **kwargs)
+        for key in ["date_after", "date_before"]:
+            v = data.get(key)
+            if isinstance(v, (date, datetime)):
+                data[key] = v.isoformat()
+        return data
+
+    @validator("date_after", "date_before", pre=True, always=True)
+    def convert_date(cls, v):
+        """Convertit automatiquement les objets date/datetime en ISO string."""
+        if isinstance(v, (date, datetime)):
+            return v.isoformat()
+        return v
+
+    def dict(self, *args, **kwargs):
+        """S’assure que toutes les dates sont des chaînes sérialisables."""
+        data = super().dict(*args, **kwargs)
+        for key in ["date_after", "date_before"]:
+            v = data.get(key)
+            if isinstance(v, (date, datetime)):
+                data[key] = v.isoformat()
+        return data
+
     def to_json(self) -> str:
         return json.dumps(self.dict(), ensure_ascii=False, indent=2)
 
     @classmethod
     def from_json(cls, raw):
-        """Accepte None, str vide ou dict JSON."""
         if not raw:
             return cls()
         if isinstance(raw, dict):
diff --git a/app/playlists/playlist_page.py b/app/playlists/playlist_page.py
index 198d765..496d732 100644
--- a/app/playlists/playlist_page.py
+++ b/app/playlists/playlist_page.py
@@ -21,14 +21,31 @@ def main():
     # Appliquer les filtres
     filtered = []
     for p in playlists:
+        # filtrage texte
         if search_term.lower() not in p.name.lower() and search_term.lower() not in (p.description or "").lower():
             continue
-        if date_filter and datetime.fromisoformat(p.created_at) < datetime.combine(date_filter, datetime.min.time()):
-            continue
+        # filtrage date de création
+        if date_filter:
+            created = p.created_at
+            if isinstance(created, datetime):
+                created_dt = created
+            elif isinstance(created, (str, bytes)):
+                try:
+                    created_dt = datetime.fromisoformat(created)
+                except ValueError:
+                    continue  # ignore invalid date
+            else:
+                continue
+
+            if created_dt < datetime.combine(date_filter, datetime.min.time()):
+                continue
+
         filtered.append(p)
 
     # --- Sélection ou création ---
     names = ["(➕ Nouvelle playlist)"] + [p.name for p in filtered]
+    if "new_playlist_name" in st.session_state:
+        st.session_state["playlist_select"] = st.session_state.pop("new_playlist_name")
     selected_name = st.selectbox("Sélectionnez une playlist", names, key="playlist_select")
 
     # --- Création ---
@@ -43,11 +60,8 @@ def main():
             else:
                 pl = Playlist(name=name.strip(), description=desc, type=type_choice, rules=RuleSet())
                 pl.save()
-                st.session_state["playlist_select"] = pl.name  # ✅ sélectionne automatiquement
-                if hasattr(st, "rerun"):
-                    st.rerun()
-                else:
-                    st.experimental_rerun()
+                st.session_state["new_playlist_name"] = pl.name  # on stocke temporairement
+                st.rerun()
         return
 
     # --- Mode édition ---
diff --git a/app/playlists/sql_builder.py b/app/playlists/sql_builder.py
new file mode 100644
index 0000000..a94d4ec
--- /dev/null
+++ b/app/playlists/sql_builder.py
@@ -0,0 +1,109 @@
+# playlists/sql_builder.py
+from typing import Tuple, List
+from playlists.playlist_model import RuleSet
+from datetime import datetime, timedelta
+
+def build_sql_from_rules(rules: RuleSet) -> Tuple[str, List]:
+    """
+    Construit une requête SQL complète (SELECT * FROM videos ...) 
+    en fonction d'un RuleSet.
+    Retourne (sql_query, params).
+    """
+    where = ["1=1"]
+    params = []
+     # --- DATES (delta prioritaire) ---
+    if rules.date_delta_days is not None:
+        try:
+            delta_days = int(rules.date_delta_days)
+            date_after = (datetime.now() + timedelta(days=delta_days)).strftime("%Y-%m-%d")
+            where.append("record_datetime >= ?")
+            params.append(date_after)
+        except (ValueError, TypeError) as e:
+            print(f"⚠️ [SQL Builder] Delta invalide ({rules.date_delta_days!r}) : {e}")
+    else:
+        if rules.date_after:
+            where.append("record_datetime >= ?")
+            params.append(rules.date_after)
+        if rules.date_before:
+            where.append("record_datetime <= ?")
+            params.append(rules.date_before)
+
+    # --- LABELS ---
+    if rules.include_labels:
+        placeholders = ",".join("?" * len(rules.include_labels))
+        if rules.label_logic == "AND":
+            where.append(f"""
+                file_name IN (
+                    SELECT vl.video_file_name
+                    FROM video_labels vl
+                    JOIN labels l ON l.id = vl.label_id
+                    WHERE l.name IN ({placeholders})
+                    GROUP BY vl.video_file_name
+                    HAVING COUNT(DISTINCT l.name) = {len(rules.include_labels)}
+                )
+            """)
+        else:
+            where.append(f"""
+                file_name IN (
+                    SELECT vl.video_file_name
+                    FROM video_labels vl
+                    JOIN labels l ON l.id = vl.label_id
+                    WHERE l.name IN ({placeholders})
+                )
+            """)
+        params.extend(rules.include_labels)
+
+    if rules.exclude_labels:
+        placeholders = ",".join("?" * len(rules.exclude_labels))
+        where.append(f"""
+            file_name NOT IN (
+                SELECT vl.video_file_name
+                FROM video_labels vl
+                JOIN labels l ON l.id = vl.label_id
+                WHERE l.name IN ({placeholders})
+            )
+        """)
+        params.extend(rules.exclude_labels)
+
+    # --- PLAYLISTS ---
+    if rules.include_playlists:
+        placeholders = ",".join("?" * len(rules.include_playlists))
+        where.append(f"""
+            file_name IN (
+                SELECT vp.video_file_name
+                FROM video_playlists vp
+                JOIN playlists p ON p.id = vp.playlist_id
+                WHERE p.name IN ({placeholders})
+            )
+        """)
+        params.extend(rules.include_playlists)
+
+    if rules.exclude_playlists:
+        placeholders = ",".join("?" * len(rules.exclude_playlists))
+        where.append(f"""
+            file_name NOT IN (
+                SELECT vp.video_file_name
+                FROM video_playlists vp
+                JOIN playlists p ON p.id = vp.playlist_id
+                WHERE p.name IN ({placeholders})
+            )
+        """)
+        params.extend(rules.exclude_playlists)
+
+    # --- DIFFICULTÉ ---
+    if rules.difficulty and rules.difficulty != "Tous":
+        where.append("difficulty_level = ?")
+        params.append(rules.difficulty)
+
+    # --- JOUR ---
+    if rules.day_of_week:
+        where.append("day_of_week = ?")
+        params.append(rules.day_of_week)
+
+    # --- ADRESSE ---
+    if rules.address_keyword:
+        where.append("address NOT LIKE '%unknown%' AND address LIKE ?")
+        params.append(f"%{rules.address_keyword}%")
+
+    sql = f"SELECT * FROM videos WHERE {' AND '.join(where)} ORDER BY record_datetime DESC"
+    return sql, params
diff --git a/app/views/label_views.py b/app/views/label_views.py
index eb7e549..50dcb37 100644
--- a/app/views/label_views.py
+++ b/app/views/label_views.py
@@ -4,7 +4,7 @@ from models import Video
 from views.video_views import show_video_row
 from controllers.label_controller import label_widget
 
-def video_filter_sidebar():
+def video_filter_sidebar(unlabeled=False):
     """Affiche les filtres dans la barre latérale et renvoie les paramètres de recherche."""
     st.sidebar.header("⚙️ Filtres et affichage")
     max_height = st.sidebar.slider("Hauteur max (px)", 100, 800, 300, 50)
@@ -25,7 +25,7 @@ def video_filter_sidebar():
     address_keyword = st.sidebar.selectbox("Adresse (mot-clé)", [""] + unique_addresses)
     start_date = st.sidebar.date_input("Date de début", value=None)
     end_date = st.sidebar.date_input("Date de fin", value=None)
-    show_unlabeled_only = st.sidebar.checkbox("Afficher uniquement les vidéos sans labels")
+    show_unlabeled_only = st.sidebar.checkbox("Afficher uniquement les vidéos sans labels", value=unlabeled)
 
     return dict(
         max_height=max_height,
@@ -39,7 +39,7 @@ def video_filter_sidebar():
         show_unlabeled_only=show_unlabeled_only
     )
 
-def video_list_view(filters: dict, editable_labels=True, editable_difficulty=True):
+def video_list_view(filters: dict, editable_labels=True, editable_difficulty=True, playlist=None):
     """Affiche les vidéos selon les filtres fournis."""
     st.markdown(f"""
         <style>
@@ -93,7 +93,7 @@ def video_list_view(filters: dict, editable_labels=True, editable_difficulty=Tru
         css_class = "unlabeled" if not preselected else ""
         with st.container():
             st.markdown(f"<div class='{css_class}'>", unsafe_allow_html=True)
-            show_video_row(video, preselected, editable_labels, editable_difficulty)
+            show_video_row(video, preselected, editable_labels, editable_difficulty, playlist)
             st.markdown("</div>", unsafe_allow_html=True)
 
     # lazy loading bouton
diff --git a/app/views/video_views.py b/app/views/video_views.py
index 48ca638..6c18725 100644
--- a/app/views/video_views.py
+++ b/app/views/video_views.py
@@ -1,32 +1,129 @@
+# video_views.py
+import os
 import streamlit as st
-from controllers.label_controller import label_widget
 import db
+from models import Video
+from controllers.label_controller import label_widget
+
+
+def show_video_row(
+    video: Video,
+    preselected_labels,
+    editable_labels=True,
+    editable_difficulty=True,
+    playlist=None,
+    playlist_video_ids=None,
+    video_playlists=None,
+):
+    """
+    Affiche une ligne Streamlit pour une vidéo :
+    - miniature + lecture conditionnelle
+    - métadonnées et labels
+    - édition des labels et difficulté
+    - (optionnel) ajout/retrait d'une playlist
+    """
+
+    # --- Vérifie si la vidéo est dans la playlist ---
+    in_playlist = False
+    if playlist and playlist_video_ids is not None:
+        in_playlist = video.file_name in playlist_video_ids
+    elif playlist:
+        playlist_video_ids = db.get_video_file_names_in_playlist(playlist.id)
+        in_playlist = video.file_name in playlist_video_ids
+
+    # --- Layout : miniature / infos / édition / action ---
+    if playlist:
+        col1, col2, col3, col4 = st.columns([1, 3, 2, 0.8])
+    else:
+        col1, col2, col3 = st.columns([1, 3, 2])
+        col4 = None
+
+    # --- Colonne 1 : miniature + boutons Play/Stop ---
+    play_key = f"playing_{video.file_name}"
+    st.session_state.setdefault(play_key, False)
 
-def show_video_row(video, preselected_labels, editable_labels=True, editable_difficulty=True):
-    col1, col2, col3 = st.columns([1, 3, 2])
     with col1:
-        if video.thumbnail_file:
+        if getattr(video, "thumbnail_file", None) and os.path.exists(video.thumbnail_file):
             st.image(video.thumbnail_file)
-        st.caption(video.mp4_file_name)
+        else:
+            st.caption("Pas de miniature")
 
+        st.caption(video.file_name or video.mp4_file_name)
+
+        c1, c2 = st.columns(2)
+        with c1:
+            if st.button("▶️ Lire", key=f"play_{video.file_name}"):
+                st.session_state[play_key] = True
+                (st.rerun if hasattr(st, "rerun") else st.experimental_rerun)()
+        with c2:
+            if st.button("⏸️ Stop", key=f"stop_{video.file_name}"):
+                st.session_state[play_key] = False
+                (st.rerun if hasattr(st, "rerun") else st.experimental_rerun)()
+
+        if st.session_state[play_key]:
+            mp4_path = getattr(video, "mp4_file", None)
+            if mp4_path and os.path.exists(mp4_path):
+                st.video(mp4_path)
+            else:
+                st.warning("Fichier vidéo introuvable.")
+
+    # --- Colonne 2 : métadonnées ---
     with col2:
         st.markdown(f"**📅 {video.record_datetime or ''}** — {video.day_of_week or ''}")
+        st.write(f"📍 {video.address or 'Inconnue'}")
+        st.write(f"💪 Difficulté : {video.difficulty_display}")
         st.text(f"🏷️ Labels: {', '.join(preselected_labels) or 'Aucun'}")
-        playlists = db.get_video_playlists(video.file_name)
-        if playlists:
-            st.text(f"🎵 Playlists: {', '.join(playlists)}")
 
+        if video_playlists:
+            st.text(f"🎵 Playlists: {', '.join(video_playlists)}")
+        else:
+            playlists = db.get_video_playlists(video.file_name)
+            if playlists:
+                st.text(f"🎵 Playlists: {', '.join(playlists)}")
+
+    # --- Colonne 3 : édition ---
     with col3:
         if editable_labels:
             label_widget(video, preselected=preselected_labels)
         if editable_difficulty:
             levels = ["Tout niveau", "Débutant", "Intermédiaire", "Avancé", "Star"]
+            try:
+                idx = levels.index(video.difficulty_display)
+            except ValueError:
+                idx = 0
             new_level = st.selectbox(
                 "🎚 Niveau",
                 levels,
-                index=levels.index(video.difficulty_display),
+                index=idx,
                 key=f"diff_{video.file_name}"
             )
             if new_level != video.difficulty_display:
                 db.update_video_difficulty(video.file_name, new_level)
                 st.success(f"Niveau mis à jour pour {video.file_name}")
+
+    # --- Colonne 4 : action playlist ---
+    if col4 and playlist:
+        with col4:
+            key_toggle = f"toggle_{playlist.id}_{video.file_name}"
+            prev_state_key = f"{key_toggle}_prev"
+            prev_state = st.session_state.get(prev_state_key, in_playlist)
+
+            toggled = st.toggle(
+                "🎵",
+                value=in_playlist,
+                key=key_toggle,
+                help="Inclure dans la playlist"
+            )
+
+            if toggled != prev_state:
+                if toggled:
+                    db.add_video_to_playlist(file_name=video.file_name, playlist_id=playlist.id)
+                    st.toast(f"✅ {video.file_name} ajouté à {playlist.name}")
+                else:
+                    db.remove_video_from_playlist(file_name=video.file_name, playlist_id=playlist.id)
+                    st.toast(f"🗑️ {video.file_name} retiré de {playlist.name}")
+
+                st.session_state[prev_state_key] = toggled
+                (st.rerun if hasattr(st, "rerun") else st.experimental_rerun)()
+            else:
+                st.session_state[prev_state_key] = toggled
diff --git a/model/register_video.sh b/model/register_video.sh
index ec7bc86..5d28cea 100644
--- a/model/register_video.sh
+++ b/model/register_video.sh
@@ -22,6 +22,6 @@ register_video() {
   fi
   local mp4_file_name=$(basename $(dirname $mp4_file))
 
-  sqlite3 $DANCE_VIDEOS_DB "INSERT OR REPLACE INTO videos (file_name, raw_file, duration, mp4_file, mp4_file_name, rotated_file, thumbnail_file, record_datetime, day_of_week, lat, long, address) VALUES('$file_name','$raw_file', '$duration', '$mp4_file', '$mp4_file_name', '$rotated_file', '$thumbnail_file', $record_datetime, '$day_of_week', $lat, $long, '$address')"
+  sqlite3 $DANCE_VIDEOS_DB "PRAGMA busy_timeout = 10000; INSERT OR REPLACE INTO videos (file_name, raw_file, duration, mp4_file, mp4_file_name, rotated_file, thumbnail_file, record_datetime, day_of_week, lat, long, address) VALUES('$file_name','$raw_file', '$duration', '$mp4_file', '$mp4_file_name', '$rotated_file', '$thumbnail_file', $record_datetime, '$day_of_week', $lat, $long, '$address');"
 }
 export -f register_video
\ No newline at end of file
diff --git a/model/videos_summary.sql b/model/videos_summary.sql
index b662876..6dc6716 100644
--- a/model/videos_summary.sql
+++ b/model/videos_summary.sql
@@ -1,136 +1,244 @@
-CREATE TABLE IF NOT EXISTS video_summary AS
-SELECT
-    v.file_name,
-    v.raw_file,
-    v.mp4_file,
-    v.record_datetime,
-    v.day_of_week,
-    v.difficulty_level,
-    v.address,
-    GROUP_CONCAT(DISTINCT l.name) AS labels,
-    GROUP_CONCAT(DISTINCT p.name) AS playlists
-FROM videos v
-LEFT JOIN video_labels vl ON vl.video_file_name = v.file_name
-LEFT JOIN labels l ON l.id = vl.label_id
-LEFT JOIN video_playlists vp ON vp.video_file_name = v.file_name
-LEFT JOIN playlists p ON p.id = vp.playlist_id
-GROUP BY v.file_name;
+-- ============================================================================
+-- VIEW : playlist_videos
+-- ============================================================================
+DROP VIEW IF EXISTS playlist_videos;
 
-DROP VIEW playlist_videos;
 CREATE VIEW playlist_videos AS
 WITH
--- Sous-requête pour les playlists manuelles
-manual_playlist_videos AS (
+-- 1️⃣ Playlists manuelles
+manual_playlists_videos AS (
   SELECT
     p.id AS playlist_id,
     p.name AS playlist_name,
-    vp.video_file_name,
-    v.*,
-    'manual' AS playlist_type
+    'manual' AS playlist_type,
+    vp.video_file_name
   FROM playlists p
   JOIN video_playlists vp ON p.id = vp.playlist_id
-  JOIN videos v ON vp.video_file_name = v.file_name
   WHERE p.type = 'manual'
 ),
 
--- Sous-requête pour les playlists dynamiques
-dynamic_playlist_videos AS (
+-- 2️⃣ Dynamiques sans include/exclude
+dynamic_playlist_videos_base AS (
   SELECT DISTINCT
     p.id AS playlist_id,
     p.name AS playlist_name,
-    v.file_name AS video_file_name,
-    v.*,
-    'dynamic' AS playlist_type
+    'dynamic' AS playlist_type,
+    v.file_name AS video_file_name
   FROM playlists p
   JOIN videos v
   WHERE p.type = 'dynamic'
-    -- Inclure les vidéos qui ont les labels requis
+    -- Labels inclus (AND/OR)
     AND (
       json_array_length(json_extract(p.rules_json, '$.include_labels')) = 0
-      OR EXISTS (
-        SELECT 1 FROM labels l
-        JOIN video_labels vl ON l.id = vl.label_id
-        WHERE vl.video_file_name = v.file_name
-          AND EXISTS (
-            SELECT 1
-            FROM (
-              SELECT 0 AS n UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4
-              -- Ajoute plus de lignes si tes tableaux JSON ont plus de 5 éléments
-            ) n
-            WHERE n.n < json_array_length(json_extract(p.rules_json, '$.include_labels'))
-              AND l.name = json_extract(
-                json_extract(p.rules_json, '$.include_labels'),
-                '$[' || n.n || ']'
-              )
+      OR (
+        json_extract(p.rules_json, '$.label_logic') = 'OR'
+        AND EXISTS (
+          SELECT 1 FROM json_each(json_extract(p.rules_json, '$.include_labels')) jl
+          JOIN labels l ON l.name = jl.value
+          JOIN video_labels vl ON vl.label_id = l.id AND vl.video_file_name = v.file_name
+        )
+      )
+      OR (
+        json_extract(p.rules_json, '$.label_logic') = 'AND'
+        AND NOT EXISTS (
+          SELECT 1
+          FROM json_each(json_extract(p.rules_json, '$.include_labels')) jl
+          WHERE jl.value NOT IN (
+            SELECT l2.name
+            FROM labels l2
+            JOIN video_labels vl2 ON l2.id = vl2.label_id
+            WHERE vl2.video_file_name = v.file_name
           )
+        )
       )
     )
-    -- Exclure les vidéos qui ont les labels exclus
+    -- Labels exclus
     AND NOT EXISTS (
-      SELECT 1 FROM labels l
-      JOIN video_labels vl ON l.id = vl.label_id
-      WHERE vl.video_file_name = v.file_name
-        AND EXISTS (
-          SELECT 1
-          FROM (
-            SELECT 0 AS n UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4
-          ) n
-          WHERE n.n < json_array_length(json_extract(p.rules_json, '$.exclude_labels'))
-            AND l.name = json_extract(
-              json_extract(p.rules_json, '$.exclude_labels'),
-              '$[' || n.n || ']'
-            )
-        )
+      SELECT 1 FROM json_each(json_extract(p.rules_json, '$.exclude_labels')) je
+      JOIN labels lx ON lx.name = je.value
+      JOIN video_labels vlx ON vlx.label_id = lx.id AND vlx.video_file_name = v.file_name
     )
-    -- Inclure les vidéos qui sont dans les playlists requises
-    AND (
-      json_array_length(json_extract(p.rules_json, '$.include_playlists')) = 0
-      OR EXISTS (
-        SELECT 1 FROM playlists pl
-        JOIN video_playlists vp ON pl.id = vp.playlist_id
-        WHERE vp.video_file_name = v.file_name
-          AND EXISTS (
-            SELECT 1
-            FROM (
-              SELECT 0 AS n UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4
-            ) n
-            WHERE n.n < json_array_length(json_extract(p.rules_json, '$.include_playlists'))
-              AND pl.name = json_extract(
-                json_extract(p.rules_json, '$.include_playlists'),
-                '$[' || n.n || ']'
-              )
-          )
-      )
-    )
-    -- Exclure les vidéos qui sont dans les playlists exclues
-    AND NOT EXISTS (
-      SELECT 1 FROM playlists pl
-      JOIN video_playlists vp ON pl.id = vp.playlist_id
-      WHERE vp.video_file_name = v.file_name
-        AND EXISTS (
-          SELECT 1
-          FROM (
-            SELECT 0 AS n UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4
-          ) n
-          WHERE n.n < json_array_length(json_extract(p.rules_json, '$.exclude_playlists'))
-            AND pl.name = json_extract(
-              json_extract(p.rules_json, '$.exclude_playlists'),
-              '$[' || n.n || ']'
-            )
-        )
-    )
-    -- Filtrer par date si nécessaire
+    -- Dates
     AND (
       json_extract(p.rules_json, '$.date_after') IS NULL
       OR v.record_datetime >= json_extract(p.rules_json, '$.date_after')
+      OR (
+        json_extract(p.rules_json, '$.date_delta_days') IS NOT NULL
+        AND v.record_datetime >= date('now', (json_extract(p.rules_json, '$.date_delta_days') || ' days'))
+      )
     )
     AND (
       json_extract(p.rules_json, '$.date_before') IS NULL
       OR v.record_datetime <= json_extract(p.rules_json, '$.date_before')
     )
+    -- Difficulty / day / address
+    AND (
+      json_extract(p.rules_json, '$.difficulty') IS NULL
+      OR v.difficulty_level = json_extract(p.rules_json, '$.difficulty')
+    )
+    AND (
+      json_extract(p.rules_json, '$.day_of_week') IS NULL
+      OR v.day_of_week = json_extract(p.rules_json, '$.day_of_week')
+    )
+    AND (
+      json_extract(p.rules_json, '$.address_keyword') IS NULL
+      OR (
+        v.address NOT LIKE '%unknown%'
+        AND v.address LIKE '%' || json_extract(p.rules_json, '$.address_keyword') || '%'
+      )
+    )
+),
+
+-- 3️⃣ Inclusions directes (parent → enfant)
+playlist_direct_includes AS (
+  SELECT
+    p.id AS parent_playlist_id,
+    CAST(inc.value AS INTEGER) AS child_playlist_id
+  FROM playlists p
+  JOIN json_each(json_extract(p.rules_json, '$.include_playlists')) inc
+    ON json_type(inc.value) IN ('integer', 'text')
+  WHERE json_array_length(json_extract(p.rules_json, '$.include_playlists')) > 0
+),
+
+-- 4️⃣ Récursion : parent → descendant (transitif)
+playlist_includes_recursive AS (
+  WITH RECURSIVE rec(parent_playlist_id, child_playlist_id) AS (
+    SELECT parent_playlist_id, child_playlist_id FROM playlist_direct_includes
+    UNION ALL
+    SELECT d.parent_playlist_id, di.child_playlist_id
+    FROM playlist_direct_includes d
+    JOIN rec di ON di.parent_playlist_id = d.child_playlist_id
+  )
+  SELECT DISTINCT parent_playlist_id AS parent_id, child_playlist_id AS child_id FROM rec
+),
+
+-- 5️⃣ Exclusions directes et récursives
+playlist_direct_excludes AS (
+  SELECT
+    p.id AS parent_playlist_id,
+    CAST(exc.value AS INTEGER) AS child_playlist_id
+  FROM playlists p
+  JOIN json_each(json_extract(p.rules_json, '$.exclude_playlists')) exc
+    ON json_type(exc.value) IN ('integer', 'text')
+  WHERE json_array_length(json_extract(p.rules_json, '$.exclude_playlists')) > 0
+),
+playlist_excludes_recursive AS (
+  WITH RECURSIVE rec_ex(parent_playlist_id, child_playlist_id) AS (
+    SELECT parent_playlist_id, child_playlist_id FROM playlist_direct_excludes
+    UNION ALL
+    SELECT d.parent_playlist_id, di.child_playlist_id
+    FROM playlist_direct_excludes d
+    JOIN rec_ex di ON di.parent_playlist_id = d.child_playlist_id
+  )
+  SELECT DISTINCT parent_playlist_id AS parent_id, child_playlist_id AS child_id FROM rec_ex
+),
+
+-- 6️⃣ Vidéos issues des playlists incluses
+playlist_included_videos AS (
+  SELECT pir.parent_id AS parent_playlist_id, mpv.video_file_name
+  FROM playlist_includes_recursive pir
+  JOIN manual_playlists_videos mpv ON mpv.playlist_id = pir.child_id
+  UNION
+  SELECT pir.parent_id AS parent_playlist_id, dpb.video_file_name
+  FROM playlist_includes_recursive pir
+  JOIN dynamic_playlist_videos_base dpb ON dpb.playlist_id = pir.child_id
+),
+
+-- 7️⃣ Inclusion logique OR
+playlist_includes_union AS (
+  SELECT DISTINCT db.playlist_id, db.playlist_name, db.playlist_type, db.video_file_name
+  FROM dynamic_playlist_videos_base db
+  JOIN playlists p ON p.id = db.playlist_id
+  WHERE json_extract(p.rules_json, '$.logic') = 'OR'
+  UNION
+  SELECT DISTINCT iv.parent_playlist_id AS playlist_id,
+         (SELECT name FROM playlists WHERE id = iv.parent_playlist_id) AS playlist_name,
+         'dynamic' AS playlist_type,
+         iv.video_file_name
+  FROM playlist_included_videos iv
+  JOIN playlists p ON p.id = iv.parent_playlist_id
+  WHERE json_extract(p.rules_json, '$.logic') = 'OR'
+),
+
+-- 8️⃣ Inclusion logique AND (+ fallback si 0 include)
+playlist_includes_intersection AS (
+  SELECT DISTINCT db.playlist_id, db.playlist_name, db.playlist_type, db.video_file_name
+  FROM dynamic_playlist_videos_base db
+  JOIN playlists p ON p.id = db.playlist_id
+  WHERE json_extract(p.rules_json, '$.logic') = 'AND'
+    AND json_array_length(json_extract(p.rules_json, '$.include_playlists')) > 0
+    AND db.video_file_name IN (
+      SELECT iv.video_file_name
+      FROM playlist_included_videos iv
+      WHERE iv.parent_playlist_id = db.playlist_id
+    )
+  UNION ALL
+  SELECT DISTINCT db.playlist_id, db.playlist_name, db.playlist_type, db.video_file_name
+  FROM dynamic_playlist_videos_base db
+  JOIN playlists p ON p.id = db.playlist_id
+  WHERE json_extract(p.rules_json, '$.logic') = 'AND'
+    AND (
+      json_array_length(json_extract(p.rules_json, '$.include_playlists')) IS NULL
+      OR json_array_length(json_extract(p.rules_json, '$.include_playlists')) = 0
+    )
+),
+
+-- 9️⃣ Fusion des deux logiques d’inclusion
+playlist_after_includes AS (
+  SELECT * FROM playlist_includes_union
+  UNION ALL
+  SELECT * FROM playlist_includes_intersection
+),
+
+-- 🔟 Vidéos exclues (via exclude_playlists récursif)
+playlist_excluded_videos AS (
+  SELECT per.parent_id AS parent_playlist_id, mpv.video_file_name
+  FROM playlist_excludes_recursive per
+  JOIN manual_playlists_videos mpv ON mpv.playlist_id = per.child_id
+  UNION
+  SELECT per.parent_id AS parent_playlist_id, dpb.video_file_name
+  FROM playlist_excludes_recursive per
+  JOIN dynamic_playlist_videos_base dpb ON dpb.playlist_id = per.child_id
+),
+
+-- 1️⃣1️⃣ Application des exclusions
+playlist_after_excludes AS (
+  SELECT pai.playlist_id, pai.playlist_name, pai.playlist_type, pai.video_file_name
+  FROM playlist_after_includes pai
+  LEFT JOIN playlist_excluded_videos pev
+    ON pev.parent_playlist_id = pai.playlist_id AND pev.video_file_name = pai.video_file_name
+  WHERE pev.parent_playlist_id IS NULL
 )
 
--- Union des deux types de playlists
-SELECT * FROM manual_playlist_videos
+-- 1️⃣2️⃣ Résultat final : union manuelles + dynamiques
+SELECT playlist_id, playlist_name, playlist_type, video_file_name
+FROM manual_playlists_videos
 UNION ALL
-SELECT * FROM dynamic_playlist_videos;
+SELECT playlist_id, playlist_name, playlist_type, video_file_name
+FROM playlist_after_excludes;
+
+
+-- ============================================================================
+-- TABLE AGRÉGÉE : video_summary
+-- ============================================================================
+DROP VIEW IF EXISTS video_summary;
+
+CREATE VIEW video_summary AS
+SELECT
+  v.file_name,
+  v.raw_file,
+  v.mp4_file,
+  v.record_datetime,
+  v.day_of_week,
+  v.difficulty_level,
+  v.address,
+  GROUP_CONCAT(DISTINCT l.name) AS labels,
+  GROUP_CONCAT(DISTINCT pv.playlist_name) AS playlists
+FROM videos v
+LEFT JOIN video_labels vl ON vl.video_file_name = v.file_name
+LEFT JOIN labels l ON l.id = vl.label_id
+LEFT JOIN playlist_videos pv ON pv.video_file_name = v.file_name
+GROUP BY v.file_name;
+
+CREATE TABLE IF NOT EXISTS video_summary_materialized AS
+SELECT * FROM video_summary;
\ No newline at end of file
diff --git a/model/views.sql b/model/views.sql
new file mode 100644
index 0000000..93da2b7
--- /dev/null
+++ b/model/views.sql
@@ -0,0 +1,236 @@
+-- 1) Vidéos manuelles (source unique, simple)
+DROP VIEW IF EXISTS manual_playlists_videos;
+CREATE VIEW manual_playlists_videos AS
+SELECT
+  p.id         AS playlist_id,
+  p.name       AS playlist_name,
+  'manual'     AS playlist_type,
+  vp.video_file_name
+FROM playlists p
+JOIN video_playlists vp ON p.id = vp.playlist_id
+WHERE p.type = 'manual';
+
+-- 2) Vidéos dynamiques : tout sauf include_playlists / exclude_playlists
+--    (ceci applique labels, date_after/date_before/date_delta_days, difficulty, day_of_week, address_keyword)
+DROP VIEW IF EXISTS dynamic_playlist_videos_base;
+CREATE VIEW dynamic_playlist_videos_base AS
+SELECT DISTINCT
+  p.id            AS playlist_id,
+  p.name          AS playlist_name,
+  'dynamic'       AS playlist_type,
+  v.file_name     AS video_file_name
+FROM playlists p
+JOIN videos v
+WHERE p.type = 'dynamic'
+
+  /* --- include_labels (AND/OR) --- */
+  AND (
+    json_array_length(json_extract(p.rules_json, '$.include_labels')) = 0
+    OR (
+      json_extract(p.rules_json, '$.label_logic') = 'OR'
+      AND EXISTS (
+        SELECT 1 FROM json_each(json_extract(p.rules_json, '$.include_labels')) jl
+        JOIN labels l ON l.name = jl.value
+        JOIN video_labels vl ON vl.label_id = l.id AND vl.video_file_name = v.file_name
+      )
+    )
+    OR (
+      json_extract(p.rules_json, '$.label_logic') = 'AND'
+      AND NOT EXISTS (
+        -- il existe un label requis qui n'est pas présent pour la video
+        SELECT 1
+        FROM json_each(json_extract(p.rules_json, '$.include_labels')) jl
+        WHERE jl.value NOT IN (
+          SELECT l2.name
+          FROM labels l2
+          JOIN video_labels vl2 ON l2.id = vl2.label_id
+          WHERE vl2.video_file_name = v.file_name
+        )
+      )
+    )
+  )
+
+  /* --- exclude_labels --- */
+  AND NOT EXISTS (
+    SELECT 1 FROM json_each(json_extract(p.rules_json, '$.exclude_labels')) je
+    JOIN labels lx ON lx.name = je.value
+    JOIN video_labels vlx ON vlx.label_id = lx.id AND vlx.video_file_name = v.file_name
+  )
+
+  /* --- date_after / date_delta_days / date_before --- */
+  AND (
+    json_extract(p.rules_json, '$.date_after') IS NULL
+    OR v.record_datetime >= json_extract(p.rules_json, '$.date_after')
+    OR (
+      json_extract(p.rules_json, '$.date_delta_days') IS NOT NULL
+      AND v.record_datetime >= date('now', (json_extract(p.rules_json, '$.date_delta_days') || ' days'))
+    )
+  )
+  AND (
+    json_extract(p.rules_json, '$.date_before') IS NULL
+    OR v.record_datetime <= json_extract(p.rules_json, '$.date_before')
+  )
+
+  /* --- difficulty, day_of_week, address_keyword --- */
+  AND (
+    json_extract(p.rules_json, '$.difficulty') IS NULL
+    OR v.difficulty_level = json_extract(p.rules_json, '$.difficulty')
+  )
+  AND (
+    json_extract(p.rules_json, '$.day_of_week') IS NULL
+    OR v.day_of_week = json_extract(p.rules_json, '$.day_of_week')
+  )
+  AND (
+    json_extract(p.rules_json, '$.address_keyword') IS NULL
+    OR (
+      v.address NOT LIKE '%unknown%'
+      AND v.address LIKE '%' || json_extract(p.rules_json, '$.address_keyword') || '%'
+    )
+  );
+
+
+-- 3) Mapping direct parent -> child playlist ids (extrait JSON include_playlists)
+DROP VIEW IF EXISTS playlist_direct_includes;
+CREATE VIEW playlist_direct_includes AS
+SELECT
+  p.id AS parent_playlist_id,
+  CAST(inc.value AS INTEGER) AS child_playlist_id
+FROM playlists p
+JOIN json_each(json_extract(p.rules_json, '$.include_playlists')) inc
+  ON json_type(inc.value) IN ('integer', 'text')
+WHERE json_array_length(json_extract(p.rules_json, '$.include_playlists')) > 0;
+
+
+-- 4) Fermeture transitive des inclusions : parent -> descendant child
+DROP VIEW IF EXISTS playlist_includes_recursive;
+CREATE VIEW playlist_includes_recursive AS
+WITH RECURSIVE rec(parent_playlist_id, child_playlist_id) AS (
+  -- base : les inclusions directes
+  SELECT parent_playlist_id, child_playlist_id FROM playlist_direct_includes
+
+  UNION ALL
+
+  -- récursion : si A inclut B et B inclut C, alors A inclut C
+  SELECT d.parent_playlist_id, di.child_playlist_id
+  FROM playlist_direct_includes d
+  JOIN rec di ON di.parent_playlist_id = d.child_playlist_id
+)
+SELECT DISTINCT parent_playlist_id AS parent_id, child_playlist_id AS child_id FROM rec;
+
+
+-- 5) De même pour exclusions directes et récursives
+DROP VIEW IF EXISTS playlist_direct_excludes;
+CREATE VIEW playlist_direct_excludes AS
+SELECT
+  p.id AS parent_playlist_id,
+  CAST(exc.value AS INTEGER) AS child_playlist_id
+FROM playlists p
+JOIN json_each(json_extract(p.rules_json, '$.exclude_playlists')) exc
+  ON json_type(exc.value) IN ('integer', 'text')
+WHERE json_array_length(json_extract(p.rules_json, '$.exclude_playlists')) > 0;
+
+DROP VIEW IF EXISTS playlist_excludes_recursive;
+CREATE VIEW playlist_excludes_recursive AS
+WITH RECURSIVE rec_ex(parent_playlist_id, child_playlist_id) AS (
+  SELECT parent_playlist_id, child_playlist_id FROM playlist_direct_excludes
+  UNION ALL
+  SELECT d.parent_playlist_id, di.child_playlist_id
+  FROM playlist_direct_excludes d
+  JOIN rec_ex di ON di.parent_playlist_id = d.child_playlist_id
+)
+SELECT DISTINCT parent_playlist_id AS parent_id, child_playlist_id AS child_id FROM rec_ex;
+
+
+-- 6) vidéos apportées par les playlists incluses (manuelles + dynamic_base)
+--    For each parent, collect videos that belong to any included child playlist (direct or transitive).
+--    union logique (rules.logic = 'OR')
+DROP VIEW IF EXISTS playlist_includes_union;
+CREATE VIEW playlist_includes_union AS
+-- union de base + vidéos incluses
+SELECT DISTINCT db.playlist_id, db.playlist_name, db.playlist_type, db.video_file_name
+FROM dynamic_playlist_videos_base db
+WHERE
+  json_extract((SELECT rules_json FROM playlists WHERE id = db.playlist_id), '$.logic') = 'OR'
+
+UNION
+
+SELECT DISTINCT iv.parent_playlist_id AS playlist_id,
+       (SELECT name FROM playlists WHERE id = iv.parent_playlist_id) AS playlist_name,
+       'dynamic' AS playlist_type,
+       iv.video_file_name
+FROM playlist_included_videos iv
+JOIN playlists p ON p.id = iv.parent_playlist_id
+WHERE json_extract(p.rules_json, '$.logic') = 'OR';
+
+
+
+-- 7) intersection logique (rules.logic = 'AND')
+DROP VIEW IF EXISTS playlist_includes_intersection;
+CREATE VIEW playlist_includes_intersection AS
+-- Cas 1️⃣ : AND + playlists incluses => intersection stricte
+SELECT DISTINCT db.playlist_id, db.playlist_name, db.playlist_type, db.video_file_name
+FROM dynamic_playlist_videos_base db
+WHERE json_extract((SELECT rules_json FROM playlists WHERE id = db.playlist_id), '$.logic') = 'AND'
+  AND json_array_length(json_extract((SELECT rules_json FROM playlists WHERE id = db.playlist_id), '$.include_playlists')) > 0
+  AND db.video_file_name IN (
+      SELECT iv.video_file_name
+      FROM playlist_included_videos iv
+      WHERE iv.parent_playlist_id = db.playlist_id
+  )
+
+UNION ALL
+
+-- Cas 2️⃣ : AND + aucune playlist incluse => garder la base telle quelle
+SELECT DISTINCT db.playlist_id, db.playlist_name, db.playlist_type, db.video_file_name
+FROM dynamic_playlist_videos_base db
+WHERE json_extract((SELECT rules_json FROM playlists WHERE id = db.playlist_id), '$.logic') = 'AND'
+  AND (
+    json_array_length(json_extract((SELECT rules_json FROM playlists WHERE id = db.playlist_id), '$.include_playlists')) IS NULL
+    OR json_array_length(json_extract((SELECT rules_json FROM playlists WHERE id = db.playlist_id), '$.include_playlists')) = 0
+  );
+
+
+
+
+-- 8) regroupement des deux logiques
+DROP VIEW IF EXISTS playlist_after_includes;
+CREATE VIEW playlist_after_includes AS
+SELECT * FROM playlist_includes_union
+UNION ALL
+SELECT * FROM playlist_includes_intersection;
+
+
+
+-- 9) exclusions
+DROP VIEW IF EXISTS playlist_excluded_videos;
+CREATE VIEW playlist_excluded_videos AS
+SELECT per.parent_id AS parent_playlist_id, mpv.video_file_name
+FROM playlist_excludes_recursive per
+JOIN manual_playlists_videos mpv ON mpv.playlist_id = per.child_id
+
+UNION
+
+SELECT per.parent_id AS parent_playlist_id, dpb.video_file_name
+FROM playlist_excludes_recursive per
+JOIN dynamic_playlist_videos_base dpb ON dpb.playlist_id = per.child_id;
+
+
+
+-- 10)  Appliquer exclusions
+DROP VIEW IF EXISTS playlist_after_excludes;
+CREATE VIEW playlist_after_excludes AS
+SELECT pai.playlist_id, pai.playlist_name, pai.playlist_type, pai.video_file_name
+FROM playlist_after_includes pai
+LEFT JOIN playlist_excluded_videos pev
+  ON pev.parent_playlist_id = pai.playlist_id AND pev.video_file_name = pai.video_file_name
+WHERE pev.parent_playlist_id IS NULL;
+
+-- 11) résultat final « flat »
+
+DROP VIEW IF EXISTS playlist_videos_flat;
+CREATE VIEW playlist_videos_flat AS
+SELECT playlist_id, playlist_name, playlist_type, video_file_name
+FROM manual_playlists_videos
+UNION ALL
+SELECT playlist_id, playlist_name, playlist_type, video_file_name
+FROM playlist_after_excludes;
diff --git a/program1/append_with_lock.sh b/program1/append_with_lock.sh
new file mode 100644
index 0000000..572f2a4
--- /dev/null
+++ b/program1/append_with_lock.sh
@@ -0,0 +1,50 @@
+# Fonction pour ajouter une ligne à un fichier avec verrouillage (bloquant + timeout + gestion des signaux)
+append_with_lock() {
+    local line="$1"
+    local file="$2"
+    local lock_dir="/tmp/dancevideos_moved_files.lock"
+    local timeout=30  # Timeout en secondes (ajustable)
+    local start_time=$(date +%s)
+    local got_lock=false
+
+    # Fonction de nettoyage du verrou (appelée en cas de signal ou de sortie)
+    cleanup_lock() {
+        if [ -d "$lock_dir" ]; then
+            rmdir "$lock_dir" 2>/dev/null
+        fi
+    }
+
+    # Piège les signaux d'interruption pour libérer le verrou
+    trap cleanup_lock INT TERM EXIT
+
+    # Attendre le verrou avec timeout
+    while true; do
+        # Vérifier le timeout
+        local current_time=$(date +%s)
+        if [ $((current_time - start_time)) -ge $timeout ]; then
+            echo "Timeout atteint pour l'obtention du verrou sur $file" >&2
+            trap - INT TERM EXIT  # Désactive le piège pour éviter un nettoyage double
+            return 1
+        fi
+
+        # Tentative de verrouillage
+        if mkdir "$lock_dir" 2>/dev/null; then
+            got_lock=true
+            break
+        else
+            sleep 0.1  # Attendre avant de réessayer
+        fi
+    done
+
+    # Écriture dans le fichier (si verrou obtenu)
+    if $got_lock; then
+        set -x
+        echo "$line" >> "$file"
+        echo "$line" >> "$file" # write them twice because of bug where a line is skipped
+        set +x
+        # Libérer le verrou
+        rmdir "$lock_dir"
+        trap - INT TERM EXIT  # Désactive le piège après utilisation
+    fi
+}
+export -f append_with_lock
diff --git a/program1/program1.sh b/program1/program1.sh
index c0bf4ff..e6d9da3 100755
--- a/program1/program1.sh
+++ b/program1/program1.sh
@@ -2,11 +2,49 @@
 set -euo pipefail
 IFS=$'\n\t'
 
+# === Gestion des arguments ===
+PROCESS_ALL=false
+PRINT_ERR=false
+
+# Fonction pour afficher l'aide
+usage() {
+    echo "Usage: $0 [--all|-a]"
+    echo "Options:"
+    echo "  --all, -a    Traiter tous les fichiers (ignore la liste de fichiers)"
+    echo "  --help, -h   Afficher cette aide"
+    exit 1
+}
+
+# Traitement des arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --all|-a)
+            PROCESS_ALL=true
+            shift
+            ;;
+        --help|-h)
+            usage
+            ;;
+        --print-err)
+            PRINT_ERR=true
+            shift
+            ;;
+        *)
+            echo "Option inconnue : $1" >&2
+            usage
+            ;;
+    esac
+done
+
 SCRIPTS_DIR=$(dirname `realpath ${BASH_SOURCE[0]}`)
 
 # === CONFIGURATION ===
 export DOSSIER_SOURCE="${HOME}/Downloads"
 export DOSSIER_DESTINATION_RAW="${HOME}/Documents/.DanceVideos/raw"
+export TEMP_FILE="/tmp/dancevideos_moved_files.txt"
+
+# Initialiser le fichier temporaire
+> "$TEMP_FILE"
 
 sanitize_name() {
     local name="$1"
@@ -17,6 +55,8 @@ sanitize_name() {
 }
 export -f sanitize_name
 
+source $SCRIPTS_DIR/append_with_lock.sh
+
 # Fonction pour vérifier et déplacer un fichier
 check_and_move() {
     local fichier="$1"
@@ -28,6 +68,9 @@ check_and_move() {
     if [ "$taille1" -eq "$taille2" ] && [ "$taille2" -gt 0 ]; then
         echo "Déplacement de $(basename "$fichier")"
         rsync -av --remove-source-files "$fichier" "$DOSSIER_DESTINATION_RAW/$(sanitize_name "$(basename "$fichier")")"
+        if ! append_with_lock "$DOSSIER_DESTINATION_RAW/$(sanitize_name "$(basename "$fichier")")" "$TEMP_FILE"; then
+            echo "Échec de l'écriture dans $TEMP_FILE (timeout)" >&2
+        fi
     else
         echo "Fichier $(basename "$fichier") encore en cours de réception."
     fi
@@ -90,6 +133,10 @@ process_raw_file() {
     local ct weekday duration lat lon address
     IFS="|" read -r ct weekday duration lat lon address <<<"$(process_video "$raw")"
 
+    # récupérer les infos eventuelles dans la BDD
+    # si fichier videos existent toujours ingorer, sinon écraser
+    # TODO
+
     local dir=$(mp4_dir $raw $weekday "$address")
 
     local thumbnail=${dir}/thumbnail.jpg
@@ -124,19 +171,53 @@ whatsapp_video() {
 export -f whatsapp_video
 
 convert_raws() {
+
+    if $PROCESS_ALL; then
     
-    # ##_##.mov
-    find "$DOSSIER_DESTINATION_RAW" -type f \
-    -name "*.mov" \
-    -print0 | parallel -0 -j 4 iphone_video
+        find "$DOSSIER_DESTINATION_RAW" -type f \
+        -name "*.mov" \
+        -print0 | parallel -0 -j 4 iphone_video
 
-    find "$DOSSIER_DESTINATION_RAW" -type f \
-    -name "screenrecording*.mp4" \
-    -print0 | parallel -0 -j 4 screen_video
+        find "$DOSSIER_DESTINATION_RAW" -type f \
+        -name "screenrecording*.mp4" \
+        -print0 | parallel -0 -j 4 screen_video
 
-    find "$DOSSIER_DESTINATION_RAW" -type f \
-    -name '*[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]-[0-9a-f][0-9a-f][0-9a-f][0-9a-f]-[0-9a-f][0-9a-f][0-9a-f][0-9a-f]-[0-9a-f][0-9a-f][0-9a-f][0-9a-f]-[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]*.mp4' \
-    -print0 | parallel -0 -j 4 whatsapp_video
+        find "$DOSSIER_DESTINATION_RAW" -type f \
+        -name '*[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]-[0-9a-f][0-9a-f][0-9a-f][0-9a-f]-[0-9a-f][0-9a-f][0-9a-f][0-9a-f]-[0-9a-f][0-9a-f][0-9a-f][0-9a-f]-[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]*.mp4' \
+        -print0 | parallel -0 -j 4 whatsapp_video
+    
+    else
+        if [ -f "$TEMP_FILE" ]; then
+            while IFS= read -r file || [ -n "$file" ]; do
+                file=$(echo "$file" | tr -d '\r' | xargs)
+                # Ignorer les lignes vides
+                if [ -z "$file" ]; then
+                    continue
+                fi
+                echo "Dealing with $file"
+                local filename=$(basename "$file")
+                if [[ "$filename" == *.mov ]]; then
+                    iphone_video "$file"
+                elif [[ "$filename" == screenrecording*.mp4 ]]; then
+                    screen_video "$file"
+                elif [[ "$filename" =~ ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.mp4$ ]]; then
+                    whatsapp_video "$file"
+                else
+                    echo "$file didn't match any pattern"
+                fi
+            done < "$TEMP_FILE"
+        fi
+    fi
 }
 
-convert_raws
\ No newline at end of file
+$PRINT_ERR || exec 2> /tmp/DanceVideos.stderr
+
+convert_raws
+
+set -x
+if [ 0 -lt $(wc -l /tmp/dancevideos_moved_files.txt | awk '{print $1}') ]; then
+
+    STREAMLIT_PID=$(ps aux | grep streamlit | grep -v 'grep' | awk '{print $2}'); [ ! -z "$STREAMLIT_PID" ] && kill $STREAMLIT_PID
+    (cd $SCRIPTS_DIR/..; source .venv/bin/activate; streamlit run app/app.py -- --unlabeled)
+
+fi
\ No newline at end of file
diff --git a/program1/rotation.sh b/program1/rotation.sh
index be14475..8461ec1 100644
--- a/program1/rotation.sh
+++ b/program1/rotation.sh
@@ -2,25 +2,21 @@ get_rotation_filter() {
     local f="$1"
     local rotation
     rotation=$(exiftool -Rotation -n "$f" | awk '{print $3}')
-    # echo $rotation $f >> "rotations.txt"
     case "$rotation" in
-        # 90)  echo "transpose=1" ;;
-        # 270) echo "transpose=2" ;;
-        # 180) echo "hflip,vflip" ;;
-        # *)   echo "" ;;
         *) echo "transpose=1" ;;
     esac
 }
 export -f get_rotation_filter
 
 reencode_with_rotation() {
+    set -x
     local src="$1"
     local dst="$2"
     local filter
     filter="$(get_rotation_filter "$src")"
 
     if [ -n "$filter" ]; then
-        echo "  Correction d’orientation (rotation=${filter})"
+        #echo "  Correction d’orientation (rotation=${filter})"
         if ffmpeg -encoders 2>/dev/null | grep -q 'h264_videotoolbox'; then
             ffmpeg -nostdin -i "$src" -vf "$filter" \
                 -c:v h264_videotoolbox -b:v 5M -c:a aac -map_metadata -1 -y "$dst"
@@ -42,5 +38,6 @@ reencode_with_rotation() {
             fi
         fi
     fi
+    set +x
 }
 export -f reencode_with_rotation
\ No newline at end of file
diff --git a/program2/program2.sh b/program2/program2.sh
index d1cba52..26743bc 100755
--- a/program2/program2.sh
+++ b/program2/program2.sh
@@ -18,9 +18,9 @@ mkdir -p "$DOSSIER_PLAYLIST"
 
 # Pour chaque playlist, créer un dossier et ajouter les liens symboliques
 sqlite3 -separator '|' "$DANCE_VIDEOS_DB" "
-    SELECT playlist_id, playlist_name, video_file_name, rotated_file
-    FROM playlist_videos
-    WHERE rotated_file IS NOT NULL;
+    SELECT pv.playlist_id, pv.playlist_name, pv.video_file_name, v.rotated_file
+    FROM playlist_videos pv JOIN videos v ON pv.video_file_name=v.file_name
+    WHERE v.rotated_file IS NOT NULL;
 " | while IFS='|' read -r playlist_id playlist_name video_file_name rotated_file; do
     # Sauter l'en-tête
     if [[ "$playlist_id" == "playlist_id" ]]; then