Fix smart filter in both pages/comments.py and frontend/streamlit_app.py

frontend/streamlit_app.py

@@ -25,9 +25,10 @@ st.set_page_config(
 
 r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB, decode_responses=True)
 
-TOPIC_LABELS = ["Appreciation", "Question", "Promo", "Spam", "General", "MCQ Answer"]
+TOPIC_LABELS = ["Appreciation", "Question", "Request/Feedback", "Promo", "Spam", "General", "MCQ Answer"]
 TOPIC_COLOR  = {
     "Appreciation": "#f59e0b", "Question": "#3b82f6",
+    "Request/Feedback": "#8b5cf6",
     "Promo": "#ec4899", "Spam": "#ef4444", "General": "#6b7280",
     "MCQ Answer": "#10b981"
 }
@@ -197,6 +198,18 @@ hr{border:none!important;border-top:1px solid var(--divider)!important;margin:1.
 .empty-icon{font-size:3.5rem;margin-bottom:16px;}
 .empty-title{font-size:1.1rem;color:var(--text-2);font-weight:700;}
 .empty-sub{font-size:0.84rem;color:var(--text-3);margin-top:6px;}
+
+[data-testid="stSidebar"] [role="radiogroup"] { display:flex; flex-direction:row; flex-wrap:nowrap; gap:4px; }
+[data-testid="stSidebar"] [role="radiogroup"] label { flex:1; display:flex; align-items:center; justify-content:center; background:var(--bg-card); border:1px solid var(--pill-border); border-radius:8px; padding:6px 2px; cursor:pointer; transition:background 0.15s,border 0.15s; }
+[data-testid="stSidebar"] [role="radiogroup"] label:hover { background:var(--pill-bg); border-color:var(--accent); }
+[data-testid="stSidebar"] [role="radiogroup"] label[data-checked="true"],
+[data-testid="stSidebar"] [role="radiogroup"] label:has(input:checked) { background:linear-gradient(135deg,var(--accent),var(--accent2)); border-color:var(--accent); }
+[data-testid="stSidebar"] [role="radiogroup"] label p,
+[data-testid="stSidebar"] [role="radiogroup"] label span { font-size:0.82rem !important; font-weight:700 !important; color:var(--text-1) !important; white-space:nowrap !important; }
+[data-testid="stSidebar"] [role="radiogroup"] label:has(input:checked) p,
+[data-testid="stSidebar"] [role="radiogroup"] label:has(input:checked) span { color:#fff !important; }
+[data-testid="stSidebar"] [role="radiogroup"] input[type="radio"] { display:none !important; }
+[data-testid="stSidebar"] [data-testid="stWidgetLabel"]:has(+ [role="radiogroup"]) { color:var(--text-2) !important; font-size:0.75rem !important; margin-bottom:4px; }
 </style>"""
 
 st.markdown(THEME_JS, unsafe_allow_html=True)
@@ -379,22 +392,31 @@ def compute_engagement(all_data_json: str, window: int = 50) -> dict:
 
 @st.cache_data(ttl=10, show_spinner=False)
 def compute_top_contributors(all_data_json: str, top_n: int = 10) -> list[dict]:
-    """Return top N authors by message count with their sentiment breakdown."""
+    """Return top N authors by message count with sentiment + topic breakdown."""
     import json as _j
     from collections import Counter
     msgs = _j.loads(all_data_json)
     if not msgs:
         return []
 
+    TOPICS = ["Appreciation", "Question", "Request/Feedback", "Promo", "Spam", "General", "MCQ Answer"]
     author_data: dict[str, dict] = {}
     for m in msgs:
         a = m.get("author", "Unknown")
         if a not in author_data:
-            author_data[a] = {"count": 0, "Positive": 0, "Neutral": 0, "Negative": 0}
+            author_data[a] = {
+                "count": 0,
+                "Positive": 0, "Neutral": 0, "Negative": 0,
+                **{t: 0 for t in TOPICS},
+            }
         author_data[a]["count"] += 1
         s = m.get("sentiment", "Neutral")
-        if s in author_data[a]:
+        if s in ("Positive", "Neutral", "Negative"):
             author_data[a][s] += 1
+        t = m.get("topic", "General")
+        if t not in TOPICS:
+            t = "General"
+        author_data[a][t] += 1
 
     sorted_authors = sorted(author_data.items(), key=lambda x: x[1]["count"], reverse=True)[:top_n]
     result = []
@@ -403,9 +425,16 @@ def compute_top_contributors(all_data_json: str, top_n: int = 10) -> list[dict]:
         result.append({
             "author":    author,
             "count":     d["count"],
-            "pos_pct":   round(d["Positive"] / total * 100),
-            "neu_pct":   round(d["Neutral"]  / total * 100),
-            "neg_pct":   round(d["Negative"] / total * 100),
+            "pos_pct":   round(d["Positive"]          / total * 100),
+            "neu_pct":   round(d["Neutral"]            / total * 100),
+            "neg_pct":   round(d["Negative"]           / total * 100),
+            "t_appr":    round(d["Appreciation"]       / total * 100),
+            "t_ques":    round(d["Question"]           / total * 100),
+            "t_rf":      round(d["Request/Feedback"]   / total * 100),
+            "t_promo":   round(d["Promo"]              / total * 100),
+            "t_spam":    round(d["Spam"]               / total * 100),
+            "t_gen":     round(d["General"]            / total * 100),
+            "t_mcq":     round(d["MCQ Answer"]         / total * 100),
         })
     return result
 
@@ -459,6 +488,74 @@ def check_spam_alert(df_all: pd.DataFrame, threshold: float = 0.3, window: int =
     return None
 
 
+@st.cache_data(ttl=10, show_spinner=False)
+def detect_repeat_spammers(all_data_json: str, window_sec: int = 15, min_repeats: int = 2) -> list[dict]:
+    """
+    Detect users who send the same (or near-identical) message multiple times
+    within `window_sec` seconds. Returns list of spam burst dicts sorted by
+    repeat count descending.
+    """
+    import json as _j
+    import re as _re
+
+    msgs = _j.loads(all_data_json)
+    if not msgs:
+        return []
+
+    def _normalize(t: str) -> str:
+        return _re.sub(r"[^\w]", "", t.lower().strip())
+
+    bursts: dict[tuple, dict] = {}
+    for m in msgs:
+        author = m.get("author", "Unknown")
+        text   = m.get("text", "").strip()
+        if not text:
+            continue
+        norm = _normalize(text)
+        if len(norm) < 4:
+            continue
+        ts_str = m.get("time", "")
+        try:
+            ts = datetime.fromisoformat(ts_str)
+        except Exception:
+            continue
+        key = (author, norm)
+        if key not in bursts:
+            bursts[key] = {
+                "author":    author,
+                "text":      text,
+                "topic":     m.get("topic", "General"),
+                "sentiment": m.get("sentiment", "Neutral"),
+                "timestamps": [],
+            }
+        bursts[key]["timestamps"].append(ts)
+
+    results = []
+    for key, burst in bursts.items():
+        times = sorted(burst["timestamps"])
+        max_in_window = 1
+        for i in range(len(times)):
+            count_in_window = sum(
+                1 for t in times[i:]
+                if (t - times[i]).total_seconds() <= window_sec
+            )
+            max_in_window = max(max_in_window, count_in_window)
+
+        if max_in_window >= min_repeats:
+            results.append({
+                "author":     burst["author"],
+                "text":       burst["text"],
+                "topic":      burst["topic"],
+                "sentiment":  burst["sentiment"],
+                "count":      len(times),
+                "max_burst":  max_in_window,
+                "first_seen": times[0].strftime("%H:%M:%S"),
+                "last_seen":  times[-1].strftime("%H:%M:%S"),
+            })
+
+    return sorted(results, key=lambda x: x["max_burst"], reverse=True)
+
+
 # ── SESSION STATE INIT ────────────────────────────────────────
 MAX_STREAMS = 5
 STREAM_COLORS = ["#7c3aed", "#10b981", "#f59e0b", "#3b82f6", "#ec4899"]
@@ -470,6 +567,8 @@ if "alert_dismissed" not in st.session_state:
     st.session_state.alert_dismissed = False
 if "last_alert_count" not in st.session_state:
     st.session_state.last_alert_count = 0
+if "last_view" not in st.session_state:
+    st.session_state.last_view = "💬 Comments"
 # Multi-stream: list of dicts {video_id, redis_key, label, proc}
 if "streams" not in st.session_state:
     st.session_state.streams = [
@@ -488,8 +587,21 @@ with st.sidebar:
 
     # ── Display Settings ──
     st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Display Settings</p>', unsafe_allow_html=True)
-    refresh_rate = st.slider("Refresh interval (s)", 5, 60, 15)
-    msg_limit    = st.slider("Message window", 10, 200, 50)
+    active_view = st.radio(
+        "View",
+        options=["💬 Comments", "📊 Stats & Info"],
+        index=0,
+        horizontal=True,
+        key="active_view",
+    )
+    refresh_rate = st.radio(
+        "Refresh interval (s)",
+        options=[10, 20, 30, 40, 50, 60],
+        index=0,
+        horizontal=True,
+        key="refresh_rate",
+    )
+    msg_limit    = st.slider("Message window", 10, 400, 50, step=10)
     auto_refresh = st.toggle("Live auto-refresh", value=True)
     st.divider()
 
@@ -553,11 +665,12 @@ with st.sidebar:
                     st.session_state.streams[idx]["proc"]      = proc
                     st.session_state.streams[idx]["video_id"]  = vid
                     st.session_state.streams[idx]["redis_key"] = rkey
-                    # Store title for stream A only (page header)
+                    # Fetch and store title for ALL streams (used in header pills)
+                    _title = fetch_video_title(vid)
+                    st.session_state.streams[idx]["video_title"] = _title or vid
                     if idx == 0:
                         update_config_video_id(vid)
-                        title = fetch_video_title(vid)
-                        r.set("video_title", title) if title else r.delete("video_title")
+                        r.set("video_title", _title) if _title else r.delete("video_title")
                         st.session_state.alert_dismissed = False
                     st.success(f"Stream {label} started → `{rkey}`")
                 else:
@@ -613,6 +726,38 @@ with st.sidebar:
         st.rerun()
     st.divider()
 
+    # ── Download Data ──
+    st.markdown('<p style="font-size:0.68rem;font-weight:700;color:var(--accent);text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Download Data</p>', unsafe_allow_html=True)
+    _active_streams = [s for s in st.session_state.streams if s.get("redis_key")]
+    if _active_streams:
+        for _s in _active_streams:
+            _rkey = _s["redis_key"]
+            _slabel = _s["label"]
+            _all_raws = r.lrange(_rkey, 0, -1)
+            _dl_rows = []
+            for _raw in _all_raws:
+                try:
+                    _dl_rows.append(json.loads(_raw))
+                except Exception:
+                    pass
+            if _dl_rows:
+                _dl_df = pd.DataFrame(_dl_rows)
+                _ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+                _fname = f"livepulse_{_rkey}_{_ts}.csv"
+                _csv_bytes = _dl_df.to_csv(index=False).encode("utf-8")
+                st.download_button(
+                    label=f"⬇ {_slabel} ({len(_dl_rows)} msgs)",
+                    data=_csv_bytes,
+                    file_name=_fname,
+                    mime="text/csv",
+                    key=f"dl_{_rkey}",
+                )
+            else:
+                st.markdown(f'<div style="font-size:0.72rem;color:var(--text-3);">{_slabel}: no data yet</div>', unsafe_allow_html=True)
+    else:
+        st.markdown('<div style="font-size:0.72rem;color:var(--text-3);">No active streams</div>', unsafe_allow_html=True)
+    st.divider()
+
     # ── Danger Zone ──
     st.markdown('<p style="font-size:0.68rem;font-weight:700;color:#ef4444;text-transform:uppercase;letter-spacing:0.1em;margin-bottom:8px;">Danger Zone</p>', unsafe_allow_html=True)
     if st.button("🗑 Clear all data", width='stretch'):
@@ -632,7 +777,43 @@ with st.sidebar:
 
 # ── PAGE HEADER ───────────────────────────────────────────────
 _video_title = r.get("video_title")
-_subtitle = f"▶ {_video_title}" if _video_title else "Real-time sentiment · topic classification · engagement insights"
+
+# Build subtitle showing ALL active stream titles
+_all_titles = []
+for _si, _ss in enumerate(st.session_state.streams):
+    _st = _ss.get("video_title") or _ss.get("video_id")
+    _sk = _ss.get("redis_key", "")
+    _sp = _ss.get("proc")
+    _sr = _sp is not None and _sp.poll() is None
+    if _st and (r.llen(_sk) > 0 or _sr):
+        _all_titles.append(f"▶ {_st}")
+if _all_titles:
+    _subtitle = "  ·  ".join(_all_titles)
+else:
+    _subtitle = "Real-time sentiment · topic classification · engagement insights"
+
+# Build active stream pills for header
+_active_stream_pills = ""
+for _hi, _hs in enumerate(st.session_state.streams):
+    _hkey  = _hs.get("redis_key", "")
+    _hproc = _hs.get("proc")
+    _hrunning = _hproc is not None and _hproc.poll() is None
+    if r.llen(_hkey) > 0 or _hrunning:
+        _hcolor = STREAM_COLORS[_hi]
+        _hlabel = STREAM_NAMES[_hi]
+        _htitle = (
+            _hs.get("video_title")
+            or _hs.get("video_id")
+            or _hkey
+            or f"Stream {_hlabel}"
+        )
+        _hdot = f'<span style="display:inline-block;width:7px;height:7px;background:{"#22c55e" if _hrunning else "#ef4444"};border-radius:50%;margin-right:5px;vertical-align:middle;"></span>'
+        _active_stream_pills += (
+            f'<span style="display:inline-flex;align-items:center;background:{_hcolor}18;'
+            f'border:1px solid {_hcolor}44;border-radius:20px;padding:3px 12px;'
+            f'font-size:0.75rem;font-weight:700;color:{_hcolor};margin-right:8px;">'
+            f'{_hdot}Stream {_hlabel} · {str(_htitle)[:22]}</span>'
+        )
 
 col_title, col_live = st.columns([7, 1])
 with col_title:
@@ -640,6 +821,7 @@ with col_title:
         '<div style="padding:8px 0 4px;">'
         '<div style="font-size:2rem;font-weight:800;color:var(--text-1);letter-spacing:-0.04em;">YouTube Live Chat Analytics</div>'
         f'<div style="font-size:1.25rem;color:var(--accent-text);font-weight:600;margin-top:6px;">{_subtitle}</div>'
+        + (f'<div style="margin-top:10px;">{_active_stream_pills}</div>' if _active_stream_pills else '') +
         '</div>', unsafe_allow_html=True
     )
 with col_live:
@@ -652,8 +834,35 @@ with col_live:
 
 st.divider()
 
+# ── PRIMARY STREAM SELECTOR ───────────────────────────────────
+_streams_with_data = [
+    s for s in st.session_state.streams
+    if r.llen(s.get("redis_key", "")) > 0 or (s.get("proc") is not None and s.get("proc").poll() is None)
+]
+if len(_streams_with_data) > 1:
+    _ps_options = {}
+    for _pss in _streams_with_data:
+        _psi_real = st.session_state.streams.index(_pss)
+        _pst = _pss.get("video_title") or _pss.get("video_id") or _pss.get("redis_key")
+        _psl = f"Stream {STREAM_NAMES[_psi_real]} — {str(_pst)[:35]}"
+        _ps_options[_psl] = _pss["redis_key"]
+    _ps_col, _ = st.columns([2, 3])
+    with _ps_col:
+        _selected_primary_label = st.selectbox(
+            "📊 Dashboard data source",
+            list(_ps_options.keys()),
+            key="primary_stream_select",
+            help="Switch which stream's data powers the main dashboard stats and charts"
+        )
+    _primary_key = _ps_options[_selected_primary_label]
+else:
+    _primary_key = st.session_state.streams[0]["redis_key"]
+
 # ── DATA LOAD ─────────────────────────────────────────────────
-all_data = load_stream_data("chat_messages")
+_current_len = r.llen(_primary_key)
+# Cap cumulative load at 50k — enough for accurate stats, avoids 100k+ slowdowns
+_CUMULATIVE_CAP = 50_000
+all_data = load_stream_data(_primary_key, limit=_CUMULATIVE_CAP if _current_len > _CUMULATIVE_CAP else None)
 data     = all_data[-msg_limit:] if len(all_data) > msg_limit else all_data
 
 if not all_data:
@@ -677,7 +886,190 @@ df["topic"]         = df["topic"].apply(clean_topic) if "topic" in df.columns el
 all_df["sentiment"] = all_df["sentiment"].apply(clean_sentiment)
 all_df["topic"]     = all_df["topic"].apply(clean_topic) if "topic" in all_df.columns else "General"
 
-# ── ALERT BANNERS ─────────────────────────────────────────────
+# ── VIEW ROUTING ──────────────────────────────────────────────
+# Read directly from session state to get the current widget value
+_active_view   = st.session_state.get("active_view", "💬 Comments")
+_show_stats    = _active_view == "📊 Stats & Info"
+_show_comments = _active_view == "💬 Comments"
+
+if _show_comments:
+    st.markdown('<div class="sec-hdr"><span class="sec-ttl">Live Chat Feed</span></div>', unsafe_allow_html=True)
+
+    # Build stream options
+    _feed_stream_options = {}
+    for _fs in st.session_state.streams:
+        _fkey = _fs.get("redis_key", "")
+        _flen = r.llen(_fkey)
+        if _flen > 0:
+            _fidx  = st.session_state.streams.index(_fs)
+            _flabel = f"Stream {STREAM_NAMES[_fidx]} — {_fs.get('video_id', _fkey)[:20]}"
+            _feed_stream_options[_flabel] = _fkey
+
+    _cf0, _cf1, _cf2, _cf3, _cf4 = st.columns([1, 1, 1, 1, 2])
+    with _cf0:
+        if len(_feed_stream_options) > 1:
+            _selected_stream_label = st.selectbox(
+                "Stream", list(_feed_stream_options.keys()), key="feed_stream_select"
+            )
+            _feed_key = _feed_stream_options[_selected_stream_label]
+        else:
+            _feed_key = st.session_state.streams[0]["redis_key"]
+            if _feed_stream_options:
+                st.markdown(
+                    f'<div style="font-size:0.75rem;color:var(--text-2);padding-top:28px;">'
+                    f'{list(_feed_stream_options.keys())[0]}</div>',
+                    unsafe_allow_html=True
+                )
+
+    if _feed_key == st.session_state.streams[0]["redis_key"]:
+        _feed_df = df.copy()
+    else:
+        _feed_raw = load_stream_data(_feed_key, limit=msg_limit)
+        _feed_df  = pd.DataFrame(_feed_raw) if _feed_raw else pd.DataFrame()
+        if not _feed_df.empty:
+            _feed_df["sentiment"] = _feed_df["sentiment"].apply(clean_sentiment)
+            _feed_df["topic"]     = _feed_df["topic"].apply(clean_topic) if "topic" in _feed_df.columns else "General"
+
+    with _cf1:
+        _sentiment_filter = st.selectbox("Sentiment", ["All", "Positive", "Neutral", "Negative"])
+    with _cf2:
+        _topic_filter = st.selectbox("Topic", ["All"] + TOPIC_LABELS)
+    with _cf3:
+        _all_action_types = [
+            "General Appreciation", "Testimonials", "Faculty Request", "Faculty Feedback",
+            "Content requests", "Content Feedback", "Academic / Lecture / Concept Doubts",
+            "Academic requests", "Study Materials, Deliverables & Learning Resources",
+            "Access & Support", "Batch details / structure / offerings (incl faculty)",
+            "Schedule & logistics (Batch)", "Information- Exam", "Information- Post Exam",
+            "Eligibility & audience fit - Can I take this?", "Suitability & Sufficiency (Is this enough?)",
+            "Guidance- What should I take/do?", "Language Request", "Language medium",
+            "Pricing, discounts, scholarships, offer validity", "Fees + Financial Queries",
+            "Product/feature requests (non-content)", "Offline expansion & event-city requests",
+            "Offers + Events", "General Feedback", "Others", "N/A",
+        ]
+        _action_type_filter = st.selectbox("Action Type", ["All"] + _all_action_types)
+    with _cf4:
+        _search_term = st.text_input("Search messages", placeholder="Filter by keyword...")
+
+    _filtered = _feed_df.copy() if not _feed_df.empty else pd.DataFrame()
+    _any_filter = (
+        _sentiment_filter != "All"
+        or _topic_filter != "All"
+        or _action_type_filter != "All"
+        or bool(_search_term)
+    )
+
+    if _any_filter:
+        _full_raw = load_stream_data(_feed_key)
+        if _full_raw:
+            _full_df = pd.DataFrame(_full_raw)
+            _full_df["sentiment"] = _full_df["sentiment"].apply(clean_sentiment)
+            _full_df["topic"]     = _full_df["topic"].apply(clean_topic) if "topic" in _full_df.columns else "General"
+            _filtered = _full_df.copy()
+            if _sentiment_filter != "All":
+                _filtered = _filtered[_filtered["sentiment"] == _sentiment_filter]
+            if _topic_filter != "All":
+                _filtered = _filtered[_filtered["topic"] == _topic_filter]
+            if _action_type_filter != "All":
+                if "action_type" in _filtered.columns:
+                    _filtered = _filtered[_filtered["action_type"] == _action_type_filter]
+            if _search_term:
+                _filtered = _filtered[_filtered["text"].str.contains(_search_term, case=False, na=False)]
+            if len(_filtered) > msg_limit:
+                _filtered = _filtered.iloc[-msg_limit:]
+        else:
+            _filtered = pd.DataFrame()
+        _total_scanned = len(_full_raw) if _full_raw else 0
+    else:
+        if not _filtered.empty:
+            if _sentiment_filter != "All":
+                _filtered = _filtered[_filtered["sentiment"] == _sentiment_filter]
+            if _topic_filter != "All":
+                _filtered = _filtered[_filtered["topic"] == _topic_filter]
+            if _action_type_filter != "All":
+                if "action_type" in _filtered.columns:
+                    _filtered = _filtered[_filtered["action_type"] == _action_type_filter]
+            if _search_term:
+                _filtered = _filtered[_filtered["text"].str.contains(_search_term, case=False, na=False)]
+        _total_scanned = len(_feed_df)
+
+    _feed_hdr, _feed_dl = st.columns([3, 1])
+    with _feed_hdr:
+        if _any_filter:
+            st.markdown(
+                f'<div style="font-size:0.78rem;color:var(--text-3);margin-bottom:12px;">'
+                f'Showing {len(_filtered)} matching (last {msg_limit} from {_total_scanned} total)</div>',
+                unsafe_allow_html=True
+            )
+        else:
+            st.markdown(
+                f'<div style="font-size:0.78rem;color:var(--text-3);margin-bottom:12px;">'
+                f'Showing {len(_filtered)} of {len(_feed_df)} messages</div>',
+                unsafe_allow_html=True
+            )
+    with _feed_dl:
+        if not _filtered.empty:
+            _export_cols = [c for c in ["author", "text", "sentiment", "confidence", "topic", "time"] if c in _filtered.columns]
+            csv_download(_filtered[_export_cols], "Download Feed CSV", "chat_feed.csv")
+
+    _SENT_ICON = {"Positive": "🟢", "Negative": "🔴", "Neutral": "🟡"}
+    _pinned_texts = {m.get("text", "") for m in st.session_state.pinned_messages}
+
+    for _i, (_, _row) in enumerate(_filtered.iloc[::-1].iterrows()):
+        _s         = _row.get("sentiment", "Neutral")
+        _conf_pct  = int(_row.get("confidence", 0) * 100)
+        _topic     = clean_topic(_row.get("topic", "General"))
+        _t_color   = TOPIC_COLOR.get(_topic, "#6b7280")
+        _s_color   = SENT_COLORS.get(_s, "#6b7280")
+        _s_icon    = _SENT_ICON.get(_s, "⚪")
+        _conf_color = "#22c55e" if _conf_pct >= 70 else "#eab308" if _conf_pct >= 40 else "#ef4444"
+        _msg_text  = _row.get("text", "")
+        import re as _re2
+        _display_text = _re2.sub(r":[a-zA-Z0-9_\-]+:", "", _msg_text).strip() or _msg_text
+        _is_pinned = _msg_text in _pinned_texts
+        _action_type = _row.get("action_type", "N/A") or "N/A"
+        _card_class = f"chat-card chat-{_s.lower()}" + (" chat-pinned" if _is_pinned else "")
+
+        _msg_col, _pin_col = st.columns([11, 1])
+        with _msg_col:
+            _ab = (
+                f'<span class="badge" style="color:#a78bfa;border-color:#a78bfa33;">🏷 {_action_type}</span>'
+                if _action_type not in ("N/A", "", None) else ""
+            )
+            st.markdown(
+                f'<div class="{_card_class}">'
+                f'<div class="chat-author">{_s_icon} {_row.get("author", "Unknown")}'
+                + (' <span style="font-size:0.7rem;color:#eab308;">📌</span>' if _is_pinned else '') +
+                f'</div>'
+                f'<div class="chat-text">{_display_text}</div>'
+                f'<div class="chat-badges">'
+                f'<span class="badge" style="color:{_s_color};border-color:{_s_color}33;">{_s}</span>'
+                f'<span class="badge" style="color:{_conf_color};">Confidence: {_conf_pct}%</span>'
+                f'<span class="badge" style="color:{_t_color};border-color:{_t_color}33;">{_topic}</span>'
+                f'{_ab}'
+                f'</div></div>',
+                unsafe_allow_html=True
+            )
+        with _pin_col:
+            if _is_pinned:
+                if st.button("📌", key=f"unpin_feed_{_i}", help="Unpin this message"):
+                    st.session_state.pinned_messages = [
+                        m for m in st.session_state.pinned_messages if m.get("text") != _msg_text
+                    ]
+                    st.rerun()
+            else:
+                if st.button("📍", key=f"pin_{_i}", help="Pin this message"):
+                    _msg_dict = _row.to_dict()
+                    if _msg_dict not in st.session_state.pinned_messages:
+                        st.session_state.pinned_messages.append(_msg_dict)
+                    st.rerun()
+
+    if auto_refresh:
+        time.sleep(refresh_rate)
+        st.rerun()
+    st.stop()
+
+# ── ALERT BANNERS (Stats view only) ───────────────────────────
 if alert_enabled:
     alert = check_alert(all_df, threshold=alert_threshold, window=alert_window)
     total_now = len(all_df)
@@ -778,6 +1170,26 @@ with v5:
         unsafe_allow_html=True
     )
 
+# ── CUMULATIVE TOPIC ──────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Cumulative Topic</span><span class="sec-pill">All Time</span></div>',
+    unsafe_allow_html=True
+)
+_topic_colors_list = ["#f59e0b", "#3b82f6", "#ec4899", "#ef4444", "#6b7280", "#10b981"]
+_ct_cols = st.columns(len(TOPIC_LABELS))
+for _ci, (_lbl, _clr) in enumerate(zip(TOPIC_LABELS, _topic_colors_list)):
+    _cnt = int((all_df["topic"] == _lbl).sum()) if "topic" in all_df.columns else 0
+    _pct = _cnt / max(c_total, 1) * 100
+    with _ct_cols[_ci]:
+        st.markdown(
+            f'<div class="stat-card"><div class="stat-accent" style="background:{_clr};"></div>'
+            f'<div class="stat-number" style="color:{_clr};font-size:1.8rem;">{_cnt}</div>'
+            f'<div class="stat-label">{_lbl}</div>'
+            f'<div class="stat-sub">{_pct:.1f}% of msgs</div></div>',
+            unsafe_allow_html=True
+        )
+
 
 # ── WINDOW METRICS ────────────────────────────────────────────
 st.divider()
@@ -797,19 +1209,19 @@ c2.metric("Positive",  pos,  f"{pos/total*100:.1f}%")
 c3.metric("Neutral",   neu,  f"{neu/total*100:.1f}%")
 c4.metric("Negative",  neg,  f"{neg/total*100:.1f}%")
 
-# ── SENTIMENT CHARTS ──────────────────────────────────────────
+# ── SENTIMENT + TOPIC CHARTS (ALL TIME) ──────────────────────
 st.divider()
-col_l, col_r = st.columns(2)
+col_s1, col_s2, col_t1, col_t2 = st.columns(4)
 
-with col_l:
+with col_s1:
     st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
-    st.markdown('<div class="chart-title">Sentiment Distribution</div><div class="chart-sub">Message count by sentiment class</div>', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Sentiment Distribution</div><div class="chart-sub">All-time message count by sentiment class</div>', unsafe_allow_html=True)
     fig_bar = go.Figure(go.Bar(
         x=["Positive", "Neutral", "Negative"],
-        y=[pos, neu, neg],
+        y=[c_pos, c_neu, c_neg],
         marker_color=["#22c55e", "#eab308", "#ef4444"],
         marker_line_width=0,
-        text=[pos, neu, neg],
+        text=[c_pos, c_neu, c_neg],
         textposition="outside",
         textfont=dict(size=12),
         hovertemplate="<b>%{x}</b><br>Count: %{y}<extra></extra>",
@@ -820,18 +1232,18 @@ with col_l:
     with bar_hdr:
         show_bar_data = st.checkbox("View data", key="show_bar")
     with bar_dl:
-        bar_df = pd.DataFrame({"Sentiment": ["Positive", "Neutral", "Negative"], "Count": [pos, neu, neg]})
+        bar_df = pd.DataFrame({"Sentiment": ["Positive", "Neutral", "Negative"], "Count": [c_pos, c_neu, c_neg]})
         csv_download(bar_df, "Download CSV", "sentiment_distribution.csv")
     if show_bar_data:
         st.dataframe(bar_df, width='stretch', hide_index=True)
     st.markdown('</div>', unsafe_allow_html=True)
 
-with col_r:
+with col_s2:
     st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
-    st.markdown('<div class="chart-title">Sentiment Breakdown</div><div class="chart-sub">Proportional share per class</div>', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Sentiment Donut</div><div class="chart-sub">All-time proportional share per class</div>', unsafe_allow_html=True)
     fig_pie = go.Figure(go.Pie(
         labels=["Positive", "Neutral", "Negative"],
-        values=[pos, neu, neg],
+        values=[c_pos, c_neu, c_neg],
         marker_colors=["#22c55e", "#eab308", "#ef4444"],
         hole=0.58,
         textinfo="percent",
@@ -840,7 +1252,7 @@ with col_r:
     fig_pie.update_layout(
         **{**plotly_layout(260),
            "showlegend": True,
-           "legend": dict(orientation="h", y=-0.08, font=dict(size=11))}
+           "legend": dict(orientation="h", y=-0.08, font=dict(size=11, color="#f1f5f9"))}
     )
     st.plotly_chart(fig_pie, width='stretch', config={"displayModeBar": False})
     pie_hdr, pie_dl = st.columns([1, 1])
@@ -849,14 +1261,54 @@ with col_r:
     with pie_dl:
         pie_df = pd.DataFrame({
             "Sentiment": ["Positive", "Neutral", "Negative"],
-            "Count": [pos, neu, neg],
-            "Percentage": [f"{pos/total*100:.1f}%", f"{neu/total*100:.1f}%", f"{neg/total*100:.1f}%"]
+            "Count": [c_pos, c_neu, c_neg],
+            "Percentage": [f"{c_pos/c_total*100:.1f}%", f"{c_neu/c_total*100:.1f}%", f"{c_neg/c_total*100:.1f}%"]
         })
         csv_download(pie_df, "Download CSV", "sentiment_breakdown.csv")
     if show_pie_data:
         st.dataframe(pie_df, width='stretch', hide_index=True)
     st.markdown('</div>', unsafe_allow_html=True)
 
+with col_t1:
+    st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Topic Distribution</div><div class="chart-sub">Message count by topic class</div>', unsafe_allow_html=True)
+    _tc_vals = [int((all_df["topic"] == l).sum()) if "topic" in all_df.columns else 0 for l in TOPIC_LABELS]
+    _tc_colors = ["#f59e0b", "#3b82f6", "#ec4899", "#ef4444", "#6b7280", "#10b981"]
+    fig_tbar = go.Figure(go.Bar(
+        x=TOPIC_LABELS,
+        y=_tc_vals,
+        marker_color=_tc_colors,
+        marker_line_width=0,
+        text=_tc_vals,
+        textposition="outside",
+        textfont=dict(size=11),
+        hovertemplate="<b>%{x}</b><br>Count: %{y}<extra></extra>",
+    ))
+    _tbar_layout = plotly_layout(260)
+    _tbar_layout["xaxis"]["tickfont"] = dict(size=9)
+    fig_tbar.update_layout(**_tbar_layout)
+    st.plotly_chart(fig_tbar, width='stretch', config={"displayModeBar": False})
+    st.markdown('</div>', unsafe_allow_html=True)
+
+with col_t2:
+    st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Topic Donut</div><div class="chart-sub">Proportional share per topic</div>', unsafe_allow_html=True)
+    fig_tpie = go.Figure(go.Pie(
+        labels=TOPIC_LABELS,
+        values=_tc_vals,
+        marker_colors=_tc_colors,
+        hole=0.58,
+        textinfo="percent",
+        hovertemplate="<b>%{label}</b><br>%{value} messages (%{percent})<extra></extra>",
+    ))
+    fig_tpie.update_layout(
+        **{**plotly_layout(260),
+           "showlegend": True,
+           "legend": dict(orientation="h", y=-0.08, font=dict(size=10, color="#f1f5f9"))}
+    )
+    st.plotly_chart(fig_tpie, width='stretch', config={"displayModeBar": False})
+    st.markdown('</div>', unsafe_allow_html=True)
+
 # ── Confidence trend ──────────────────────────────────────────
 if "confidence" in df.columns:
     st.divider()
@@ -979,6 +1431,210 @@ if show_topic_data:
     st.dataframe(topic_df, width='stretch', hide_index=True)
 st.markdown('</div>', unsafe_allow_html=True)
 
+# ── Topic Sentiment breakdown ──────────────────────────────────
+st.markdown('<div class="chart-wrap" style="margin-top:16px;">', unsafe_allow_html=True)
+st.markdown('<div class="chart-title">Sentiment by Topic</div><div class="chart-sub">% positive / neutral / negative within each topic category</div>', unsafe_allow_html=True)
+_topic_sent_data = []
+for _lbl in TOPIC_LABELS:
+    _mask = all_df["topic"] == _lbl
+    _total = int(_mask.sum())
+    if _total == 0:
+        _topic_sent_data.append({"topic": _lbl, "pos": 0, "neu": 0, "neg": 0})
+        continue
+    _sub = all_df[_mask]
+    _topic_sent_data.append({
+        "topic": _lbl,
+        "pos": round((_sub["sentiment"] == "Positive").sum() / _total * 100),
+        "neu": round((_sub["sentiment"] == "Neutral").sum()  / _total * 100),
+        "neg": round((_sub["sentiment"] == "Negative").sum() / _total * 100),
+    })
+fig_ts = go.Figure()
+for _sk, _sl, _sc in [("neg", "Neg", "#ef4444"), ("neu", "Neu", "#eab308"), ("pos", "Pos", "#22c55e")]:
+    fig_ts.add_trace(go.Bar(
+        y=[d["topic"] for d in _topic_sent_data],
+        x=[d[_sk] for d in _topic_sent_data],
+        name=_sl,
+        orientation="h",
+        marker_color=_sc,
+        hovertemplate="<b>%{y}</b><br>" + _sl + ": %{x}%<extra></extra>",
+    ))
+_layout_ts = plotly_layout(260)
+_layout_ts["barmode"] = "stack"
+_layout_ts["showlegend"] = True
+_layout_ts["legend"] = dict(orientation="h", y=1.08, x=0.35, font=dict(size=11))
+_layout_ts["xaxis"]["range"] = [0, 100]
+_layout_ts["xaxis"]["ticksuffix"] = "%"
+_layout_ts["yaxis"]["autorange"] = "reversed"
+fig_ts.update_layout(**_layout_ts)
+st.plotly_chart(fig_ts, width='stretch', config={"displayModeBar": False})
+st.markdown('</div>', unsafe_allow_html=True)
+
+
+# ── ACTION TYPE CHARTS ────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Action Type Analysis</span><span class="sec-pill">Last 100 msgs</span></div>',
+    unsafe_allow_html=True
+)
+
+# Category groupings
+_QUESTION_ACTIONS = [
+    "Access & Support",
+    "Academic / Lecture / Concept Doubts",
+    "Study Materials, Deliverables & Learning Resources",
+    "Batch details / structure / offerings (incl faculty)",
+    "Schedule & logistics (Batch)",
+    "Guidance- What should I take/do?",
+    "Suitability & Sufficiency (Is this enough?)",
+    "Eligibility & audience fit - Can I take this?",
+    "Information- Exam",
+    "Information- Post Exam",
+]
+_REQUEST_ACTIONS = [
+    "Content requests",
+    "Content Feedback",
+    "Faculty Request",
+    "Faculty Feedback",
+    "Academic requests",
+    "Language Request",
+    "Language medium",
+    "Product/feature requests (non-content)",
+    "Offline expansion & event-city requests",
+    "General Feedback",
+    "Others",
+]
+_SHORT_ACTION = {
+    "Access & Support":                                          "Access & Support",
+    "Academic / Lecture / Concept Doubts":                      "Academic Doubts",
+    "Study Materials, Deliverables & Learning Resources":       "Study Materials & Learning Resources",
+    "Batch details / structure / offerings (incl faculty)":     "Batch Details & Offerings",
+    "Schedule & logistics (Batch)":                             "Batch Schedule & Logistics",
+    "Guidance- What should I take/do?":                         "Guidance (What Should I Take/Do?)",
+    "Suitability & Sufficiency (Is this enough?)":              "Suitability & Sufficiency (Is This Enough?)",
+    "Eligibility & audience fit - Can I take this?":            "Eligibility (Can I Take This?)",
+    "Information- Exam":                                        "Exam Information",
+    "Information- Post Exam":                                   "Post Exam Information",
+    "Content requests":                                         "Content requests",
+    "Content Feedback":                                         "Content Feedback",
+    "Faculty Request":                                          "Faculty Request",
+    "Faculty Feedback":                                         "Faculty Feedback",
+    "Academic requests":                                        "Academic requests",
+    "Language Request":                                         "Language Request",
+    "Language medium":                                          "Language Medium",
+    "Product/feature requests (non-content)":                   "Non Content Product Requests",
+    "Offline expansion & event-city requests":                  "Offline Expansion & Event Requests",
+    "General Feedback":                                         "General Feedback",
+    "Others":                                                   "Others",
+}
+
+# Compute counts from last 100 messages
+_at_counts: dict[str, int] = {}
+if "action_type" in all_df.columns:
+    for _at in _QUESTION_ACTIONS + _REQUEST_ACTIONS:
+        _at_counts[_at] = int((all_df.tail(100)["action_type"] == _at).sum())
+else:
+    _at_counts = {_at: 0 for _at in _QUESTION_ACTIONS + _REQUEST_ACTIONS}
+
+_q_data  = {k: _at_counts.get(k, 0) for k in _QUESTION_ACTIONS if _at_counts.get(k, 0) > 0}
+_rf_data = {k: _at_counts.get(k, 0) for k in _REQUEST_ACTIONS  if _at_counts.get(k, 0) > 0}
+_q_total  = sum(_q_data.values())
+_rf_total = sum(_rf_data.values())
+
+_at_col1, _at_col2 = st.columns(2)
+
+with _at_col1:
+    st.markdown(
+        f'<div class="chart-wrap"><div class="chart-title">Type of Questions</div>'
+        f'<div class="chart-sub">({_q_total} comments)</div>',
+        unsafe_allow_html=True
+    )
+    if _q_data:
+        _q_sorted = sorted(_q_data.items(), key=lambda x: x[1], reverse=True)
+        _q_labels = [_SHORT_ACTION.get(k, k) for k, _ in _q_sorted]
+        _q_vals   = [v for _, v in _q_sorted]
+        fig_q = go.Figure(go.Bar(
+            x=_q_labels, y=_q_vals,
+            marker_color="#4a90d9",
+            marker_line_width=0,
+            text=_q_vals, textposition="outside",
+            textfont=dict(size=11, color="#fff"),
+            hovertemplate="<b>%{x}</b><br>Comments: %{y}<extra></extra>",
+        ))
+        fig_q.update_layout(**plotly_layout(280))
+        st.plotly_chart(fig_q, width='stretch', config={"displayModeBar": False})
+    else:
+        st.markdown('<div style="text-align:center;padding:40px;color:var(--text-3);">No data yet</div>', unsafe_allow_html=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+with _at_col2:
+    st.markdown(
+        f'<div class="chart-wrap"><div class="chart-title">Type of Requests &amp; Feedback</div>'
+        f'<div class="chart-sub">({_rf_total} comments)</div>',
+        unsafe_allow_html=True
+    )
+    if _rf_data:
+        _rf_sorted = sorted(_rf_data.items(), key=lambda x: x[1], reverse=True)
+        _rf_labels = [_SHORT_ACTION.get(k, k) for k, _ in _rf_sorted]
+        _rf_vals   = [v for _, v in _rf_sorted]
+        fig_rf = go.Figure(go.Bar(
+            x=_rf_labels, y=_rf_vals,
+            marker_color="#f5a623",
+            marker_line_width=0,
+            text=_rf_vals, textposition="outside",
+            textfont=dict(size=11, color="#fff"),
+            hovertemplate="<b>%{x}</b><br>Comments: %{y}<extra></extra>",
+        ))
+        fig_rf.update_layout(**plotly_layout(280))
+        st.plotly_chart(fig_rf, width='stretch', config={"displayModeBar": False})
+    else:
+        st.markdown('<div style="text-align:center;padding:40px;color:var(--text-3);">No data yet</div>', unsafe_allow_html=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# Top-5 horizontal bar panels
+_top5_col1, _top5_col2 = st.columns(2)
+
+def _hbar_rows_html(data: dict, color: str, max_val: int) -> str:
+    html = ""
+    for cat, count in sorted(data.items(), key=lambda x: x[1], reverse=True)[:5]:
+        pct = round(count / max(max_val, 1) * 100)
+        label = _SHORT_ACTION.get(cat, cat)
+        html += (
+            f'<div style="display:flex;align-items:center;gap:10px;margin-bottom:10px;">'
+            f'<div style="width:170px;font-size:12px;text-align:right;opacity:0.85;line-height:1.3;">{label}</div>'
+            f'<div style="flex:1;height:22px;border-radius:4px;background:rgba(255,255,255,0.06);overflow:hidden;">'
+            f'<div style="width:{pct}%;height:100%;background:{color};border-radius:4px;'
+            f'display:flex;align-items:center;justify-content:flex-end;padding-right:6px;'
+            f'font-size:11px;font-weight:700;color:#fff;">{pct}%</div>'
+            f'</div></div>'
+        )
+    return html
+
+with _top5_col1:
+    st.markdown(
+        '<div class="chart-wrap">'
+        '<div class="chart-title">Top 5 <span style="color:#60a5fa;">Questions</span> Students Ask</div>'
+        '<div class="chart-sub">Type of action count for Questions across tagged videos.</div>',
+        unsafe_allow_html=True
+    )
+    if _q_data:
+        st.markdown(_hbar_rows_html(_q_data, "#f87171", max(_q_data.values(), default=1)), unsafe_allow_html=True)
+    else:
+        st.markdown('<div style="text-align:center;padding:20px;color:var(--text-3);">No data yet</div>', unsafe_allow_html=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+with _top5_col2:
+    st.markdown(
+        '<div class="chart-wrap">'
+        '<div class="chart-title">Top 5 Types of <span style="color:#f87171;">Requests &amp; Feedback</span> Students Give</div>'
+        '<div class="chart-sub">Type of action count for Request/Feedback across tagged videos.</div>',
+        unsafe_allow_html=True
+    )
+    if _rf_data:
+        st.markdown(_hbar_rows_html(_rf_data, "#f87171", max(_rf_data.values(), default=1)), unsafe_allow_html=True)
+    else:
+        st.markdown('<div style="text-align:center;padding:20px;color:var(--text-3);">No data yet</div>', unsafe_allow_html=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
 
 # ── ENGAGEMENT SCORE ─────────────────────────────────────────
 st.divider()
@@ -1020,65 +1676,202 @@ st.markdown(
     unsafe_allow_html=True
 )
 
-_contrib_json = json.dumps([{"author": m.get("author",""), "sentiment": m.get("sentiment","Neutral")} for m in all_data])
+_contrib_json = json.dumps([{"author": m.get("author",""), "sentiment": m.get("sentiment","Neutral"), "topic": m.get("topic","General")} for m in all_data])
 contributors = compute_top_contributors(_contrib_json)
 
 if contributors:
     max_count = contributors[0]["count"]
-    lc1, lc2 = st.columns([3, 2])
-    with lc1:
-        rank_icons = {1: "🥇", 2: "🥈", 3: "🥉"}
-        rank_classes = {1: "gold", 2: "silver", 3: "bronze"}
-        for rank, c in enumerate(contributors, 1):
-            bar_pct  = int(c["count"] / max(max_count, 1) * 100)
-            rank_cls = rank_classes.get(rank, "")
-            rank_icon = rank_icons.get(rank, f"#{rank}")
-            author   = c["author"]
-            count    = c["count"]
-            pos_pct  = c["pos_pct"]
-            neu_pct  = c["neu_pct"]
-            neg_pct  = c["neg_pct"]
-            html = (
-                f'<div class="leaderboard-row">'
-                f'<div class="lb-rank {rank_cls}">{rank_icon}</div>'
-                f'<div class="lb-author">{author}</div>'
-                f'<div class="lb-bar"><div class="lb-bar-fill" style="width:{bar_pct}%;background:var(--accent);"></div></div>'
-                f'<div class="lb-sent">'
-                f'<span class="lb-dot" style="background:#22c55e;" title="Positive {pos_pct}%"></span>'
-                f'<span class="lb-dot" style="background:#eab308;" title="Neutral {neu_pct}%"></span>'
-                f'<span class="lb-dot" style="background:#ef4444;" title="Negative {neg_pct}%"></span>'
-                f'</div>'
-                f'<div class="lb-count">{count} msgs</div>'
-                f'</div>'
-            )
-            st.markdown(html, unsafe_allow_html=True)
-    with lc2:
-        # Stacked bar of top 5 contributors
-        top5 = contributors[:5]
-        fig_lb = go.Figure()
-        for sent, color in [("pos_pct","#22c55e"),("neu_pct","#eab308"),("neg_pct","#ef4444")]:
-            fig_lb.add_trace(go.Bar(
-                y=[c["author"][:18] for c in top5],
-                x=[c[sent] for c in top5],
-                name=sent.replace("_pct","").capitalize(),
-                orientation="h",
-                marker_color=color,
-                hovertemplate="%{y}: %{x}%<extra></extra>",
-            ))
-        layout_lb = plotly_layout(260)
-        layout_lb["barmode"] = "stack"
-        layout_lb["showlegend"] = True
-        layout_lb["legend"] = dict(orientation="h", y=1.1, font=dict(size=10))
-        layout_lb["xaxis"]["range"] = [0, 100]
-        layout_lb["xaxis"]["ticksuffix"] = "%"
-        fig_lb.update_layout(**layout_lb)
-        st.plotly_chart(fig_lb, width='stretch', config={"displayModeBar": False})
+    rank_icons = {1: "🥇", 2: "🥈", 3: "🥉"}
+    rank_classes = {1: "gold", 2: "silver", 3: "bronze"}
+    for rank, c in enumerate(contributors, 1):
+        bar_pct  = int(c["count"] / max(max_count, 1) * 100)
+        rank_cls = rank_classes.get(rank, "")
+        rank_icon = rank_icons.get(rank, f"#{rank}")
+        author   = c["author"]
+        count    = c["count"]
+        pos_pct  = c["pos_pct"]
+        neu_pct  = c["neu_pct"]
+        neg_pct  = c["neg_pct"]
+        html = (
+            f'<div class="leaderboard-row">'
+            f'<div class="lb-rank {rank_cls}">{rank_icon}</div>'
+            f'<div class="lb-author">{author}</div>'
+            f'<div class="lb-bar"><div class="lb-bar-fill" style="width:{bar_pct}%;background:var(--accent);"></div></div>'
+            f'<div class="lb-sent">'
+            f'<span class="lb-dot" style="background:#22c55e;" title="Positive {pos_pct}%"></span>'
+            f'<span class="lb-dot" style="background:#eab308;" title="Neutral {neu_pct}%"></span>'
+            f'<span class="lb-dot" style="background:#ef4444;" title="Negative {neg_pct}%"></span>'
+            f'</div>'
+            f'<div class="lb-count">{count} msgs</div>'
+            f'</div>'
+        )
+        st.markdown(html, unsafe_allow_html=True)
+
+    # ── Combined Sentiment + Topic dual-bar chart ──────────────
+    st.markdown('<div class="chart-wrap" style="margin-top:16px;">', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="chart-title">Sentiment &amp; Topic Breakdown — Top Contributors</div>'
+        '<div class="chart-sub">Top bar = sentiment (Neg/Neu/Pos) · Bottom bar = topic mix · right = message count</div>',
+        unsafe_allow_html=True
+    )
+
+    # Each user occupies 2 numeric slots: sentiment at i*2+0.3, topic at i*2-0.3
+    # Tick label sits at i*2 (midpoint) showing the name once
+    n = len(contributors)
+    y_sent_num  = [i * 2 + 0.3 for i in range(n)]
+    y_topic_num = [i * 2 - 0.3 for i in range(n)]
+    tick_vals   = [i * 2       for i in range(n)]
+    tick_text   = [c["author"][:22] for c in contributors]
+
+    fig_combo = go.Figure()
+
+    # ── Sentiment traces ──
+    for key, label, color in [
+        ("neg_pct", "Neg", "#ef4444"),
+        ("neu_pct", "Neu", "#eab308"),
+        ("pos_pct", "Pos", "#22c55e"),
+    ]:
+        fig_combo.add_trace(go.Bar(
+            name=label,
+            y=y_sent_num,
+            x=[c[key] for c in contributors],
+            orientation="h",
+            marker_color=color,
+            legendgroup="sent",
+            legendgrouptitle_text="Sentiment" if key == "neg_pct" else None,
+            width=0.5,
+            hovertemplate="<b>" + label + "</b>: %{x}%<extra></extra>",
+        ))
+
+    # ── Topic traces ──
+    for key, label, color in [
+        ("t_appr",  "Appreciation",    "#f59e0b"),
+        ("t_ques",  "Question",        "#3b82f6"),
+        ("t_rf",    "Request/Feedback","#8b5cf6"),
+        ("t_promo", "Promo",           "#ec4899"),
+        ("t_spam",  "Spam",            "#ef4444"),
+        ("t_gen",   "General",         "#6b7280"),
+        ("t_mcq",   "MCQ Answer",      "#10b981"),
+    ]:
+        fig_combo.add_trace(go.Bar(
+            name=label,
+            y=y_topic_num,
+            x=[c[key] for c in contributors],
+            orientation="h",
+            marker_color=color,
+            legendgroup="topic",
+            legendgrouptitle_text="Topic" if key == "t_appr" else None,
+            width=0.5,
+            hovertemplate="<b>" + label + "</b>: %{x}%<extra></extra>",
+        ))
+
+    # ── Message count annotations (right of sentiment bar) ──
+    annotations = []
+    for i, c in enumerate(contributors):
+        annotations.append(dict(
+            x=102, y=y_sent_num[i],
+            text=f"<b>{c['count']} msgs</b>",
+            showarrow=False,
+            xanchor="left",
+            font=dict(size=10, color="#94a3b8"),
+            xref="x", yref="y",
+        ))
+
+    chart_h = max(400, n * 56)
+    layout_combo = plotly_layout(chart_h)
+    layout_combo["barmode"]    = "stack"
+    layout_combo["bargap"]     = 0.1
+    layout_combo["showlegend"] = True
+    layout_combo["legend"]     = dict(
+        orientation="h", y=1.0, x=0,
+        font=dict(size=12, color="#f1f5f9"),
+        title_font=dict(size=12, color="#a78bfa"),
+        groupclick="toggleitem",
+        yanchor="bottom",
+        xanchor="left",
+        bgcolor="rgba(0,0,0,0)",
+    )
+    layout_combo["margin"]     = dict(l=10, r=80, t=80, b=10)
+    layout_combo["xaxis"]["range"]      = [0, 115]
+    layout_combo["xaxis"]["ticksuffix"] = "%"
+    layout_combo["yaxis"] = dict(
+        tickvals=tick_vals,
+        ticktext=tick_text,
+        tickfont=dict(size=10),
+        autorange="reversed",
+        showgrid=False,
+        zeroline=False,
+        showline=False,
+    )
+    layout_combo["annotations"] = annotations
+    fig_combo.update_layout(**layout_combo)
+
+    st.plotly_chart(fig_combo, width='stretch', config={"displayModeBar": False})
+    st.markdown('</div>', unsafe_allow_html=True)
 
     contrib_df = pd.DataFrame(contributors)
     csv_download(contrib_df, "Download CSV", "top_contributors.csv")
 else:
     st.info("Not enough data yet.")
 
+# ── REPEAT SPAMMERS ───────────────────────────────────────────
+st.divider()
+st.markdown(
+    '<div class="sec-hdr"><span class="sec-ttl">Repeat Spammers</span><span class="sec-pill">All Time</span></div>',
+    unsafe_allow_html=True
+)
+rs_col1, rs_col2 = st.columns([1, 1])
+with rs_col1:
+    rs_window = st.slider("Time window (sec)", 5, 60, 15, key="rs_window")
+with rs_col2:
+    rs_min = st.slider("Min repeats to flag", 2, 10, 2, key="rs_min")
+
+_rs_json = json.dumps([{
+    "author": m.get("author",""), "text": m.get("text",""),
+    "topic": m.get("topic","General"), "sentiment": m.get("sentiment","Neutral"),
+    "time": m.get("time","")
+} for m in all_data])
+repeat_spammers = detect_repeat_spammers(_rs_json, window_sec=rs_window, min_repeats=rs_min)
+
+if repeat_spammers:
+    st.markdown(
+        f'<div style="font-size:0.78rem;color:var(--text-3);margin-bottom:12px;">'
+        f'Found <b style="color:var(--text-1);">{len(repeat_spammers)}</b> users repeating the same message '
+        f'≥{rs_min}× within {rs_window}s</div>',
+        unsafe_allow_html=True
+    )
+    for rs in repeat_spammers:
+        _t_color  = TOPIC_COLOR.get(rs["topic"], "#6b7280")
+        _s_color  = SENT_COLORS.get(rs["sentiment"], "#6b7280")
+        _burst    = rs["max_burst"]
+        _total    = rs["count"]
+        _severity = "#ef4444" if _burst >= 5 else "#eab308" if _burst >= 3 else "#f59e0b"
+        st.markdown(
+            f'<div class="chat-card" style="border-left:3px solid {_severity};">'
+            f'<div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:6px;">'
+            f'<div class="chat-author">⚠️ {rs["author"]}</div>'
+            f'<div style="display:flex;gap:6px;">'
+            f'<span class="badge" style="color:{_severity};border-color:{_severity}44;">'
+            f'🔁 {_burst}× in {rs_window}s</span>'
+            f'<span class="badge" style="color:var(--text-3);">{_total} total</span>'
+            f'</div></div>'
+            f'<div class="chat-text">"{rs["text"]}"</div>'
+            f'<div class="chat-badges">'
+            f'<span class="badge" style="color:{_s_color};border-color:{_s_color}33;">{rs["sentiment"]}</span>'
+            f'<span class="badge" style="color:{_t_color};border-color:{_t_color}33;">{rs["topic"]}</span>'
+            f'<span class="badge">First: {rs["first_seen"]}</span>'
+            f'<span class="badge">Last: {rs["last_seen"]}</span>'
+            f'</div></div>',
+            unsafe_allow_html=True
+        )
+    rs_df = pd.DataFrame(repeat_spammers)
+    csv_download(rs_df, "Download CSV", "repeat_spammers.csv")
+else:
+    st.markdown(
+        '<div style="font-size:0.84rem;color:var(--text-3);padding:12px 0;">No repeat spammers detected in current window.</div>',
+        unsafe_allow_html=True
+    )
+
 # ── WORD CLOUD ────────────────────────────────────────────────
 st.divider()
 st.markdown(
@@ -1154,81 +1947,154 @@ if len(active_streams) > 1:
         unsafe_allow_html=True
     )
 
-    def stream_summary_chart(stream_df, color):
-        counts_s = stream_df["sentiment"].value_counts().to_dict()
-        p = counts_s.get("Positive", 0)
-        n = counts_s.get("Neutral",  0)
-        g = counts_s.get("Negative", 0)
-        t = max(p + n + g, 1)
-        fig = go.Figure(go.Bar(
-            x=["Positive", "Neutral", "Negative"],
-            y=[p, n, g],
-            marker_color=["#22c55e", "#eab308", "#ef4444"],
-            marker_line_width=0,
-            text=[p, n, g],
-            textposition="outside",
-            hovertemplate="<b>%{x}</b><br>%{y}<extra></extra>",
-        ))
-        fig.update_layout(**plotly_layout(200))
-        return fig, p, n, g, t
-
-    # Render in rows of up to 3 columns
-    chunk_size = 3
-    for row_start in range(0, n_streams, chunk_size):
-        row_streams = active_streams[row_start:row_start + chunk_size]
-        cols = st.columns(len(row_streams))
-        for col, stream in zip(cols, row_streams):
-            sidx   = st.session_state.streams.index(stream)
-            color  = STREAM_COLORS[sidx]
-            slabel = STREAM_NAMES[sidx]
-            s_data = load_stream_data(stream["redis_key"])
-            if not s_data:
-                col.info(f"No data yet for Stream {slabel}")
-                continue
-            s_df = pd.DataFrame(s_data)
-            s_df["sentiment"] = s_df["sentiment"].apply(clean_sentiment)
-            s_df["topic"]     = s_df["topic"].apply(clean_topic) if "topic" in s_df.columns else "General"
-            fig, p, n, g, t = stream_summary_chart(s_df, color)
+    # ── Load all stream data ONCE (fix double-load) ───────────
+    _stream_cache: dict[str, dict] = {}
+    for _s in active_streams:
+        _rkey = _s["redis_key"]
+        _raw  = load_stream_data(_rkey)
+        if not _raw:
+            continue
+        _sdf = pd.DataFrame(_raw)
+        _sdf["sentiment"] = _sdf["sentiment"].apply(clean_sentiment)
+        _sdf["topic"]     = _sdf["topic"].apply(clean_topic) if "topic" in _sdf.columns else "General"
+        _sc = _sdf["sentiment"].value_counts().to_dict()
+        _p  = _sc.get("Positive", 0)
+        _n  = _sc.get("Neutral",  0)
+        _g  = _sc.get("Negative", 0)
+        _t  = max(_p + _n + _g, 1)
+        _tc = {lbl: int((_sdf["topic"] == lbl).sum()) for lbl in TOPIC_LABELS}
+        _top_topic = max(_tc, key=_tc.get)
+        _eng_json = json.dumps([
+            {"sentiment": m.get("sentiment","Neutral"),
+             "topic":     m.get("topic","General"),
+             "time":      m.get("time","")} for m in _raw
+        ])
+        _eng = compute_engagement(_eng_json)
+        _title = _s.get("video_title") or _s.get("video_id") or _rkey
+        _stream_cache[_rkey] = {
+            "df": _sdf, "raw": _raw,
+            "p": _p, "n": _n, "g": _g, "t": _t,
+            "tc": _tc, "top_topic": _top_topic,
+            "eng": _eng, "title": _title,
+            "sidx": st.session_state.streams.index(_s),
+        }
+
+    # ── Head-to-head comparison table ─────────────────────────
+    st.markdown('<div class="chart-wrap" style="margin-bottom:16px;">', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Head-to-Head Summary</div><div class="chart-sub">All active streams at a glance</div>', unsafe_allow_html=True)
+    _hth_rows = []
+    for _s in active_streams:
+        _rkey = _s["redis_key"]
+        if _rkey not in _stream_cache:
+            continue
+        _c = _stream_cache[_rkey]
+        _sidx = _c["sidx"]
+        _hth_rows.append({
+            "Stream":      f"Stream {STREAM_NAMES[_sidx]}",
+            "Title":       _c["title"][:30],
+            "Messages":    _c["t"],
+            "Positive %":  f"{_c['p']/_c['t']*100:.1f}%",
+            "Neutral %":   f"{_c['n']/_c['t']*100:.1f}%",
+            "Negative %":  f"{_c['g']/_c['t']*100:.1f}%",
+            "Top Topic":   _c["top_topic"],
+            "Engagement":  f"{_c['eng']['score']}/100 {_c['eng']['grade']}",
+        })
+    if _hth_rows:
+        st.dataframe(pd.DataFrame(_hth_rows), hide_index=True, use_container_width=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+    # ── Per-stream sentiment + topic + engagement cards ────────
+    chunk_size = 2
+    _cached_keys = [_s["redis_key"] for _s in active_streams if _s["redis_key"] in _stream_cache]
+    for row_start in range(0, len(_cached_keys), chunk_size):
+        row_keys = _cached_keys[row_start:row_start + chunk_size]
+        cols = st.columns(len(row_keys))
+        for col, _rkey in zip(cols, row_keys):
+            _c     = _stream_cache[_rkey]
+            _sidx  = _c["sidx"]
+            color  = STREAM_COLORS[_sidx]
+            slabel = STREAM_NAMES[_sidx]
+            _p, _n, _g, _t = _c["p"], _c["n"], _c["g"], _c["t"]
+            _eng   = _c["eng"]
+            _tc    = _c["tc"]
             with col:
                 st.markdown(
                     f'<span class="compare-label" style="background:{color}18;color:{color};border:1px solid {color}44;">'
-                    f'Stream {slabel} — {stream["redis_key"]}</span>',
+                    f'Stream {slabel} · {_c["title"][:25]}</span>',
                     unsafe_allow_html=True
                 )
-                st.plotly_chart(fig, width='stretch', config={"displayModeBar": False})
+                _ec = "#22c55e" if _eng["score"] >= 70 else "#eab308" if _eng["score"] >= 40 else "#ef4444"
                 st.markdown(
-                    f'<div style="font-size:0.78rem;color:var(--text-3);margin-bottom:8px;">'
-                    f'{t} msgs · <span style="color:#22c55e;">{p/t*100:.1f}% pos</span> · '
-                    f'<span style="color:#ef4444;">{g/t*100:.1f}% neg</span></div>',
+                    f'<div style="display:flex;gap:10px;margin:6px 0 10px;flex-wrap:wrap;">'
+                    f'<div style="background:var(--bg-card);border:1px solid {_ec}44;border-radius:12px;padding:8px 14px;">'
+                    f'<div style="font-size:1.4rem;font-weight:800;color:{_ec};">{_eng["score"]}</div>'
+                    f'<div style="font-size:0.68rem;color:var(--text-3);text-transform:uppercase;">Engagement</div>'
+                    f'</div>'
+                    f'<div style="background:var(--bg-card);border:1px solid var(--border);border-radius:12px;padding:8px 14px;">'
+                    f'<div style="font-size:1.4rem;font-weight:800;color:var(--text-1);">{_t}</div>'
+                    f'<div style="font-size:0.68rem;color:var(--text-3);text-transform:uppercase;">Messages</div>'
+                    f'</div>'
+                    f'<div style="background:var(--bg-card);border:1px solid var(--border);border-radius:12px;padding:8px 14px;">'
+                    f'<div style="font-size:1.4rem;font-weight:800;color:#22c55e;">{_p/_t*100:.0f}%</div>'
+                    f'<div style="font-size:0.68rem;color:var(--text-3);text-transform:uppercase;">Positive</div>'
+                    f'</div>'
+                    f'</div>',
                     unsafe_allow_html=True
                 )
-
-    # Overlay line chart — positive ratio over time for all streams
+                st.markdown('<div class="chart-wrap" style="margin-bottom:8px;">', unsafe_allow_html=True)
+                st.markdown('<div class="chart-title" style="font-size:0.78rem;">Sentiment</div>', unsafe_allow_html=True)
+                fig_s = go.Figure(go.Bar(
+                    x=["Pos", "Neu", "Neg"],
+                    y=[_p, _n, _g],
+                    marker_color=["#22c55e", "#eab308", "#ef4444"],
+                    marker_line_width=0,
+                    text=[_p, _n, _g],
+                    textposition="outside",
+                    hovertemplate="<b>%{x}</b>: %{y}<extra></extra>",
+                ))
+                fig_s.update_layout(**plotly_layout(180))
+                st.plotly_chart(fig_s, width='stretch', config={"displayModeBar": False})
+                st.markdown('</div>', unsafe_allow_html=True)
+                st.markdown('<div class="chart-wrap">', unsafe_allow_html=True)
+                st.markdown('<div class="chart-title" style="font-size:0.78rem;">Topic Breakdown</div>', unsafe_allow_html=True)
+                _tc_colors = ["#f59e0b","#3b82f6","#ec4899","#ef4444","#6b7280","#10b981"]
+                fig_t = go.Figure(go.Bar(
+                    x=TOPIC_LABELS,
+                    y=[_tc[l] for l in TOPIC_LABELS],
+                    marker_color=_tc_colors,
+                    marker_line_width=0,
+                    text=[_tc[l] for l in TOPIC_LABELS],
+                    textposition="outside",
+                    hovertemplate="<b>%{x}</b>: %{y}<extra></extra>",
+                ))
+                _tl = plotly_layout(180)
+                _tl["xaxis"]["tickfont"] = dict(size=8)
+                fig_t.update_layout(**_tl)
+                st.plotly_chart(fig_t, width='stretch', config={"displayModeBar": False})
+                st.markdown('</div>', unsafe_allow_html=True)
+
+    # ── Overlay: positive ratio over time (all streams) ────────
     st.markdown('<div class="chart-wrap" style="margin-top:14px;">', unsafe_allow_html=True)
-    st.markdown('<div class="chart-title">Positive Ratio Over Time</div><div class="chart-sub">Rolling positive % per stream</div>', unsafe_allow_html=True)
+    st.markdown('<div class="chart-title">Positive Ratio Over Time</div><div class="chart-sub">Rolling positive % per stream (synced refresh)</div>', unsafe_allow_html=True)
     fig_overlay = go.Figure()
-    for stream in active_streams:
-        sidx  = st.session_state.streams.index(stream)
-        color = STREAM_COLORS[sidx]
-        slabel = STREAM_NAMES[sidx]
-        s_data = load_stream_data(stream["redis_key"])
-        if not s_data:
-            continue
-        s_df = pd.DataFrame(s_data)
-        s_df["sentiment"] = s_df["sentiment"].apply(clean_sentiment)
-        s_df["is_pos"]    = (s_df["sentiment"] == "Positive").astype(int)
-        s_df["rolling"]   = s_df["is_pos"].rolling(10, min_periods=1).mean() * 100
+    for _rkey, _c in _stream_cache.items():
+        _sidx  = _c["sidx"]
+        color  = STREAM_COLORS[_sidx]
+        slabel = STREAM_NAMES[_sidx]
+        _sdf   = _c["df"].copy()
+        _sdf["is_pos"]  = (_sdf["sentiment"] == "Positive").astype(int)
+        _sdf["rolling"] = _sdf["is_pos"].rolling(10, min_periods=1).mean() * 100
         fig_overlay.add_trace(go.Scatter(
-            x=list(range(len(s_df))),
-            y=s_df["rolling"],
+            x=list(range(len(_sdf))),
+            y=_sdf["rolling"],
             mode="lines",
-            name=f"Stream {slabel}",
+            name=f"Stream {slabel} · {_c['title'][:20]}",
             line=dict(color=color, width=2),
             hovertemplate=f"Stream {slabel} msg %{{x}}: %{{y:.1f}}%<extra></extra>",
         ))
-    layout_ov = plotly_layout(200)
+    layout_ov = plotly_layout(220)
     layout_ov["showlegend"] = True
-    layout_ov["legend"] = dict(orientation="h", y=1.1, font=dict(size=11))
+    layout_ov["legend"] = dict(orientation="h", y=1.08, font=dict(size=11, color="#f1f5f9"))
     layout_ov["yaxis"]["range"] = [0, 100]
     fig_overlay.update_layout(**layout_ov)
     st.plotly_chart(fig_overlay, width='stretch', config={"displayModeBar": False})
@@ -1270,84 +2136,6 @@ if st.session_state.pinned_messages:
                 st.rerun()
 
 
-# ── LIVE CHAT FEED ────────────────────────────────────────────
-st.divider()
-st.markdown('<div class="sec-hdr"><span class="sec-ttl">Live Chat Feed</span></div>', unsafe_allow_html=True)
-
-f1, f2, f3 = st.columns([1, 1, 2])
-with f1:
-    sentiment_filter = st.selectbox("Sentiment", ["All", "Positive", "Neutral", "Negative"])
-with f2:
-    topic_filter = st.selectbox("Topic", ["All"] + TOPIC_LABELS)
-with f3:
-    search_term = st.text_input("Search messages", placeholder="Filter by keyword...")
-
-filtered = df.copy()
-if sentiment_filter != "All":
-    filtered = filtered[filtered["sentiment"] == sentiment_filter]
-if topic_filter != "All":
-    filtered = filtered[filtered["topic"] == topic_filter]
-if search_term:
-    filtered = filtered[filtered["text"].str.contains(search_term, case=False, na=False)]
-
-feed_hdr, feed_dl = st.columns([3, 1])
-with feed_hdr:
-    st.markdown(
-        f'<div style="font-size:0.78rem;color:var(--text-3);margin-bottom:12px;">Showing {len(filtered)} of {len(df)} messages</div>',
-        unsafe_allow_html=True
-    )
-with feed_dl:
-    if not filtered.empty:
-        export_cols = [c for c in ["author", "text", "sentiment", "confidence", "topic", "time"] if c in filtered.columns]
-        csv_download(filtered[export_cols], "Download Feed CSV", "chat_feed.csv")
-
-SENT_ICON = {"Positive": "🟢", "Negative": "🔴", "Neutral": "🟡"}
-
-# Build a set of pinned texts for quick lookup
-pinned_texts = {m.get("text", "") for m in st.session_state.pinned_messages}
-
-for i, (_, row) in enumerate(filtered.iloc[::-1].iterrows()):
-    s          = row.get("sentiment", "Neutral")
-    conf_pct   = int(row.get("confidence", 0) * 100)
-    topic      = clean_topic(row.get("topic", "General"))
-    t_color    = TOPIC_COLOR.get(topic, "#6b7280")
-    s_color    = SENT_COLORS.get(s, "#6b7280")
-    s_icon     = SENT_ICON.get(s, "⚪")
-    conf_color = "#22c55e" if conf_pct >= 70 else "#eab308" if conf_pct >= 40 else "#ef4444"
-    msg_text   = row.get("text", "")
-    is_pinned  = msg_text in pinned_texts
-
-    card_class = f"chat-card chat-{s.lower()}" + (" chat-pinned" if is_pinned else "")
-
-    msg_col, pin_col = st.columns([11, 1])
-    with msg_col:
-        st.markdown(
-            f'<div class="{card_class}">'
-            f'<div class="chat-author">{s_icon} {row.get("author", "Unknown")}'
-            + (' <span style="font-size:0.7rem;color:#eab308;">📌</span>' if is_pinned else '') +
-            f'</div>'
-            f'<div class="chat-text">{msg_text}</div>'
-            f'<div class="chat-badges">'
-            f'<span class="badge" style="color:{s_color};border-color:{s_color}33;">{s}</span>'
-            f'<span class="badge" style="color:{conf_color};">Confidence: {conf_pct}%</span>'
-            f'<span class="badge" style="color:{t_color};border-color:{t_color}33;">{topic}</span>'
-            f'</div></div>',
-            unsafe_allow_html=True
-        )
-    with pin_col:
-        if is_pinned:
-            if st.button("📌", key=f"unpin_feed_{i}", help="Unpin this message"):
-                st.session_state.pinned_messages = [
-                    m for m in st.session_state.pinned_messages if m.get("text") != msg_text
-                ]
-                st.rerun()
-        else:
-            if st.button("📍", key=f"pin_{i}", help="Pin this message"):
-                msg_dict = row.to_dict()
-                if msg_dict not in st.session_state.pinned_messages:
-                    st.session_state.pinned_messages.append(msg_dict)
-                st.rerun()
-
 # ── AUTO REFRESH ──────────────────────────────────────────────
 if auto_refresh:
     time.sleep(refresh_rate)