Fixing deployment issues:

Transferring files from visualization directory to the root and modifying paths.

app.py

@@ -1,26 +1,308 @@
 """
-HuggingFace Space Entry Point
-This file serves as the entry point for the HuggingFace Space,
-redirecting to the visualization app.
+AI Messaging System - Visualization Tool
+Main entry point with authentication and brand selection.
 """
 
+import streamlit as st
 import sys
 from pathlib import Path
+from dotenv import load_dotenv
 
-# Get directories
-root_dir = Path(__file__).parent
-visualization_dir = root_dir / "visualization"
+# Load environment variables from .env file FIRST
+env_path = Path(__file__).parent / '.env'
+if env_path.exists():
+    load_dotenv(env_path)
 
-# Add both directories to Python path
-sys.path.insert(0, str(root_dir))
-sys.path.insert(0, str(root_dir / "ai_messaging_system_v2"))
-sys.path.insert(0, str(visualization_dir))
+# Add root directory to path (for ai_messaging_system_v2 imports)
+sys.path.insert(0, str(Path(__file__).parent))
 
-# Import and run the visualization app
-import importlib.util
+from utils.auth import verify_login, check_authentication, get_current_user, logout
+from utils.theme import apply_theme, get_brand_emoji, get_brand_theme
+from utils.data_loader import DataLoader
 
-# Load the visualization app module
-app_path = visualization_dir / "app.py"
-spec = importlib.util.spec_from_file_location("visualization_app", app_path)
-visualization_app = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(visualization_app)
+# Page configuration
+st.set_page_config(
+    page_title="AI Messaging System - Visualization",
+    page_icon="🎵",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Initialize session state
+def init_session_state():
+    """Initialize session state variables."""
+    defaults = {
+        "authenticated": False,
+        "user_email": "",
+        "selected_brand": None,
+        "current_experiment_id": None,
+    }
+    for key, value in defaults.items():
+        if key not in st.session_state:
+            st.session_state[key] = value
+
+
+init_session_state()
+
+# Authentication check
+if not check_authentication():
+    # Show login page
+    st.title("🔐 AI Messaging System - Login")
+
+    st.markdown("""
+    Welcome to the **AI Messaging System Visualization Tool**!
+
+    This tool enables you to:
+    - 🏗️ Build and configure message campaigns
+    - 👀 Visualize generated messages across all stages
+    - 📊 Analyze performance and provide feedback
+    - 🧪 Run A/B tests to compare different approaches
+
+    ---
+
+    **Access is restricted to authorized team members only.**
+    Please enter your credentials below.
+    """)
+
+    with st.form("login_form"):
+        email = st.text_input("📧 Email Address", placeholder="your.name@musora.com")
+        token = st.text_input("🔑 Access Token", type="password", placeholder="Enter your access token")
+        submit = st.form_submit_button("🚀 Login", use_container_width=True)
+
+    if submit:
+        if verify_login(email, token):
+            st.session_state.authenticated = True
+            st.session_state.user_email = email
+            st.success("✅ Login successful! Redirecting...")
+            st.rerun()
+        else:
+            st.error("❌ Invalid email or access token. Please try again.")
+
+    st.stop()
+
+# User is authenticated - show main app
+# Apply base theme initially
+apply_theme("base")
+
+# Sidebar - Brand Selection
+with st.sidebar:
+    st.title("🎵 AI Messaging System")
+
+    st.markdown(f"**Logged in as:** {get_current_user()}")
+
+    if st.button("🚪 Logout", use_container_width=True):
+        logout()
+        st.rerun()
+
+    st.markdown("---")
+
+    # Brand Selection
+    st.subheader("🎨 Select Brand")
+
+    brands = ["drumeo", "pianote", "guitareo", "singeo"]
+    brand_labels = {
+        "drumeo": "🥁 Drumeo",
+        "pianote": "🎹 Pianote",
+        "guitareo": "🎸 Guitareo",
+        "singeo": "🎤 Singeo"
+    }
+
+    # Get current brand from session state if exists
+    current_brand = st.session_state.get("selected_brand", brands[0])
+
+    selected_brand = st.selectbox(
+        "Brand",
+        brands,
+        index=brands.index(current_brand) if current_brand in brands else 0,
+        format_func=lambda x: brand_labels[x],
+        key="brand_selector",
+        label_visibility="collapsed"
+    )
+
+    # Update session state with selected brand
+    st.session_state.selected_brand = selected_brand
+
+    # Apply brand theme
+    if selected_brand:
+        apply_theme(selected_brand)
+
+    st.markdown("---")
+
+    # Navigation info
+    st.subheader("📖 Navigation")
+    st.markdown("""
+    Use the pages in the sidebar to navigate:
+    - **Campaign Builder**: Create campaigns & A/B tests
+    - **Message Viewer**: Review messages
+    - **Analytics**: View current performance
+    - **Historical Analytics**: Track improvements
+    """)
+
+# Main Content Area
+if not selected_brand:
+    st.title("🎵 Welcome to AI Messaging System")
+
+    st.markdown("""
+    ### Get Started
+
+    **Please select a brand from the sidebar to begin.**
+
+    Once you've selected a brand, you can:
+
+    1. **Build Campaigns** - Configure and generate personalized messages
+    2. **View Messages** - Browse and provide feedback on generated messages
+    3. **Run A/B Tests** - Compare different configurations side-by-side
+    4. **Analyze Results** - Review performance metrics and insights
+    """)
+
+    # Show feature cards
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("""
+        #### 🏗️ Campaign Builder
+        - Configure multi-stage campaigns
+        - Built-in A/B testing mode
+        - Parallel experiment processing
+        - Automatic experiment archiving
+        - Save custom configurations
+        """)
+
+        st.markdown("""
+        #### 👀 Message Viewer
+        - View all generated messages
+        - Side-by-side A/B comparison
+        - User-centric or stage-centric views
+        - Search and filter messages
+        - Provide detailed feedback
+        """)
+
+    with col2:
+        st.markdown("""
+        #### 📊 Analytics Dashboard
+        - Real-time performance metrics
+        - A/B test winner determination
+        - Rejection reason analysis
+        - Stage-by-stage performance
+        - Export capabilities
+        """)
+
+        st.markdown("""
+        #### 📚 Historical Analytics
+        - Track all past experiments
+        - Rejection rate trends over time
+        - Compare historical A/B tests
+        - Export historical data
+        """)
+
+else:
+    # Brand is selected - show brand-specific homepage
+    emoji = get_brand_emoji(selected_brand)
+    theme = get_brand_theme(selected_brand)
+
+    st.title(f"{emoji} {selected_brand.title()} - AI Messaging System")
+
+    st.markdown(f"""
+    ### Welcome to {selected_brand.title()} Message Generation!
+
+    You're all set to create personalized messages for {selected_brand.title()} users.
+    """)
+
+    # Quick stats
+    data_loader = DataLoader()
+
+    # Check if we have brand users
+    has_users = data_loader.has_brand_users(selected_brand)
+
+    # Check if we have generated messages
+    messages_df = data_loader.load_generated_messages()
+    has_messages = messages_df is not None and len(messages_df) > 0
+
+    st.markdown("---")
+
+    # Status cards
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.markdown("### 👥 Available Users")
+        if has_users:
+            user_count = data_loader.get_brand_user_count(selected_brand)
+            st.metric("Users Available", user_count)
+            st.success(f"✅ {user_count} users ready")
+        else:
+            st.metric("Users Available", 0)
+            st.info("ℹ️ No users available")
+
+    with col2:
+        st.markdown("### 📨 Generated Messages")
+        if has_messages:
+            stats = data_loader.get_message_stats()
+            st.metric("Total Messages", stats['total_messages'])
+            st.success(f"✅ {stats['total_stages']} stages")
+        else:
+            st.metric("Total Messages", 0)
+            st.info("ℹ️ No messages generated yet")
+
+    with col3:
+        st.markdown("### 🎯 Quick Actions")
+        st.markdown("")  # spacing
+        if st.button("🏗️ Build Campaign", use_container_width=True):
+            st.switch_page("pages/1_Campaign_Builder.py")
+        if has_messages:
+            if st.button("👀 View Messages", use_container_width=True):
+                st.switch_page("pages/2_Message_Viewer.py")
+
+    st.markdown("---")
+
+    # Getting started guide
+    st.markdown("### 🚀 Quick Start Guide")
+
+    st.markdown("""
+    #### Step 1: Build a Campaign
+    Navigate to **Campaign Builder** to:
+    - Toggle A/B testing mode on/off as needed
+    - Select number of users to experiment with (1-25)
+    - Configure campaign stages (or two experiments side-by-side)
+    - Set LLM models and instructions
+    - Generate personalized messages with automatic archiving
+
+    #### Step 2: Review Messages
+    Go to **Message Viewer** to:
+    - Browse all generated messages
+    - View A/B tests side-by-side automatically
+    - Switch between user-centric and stage-centric views
+    - Provide detailed feedback with rejection reasons
+    - Track message headers and content
+
+    #### Step 3: Analyze Performance
+    Check **Analytics Dashboard** for:
+    - Real-time approval and rejection rates
+    - A/B test comparisons with winner determination
+    - Common rejection reasons with visual charts
+    - Stage-by-stage performance insights
+    - Export analytics data
+
+    #### Step 4: Track Improvements
+    View **Historical Analytics** to:
+    - See all past experiments over time
+    - Identify rejection rate trends
+    - Compare historical A/B tests
+    - Export comprehensive historical data
+    """)
+
+    st.markdown("---")
+
+    # Tips
+    with st.expander("💡 Tips & Best Practices"):
+        st.markdown("""
+        - **User Selection**: Select 1-25 users for quick experimentation
+        - **Configuration Templates**: Start with default configurations and customize as needed
+        - **A/B Testing**: Enable A/B mode in Campaign Builder to compare two configurations in parallel
+        - **Feedback**: Reject poor messages with specific categories including the new 'Similar To Previous' option
+        - **Historical Tracking**: Check Historical Analytics regularly to track improvements over time
+        - **Stage Design**: Each stage should build upon previous stages with varied messaging approaches
+        - **Automatic Archiving**: Previous experiments are automatically archived when you start a new one
+        """)
+
+st.markdown("---")
+st.markdown("**Built with ❤️ for the Musora team**")

data/UI_users/drumeo_users.csv

@@ -0,0 +1,101 @@
+USER_ID
+668594
+268920
+223559
+830729
+356828
+703749
+840761
+773120
+847327
+566765
+843750
+825806
+551310
+924846
+655113
+576751
+334867
+691463
+680767
+812160
+164216
+881978
+539894
+566222
+660036
+531101
+591381
+876151
+596577
+910512
+395956
+173257
+792254
+911568
+914399
+903638
+736051
+675660
+892433
+346547
+824636
+774712
+488145
+688315
+546326
+610623
+560107
+356255
+757824
+826319
+272269
+919799
+670740
+919348
+324493
+284107
+772112
+821339
+433101
+705894
+775898
+922718
+627434
+811134
+922432
+922696
+934924
+158386
+488116
+167704
+721421
+785019
+831724
+928899
+911985
+911041
+552685
+391892
+265614
+916134
+402573
+900149
+717562
+161665
+389376
+509974
+913237
+760712
+415475
+346652
+604378
+817870
+698502
+904044
+931916
+662869
+837947
+666152
+367181
+510852

data/UI_users/guitareo_users.csv

@@ -0,0 +1,101 @@
+USER_ID
+157715
+911553
+156907
+694766
+914407
+158017
+157707
+931216
+157275
+157049
+762379
+922989
+894939
+156233
+445299
+893526
+502852
+412696
+524379
+934803
+533843
+918486
+326346
+825138
+510105
+836199
+903763
+847337
+920186
+367515
+464147
+876953
+820530
+483932
+804270
+652888
+611387
+901114
+161990
+858049
+504479
+793688
+596030
+856499
+830288
+905807
+737373
+801123
+936207
+161806
+844885
+156673
+156417
+166828
+157214
+163682
+157637
+815647
+445428
+848726
+345886
+645329
+908931
+157569
+900579
+161677
+898048
+429111
+902004
+161816
+676947
+160755
+921572
+453858
+548274
+922381
+825297
+720840
+449753
+504742
+157789
+162667
+920329
+157258
+739976
+641480
+157176
+565814
+870217
+574774
+420668
+344602
+918695
+174797
+270977
+903413
+157324
+158234
+156592
+491409

data/UI_users/pianote_users.csv

@@ -0,0 +1,101 @@
+USER_ID
+901462
+663534
+925578
+808019
+727360
+907785
+903125
+358505
+903293
+926435
+577983
+640044
+871545
+689297
+839797
+838978
+894404
+388259
+742545
+875618
+906682
+156360
+615274
+496647
+837649
+819147
+762360
+667066
+922040
+165396
+491498
+643639
+388015
+876565
+391879
+451960
+508244
+426511
+401073
+869259
+522076
+631399
+428081
+867206
+815870
+458726
+547732
+554044
+364525
+825266
+844418
+818026
+751982
+356018
+345635
+427868
+586083
+166330
+825075
+343531
+843298
+558798
+352221
+558176
+813053
+386914
+154237
+362024
+855589
+807289
+307320
+623466
+825321
+605229
+348870
+388261
+519602
+153096
+586282
+716526
+401891
+874652
+834192
+732481
+508825
+859490
+519051
+482569
+518170
+541203
+421310
+550180
+406176
+520979
+593825
+549999
+483788
+841717
+703563
+364690

data/UI_users/singeo_users.csv

@@ -0,0 +1,101 @@
+USER_ID
+397959
+807871
+532351
+344867
+491564
+687686
+912997
+757896
+475186
+559116
+476436
+430839
+929828
+546602
+660403
+809863
+930638
+308771
+156181
+832580
+642142
+484262
+672837
+723502
+735251
+440691
+676900
+891419
+912102
+605067
+727808
+449959
+295615
+934452
+932834
+631715
+933185
+247877
+550753
+841927
+795745
+555274
+679834
+675272
+911688
+689022
+414410
+502875
+649091
+540841
+616322
+761625
+534677
+830290
+870293
+510636
+932700
+533364
+540891
+584369
+739290
+914907
+934815
+760925
+411509
+420037
+566575
+667578
+483362
+787773
+164176
+876127
+344023
+634693
+365543
+160559
+474363
+675851
+934109
+563890
+875101
+768715
+405549
+509855
+615509
+800896
+901230
+444234
+152323
+610485
+628039
+854271
+503894
+339113
+441986
+721231
+486789
+807279
+749298
+923577

data/configs/drumeo_re_engagement_test.json

@@ -0,0 +1,193 @@
+{
+  "brand": "drumeo",
+  "campaign_type": "re_engagement",
+  "campaign_name": "UI-Test-Campaign-Re-engagement",
+  "campaign_instructions": "Keep messages encouraging and motivational. Focus on getting users excited about practicing.",
+  "1": {
+    "stage": 1,
+    "model": "gpt-5-nano",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: Your next lesson is waiting 👇 \n Message: Check it out now and improve your playing!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "2": {
+    "stage": 2,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: It's a great day to play 🤩,\n Message: It's been a few days — warm up with a quick lesson!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "3": {
+    "stage": 3,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: Practice makes progress 💪, \nMessage: You don't need to be perfect. But you do need practice to reach your goals!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "4": {
+    "stage": 4,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: Never stop learning, \nMessage: Take a lesson today and get back on track!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "5": {
+    "stage": 5,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: Get back on track ⏱️\nMessage: It's been two weeks since your last practice session. Take a lesson today!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "6": {
+    "stage": 6,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: Keep on going!\nMessage: Get back to playing today. It only takes a few minutes!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "7": {
+    "stage": 7,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: Ready to play? 🎸\nMessage: Let's get started. Time for a quick practice session!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "8": {
+    "stage": 8,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: Your lesson's waiting. 📥\nMessage: We want to hear you play! Dive in today.",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "9": {
+    "stage": 9,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: Time for a comeback!\nMessage: We haven't seen you in 25 days. This will help get you back into the groove!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "10": {
+    "stage": 10,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: Have you been practicing?\nMessage: You're very talented. We'd love to hear you play again!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  },
+  "11": {
+    "stage": 11,
+    "model": "gemini-2.5-flash-lite",
+    "personalization": true,
+    "involve_recsys_result": true,
+    "recsys_contents": [
+      "workout",
+      "course",
+      "quick_tips"
+    ],
+    "specific_content_id": null,
+    "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+    "instructions": "",
+    "sample_examples": "Header: We Miss You 😔Message: All your lessons will just be here when you get back!",
+    "identifier_column": "user_id",
+    "platform": "push"
+  }
+}

data/configs/guitareo_re_engagement_test.json

@@ -0,0 +1,116 @@
+{
+        "campaign_name": "UI-Test-Campaign-Re-engagement",
+        "brand": "guitareo",
+        "campaign_instructions": "Keep messages encouraging and motivational. Focus on getting users excited about practicing.",
+
+        "1": {
+            "identifier_column": "user_id",
+            "stage": 1,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Your next lesson is waiting 👇 \n Message: Check it out now and improve your playing!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "2": {
+            "identifier_column": "user_id",
+            "stage": 2,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: It's a great day to play 🤩,\n Message: It's been a few days — warm up with a quick lesson!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "3": {
+            "identifier_column": "user_id",
+            "stage": 3,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Practice makes progress 💪, \nMessage: You don't need to be perfect. But you do need practice to reach your goals!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "4": {
+            "identifier_column": "user_id",
+            "stage": 4,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Never stop learning, \nMessage: Take a lesson today and get back on track!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "5": {
+            "identifier_column": "user_id",
+            "stage": 5,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Get back on track ⏱️\nMessage: It's been two weeks since your last practice session. Take a lesson today!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "6": {
+            "identifier_column": "user_id",
+            "stage": 6,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Keep on going!\nMessage: Get back to playing today. It only takes a few minutes!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "7": {
+            "identifier_column": "user_id",
+            "stage": 7,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Ready to play? 🎸\nMessage: Let's get started. Time for a quick practice session!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "8": {
+            "identifier_column": "user_id",
+            "stage": 8,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Your lesson's waiting. 📥\nMessage: We want to hear you play! Dive in today.",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "9": {
+            "identifier_column": "user_id",
+            "stage": 9,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Time for a comeback!\nMessage: We haven't seen you in 25 days. This will help get you back into the groove!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "10": {
+            "identifier_column": "user_id",
+            "stage": 10,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Have you been practicing?\nMessage: You're very talented. We'd love to hear you play again!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "11": {
+            "identifier_column": "user_id",
+            "stage": 11,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: We Miss You 😔Message: All your lessons will just be here when you get back!",
+            "model": "gemini-2.5-flash-lite"
+        }
+    }

data/configs/pianote_re_engagement_test.json

@@ -0,0 +1,116 @@
+{
+        "campaign_name": "UI-Test-Campaign-Re-engagement",
+        "brand": "pianote",
+        "campaign_instructions": "Keep messages encouraging and motivational. Focus on getting users excited about practicing.",
+
+        "1": {
+            "identifier_column": "user_id",
+            "stage": 1,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Your next lesson is waiting 👇 \n Message: Check it out now and improve your playing!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "2": {
+            "identifier_column": "user_id",
+            "stage": 2,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: It's a great day to play 🤩,\n Message: It's been a few days — warm up with a quick lesson!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "3": {
+            "identifier_column": "user_id",
+            "stage": 3,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Practice makes progress 💪, \nMessage: You don't need to be perfect. But you do need practice to reach your goals!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "4": {
+            "identifier_column": "user_id",
+            "stage": 4,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Never stop learning, \nMessage: Take a lesson today and get back on track!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "5": {
+            "identifier_column": "user_id",
+            "stage": 5,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Get back on track ⏱️\nMessage: It's been two weeks since your last practice session. Take a lesson today!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "6": {
+            "identifier_column": "user_id",
+            "stage": 6,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Keep on going!\nMessage: Get back to playing today. It only takes a few minutes!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "7": {
+            "identifier_column": "user_id",
+            "stage": 7,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Ready to play? 🎸\nMessage: Let's get started. Time for a quick practice session!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "8": {
+            "identifier_column": "user_id",
+            "stage": 8,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Your lesson's waiting. 📥\nMessage: We want to hear you play! Dive in today.",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "9": {
+            "identifier_column": "user_id",
+            "stage": 9,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Time for a comeback!\nMessage: We haven't seen you in 25 days. This will help get you back into the groove!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "10": {
+            "identifier_column": "user_id",
+            "stage": 10,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Have you been practicing?\nMessage: You're very talented. We'd love to hear you play again!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "11": {
+            "identifier_column": "user_id",
+            "stage": 11,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: We Miss You 😔Message: All your lessons will just be here when you get back!",
+            "model": "gemini-2.5-flash-lite"
+        }
+    }

data/configs/singeo_re_engagement_test.json

@@ -0,0 +1,116 @@
+{
+        "campaign_name": "UI-Test-Campaign-Re-engagement",
+        "brand": "singeo",
+        "campaign_instructions": "Keep messages encouraging and motivational. Focus on getting users excited about practicing.",
+
+        "1": {
+            "identifier_column": "user_id",
+            "stage": 1,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Your next lesson is waiting 👇 \n Message: Check it out now and improve your singing!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "2": {
+            "identifier_column": "user_id",
+            "stage": 2,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: It's a great day to sing 🤩,\n Message: It's been a few days — warm up with a quick lesson!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "3": {
+            "identifier_column": "user_id",
+            "stage": 3,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Practice makes progress 💪, \nMessage: You don't need to be perfect. But you do need practice to reach your goals!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "4": {
+            "identifier_column": "user_id",
+            "stage": 4,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Never stop learning, \nMessage: Take a lesson today and get back on track!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "5": {
+            "identifier_column": "user_id",
+            "stage": 5,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Get back on track ⏱️\nMessage: It's been two weeks since your last practice session. Take a lesson today!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "6": {
+            "identifier_column": "user_id",
+            "stage": 6,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Keep on going!\nMessage: Get back to singing today. It only takes a few minutes!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "7": {
+            "identifier_column": "user_id",
+            "stage": 7,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Ready to play? 🎸\nMessage: Let's get started. Time for a quick practice session!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "8": {
+            "identifier_column": "user_id",
+            "stage": 8,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Your lesson's waiting. 📥\nMessage: We want to hear you sing! Dive in today.",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "9": {
+            "identifier_column": "user_id",
+            "stage": 9,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Time for a comeback!\nMessage: We haven't seen you in 25 days. This will help get you back into the groove!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "10": {
+            "identifier_column": "user_id",
+            "stage": 10,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: Have you been practicing?\nMessage: You have a lovely voice. We'd love to hear it again!",
+            "model": "gemini-2.5-flash-lite"
+        },
+        "11": {
+            "identifier_column": "user_id",
+            "stage": 11,
+            "segment_info": "Students who haven't practiced and logged into the app after at least 3 days.",
+            "recsys_contents": ["workout", "course", "quick_tips"],
+            "involve_recsys_result": true,
+            "personalization": true,
+            "sample_examples": "Header: We Miss You 😔Message: All your lessons will just be here when you get back!",
+            "model": "gemini-2.5-flash-lite"
+        }
+    }

pages/1_Campaign_Builder.py

@@ -1,24 +1,1043 @@
 """
-Campaign Builder Page - HuggingFace Space Wrapper
-Redirects to the actual page in visualization/pages/
+Page 1: Campaign Builder
+Configure and run message generation campaigns with A/B testing support.
 """
 
+import streamlit as st
 import sys
 from pathlib import Path
+from datetime import datetime
+import json
+import threading
+import shutil
 
-# Set up paths
-root_dir = Path(__file__).parent.parent
-visualization_dir = root_dir / "visualization"
+# Add root directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
 
-# Add directories to path
-sys.path.insert(0, str(root_dir))
-sys.path.insert(0, str(root_dir / "ai_messaging_system_v2"))
-sys.path.insert(0, str(visualization_dir))
+from utils.auth import check_authentication
+from utils.theme import apply_theme, get_brand_emoji
+from utils.data_loader import DataLoader
+from utils.config_manager import ConfigManager
 
-# Import and run the actual page
-import importlib.util
+from ai_messaging_system_v2.Messaging_system.Permes import Permes
+from ai_messaging_system_v2.configs.config_loader import get_system_config
+from snowflake.snowpark import Session
+from dotenv import load_dotenv
+import os
 
-page_path = visualization_dir / "pages" / "1_Campaign_Builder.py"
-spec = importlib.util.spec_from_file_location("campaign_builder", page_path)
-campaign_builder = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(campaign_builder)
+# Load environment variables
+env_path = Path(__file__).parent.parent / '.env'
+if env_path.exists():
+    load_dotenv(env_path)
+
+# Page configuration
+st.set_page_config(
+    page_title="Campaign Builder",
+    page_icon="🏗️",
+    layout="wide"
+)
+
+# Check authentication
+if not check_authentication():
+    st.error("🔒 Please login first")
+    st.stop()
+
+# Initialize utilities
+data_loader = DataLoader()
+config_manager = ConfigManager()
+
+# Helper function to create Snowflake session
+def create_snowflake_session() -> Session:
+    """Create a Snowflake session using environment variables."""
+    conn_params = {
+        "user": os.getenv("SNOWFLAKE_USER"),
+        "password": os.getenv("SNOWFLAKE_PASSWORD"),
+        "account": os.getenv("SNOWFLAKE_ACCOUNT"),
+        "role": os.getenv("SNOWFLAKE_ROLE"),
+        "database": os.getenv("SNOWFLAKE_DATABASE"),
+        "warehouse": os.getenv("SNOWFLAKE_WAREHOUSE"),
+        "schema": os.getenv("SNOWFLAKE_SCHEMA"),
+    }
+    return Session.builder.configs(conn_params).create()
+
+# Check if brand is selected
+if "selected_brand" not in st.session_state or not st.session_state.selected_brand:
+    st.error("⚠️ Please select a brand from the home page first")
+    st.stop()
+
+brand = st.session_state.selected_brand
+apply_theme(brand)
+
+# Initialize session state
+if "ab_testing_mode" not in st.session_state:
+    st.session_state.ab_testing_mode = False
+if "campaign_config" not in st.session_state:
+    st.session_state.campaign_config = None
+if "campaign_config_a" not in st.session_state:
+    st.session_state.campaign_config_a = None
+if "campaign_config_b" not in st.session_state:
+    st.session_state.campaign_config_b = None
+if "selected_user_count" not in st.session_state:
+    st.session_state.selected_user_count = 5
+if "generation_complete" not in st.session_state:
+    st.session_state.generation_complete = False
+if "show_next_steps" not in st.session_state:
+    st.session_state.show_next_steps = False
+
+# Page Header
+emoji = get_brand_emoji(brand)
+st.title(f"🏗️ Campaign Builder - {emoji} {brand.title()}")
+st.markdown("**Configure and generate personalized message campaigns**")
+
+st.markdown("---")
+
+# ============================================================================
+# A/B TESTING TOGGLE
+# ============================================================================
+ab_col1, ab_col2 = st.columns([3, 1])
+
+with ab_col1:
+    st.subheader("🧪 Experiment Mode")
+    st.markdown("Toggle A/B testing to run two experiments in parallel with different configurations.")
+
+with ab_col2:
+    ab_testing_enabled = st.toggle(
+        "Enable A/B Testing",
+        value=st.session_state.ab_testing_mode,
+        help="Enable to run two experiments (A and B) in parallel"
+    )
+    st.session_state.ab_testing_mode = ab_testing_enabled
+
+st.markdown("---")
+
+# ============================================================================
+# HELPER FUNCTIONS FOR CONFIGURATION SECTIONS
+# ============================================================================
+
+def render_configuration_section(prefix: str, col_container, initial_config=None):
+    """
+    Render a configuration section (used for both single mode and A/B mode).
+
+    Args:
+        prefix: Prefix for session state keys (e.g., "single", "a", "b")
+        col_container: Streamlit container/column to render in
+        initial_config: Initial configuration to load
+
+    Returns:
+        Complete configuration dictionary
+    """
+    with col_container:
+        # Configuration template selection
+        st.subheader("📋 Configuration Template")
+
+        # Get available configurations
+        all_configs = config_manager.get_all_configs(brand)
+        config_names = list(all_configs.keys())
+
+        if len(config_names) == 0:
+            st.warning("No configurations available. Please check your setup.")
+            return None
+
+        selected_config_name = st.selectbox(
+            "Template",
+            config_names,
+            index=0 if "re_engagement_test" in config_names else 0,
+            help="Select a configuration template to start with",
+            key=f"{prefix}_config_select"
+        )
+
+        # Load selected configuration
+        if selected_config_name == "re_engagement_test":
+            loaded_config = config_manager.load_default_config(brand)
+        else:
+            loaded_config = config_manager.load_custom_config(brand, selected_config_name)
+
+        if loaded_config:
+            st.success(f"✅ Loaded: **{selected_config_name}**")
+
+            # Show config preview
+            # with st.expander("📄 View Configuration Details"):
+            #     st.json(loaded_config)
+
+        st.markdown("---")
+
+        # Campaign settings
+        st.subheader("⚙️ Campaign Settings")
+
+        campaign_name = st.text_input(
+            "Campaign Name",
+            value=loaded_config.get("campaign_name", f"UI-Campaign-{brand}"),
+            help="Name for this campaign",
+            key=f"{prefix}_campaign_name"
+        )
+
+        col1, col2 = st.columns(2)
+
+        with col1:
+            campaign_type = st.selectbox(
+                "Campaign Type",
+                ["re_engagement"],
+                help="Type of campaign",
+                key=f"{prefix}_campaign_type"
+            )
+
+        with col2:
+            num_stages = st.number_input(
+                "Number of Stages",
+                min_value=1,
+                max_value=11,
+                value=min(3, len([k for k in loaded_config.keys() if k.isdigit()])),
+                help="Number of message stages (1-11)",
+                key=f"{prefix}_num_stages"
+            )
+
+        campaign_instructions = st.text_area(
+            "Campaign-Wide Instructions (Optional)",
+            value=loaded_config.get("campaign_instructions", ""),
+            height=80,
+            help="Instructions applied to all stages",
+            key=f"{prefix}_campaign_instructions"
+        )
+
+        st.markdown("---")
+
+        # Stage configuration
+        st.subheader("📝 Stage Configuration")
+
+        # Load system config for model options
+        system_config = get_system_config()
+        available_models = system_config.get("openai_models", []) + system_config.get("google_models", [])
+
+        stages_config = {}
+
+        for stage_num in range(1, num_stages + 1):
+            with st.expander(f"Stage {stage_num} Configuration", expanded=(stage_num == 1)):
+                # Load existing stage config if available
+                existing_stage = loaded_config.get(str(stage_num), {})
+
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    model = st.selectbox(
+                        "LLM Model",
+                        available_models,
+                        index=available_models.index(existing_stage.get("model", available_models[0])) if existing_stage.get("model") in available_models else 0,
+                        key=f"{prefix}_model_{stage_num}",
+                        help="Language model to use for generation"
+                    )
+
+                    personalization = st.checkbox(
+                        "Enable Personalization",
+                        value=existing_stage.get("personalization", True),
+                        key=f"{prefix}_personalization_{stage_num}",
+                        help="Personalize messages based on user profile"
+                    )
+
+                    involve_recsys = st.checkbox(
+                        "Include Content Recommendation",
+                        value=existing_stage.get("involve_recsys_result", True),
+                        key=f"{prefix}_involve_recsys_{stage_num}",
+                        help="Include content recommendations in messages"
+                    )
+
+                with col2:
+                    recsys_contents = st.multiselect(
+                        "Recommendation Types",
+                        ["workout", "course", "quick_tips", "song"],
+                        default=existing_stage.get("recsys_contents", ["workout", "course"]),
+                        key=f"{prefix}_recsys_contents_{stage_num}",
+                        help="Types of content to recommend",
+                        disabled=not involve_recsys
+                    )
+
+                    specific_content_id = st.number_input(
+                        "Specific Content ID (Optional)",
+                        min_value=0,
+                        value=existing_stage.get("specific_content_id", 0) or 0,
+                        key=f"{prefix}_specific_content_id_{stage_num}",
+                        help="Force specific content for all users (leave 0 for AI recommendations)"
+                    )
+                    specific_content_id = specific_content_id if specific_content_id > 0 else None
+
+                segment_info = st.text_area(
+                    "Segment Description",
+                    value=existing_stage.get("segment_info", f"Users eligible for stage {stage_num}"),
+                    key=f"{prefix}_segment_info_{stage_num}",
+                    height=68,
+                    help="Description of the user segment"
+                )
+
+                instructions = st.text_area(
+                    "Stage-Specific Instructions (Optional)",
+                    value=existing_stage.get("instructions", ""),
+                    key=f"{prefix}_instructions_{stage_num}",
+                    height=80,
+                    help="Instructions specific to this stage"
+                )
+
+                sample_example = st.text_area(
+                    "Example Messages",
+                    value=existing_stage.get("sample_examples", "Header: Hi!\nMessage: Check this out!"),
+                    key=f"{prefix}_sample_example_{stage_num}",
+                    height=80,
+                    help="Example messages for the LLM to learn from"
+                )
+
+                # Store stage configuration
+                stages_config[stage_num] = {
+                    "stage": stage_num,
+                    "model": model,
+                    "personalization": personalization,
+                    "involve_recsys_result": involve_recsys,
+                    "recsys_contents": recsys_contents if involve_recsys else [],
+                    "specific_content_id": specific_content_id,
+                    "segment_info": segment_info,
+                    "instructions": instructions,
+                    "sample_examples": sample_example,
+                    "identifier_column": "user_id",
+                    "platform": "push"
+                }
+
+        # Create complete configuration
+        complete_config = config_manager.create_config_from_ui(
+            brand=brand,
+            campaign_name=campaign_name,
+            campaign_type=campaign_type,
+            num_stages=num_stages,
+            campaign_instructions=campaign_instructions,
+            stages_config=stages_config
+        )
+
+        # Validation
+        is_valid, error_msg = config_manager.validate_config(complete_config)
+
+        if not is_valid:
+            st.error(f"❌ Configuration Error: {error_msg}")
+        else:
+            st.success("✅ Configuration is valid")
+
+        return complete_config
+
+def render_save_config_section(prefix: str, col_container, config):
+    """Render save configuration section."""
+    with col_container:
+        st.subheader("💾 Save Configuration")
+
+        with st.form(f"{prefix}_save_config_form"):
+            new_config_name = st.text_input(
+                "Configuration Name",
+                placeholder="my-custom-config",
+                help="Enter a name to save this configuration"
+            )
+
+            save_button = st.form_submit_button("💾 Save Configuration", use_container_width=True)
+
+            if save_button and new_config_name:
+                if config:
+                    # Check if config already exists
+                    if config_manager.config_exists(brand, new_config_name):
+                        st.warning(f"⚠️ Configuration '{new_config_name}' already exists. It will be overwritten.")
+
+                    # Save configuration
+                    if config_manager.save_custom_config(brand, new_config_name, config):
+                        st.success(f"✅ Configuration saved as '{new_config_name}'")
+                    else:
+                        st.error("❌ Failed to save configuration")
+                else:
+                    st.error("❌ No configuration loaded")
+
+# ============================================================================
+# RENDER CONFIGURATION SECTIONS BASED ON MODE
+# ============================================================================
+
+if st.session_state.ab_testing_mode:
+    # A/B Testing Mode - Two Columns
+    st.header("🧪 A/B Testing Configuration")
+    st.info("Configure two different experiments (A and B) to run in parallel with the same users.")
+
+    col_a, col_b = st.columns(2)
+
+    # Initialize A/B configs with defaults if None
+    if st.session_state.campaign_config_a is None:
+        st.session_state.campaign_config_a = config_manager.load_default_config(brand)
+    if st.session_state.campaign_config_b is None:
+        st.session_state.campaign_config_b = config_manager.load_default_config(brand)
+
+    # Column A
+    with col_a:
+        st.markdown("### 🅰️ Experiment A")
+        with st.expander("Configuration A", expanded=True):
+            config_a = render_configuration_section("a", st.container(), st.session_state.campaign_config_a)
+            if config_a is not None:
+                st.session_state.campaign_config_a = config_a
+
+        with st.expander("Save Configuration A"):
+            if st.session_state.campaign_config_a:
+                render_save_config_section("a", st.container(), st.session_state.campaign_config_a)
+
+    # Column B
+    with col_b:
+        st.markdown("### 🅱️ Experiment B")
+        with st.expander("Configuration B", expanded=True):
+            config_b = render_configuration_section("b", st.container(), st.session_state.campaign_config_b)
+            if config_b is not None:
+                st.session_state.campaign_config_b = config_b
+
+        with st.expander("Save Configuration B"):
+            if st.session_state.campaign_config_b:
+                render_save_config_section("b", st.container(), st.session_state.campaign_config_b)
+
+else:
+    # Single Mode
+    # Initialize config with default if None
+    if st.session_state.campaign_config is None:
+        st.session_state.campaign_config = config_manager.load_default_config(brand)
+
+    with st.expander("📋 Configuration", expanded=True):
+        config = render_configuration_section("single", st.container(), st.session_state.campaign_config)
+        if config is not None:
+            st.session_state.campaign_config = config
+
+    # Save section outside the main config expander
+    with st.expander("💾 Save Configuration"):
+        if st.session_state.campaign_config:
+            render_save_config_section("single", st.container(), st.session_state.campaign_config)
+
+st.markdown("---")
+
+# ============================================================================
+# USER SELECTION SECTION
+# ============================================================================
+
+with st.expander("👥 User Selection", expanded=True):
+    st.subheader("👥 Select Number of Users")
+
+    # Check if brand users file exists
+    has_brand_users = data_loader.has_brand_users(brand)
+
+    if not has_brand_users:
+        st.error(f"❌ No user file found for {brand}. Please ensure {brand}_users.csv exists in visualization/data/UI_users/")
+    else:
+        # Get total available users
+        total_users = data_loader.get_brand_user_count(brand)
+
+        st.info(f"ℹ️ {total_users} users available for {brand}")
+
+        st.markdown("""
+        Choose how many users you want to experiment with. Users will be **randomly sampled** each time you generate messages.
+
+        For quick experimentation, we recommend **5-10 users**.
+        """)
+
+        col1, col2 = st.columns([2, 3])
+
+        with col1:
+            user_count = st.number_input(
+                "Number of Users",
+                min_value=1,
+                max_value=min(25, total_users),
+                value=st.session_state.selected_user_count,
+                help="Select 1-25 users for experimentation"
+            )
+
+            # Update session state
+            st.session_state.selected_user_count = user_count
+
+        with col2:
+            st.markdown("")
+            st.markdown("")
+            st.markdown(f"**Selected:** {user_count} user{'s' if user_count != 1 else ''}")
+            st.markdown(f"**Available:** {total_users} total users")
+
+        st.markdown("---")
+
+        # Preview sample button
+        if st.button("👀 Preview Random Sample", use_container_width=False):
+            sample_df = data_loader.sample_users_randomly(brand, user_count)
+            if sample_df is not None:
+                st.success(f"✅ Sampled {len(sample_df)} random users")
+                st.dataframe(sample_df, use_container_width=True)
+
+st.markdown("---")
+
+# ============================================================================
+# GENERATION SECTION
+# ============================================================================
+
+def archive_existing_messages(campaign_name: str):
+    """Archive existing messages.csv to a timestamped file."""
+    ui_output_path = data_loader.get_ui_output_path()
+    messages_file = ui_output_path / "messages.csv"
+
+    if messages_file.exists():
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M')
+        archive_name = f"messages_{campaign_name}_{timestamp}.csv"
+        archive_path = ui_output_path / archive_name
+
+        try:
+            shutil.copy2(messages_file, archive_path)
+            st.info(f"📦 Archived existing messages to: {archive_name}")
+            return True
+        except Exception as e:
+            st.warning(f"⚠️ Could not archive existing messages: {e}")
+            return False
+    return True
+
+def generate_messages_for_experiment(
+    experiment_name: str,
+    config: dict,
+    sampled_users_df,
+    output_suffix: str = None,
+    progress_container=None
+):
+    """
+    Generate messages for a single experiment.
+
+    Args:
+        experiment_name: Name of the experiment (e.g., "A" or "B")
+        config: Configuration dictionary
+        sampled_users_df: DataFrame of sampled users
+        output_suffix: Optional suffix for output filename (e.g., "_a" or "_b")
+        progress_container: Streamlit container for progress updates
+
+    Returns:
+        tuple: (success, total_messages_generated)
+    """
+    if progress_container is None:
+        progress_container = st
+
+    with progress_container:
+        st.markdown(f"### 📊 Experiment {experiment_name} Progress")
+
+        system_config = get_system_config()
+
+        # Setup Permes for message generation
+        permes = Permes()
+        original_output_file = permes.UI_OUTPUT_FILE
+        ui_experiment_id = None
+
+        if output_suffix:
+            # Generate experiment ID for timestamping and naming
+            experiment_timestamp = datetime.now().strftime('%Y%m%d_%H%M')
+            ui_experiment_id = f"messages_{output_suffix}_{brand}_{experiment_timestamp}"
+            # Keep this for backward compatibility (though it won't be used anymore)
+            permes.UI_OUTPUT_FILE = f"{ui_experiment_id}.csv"
+            st.info(f"💾 Results will be saved to: {ui_experiment_id}.csv")
+
+        # Get campaign-level configurations
+        campaign_name = config.get("campaign_name", "UI-Campaign")
+        campaign_instructions = config.get("campaign_instructions", None)
+        num_stages = len([k for k in config.keys() if k.isdigit()])
+
+        # Generate messages for each stage
+        total_messages_generated = 0
+        generation_successful = True
+
+        for stage in range(1, num_stages + 1):
+            st.markdown(f"#### Stage {stage} of {num_stages}")
+
+            progress_bar = st.progress(0)
+            status_text = st.empty()
+
+            status_text.text(f"Generating messages for stage {stage}...")
+
+            session = None
+            try:
+                session = create_snowflake_session()
+                progress_bar.progress(10)
+
+                # Get stage configuration
+                stage_config = config.get(str(stage), {})
+
+                if not stage_config:
+                    status_text.error(f"❌ Stage {stage}: Configuration not found")
+                    generation_successful = False
+                    if session:
+                        try:
+                            session.close()
+                        except:
+                            pass
+                    continue
+
+                # Extract stage parameters
+                model = stage_config.get("model", "gemini-2.5-flash-lite")
+                segment_info = stage_config.get("segment_info", "")
+                recsys_contents = stage_config.get("recsys_contents", [])
+                involve_recsys_result = stage_config.get("involve_recsys_result", True)
+                personalization = stage_config.get("personalization", True)
+                sample_example = stage_config.get("sample_examples", "")
+                per_message_instructions = stage_config.get("instructions", None)
+                specific_content_id = stage_config.get("specific_content_id", None)
+
+                progress_bar.progress(20)
+
+                # Call Permes to generate messages
+                users_message = permes.create_personalize_messages(
+                    session=session,
+                    model=model,
+                    users=sampled_users_df.copy(),
+                    brand=brand,
+                    config_file=system_config,
+                    segment_info=segment_info,
+                    involve_recsys_result=involve_recsys_result,
+                    identifier_column="user_id",
+                    recsys_contents=recsys_contents,
+                    sample_example=sample_example,
+                    campaign_name=campaign_name,
+                    personalization=personalization,
+                    stage=stage,
+                    test_mode=False,
+                    mode="ui",
+                    campaign_instructions=campaign_instructions,
+                    per_message_instructions=per_message_instructions,
+                    specific_content_id=specific_content_id,
+                    ui_experiment_id=ui_experiment_id
+                )
+
+                progress_bar.progress(100)
+
+                if users_message is not None and len(users_message) > 0:
+                    total_messages_generated += len(users_message)
+                    status_text.success(
+                        f"✅ Stage {stage}: Generated {len(users_message)} messages"
+                    )
+                else:
+                    status_text.warning(f"⚠️ Stage {stage}: No messages generated")
+                    generation_successful = False
+
+            except Exception as e:
+                progress_bar.progress(0)
+                status_text.error(f"❌ Stage {stage}: Error - {str(e)}")
+                generation_successful = False
+
+            finally:
+                if session:
+                    try:
+                        session.close()
+                    except:
+                        pass
+
+        # Restore original output file name
+        permes.UI_OUTPUT_FILE = original_output_file
+
+        return generation_successful, total_messages_generated
+
+def generate_messages_threaded(
+    experiment_name: str,
+    config: dict,
+    sampled_users_df,
+    output_suffix: str,
+    brand: str,
+    experiment_timestamp: str = None
+):
+    """
+    Generate messages for threading (no UI updates).
+
+    Args:
+        experiment_name: Name of the experiment (e.g., "A" or "B")
+        config: Configuration dictionary
+        sampled_users_df: DataFrame of sampled users
+        output_suffix: Suffix for output filename (e.g., "a" or "b")
+        brand: Brand name
+        experiment_timestamp: Shared timestamp for A/B test pairs
+
+    Returns:
+        dict: Results with 'success', 'total_messages', 'error', 'stages_completed'
+    """
+    result = {
+        'success': False,
+        'total_messages': 0,
+        'error': None,
+        'stages_completed': 0,
+        'stage_details': []
+    }
+
+    try:
+        system_config = get_system_config()
+
+        # Setup Permes for message generation
+        permes = Permes()
+        original_output_file = permes.UI_OUTPUT_FILE
+
+        # Use provided timestamp or generate new one
+        if experiment_timestamp is None:
+            experiment_timestamp = datetime.now().strftime('%Y%m%d_%H%M')
+
+        # Create experiment ID for UI mode
+        ui_experiment_id = f"messages_{output_suffix}_{brand}_{experiment_timestamp}"
+        # Keep this for backward compatibility (though it won't be used anymore)
+        permes.UI_OUTPUT_FILE = f"{ui_experiment_id}.csv"
+
+        # Get campaign-level configurations
+        campaign_name = config.get("campaign_name", "UI-Campaign")
+        campaign_instructions = config.get("campaign_instructions", None)
+        num_stages = len([k for k in config.keys() if k.isdigit()])
+
+        # Generate messages for each stage
+        for stage in range(1, num_stages + 1):
+            session = None
+            try:
+                session = create_snowflake_session()
+
+                # Get stage configuration
+                stage_config = config.get(str(stage), {})
+
+                if not stage_config:
+                    result['stage_details'].append({
+                        'stage': stage,
+                        'status': 'error',
+                        'message': 'Configuration not found',
+                        'count': 0
+                    })
+                    continue
+
+                # Extract stage parameters
+                model = stage_config.get("model", "gemini-2.5-flash-lite")
+                segment_info = stage_config.get("segment_info", "")
+                recsys_contents = stage_config.get("recsys_contents", [])
+                involve_recsys_result = stage_config.get("involve_recsys_result", True)
+                personalization = stage_config.get("personalization", True)
+                sample_example = stage_config.get("sample_examples", "")
+                per_message_instructions = stage_config.get("instructions", None)
+                specific_content_id = stage_config.get("specific_content_id", None)
+
+                # Call Permes to generate messages
+                users_message = permes.create_personalize_messages(
+                    session=session,
+                    model=model,
+                    users=sampled_users_df.copy(),
+                    brand=brand,
+                    config_file=system_config,
+                    segment_info=segment_info,
+                    involve_recsys_result=involve_recsys_result,
+                    identifier_column="user_id",
+                    recsys_contents=recsys_contents,
+                    sample_example=sample_example,
+                    campaign_name=campaign_name,
+                    personalization=personalization,
+                    stage=stage,
+                    test_mode=False,
+                    mode="ui",
+                    campaign_instructions=campaign_instructions,
+                    per_message_instructions=per_message_instructions,
+                    specific_content_id=specific_content_id,
+                    ui_experiment_id=ui_experiment_id
+                )
+
+                if users_message is not None and len(users_message) > 0:
+                    result['total_messages'] += len(users_message)
+                    result['stages_completed'] += 1
+                    result['stage_details'].append({
+                        'stage': stage,
+                        'status': 'success',
+                        'message': f'Generated {len(users_message)} messages',
+                        'count': len(users_message)
+                    })
+                else:
+                    result['stage_details'].append({
+                        'stage': stage,
+                        'status': 'warning',
+                        'message': 'No messages generated',
+                        'count': 0
+                    })
+
+            except Exception as e:
+                result['stage_details'].append({
+                    'stage': stage,
+                    'status': 'error',
+                    'message': str(e),
+                    'count': 0
+                })
+
+            finally:
+                if session:
+                    try:
+                        session.close()
+                    except:
+                        pass
+
+        # Restore original output file name
+        permes.UI_OUTPUT_FILE = original_output_file
+
+        # Mark as successful if at least one stage completed
+        result['success'] = result['stages_completed'] > 0
+
+    except Exception as e:
+        result['error'] = str(e)
+        result['success'] = False
+
+    return result
+
+with st.expander("🚀 Generate Messages", expanded=True):
+    st.subheader("🚀 Generate Messages")
+
+    # Check prerequisites
+    if st.session_state.ab_testing_mode:
+        config_ready = (st.session_state.campaign_config_a is not None and
+                       st.session_state.campaign_config_b is not None)
+    else:
+        config_ready = st.session_state.campaign_config is not None
+
+    users_ready = data_loader.has_brand_users(brand)
+    user_count_selected = st.session_state.get("selected_user_count", 5)
+
+    # Status checks
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        if config_ready:
+            st.success("✅ Configuration ready")
+        else:
+            st.error("❌ Configuration not ready")
+
+    with col2:
+        if users_ready:
+            st.success(f"✅ {user_count_selected} users selected")
+        else:
+            st.error("❌ No users available")
+
+    with col3:
+        if st.session_state.ab_testing_mode:
+            st.metric("Mode", "A/B Testing")
+        else:
+            st.metric("Mode", "Single")
+
+    st.markdown("---")
+
+    if not config_ready:
+        st.info("👆 Please complete the configuration first")
+    elif not users_ready:
+        st.error("❌ No users available. Please check that user files exist.")
+    else:
+        # Generation settings
+        st.subheader("Generation Settings")
+
+        if st.session_state.ab_testing_mode:
+            num_stages_a = len([k for k in st.session_state.campaign_config_a.keys() if k.isdigit()])
+            num_stages_b = len([k for k in st.session_state.campaign_config_b.keys() if k.isdigit()])
+            st.info(f"ℹ️ Will generate messages for **{num_stages_a} stages (A)** and **{num_stages_b} stages (B)** in parallel")
+        else:
+            num_stages = len([k for k in st.session_state.campaign_config.keys() if k.isdigit()])
+            st.info(f"ℹ️ Will generate messages for **all {num_stages} stages** configured in the campaign")
+
+        # Clear previous results option
+        clear_previous = st.checkbox(
+            "Clear previous UI output before generating",
+            value=True,
+            help="Clear previous message results before generating new ones"
+        )
+
+        st.markdown("---")
+
+        # Generate button
+        if st.button("🚀 Start Generation", use_container_width=True, type="primary"):
+            # Reset next steps flag
+            st.session_state.show_next_steps = False
+            st.session_state.generation_complete = False
+
+            # Sample users randomly from the brand's user file
+            with st.spinner(f"Sampling {user_count_selected} random users from {brand}_users.csv..."):
+                sampled_users_df = data_loader.sample_users_randomly(brand, user_count_selected)
+
+                if sampled_users_df is None or len(sampled_users_df) == 0:
+                    st.error("❌ Failed to sample users. Please check your user files.")
+                    st.stop()
+
+                st.success(f"✅ Sampled {len(sampled_users_df)} users successfully")
+
+            # Archive existing messages before starting
+            if st.session_state.ab_testing_mode:
+                campaign_name_a = st.session_state.campaign_config_a.get("campaign_name", "Experiment_A")
+                archive_existing_messages(campaign_name_a)
+            else:
+                campaign_name = st.session_state.campaign_config.get("campaign_name", "Campaign")
+                archive_existing_messages(campaign_name)
+
+            # Clear previous output if requested
+            if clear_previous:
+                data_loader.clear_ui_output()
+
+            st.markdown("---")
+
+            if st.session_state.ab_testing_mode:
+                # A/B Testing Mode - Parallel Execution
+                st.markdown("## 🧪 Running A/B Tests in Parallel")
+                st.info("⏳ Generating messages for both experiments in parallel. This may take a few minutes...")
+
+                # Read configs from session state BEFORE starting threads
+                # (session state is not thread-safe when accessed from worker threads)
+                config_a = st.session_state.campaign_config_a
+                config_b = st.session_state.campaign_config_b
+
+                # Generate shared timestamp for both experiments (needed for A/B detection)
+                shared_timestamp = datetime.now().strftime('%Y%m%d_%H%M')
+
+                # Store results
+                results = {"a": None, "b": None}
+
+                def run_experiment_a(config, users_df, brand_name, timestamp):
+                    results["a"] = generate_messages_threaded(
+                        "A",
+                        config,
+                        users_df,
+                        "a",
+                        brand_name,
+                        timestamp
+                    )
+
+                def run_experiment_b(config, users_df, brand_name, timestamp):
+                    results["b"] = generate_messages_threaded(
+                        "B",
+                        config,
+                        users_df,
+                        "b",
+                        brand_name,
+                        timestamp
+                    )
+
+                # Start both threads with configs as arguments
+                thread_a = threading.Thread(target=run_experiment_a, args=(config_a, sampled_users_df, brand, shared_timestamp))
+                thread_b = threading.Thread(target=run_experiment_b, args=(config_b, sampled_users_df, brand, shared_timestamp))
+
+                thread_a.start()
+                thread_b.start()
+
+                # Show spinner while waiting
+                with st.spinner("Waiting for both experiments to complete..."):
+                    thread_a.join()
+                    thread_b.join()
+
+                st.markdown("---")
+
+                # Display results
+                st.markdown("## 📊 A/B Test Results")
+
+                col_a_result, col_b_result = st.columns(2)
+
+                # Experiment A Results
+                with col_a_result:
+                    st.markdown("### 🅰️ Experiment A")
+                    if results["a"]:
+                        result_a = results["a"]
+                        if result_a['error']:
+                            st.error(f"❌ Error: {result_a['error']}")
+                        elif result_a['success']:
+                            st.success(f"✅ Generated {result_a['total_messages']} messages")
+                            st.metric("Stages Completed", f"{result_a['stages_completed']}")
+
+                            # Show stage details
+                            with st.expander("View Stage Details"):
+                                for stage_detail in result_a['stage_details']:
+                                    if stage_detail['status'] == 'success':
+                                        st.success(f"Stage {stage_detail['stage']}: {stage_detail['message']}")
+                                    elif stage_detail['status'] == 'warning':
+                                        st.warning(f"Stage {stage_detail['stage']}: {stage_detail['message']}")
+                                    elif stage_detail['status'] == 'error':
+                                        st.error(f"Stage {stage_detail['stage']}: {stage_detail['message']}")
+                        else:
+                            st.warning(f"⚠️ Generation completed with issues")
+                            st.write(f"Messages: {result_a['total_messages']}")
+                    else:
+                        st.error("❌ No results available")
+
+                # Experiment B Results
+                with col_b_result:
+                    st.markdown("### 🅱️ Experiment B")
+                    if results["b"]:
+                        result_b = results["b"]
+                        if result_b['error']:
+                            st.error(f"❌ Error: {result_b['error']}")
+                        elif result_b['success']:
+                            st.success(f"✅ Generated {result_b['total_messages']} messages")
+                            st.metric("Stages Completed", f"{result_b['stages_completed']}")
+
+                            # Show stage details
+                            with st.expander("View Stage Details"):
+                                for stage_detail in result_b['stage_details']:
+                                    if stage_detail['status'] == 'success':
+                                        st.success(f"Stage {stage_detail['stage']}: {stage_detail['message']}")
+                                    elif stage_detail['status'] == 'warning':
+                                        st.warning(f"Stage {stage_detail['stage']}: {stage_detail['message']}")
+                                    elif stage_detail['status'] == 'error':
+                                        st.error(f"Stage {stage_detail['stage']}: {stage_detail['message']}")
+                        else:
+                            st.warning(f"⚠️ Generation completed with issues")
+                            st.write(f"Messages: {result_b['total_messages']}")
+                    else:
+                        st.error("❌ No results available")
+
+                # Create experiment record
+                experiment_id = f"{brand}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+                st.session_state.current_experiment_id = experiment_id
+
+                # Mark generation as complete
+                st.session_state.generation_complete = True
+                st.session_state.show_next_steps = True
+
+            else:
+                # Single Mode
+                success, total = generate_messages_for_experiment(
+                    "Single",
+                    st.session_state.campaign_config,
+                    sampled_users_df,
+                    output_suffix=None,
+                    progress_container=st.container()
+                )
+
+                st.markdown("---")
+
+                if success:
+                    st.success(f"✅ Generation complete! Generated {total} total messages.")
+                else:
+                    st.warning("⚠️ Generation completed with some errors. Please check the output above.")
+
+                # Create experiment record
+                experiment_id = f"{brand}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+                st.session_state.current_experiment_id = experiment_id
+
+            # Mark generation as complete
+            st.session_state.generation_complete = True
+            st.session_state.show_next_steps = True
+
+# Show next steps outside the generation button block (persists across reruns)
+if st.session_state.get("show_next_steps", False):
+    st.markdown("---")
+    st.subheader("📋 Next Steps")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        if st.button("👀 View Messages", use_container_width=True, key="view_messages_after_gen"):
+            st.switch_page("pages/2_Message_Viewer.py")
+
+    with col2:
+        if st.button("📊 View Analytics", use_container_width=True, key="view_analytics_after_gen"):
+            st.switch_page("pages/4_Analytics.py")
+
+# Show existing messages if any
+existing_messages = data_loader.load_generated_messages()
+
+if existing_messages is not None and len(existing_messages) > 0:
+    st.markdown("---")
+    st.subheader("📨 Existing Messages")
+
+    stats = data_loader.get_message_stats()
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.metric("Total Messages", stats['total_messages'])
+
+    with col2:
+        st.metric("Total Users", stats['total_users'])
+
+    with col3:
+        st.metric("Total Stages", stats['total_stages'])
+
+    if st.button("🗑️ Clear All Messages", use_container_width=False):
+        data_loader.clear_ui_output()
+        st.success("✅ All messages cleared")
+        st.rerun()
+
+st.markdown("---")
+st.markdown("**💡 Tip:** Use A/B testing to compare different configurations with the same users!")

pages/2_Message_Viewer.py

@@ -1,24 +1,812 @@
 """
-Message Viewer Page - HuggingFace Space Wrapper
-Redirects to the actual page in visualization/pages/
+Page 2: Message Viewer
+Browse, search, and evaluate generated messages with feedback system.
+Supports A/B testing mode for comparing two experiments side-by-side.
 """
 
+import streamlit as st
 import sys
 from pathlib import Path
+import json
+import pandas as pd
+import re
+from datetime import datetime
 
-# Set up paths
-root_dir = Path(__file__).parent.parent
-visualization_dir = root_dir / "visualization"
+# Add root directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
 
-# Add directories to path
-sys.path.insert(0, str(root_dir))
-sys.path.insert(0, str(root_dir / "ai_messaging_system_v2"))
-sys.path.insert(0, str(visualization_dir))
+from utils.auth import check_authentication
+from utils.theme import apply_theme, get_brand_emoji, create_badge
+from utils.data_loader import DataLoader
+from utils.feedback_manager import FeedbackManager
 
-# Import and run the actual page
-import importlib.util
+# Page configuration
+st.set_page_config(
+    page_title="Message Viewer",
+    page_icon="👀",
+    layout="wide"
+)
 
-page_path = visualization_dir / "pages" / "2_Message_Viewer.py"
-spec = importlib.util.spec_from_file_location("message_viewer", page_path)
-message_viewer = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(message_viewer)
+# Check authentication
+if not check_authentication():
+    st.error("🔒 Please login first")
+    st.stop()
+
+# Initialize utilities
+data_loader = DataLoader()
+feedback_manager = FeedbackManager()
+
+# Check if brand is selected
+if "selected_brand" not in st.session_state or not st.session_state.selected_brand:
+    st.error("⚠️ Please select a brand from the home page first")
+    st.stop()
+
+brand = st.session_state.selected_brand
+apply_theme(brand)
+
+# Helper functions for A/B testing
+def detect_ab_testing_files():
+    """
+    Detect if there are A/B testing files in the UI output directory.
+    Returns (is_ab_mode, messages_a_path, messages_b_path, timestamp)
+    """
+    ui_output_path = data_loader.get_ui_output_path()
+
+    # Check session state first
+    if st.session_state.get('ab_testing_mode', False):
+        # Look for files with pattern: messages_a_* and messages_b_*
+        a_files = list(ui_output_path.glob('messages_a_*.csv'))
+        b_files = list(ui_output_path.glob('messages_b_*.csv'))
+
+        if a_files and b_files:
+            # Find matching pairs by timestamp
+            for a_file in a_files:
+                # Extract timestamp from filename: messages_a_brand_variant_timestamp.csv
+                match_a = re.search(r'messages_a_.*_(\d{8}_\d{4})\.csv', a_file.name)
+                if match_a:
+                    timestamp = match_a.group(1)
+                    # Look for matching b file
+                    for b_file in b_files:
+                        if timestamp in b_file.name:
+                            return True, a_file, b_file, timestamp
+
+    # Also detect if files exist even if session state not set
+    ui_output_path = data_loader.get_ui_output_path()
+    a_files = list(ui_output_path.glob('messages_a_*.csv'))
+    b_files = list(ui_output_path.glob('messages_b_*.csv'))
+
+    if a_files and b_files:
+        # Auto-detect matching pairs
+        for a_file in a_files:
+            match_a = re.search(r'messages_a_.*_(\d{8}_\d{4})\.csv', a_file.name)
+            if match_a:
+                timestamp = match_a.group(1)
+                for b_file in b_files:
+                    if timestamp in b_file.name:
+                        return True, a_file, b_file, timestamp
+
+    return False, None, None, None
+
+
+def load_ab_test_messages(file_path):
+    """Load messages from A/B test file."""
+    try:
+        return pd.read_csv(file_path, encoding='utf-8-sig')
+    except Exception as e:
+        st.error(f"Error loading A/B test file: {e}")
+        return None
+
+
+def extract_experiment_id_from_filename(file_path):
+    """Extract experiment ID from A/B test filename."""
+    # Pattern: messages_a_brand_variant_timestamp.csv or messages_b_brand_variant_timestamp.csv
+    # Use the full filename (without .csv) to ensure A and B experiments have different IDs
+    filename = file_path.stem  # Removes .csv extension automatically
+    return filename
+
+
+# Page Header
+emoji = get_brand_emoji(brand)
+st.title(f"👀 Message Viewer - {emoji} {brand.title()}")
+st.markdown("**Browse and evaluate generated messages**")
+
+# Detect A/B testing mode
+is_ab_mode, messages_a_path, messages_b_path, ab_timestamp = detect_ab_testing_files()
+
+if is_ab_mode:
+    st.info(f"🔬 **A/B Testing Mode Active** - Comparing two experiments side-by-side (Timestamp: {ab_timestamp})")
+
+st.markdown("---")
+
+# Load messages based on mode
+if is_ab_mode:
+    # Load A/B test messages
+    messages_a_df = load_ab_test_messages(messages_a_path)
+    messages_b_df = load_ab_test_messages(messages_b_path)
+
+    if messages_a_df is None or len(messages_a_df) == 0 or messages_b_df is None or len(messages_b_df) == 0:
+        st.warning("⚠️ Error loading A/B test messages. Please check the files.")
+        if st.button("🏗️ Go to Campaign Builder"):
+            st.switch_page("pages/1_Campaign_Builder.py")
+        st.stop()
+
+    # Extract experiment IDs from filenames
+    experiment_a_id = extract_experiment_id_from_filename(messages_a_path)
+    experiment_b_id = extract_experiment_id_from_filename(messages_b_path)
+
+    messages_df = None  # Not used in AB mode
+else:
+    # Load regular messages
+    messages_df = data_loader.load_generated_messages()
+
+    if messages_df is None or len(messages_df) == 0:
+        st.warning("⚠️ No messages found. Please generate messages first in Campaign Builder.")
+        if st.button("🏗️ Go to Campaign Builder"):
+            st.switch_page("pages/1_Campaign_Builder.py")
+        st.stop()
+
+    # Get experiment ID from session state or create one
+    if "current_experiment_id" not in st.session_state or not st.session_state.current_experiment_id:
+        # Create experiment ID based on campaign name and timestamp
+        if 'campaign_name' in messages_df.columns and len(messages_df) > 0:
+            campaign_name = messages_df['campaign_name'].iloc[0]
+            experiment_id = campaign_name.replace(" ", "_")
+        else:
+            experiment_id = f"{brand}_experiment"
+
+        st.session_state.current_experiment_id = experiment_id
+
+    experiment_id = st.session_state.current_experiment_id
+    messages_a_df = None
+    messages_b_df = None
+    experiment_a_id = None
+    experiment_b_id = None
+
+# Sidebar - Filters and Settings
+with st.sidebar:
+    st.header("🔍 Filters & Settings")
+
+    # View mode
+    if is_ab_mode:
+        st.markdown("**View Mode (applies to both experiments)**")
+    view_mode = st.radio(
+        "View Mode",
+        ["User-Centric", "Stage-Centric"],
+        help="User-Centric: All stages for each user\nStage-Centric: All users for each stage"
+    )
+
+    st.markdown("---")
+
+    # Stage filter
+    if is_ab_mode:
+        # Get stages from both dataframes
+        stages_a = sorted(messages_a_df['stage'].unique()) if 'stage' in messages_a_df.columns else []
+        stages_b = sorted(messages_b_df['stage'].unique()) if 'stage' in messages_b_df.columns else []
+        available_stages = sorted(list(set(stages_a + stages_b)))
+    else:
+        available_stages = sorted(messages_df['stage'].unique()) if 'stage' in messages_df.columns else []
+
+    selected_stages = st.multiselect(
+        "Filter by Stage",
+        available_stages,
+        default=available_stages,
+        help="Select specific stages to view" + (" (applies to both experiments)" if is_ab_mode else "")
+    )
+
+    # Search
+    search_term = st.text_input(
+        "🔎 Search Messages",
+        placeholder="Enter keyword...",
+        help="Search for specific keywords in messages" + (" (applies to both experiments)" if is_ab_mode else "")
+    )
+
+    st.markdown("---")
+
+    # Display settings
+    st.subheader("⚙️ Display Settings")
+
+    show_feedback = st.checkbox(
+        "Show Feedback Options",
+        value=True,
+        help="Show reject button and feedback form"
+    )
+
+    messages_per_page = st.number_input(
+        "Messages per Page",
+        min_value=5,
+        max_value=100,
+        value=20,
+        help="Number of messages to display per page"
+    )
+
+# Filter messages
+if is_ab_mode:
+    # Filter both experiments
+    filtered_messages_a = messages_a_df.copy()
+    filtered_messages_b = messages_b_df.copy()
+
+    if selected_stages:
+        filtered_messages_a = filtered_messages_a[filtered_messages_a['stage'].isin(selected_stages)]
+        filtered_messages_b = filtered_messages_b[filtered_messages_b['stage'].isin(selected_stages)]
+
+    if search_term:
+        filtered_messages_a = data_loader.search_messages(filtered_messages_a, search_term)
+        filtered_messages_b = data_loader.search_messages(filtered_messages_b, search_term)
+
+    filtered_messages = None  # Not used in AB mode
+else:
+    filtered_messages = messages_df.copy()
+
+    if selected_stages:
+        filtered_messages = filtered_messages[filtered_messages['stage'].isin(selected_stages)]
+
+    if search_term:
+        filtered_messages = data_loader.search_messages(filtered_messages, search_term)
+
+    filtered_messages_a = None
+    filtered_messages_b = None
+
+# Summary stats
+st.subheader("📊 Summary")
+
+if is_ab_mode:
+    # Show stats for both experiments
+    st.markdown("##### Experiment A vs Experiment B")
+
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        st.metric("Total Messages (A)", len(filtered_messages_a))
+        st.metric("Total Messages (B)", len(filtered_messages_b))
+
+    with col2:
+        unique_users_a = filtered_messages_a['user_id'].nunique() if 'user_id' in filtered_messages_a.columns else 0
+        unique_users_b = filtered_messages_b['user_id'].nunique() if 'user_id' in filtered_messages_b.columns else 0
+        st.metric("Unique Users (A)", unique_users_a)
+        st.metric("Unique Users (B)", unique_users_b)
+
+    with col3:
+        unique_stages_a = filtered_messages_a['stage'].nunique() if 'stage' in filtered_messages_a.columns else 0
+        unique_stages_b = filtered_messages_b['stage'].nunique() if 'stage' in filtered_messages_b.columns else 0
+        st.metric("Stages (A)", unique_stages_a)
+        st.metric("Stages (B)", unique_stages_b)
+
+    with col4:
+        # Load feedback stats for both experiments
+        feedback_a_df = feedback_manager.load_feedback(experiment_a_id)
+        feedback_b_df = feedback_manager.load_feedback(experiment_b_id)
+
+        reject_count_a = 0
+        if feedback_a_df is not None and len(feedback_a_df) > 0:
+            reject_count_a = len(feedback_a_df[feedback_a_df['feedback_type'] == 'reject'])
+
+        reject_count_b = 0
+        if feedback_b_df is not None and len(feedback_b_df) > 0:
+            reject_count_b = len(feedback_b_df[feedback_b_df['feedback_type'] == 'reject'])
+
+        st.metric("Rejected (A)", reject_count_a)
+        st.metric("Rejected (B)", reject_count_b)
+else:
+    # Single experiment stats
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        st.metric("Total Messages", len(filtered_messages))
+
+    with col2:
+        unique_users = filtered_messages['user_id'].nunique() if 'user_id' in filtered_messages.columns else 0
+        st.metric("Unique Users", unique_users)
+
+    with col3:
+        unique_stages = filtered_messages['stage'].nunique() if 'stage' in filtered_messages.columns else 0
+        st.metric("Stages", unique_stages)
+
+    with col4:
+        # Load feedback stats
+        feedback_df = feedback_manager.load_feedback(experiment_id)
+        if feedback_df is not None and len(feedback_df) > 0:
+            reject_count = len(feedback_df[feedback_df['feedback_type'] == 'reject'])
+            st.metric("Rejected", reject_count)
+        else:
+            st.metric("Rejected", 0)
+
+st.markdown("---")
+
+# Helper function to parse message JSON
+def parse_message_content(message_str):
+    """Parse message JSON string and extract content."""
+    try:
+        if isinstance(message_str, str):
+            message_data = json.loads(message_str)
+        elif isinstance(message_str, dict):
+            message_data = message_str
+        else:
+            return None
+
+        # Handle different message formats
+        if isinstance(message_data, dict):
+            # Check for stage-keyed format: {"1": {"header": ..., "message": ...}}
+            if any(k.isdigit() for k in message_data.keys()):
+                # Extract messages from all stages
+                messages = []
+                for key in sorted(message_data.keys(), key=lambda x: int(x) if x.isdigit() else 0):
+                    if isinstance(message_data[key], dict):
+                        messages.append(message_data[key])
+                return messages
+            else:
+                # Single message format
+                return [message_data]
+        elif isinstance(message_data, list):
+            return message_data
+
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+    return None
+
+# Helper function to parse and display recommendation
+def parse_recommendation(rec_str):
+    """Parse recommendation JSON string and extract details."""
+    try:
+        if isinstance(rec_str, str):
+            rec_data = json.loads(rec_str)
+        elif isinstance(rec_str, dict):
+            rec_data = rec_str
+        else:
+            return None
+
+        if isinstance(rec_data, dict):
+            return rec_data
+
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+    return None
+
+def display_recommendation(recommendation):
+    """Display recommendation with thumbnail and link."""
+    if not recommendation:
+        return
+
+    rec_data = parse_recommendation(recommendation)
+
+    if rec_data:
+        # Extract recommendation details
+        title = rec_data.get('title', 'Recommended Content')
+        web_url = rec_data.get('web_url_path', '#')
+        thumbnail_url = rec_data.get('thumbnail_url', '')
+
+        # Create a clickable card with thumbnail
+        st.markdown("**📍 Recommended Content:**")
+
+        if thumbnail_url:
+            # Display thumbnail as clickable image
+            col1, col2 = st.columns([1, 2])
+
+            with col1:
+                st.image(thumbnail_url, use_container_width=True)
+
+            with col2:
+                st.markdown(f"**{title}**")
+                if web_url and web_url != '#':
+                    st.markdown(f"[🔗 View Content]({web_url})")
+        else:
+            # No thumbnail, just show title and link
+            st.markdown(f"**{title}**")
+            if web_url and web_url != '#':
+                st.markdown(f"[🔗 View Content]({web_url})")
+
+
+def display_user_centric_messages(filtered_df, exp_id, key_suffix, show_feedback_option, msgs_per_page):
+    """Display messages in user-centric view for a single experiment."""
+    if 'user_id' not in filtered_df.columns:
+        st.warning("No user_id column found in messages.")
+        return
+
+    unique_users = filtered_df['user_id'].unique()
+
+    # Pagination
+    total_users = len(unique_users)
+    users_per_page = msgs_per_page
+
+    if total_users > users_per_page:
+        page = st.number_input(
+            f"Page",
+            min_value=1,
+            max_value=(total_users // users_per_page) + 1,
+            value=1,
+            key=f"page_{key_suffix}"
+        )
+        start_idx = (page - 1) * users_per_page
+        end_idx = min(start_idx + users_per_page, total_users)
+        users_to_display = unique_users[start_idx:end_idx]
+
+        st.markdown(f"*Showing users {start_idx + 1}-{end_idx} of {total_users}*")
+    else:
+        users_to_display = unique_users
+
+    # Display each user
+    for user_id in users_to_display:
+        user_messages = filtered_df[filtered_df['user_id'] == user_id].sort_values('stage')
+
+        if len(user_messages) == 0:
+            continue
+
+        # Get user info from first message
+        first_msg = user_messages.iloc[0]
+        user_email = first_msg.get('email', 'N/A')
+        user_first_name = first_msg.get('first_name', 'N/A')
+
+        # User expander
+        with st.expander(f"👤 User {user_id} - {user_first_name} ({user_email})", expanded=False):
+            # User profile
+            st.markdown("##### 📋 User Profile")
+
+            profile_cols = st.columns(4)
+            profile_fields = ['first_name', 'country', 'instrument', 'subscription_status']
+
+            for idx, field in enumerate(profile_fields):
+                if field in first_msg:
+                    profile_cols[idx % 4].markdown(f"**{field.replace('_', ' ').title()}:** {first_msg[field]}")
+
+            st.markdown("---")
+
+            # Display all stages for this user
+            st.markdown("##### 📨 Messages Across All Stages")
+
+            for _, row in user_messages.iterrows():
+                stage = row['stage']
+
+                # Parse message content
+                message_content = parse_message_content(row.get('message', ''))
+
+                if message_content:
+                    # Find the message for this stage
+                    stage_message = None
+                    for msg in message_content:
+                        if isinstance(msg, dict):
+                            stage_message = msg
+                            break
+
+                    if stage_message:
+                        # Create message card
+                        st.markdown(f"**Stage {stage}**")
+
+                        msg_col1, msg_col2 = st.columns([4, 1])
+
+                        with msg_col1:
+                            header = stage_message.get('header', 'No header')
+                            message_text = stage_message.get('message', 'No message')
+
+                            st.markdown(f"**📧 Header:** {header}")
+                            st.markdown(f"**💬 Message:** {message_text}")
+
+                            # Show recommendation if available
+                            if 'thumbnail_url' in stage_message or 'web_url_path' in stage_message:
+                                rec_data = {
+                                    'title': stage_message.get('title', 'Recommended Content'),
+                                    'web_url_path': stage_message.get('web_url_path', '#'),
+                                    'thumbnail_url': stage_message.get('thumbnail_url', '')
+                                }
+                                display_recommendation(rec_data)
+                            elif 'recommendation' in row and pd.notna(row['recommendation']):
+                                display_recommendation(row['recommendation'])
+
+                        with msg_col2:
+                            # Feedback section
+                            if show_feedback_option:
+                                existing_feedback = feedback_manager.get_feedback_for_message(
+                                    exp_id, user_id, stage
+                                )
+
+                                if existing_feedback:
+                                    st.error("❌ Rejected")
+                                    if st.button(f"Undo", key=f"undo_{user_id}_{stage}_{key_suffix}"):
+                                        feedback_manager.delete_feedback(exp_id, user_id, stage)
+                                        st.rerun()
+                                else:
+                                    if st.button("🚫 Reject", key=f"reject_{user_id}_{stage}_{key_suffix}"):
+                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}"] = True
+                                        st.rerun()
+
+                        # Feedback form
+                        if st.session_state.get(f"show_feedback_form_{user_id}_{stage}_{key_suffix}", False):
+                            with st.form(f"feedback_form_{user_id}_{stage}_{key_suffix}"):
+                                st.markdown("**Why is this message rejected?**")
+
+                                rejection_reasons = feedback_manager.get_all_rejection_reasons()
+                                selected_reason = st.selectbox(
+                                    "Rejection Reason",
+                                    list(rejection_reasons.keys()),
+                                    format_func=lambda x: rejection_reasons[x],
+                                    key=f"reason_{user_id}_{stage}_{key_suffix}"
+                                )
+
+                                rejection_text = st.text_area(
+                                    "Additional Comments (Optional)",
+                                    key=f"text_{user_id}_{stage}_{key_suffix}"
+                                )
+
+                                col1, col2 = st.columns(2)
+
+                                with col1:
+                                    if st.form_submit_button("💾 Save", use_container_width=True):
+                                        feedback_manager.save_feedback(
+                                            experiment_id=exp_id,
+                                            user_id=user_id,
+                                            stage=stage,
+                                            feedback_type="reject",
+                                            rejection_reason=selected_reason,
+                                            rejection_text=rejection_text,
+                                            campaign_name=row.get('campaign_name'),
+                                            message_header=stage_message.get('header', 'N/A'),
+                                            message_body=stage_message.get('message', 'N/A')
+                                        )
+                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}"] = False
+                                        st.success("✅ Feedback saved")
+                                        st.rerun()
+
+                                with col2:
+                                    if st.form_submit_button("❌ Cancel", use_container_width=True):
+                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}"] = False
+                                        st.rerun()
+
+                        st.markdown("---")
+
+
+def display_stage_centric_messages(filtered_df, exp_id, key_suffix, show_feedback_option, msgs_per_page, stages_to_display):
+    """Display messages in stage-centric view for a single experiment."""
+    # Group by stage
+    for stage in sorted(stages_to_display if stages_to_display else filtered_df['stage'].unique()):
+        stage_messages = filtered_df[filtered_df['stage'] == stage]
+
+        if len(stage_messages) == 0:
+            continue
+
+        with st.expander(f"📨 Stage {stage} - {len(stage_messages)} messages", expanded=(stage == 1)):
+            st.markdown(f"##### Stage {stage} Messages")
+
+            # Pagination for this stage
+            total_stage_messages = len(stage_messages)
+            stage_messages_per_page = msgs_per_page
+
+            if total_stage_messages > stage_messages_per_page:
+                page = st.number_input(
+                    f"Page for Stage {stage}",
+                    min_value=1,
+                    max_value=(total_stage_messages // stage_messages_per_page) + 1,
+                    value=1,
+                    key=f"page_stage_{stage}_{key_suffix}"
+                )
+                start_idx = (page - 1) * stage_messages_per_page
+                end_idx = min(start_idx + stage_messages_per_page, total_stage_messages)
+                messages_to_display = stage_messages.iloc[start_idx:end_idx]
+
+                st.markdown(f"*Showing messages {start_idx + 1}-{end_idx} of {total_stage_messages}*")
+            else:
+                messages_to_display = stage_messages
+
+            # Display messages
+            for idx, row in messages_to_display.iterrows():
+                user_id = row.get('user_id', 'N/A')
+                user_email = row.get('email', 'N/A')
+                user_name = row.get('first_name', 'N/A')
+
+                # Parse message content
+                message_content = parse_message_content(row.get('message', ''))
+
+                if message_content:
+                    stage_message = None
+                    for msg in message_content:
+                        if isinstance(msg, dict):
+                            stage_message = msg
+                            break
+
+                    if stage_message:
+                        # Message card
+                        msg_col1, msg_col2 = st.columns([4, 1])
+
+                        with msg_col1:
+                            st.markdown(f"**User:** {user_name} ({user_email}) - ID: {user_id}")
+
+                            header = stage_message.get('header', 'No header')
+                            message_text = stage_message.get('message', 'No message')
+
+                            st.markdown(f"**📧 Header:** {header}")
+                            st.markdown(f"**💬 Message:** {message_text}")
+
+                            # Show recommendation if available
+                            if 'thumbnail_url' in stage_message or 'web_url_path' in stage_message:
+                                rec_data = {
+                                    'title': stage_message.get('title', 'Recommended Content'),
+                                    'web_url_path': stage_message.get('web_url_path', '#'),
+                                    'thumbnail_url': stage_message.get('thumbnail_url', '')
+                                }
+                                display_recommendation(rec_data)
+                            elif 'recommendation' in row and pd.notna(row['recommendation']):
+                                display_recommendation(row['recommendation'])
+
+                        with msg_col2:
+                            # Feedback section
+                            if show_feedback_option:
+                                existing_feedback = feedback_manager.get_feedback_for_message(
+                                    exp_id, user_id, stage
+                                )
+
+                                if existing_feedback:
+                                    st.error("❌ Rejected")
+                                    if st.button(f"Undo", key=f"undo_{user_id}_{stage}_{key_suffix}_sc"):
+                                        feedback_manager.delete_feedback(exp_id, user_id, stage)
+                                        st.rerun()
+                                else:
+                                    if st.button("🚫 Reject", key=f"reject_{user_id}_{stage}_{key_suffix}_sc"):
+                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}_sc"] = True
+                                        st.rerun()
+
+                        # Feedback form
+                        if st.session_state.get(f"show_feedback_form_{user_id}_{stage}_{key_suffix}_sc", False):
+                            with st.form(f"feedback_form_{user_id}_{stage}_{key_suffix}_sc"):
+                                st.markdown("**Why is this message rejected?**")
+
+                                rejection_reasons = feedback_manager.get_all_rejection_reasons()
+                                selected_reason = st.selectbox(
+                                    "Rejection Reason",
+                                    list(rejection_reasons.keys()),
+                                    format_func=lambda x: rejection_reasons[x],
+                                    key=f"reason_{user_id}_{stage}_{key_suffix}_sc"
+                                )
+
+                                rejection_text = st.text_area(
+                                    "Additional Comments (Optional)",
+                                    key=f"text_{user_id}_{stage}_{key_suffix}_sc"
+                                )
+
+                                col1, col2 = st.columns(2)
+
+                                with col1:
+                                    if st.form_submit_button("💾 Save", use_container_width=True):
+                                        feedback_manager.save_feedback(
+                                            experiment_id=exp_id,
+                                            user_id=user_id,
+                                            stage=stage,
+                                            feedback_type="reject",
+                                            rejection_reason=selected_reason,
+                                            rejection_text=rejection_text,
+                                            campaign_name=row.get('campaign_name'),
+                                            message_header=stage_message.get('header', 'N/A'),
+                                            message_body=stage_message.get('message', 'N/A')
+                                        )
+                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}_sc"] = False
+                                        st.success("✅ Feedback saved")
+                                        st.rerun()
+
+                                with col2:
+                                    if st.form_submit_button("❌ Cancel", use_container_width=True):
+                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}_sc"] = False
+                                        st.rerun()
+
+                        st.markdown("---")
+
+# Display messages based on mode and view
+if is_ab_mode:
+    # A/B Testing Mode - Show both experiments side by side
+    if view_mode == "User-Centric":
+        st.subheader("👤 User-Centric View")
+        st.markdown("*All stages for each user - comparing both experiments*")
+    else:
+        st.subheader("📊 Stage-Centric View")
+        st.markdown("*All users for each stage - comparing both experiments*")
+
+    # Create two columns for A/B comparison
+    col_a, col_b = st.columns(2)
+
+    with col_a:
+        st.markdown("### 🅰️ Experiment A")
+        if view_mode == "User-Centric":
+            display_user_centric_messages(
+                filtered_messages_a,
+                experiment_a_id,
+                "exp_a",
+                show_feedback,
+                messages_per_page
+            )
+        else:
+            display_stage_centric_messages(
+                filtered_messages_a,
+                experiment_a_id,
+                "exp_a",
+                show_feedback,
+                messages_per_page,
+                selected_stages
+            )
+
+    with col_b:
+        st.markdown("### 🅱️ Experiment B")
+        if view_mode == "User-Centric":
+            display_user_centric_messages(
+                filtered_messages_b,
+                experiment_b_id,
+                "exp_b",
+                show_feedback,
+                messages_per_page
+            )
+        else:
+            display_stage_centric_messages(
+                filtered_messages_b,
+                experiment_b_id,
+                "exp_b",
+                show_feedback,
+                messages_per_page,
+                selected_stages
+            )
+
+else:
+    # Single Experiment Mode - Original behavior
+    if view_mode == "User-Centric":
+        st.subheader("👤 User-Centric View")
+        st.markdown("*All stages for each user*")
+        display_user_centric_messages(
+            filtered_messages,
+            experiment_id,
+            "single",
+            show_feedback,
+            messages_per_page
+        )
+    else:
+        st.subheader("📊 Stage-Centric View")
+        st.markdown("*All users for each stage*")
+        display_stage_centric_messages(
+            filtered_messages,
+            experiment_id,
+            "single",
+            show_feedback,
+            messages_per_page,
+            selected_stages
+        )
+
+st.markdown("---")
+
+# Quick actions
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    if st.button("🏗️ Back to Campaign Builder", use_container_width=True):
+        st.switch_page("pages/1_Campaign_Builder.py")
+
+with col2:
+    if st.button("📊 View Analytics", use_container_width=True):
+        st.switch_page("pages/4_Analytics.py")
+
+with col3:
+    # Export messages
+    if st.button("💾 Export Messages", use_container_width=True):
+        if is_ab_mode:
+            # In AB mode, offer to export both experiments
+            st.markdown("**Export Options:**")
+            csv_a = filtered_messages_a.to_csv(index=False, encoding='utf-8')
+            csv_b = filtered_messages_b.to_csv(index=False, encoding='utf-8')
+
+            st.download_button(
+                label="⬇️ Download Experiment A CSV",
+                data=csv_a,
+                file_name=f"{brand}_messages_experiment_a_{ab_timestamp}.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+
+            st.download_button(
+                label="⬇️ Download Experiment B CSV",
+                data=csv_b,
+                file_name=f"{brand}_messages_experiment_b_{ab_timestamp}.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+        else:
+            csv = filtered_messages.to_csv(index=False, encoding='utf-8')
+            st.download_button(
+                label="⬇️ Download CSV",
+                data=csv,
+                file_name=f"{brand}_messages_{experiment_id}.csv",
+                mime="text/csv",
+                use_container_width=True
+            )

pages/4_Analytics.py

@@ -1,24 +1,1070 @@
 """
-Analytics Page - HuggingFace Space Wrapper
-Redirects to the actual page in visualization/pages/
+Page 4: Analytics Dashboard
+Visualize performance metrics and insights from generated messages and feedback.
+Supports A/B testing mode for comparing two experiments side-by-side.
 """
 
+import streamlit as st
 import sys
 from pathlib import Path
+import pandas as pd
+import re
 
-# Set up paths
-root_dir = Path(__file__).parent.parent
-visualization_dir = root_dir / "visualization"
+# Try to import plotly with helpful error message
+try:
+    import plotly.express as px
+    import plotly.graph_objects as go
+except ModuleNotFoundError:
+    st.error("""
+    ⚠️ **Missing Dependency: plotly**
 
-# Add directories to path
-sys.path.insert(0, str(root_dir))
-sys.path.insert(0, str(root_dir / "ai_messaging_system_v2"))
-sys.path.insert(0, str(visualization_dir))
+    Plotly is not installed in the current Python environment.
 
-# Import and run the actual page
-import importlib.util
+    **To fix this:**
+    1. Make sure you're running Streamlit from the correct Python environment
+    2. Install plotly: `pip install plotly>=5.17.0`
+    3. Or install all requirements: `pip install -r visualization/requirements.txt`
 
-page_path = visualization_dir / "pages" / "4_Analytics.py"
-spec = importlib.util.spec_from_file_location("analytics", page_path)
-analytics = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(analytics)
+    **Current Python:** {}
+    """.format(sys.executable))
+    st.stop()
+
+# Add root directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from utils.auth import check_authentication
+from utils.theme import apply_theme, get_brand_emoji, get_brand_theme
+from utils.data_loader import DataLoader
+from utils.feedback_manager import FeedbackManager
+
+# Page configuration
+st.set_page_config(
+    page_title="Analytics Dashboard",
+    page_icon="📊",
+    layout="wide"
+)
+
+# Check authentication
+if not check_authentication():
+    st.error("🔒 Please login first")
+    st.stop()
+
+# Initialize utilities
+data_loader = DataLoader()
+feedback_manager = FeedbackManager()
+
+# Check if brand is selected
+if "selected_brand" not in st.session_state or not st.session_state.selected_brand:
+    st.error("⚠️ Please select a brand from the home page first")
+    st.stop()
+
+brand = st.session_state.selected_brand
+apply_theme(brand)
+theme = get_brand_theme(brand)
+
+# Helper function to detect A/B testing files
+def detect_ab_testing_files():
+    """
+    Detect if there are A/B testing files in the UI output directory.
+    Returns (is_ab_mode, messages_a_path, messages_b_path, timestamp)
+    """
+    ui_output_path = data_loader.get_ui_output_path()
+
+    # Check session state first
+    if st.session_state.get('ab_testing_mode', False):
+        # Look for files with pattern: messages_a_* and messages_b_*
+        a_files = list(ui_output_path.glob('messages_a_*.csv'))
+        b_files = list(ui_output_path.glob('messages_b_*.csv'))
+
+        if a_files and b_files:
+            # Find matching pairs by timestamp
+            for a_file in a_files:
+                # Extract timestamp from filename: messages_a_brand_variant_timestamp.csv
+                match_a = re.search(r'messages_a_.*_(\d{8}_\d{4})\.csv', a_file.name)
+                if match_a:
+                    timestamp = match_a.group(1)
+                    # Look for matching b file
+                    for b_file in b_files:
+                        if timestamp in b_file.name:
+                            return True, a_file, b_file, timestamp
+
+    # Also detect if files exist even if session state not set
+    ui_output_path = data_loader.get_ui_output_path()
+    a_files = list(ui_output_path.glob('messages_a_*.csv'))
+    b_files = list(ui_output_path.glob('messages_b_*.csv'))
+
+    if a_files and b_files:
+        # Auto-detect matching pairs
+        for a_file in a_files:
+            match_a = re.search(r'messages_a_.*_(\d{8}_\d{4})\.csv', a_file.name)
+            if match_a:
+                timestamp = match_a.group(1)
+                for b_file in b_files:
+                    if timestamp in b_file.name:
+                        return True, a_file, b_file, timestamp
+
+    return False, None, None, None
+
+
+def load_ab_test_messages(file_path):
+    """Load messages from A/B test file."""
+    try:
+        return pd.read_csv(file_path, encoding='utf-8-sig')
+    except Exception as e:
+        st.error(f"Error loading A/B test file: {e}")
+        return None
+
+
+def extract_experiment_id_from_filename(file_path):
+    """Extract experiment ID from A/B test filename."""
+    # Pattern: messages_a_brand_variant_timestamp.csv or messages_b_brand_variant_timestamp.csv
+    # Use the full filename (without .csv) to ensure A and B experiments have different IDs
+    filename = file_path.stem  # Removes .csv extension automatically
+    return filename
+
+
+# Page Header
+emoji = get_brand_emoji(brand)
+st.title(f"📊 Analytics Dashboard - {emoji} {brand.title()}")
+st.markdown("**Performance metrics and insights**")
+
+# Detect A/B testing mode
+is_ab_mode, messages_a_path, messages_b_path, ab_timestamp = detect_ab_testing_files()
+
+if is_ab_mode:
+    st.success(f"🔬 **A/B Testing Mode - Comparing Experiments Side-by-Side** (Timestamp: {ab_timestamp})")
+
+st.markdown("---")
+
+# Load messages based on mode
+if is_ab_mode:
+    # Load A/B test messages
+    messages_a_df = load_ab_test_messages(messages_a_path)
+    messages_b_df = load_ab_test_messages(messages_b_path)
+
+    if messages_a_df is None or len(messages_a_df) == 0 or messages_b_df is None or len(messages_b_df) == 0:
+        st.warning("⚠️ Error loading A/B test messages. Please check the files.")
+        if st.button("🏗️ Go to Campaign Builder"):
+            st.switch_page("pages/1_Campaign_Builder.py")
+        st.stop()
+
+    # Extract experiment IDs from filenames
+    experiment_a_id = extract_experiment_id_from_filename(messages_a_path)
+    experiment_b_id = extract_experiment_id_from_filename(messages_b_path)
+
+    messages_df = None  # Not used in AB mode
+else:
+    # Load regular messages
+    messages_df = data_loader.load_generated_messages()
+
+    if messages_df is None or len(messages_df) == 0:
+        st.warning("⚠️ No messages found. Please generate messages first in Campaign Builder.")
+        if st.button("🏗️ Go to Campaign Builder"):
+            st.switch_page("pages/1_Campaign_Builder.py")
+        st.stop()
+
+    # Get experiment ID
+    if "current_experiment_id" not in st.session_state or not st.session_state.current_experiment_id:
+        if 'campaign_name' in messages_df.columns and len(messages_df) > 0:
+            campaign_name = messages_df['campaign_name'].iloc[0]
+            experiment_id = campaign_name.replace(" ", "_")
+        else:
+            experiment_id = f"{brand}_experiment"
+
+        st.session_state.current_experiment_id = experiment_id
+
+    experiment_id = st.session_state.current_experiment_id
+
+# Sidebar - Experiment Selection and Filters
+with st.sidebar:
+    st.header("⚙️ Settings")
+
+    if not is_ab_mode:
+        # List available experiments (only in single mode)
+        experiment_files = list(data_loader.ui_output_path.glob("messages_*.csv"))
+        experiment_names = [f.stem for f in experiment_files]
+
+        if len(experiment_names) > 1:
+            selected_experiment = st.selectbox(
+                "Select Experiment",
+                experiment_names,
+                help="Choose an experiment to analyze"
+            )
+
+            if selected_experiment != experiment_id:
+                # Load different experiment
+                experiment_id = selected_experiment
+                st.session_state.current_experiment_id = experiment_id
+
+                # Reload messages and feedback
+                exp_file = data_loader.ui_output_path / f"{selected_experiment}.csv"
+                if exp_file.exists():
+                    messages_df = pd.read_csv(exp_file, encoding='utf-8-sig')
+                    st.rerun()
+
+        st.markdown("---")
+
+    # Filters
+    st.subheader("🔍 Filters")
+
+    # Stage filter
+    if is_ab_mode:
+        # Get stages from both dataframes
+        stages_a = sorted(messages_a_df['stage'].unique()) if 'stage' in messages_a_df.columns else []
+        stages_b = sorted(messages_b_df['stage'].unique()) if 'stage' in messages_b_df.columns else []
+        available_stages = sorted(list(set(stages_a + stages_b)))
+    else:
+        available_stages = sorted(messages_df['stage'].unique()) if 'stage' in messages_df.columns else []
+
+    if available_stages:
+        selected_stages = st.multiselect(
+            "Filter by Stage",
+            available_stages,
+            default=available_stages,
+            help="Select stages to include in analysis" + (" (applies to both experiments)" if is_ab_mode else "")
+        )
+    else:
+        selected_stages = []
+
+# Filter messages by selected stages
+if is_ab_mode:
+    # Filter both experiments
+    filtered_messages_a = messages_a_df.copy()
+    filtered_messages_b = messages_b_df.copy()
+
+    if selected_stages:
+        filtered_messages_a = filtered_messages_a[filtered_messages_a['stage'].isin(selected_stages)]
+        filtered_messages_b = filtered_messages_b[filtered_messages_b['stage'].isin(selected_stages)]
+
+    filtered_messages = None  # Not used in AB mode
+
+    # Get feedback stats for both experiments
+    feedback_stats_a = feedback_manager.get_feedback_stats(experiment_a_id, total_messages=len(filtered_messages_a))
+    feedback_stats_b = feedback_manager.get_feedback_stats(experiment_b_id, total_messages=len(filtered_messages_b))
+    stage_feedback_stats_a = feedback_manager.get_stage_feedback_stats(experiment_a_id, messages_df=filtered_messages_a)
+    stage_feedback_stats_b = feedback_manager.get_stage_feedback_stats(experiment_b_id, messages_df=filtered_messages_b)
+else:
+    if selected_stages and 'stage' in messages_df.columns:
+        filtered_messages = messages_df[messages_df['stage'].isin(selected_stages)]
+    else:
+        filtered_messages = messages_df
+
+    # Get feedback stats (pass total messages for accurate rejection rate)
+    feedback_stats = feedback_manager.get_feedback_stats(experiment_id, total_messages=len(filtered_messages))
+    stage_feedback_stats = feedback_manager.get_stage_feedback_stats(experiment_id, messages_df=filtered_messages)
+
+# ============================================================================
+# OVERALL METRICS
+# ============================================================================
+st.header("📈 Overall Performance")
+
+if is_ab_mode:
+    # A/B Testing Mode - Show comparison side-by-side
+    st.markdown("##### Experiment A vs Experiment B")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("### 🅰️ Experiment A")
+        sub_col1, sub_col2 = st.columns(2)
+
+        with sub_col1:
+            st.metric(
+                "Total Messages",
+                len(filtered_messages_a),
+                help="Total number of generated messages"
+            )
+            st.metric(
+                "Rejected Messages",
+                feedback_stats_a['total_rejects'],
+                f"{feedback_stats_a['reject_rate']:.1f}%"
+            )
+
+        with sub_col2:
+            st.metric(
+                "Total Feedback",
+                feedback_stats_a['total_feedback'],
+                help="Number of messages with feedback"
+            )
+            approved_a = len(filtered_messages_a) - feedback_stats_a['total_rejects']
+            approval_rate_a = (approved_a / len(filtered_messages_a) * 100) if len(filtered_messages_a) > 0 else 0
+            st.metric(
+                "Approved/OK",
+                approved_a,
+                f"{approval_rate_a:.1f}%"
+            )
+
+    with col2:
+        st.markdown("### 🅱️ Experiment B")
+        sub_col1, sub_col2 = st.columns(2)
+
+        with sub_col1:
+            st.metric(
+                "Total Messages",
+                len(filtered_messages_b),
+                help="Total number of generated messages"
+            )
+            st.metric(
+                "Rejected Messages",
+                feedback_stats_b['total_rejects'],
+                f"{feedback_stats_b['reject_rate']:.1f}%"
+            )
+
+        with sub_col2:
+            st.metric(
+                "Total Feedback",
+                feedback_stats_b['total_feedback'],
+                help="Number of messages with feedback"
+            )
+            approved_b = len(filtered_messages_b) - feedback_stats_b['total_rejects']
+            approval_rate_b = (approved_b / len(filtered_messages_b) * 100) if len(filtered_messages_b) > 0 else 0
+            st.metric(
+                "Approved/OK",
+                approved_b,
+                f"{approval_rate_b:.1f}%"
+            )
+
+    # Winner determination
+    st.markdown("---")
+    st.markdown("#### 🏆 Winner Determination")
+
+    reject_rate_diff = feedback_stats_a['reject_rate'] - feedback_stats_b['reject_rate']
+
+    col1, col2, col3 = st.columns([1, 2, 1])
+
+    with col2:
+        if reject_rate_diff < -1:
+            st.success(f"**🏆 Experiment A is performing better** by {abs(reject_rate_diff):.1f}% (lower rejection rate)")
+        elif reject_rate_diff > 1:
+            st.success(f"**🏆 Experiment B is performing better** by {abs(reject_rate_diff):.1f}% (lower rejection rate)")
+        else:
+            st.info("**➡️ Both experiments have similar performance** (difference < 1%)")
+
+else:
+    # Single Experiment Mode - Original behavior
+    col1, col2, col3, col4 = st.columns(4)
+
+    with col1:
+        st.metric(
+            "Total Messages",
+            len(filtered_messages),
+            help="Total number of generated messages"
+        )
+
+    with col2:
+        st.metric(
+            "Total Feedback",
+            feedback_stats['total_feedback'],
+            help="Number of messages with feedback"
+        )
+
+    with col3:
+        st.metric(
+            "Rejected Messages",
+            feedback_stats['total_rejects'],
+            f"{feedback_stats['reject_rate']:.1f}%"
+        )
+
+    with col4:
+        approved = len(filtered_messages) - feedback_stats['total_rejects']
+        approval_rate = (approved / len(filtered_messages) * 100) if len(filtered_messages) > 0 else 0
+        st.metric(
+            "Approved/OK Messages",
+            approved,
+            f"{approval_rate:.1f}%"
+        )
+
+st.markdown("---")
+
+# ============================================================================
+# STAGE-BY-STAGE PERFORMANCE
+# ============================================================================
+st.header("📊 Stage-by-Stage Performance")
+
+if is_ab_mode:
+    # A/B Testing Mode - Show both experiments on same chart for easy comparison
+    if len(stage_feedback_stats_a) > 0 or len(stage_feedback_stats_b) > 0:
+        # Create comparison chart
+        fig = go.Figure()
+
+        if len(stage_feedback_stats_a) > 0:
+            fig.add_trace(go.Bar(
+                x=stage_feedback_stats_a['stage'],
+                y=stage_feedback_stats_a['reject_rate'],
+                name='Experiment A',
+                marker_color='#4A90E2',
+                text=stage_feedback_stats_a['reject_rate'].round(1),
+                textposition='auto',
+            ))
+
+        if len(stage_feedback_stats_b) > 0:
+            fig.add_trace(go.Bar(
+                x=stage_feedback_stats_b['stage'],
+                y=stage_feedback_stats_b['reject_rate'],
+                name='Experiment B',
+                marker_color='#E94B3C',
+                text=stage_feedback_stats_b['reject_rate'].round(1),
+                textposition='auto',
+            ))
+
+        max_reject_rate = 10
+        if len(stage_feedback_stats_a) > 0:
+            max_reject_rate = max(max_reject_rate, stage_feedback_stats_a['reject_rate'].max())
+        if len(stage_feedback_stats_b) > 0:
+            max_reject_rate = max(max_reject_rate, stage_feedback_stats_b['reject_rate'].max())
+
+        fig.update_layout(
+            title="Rejection Rate by Stage - A vs B Comparison",
+            xaxis_title="Stage",
+            yaxis_title="Rejection Rate (%)",
+            yaxis=dict(range=[0, max_reject_rate * 1.2]),
+            template="plotly_dark",
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            barmode='group'
+        )
+
+        st.plotly_chart(fig, use_container_width=True)
+
+        # Stage details tables side-by-side
+        with st.expander("📋 View Stage Details Comparison"):
+            col1, col2 = st.columns(2)
+
+            with col1:
+                st.markdown("**🅰️ Experiment A**")
+                if len(stage_feedback_stats_a) > 0:
+                    st.dataframe(
+                        stage_feedback_stats_a,
+                        use_container_width=True,
+                        column_config={
+                            "stage": "Stage",
+                            "total_messages": "Messages",
+                            "total_feedback": "Feedback",
+                            "rejects": "Rejected",
+                            "reject_rate": st.column_config.NumberColumn(
+                                "Reject Rate (%)",
+                                format="%.1f%%"
+                            )
+                        }
+                    )
+                else:
+                    st.info("No feedback data for Experiment A")
+
+            with col2:
+                st.markdown("**🅱️ Experiment B**")
+                if len(stage_feedback_stats_b) > 0:
+                    st.dataframe(
+                        stage_feedback_stats_b,
+                        use_container_width=True,
+                        column_config={
+                            "stage": "Stage",
+                            "total_messages": "Messages",
+                            "total_feedback": "Feedback",
+                            "rejects": "Rejected",
+                            "reject_rate": st.column_config.NumberColumn(
+                                "Reject Rate (%)",
+                                format="%.1f%%"
+                            )
+                        }
+                    )
+                else:
+                    st.info("No feedback data for Experiment B")
+    else:
+        st.info("ℹ️ No feedback data available yet. Provide feedback in the Message Viewer to see stage-by-stage analysis.")
+
+else:
+    # Single Experiment Mode - Original behavior
+    if len(stage_feedback_stats) > 0:
+        # Create bar chart for stage performance
+        fig = go.Figure()
+
+        fig.add_trace(go.Bar(
+            x=stage_feedback_stats['stage'],
+            y=stage_feedback_stats['reject_rate'],
+            name='Rejection Rate (%)',
+            marker_color=theme['accent'],
+            text=stage_feedback_stats['reject_rate'].round(1),
+            textposition='auto',
+        ))
+
+        fig.update_layout(
+            title="Rejection Rate by Stage",
+            xaxis_title="Stage",
+            yaxis_title="Rejection Rate (%)",
+            yaxis=dict(range=[0, max(stage_feedback_stats['reject_rate'].max() * 1.2, 10)]),
+            template="plotly_dark",
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+        )
+
+        st.plotly_chart(fig, use_container_width=True)
+
+        # Stage details table
+        with st.expander("📋 View Stage Details"):
+            st.dataframe(
+                stage_feedback_stats,
+                use_container_width=True,
+                column_config={
+                    "stage": "Stage",
+                    "total_messages": "Total Messages",
+                    "total_feedback": "Total Feedback",
+                    "rejects": "Rejected",
+                    "reject_rate": st.column_config.NumberColumn(
+                        "Rejection Rate (%)",
+                        format="%.1f%%"
+                    )
+                }
+            )
+    else:
+        st.info("ℹ️ No feedback data available yet. Provide feedback in the Message Viewer to see stage-by-stage analysis.")
+
+st.markdown("---")
+
+# ============================================================================
+# REJECTION REASONS ANALYSIS
+# ============================================================================
+st.header("🔍 Rejection Reasons Analysis")
+
+if is_ab_mode:
+    # A/B Testing Mode - Show side-by-side pie charts for both experiments
+    has_rejection_a = len(feedback_stats_a['rejection_reasons']) > 0
+    has_rejection_b = len(feedback_stats_b['rejection_reasons']) > 0
+
+    if has_rejection_a or has_rejection_b:
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.markdown("### 🅰️ Experiment A")
+            if has_rejection_a:
+                rejection_reasons_a_df = pd.DataFrame([
+                    {"Reason": reason, "Count": count}
+                    for reason, count in feedback_stats_a['rejection_reasons'].items()
+                ]).sort_values('Count', ascending=False)
+
+                # Pie chart for rejection reasons
+                fig_a = px.pie(
+                    rejection_reasons_a_df,
+                    names='Reason',
+                    values='Count',
+                    title="Distribution of Rejection Reasons",
+                    color_discrete_sequence=px.colors.qualitative.Set3
+                )
+
+                fig_a.update_layout(
+                    template="plotly_dark",
+                    paper_bgcolor='rgba(0,0,0,0)',
+                    plot_bgcolor='rgba(0,0,0,0)',
+                )
+
+                st.plotly_chart(fig_a, use_container_width=True)
+
+                # Most common issue
+                most_common_reason_a = rejection_reasons_a_df.iloc[0]
+                st.info(f"💡 **Most Common:** {most_common_reason_a['Reason']} ({most_common_reason_a['Count']})")
+            else:
+                st.info("No rejection feedback for Experiment A")
+
+        with col2:
+            st.markdown("### 🅱️ Experiment B")
+            if has_rejection_b:
+                rejection_reasons_b_df = pd.DataFrame([
+                    {"Reason": reason, "Count": count}
+                    for reason, count in feedback_stats_b['rejection_reasons'].items()
+                ]).sort_values('Count', ascending=False)
+
+                # Pie chart for rejection reasons
+                fig_b = px.pie(
+                    rejection_reasons_b_df,
+                    names='Reason',
+                    values='Count',
+                    title="Distribution of Rejection Reasons",
+                    color_discrete_sequence=px.colors.qualitative.Pastel
+                )
+
+                fig_b.update_layout(
+                    template="plotly_dark",
+                    paper_bgcolor='rgba(0,0,0,0)',
+                    plot_bgcolor='rgba(0,0,0,0)',
+                )
+
+                st.plotly_chart(fig_b, use_container_width=True)
+
+                # Most common issue
+                most_common_reason_b = rejection_reasons_b_df.iloc[0]
+                st.info(f"💡 **Most Common:** {most_common_reason_b['Reason']} ({most_common_reason_b['Count']})")
+            else:
+                st.info("No rejection feedback for Experiment B")
+
+        # Detailed rejection reasons tables side-by-side
+        with st.expander("📋 View Detailed Rejection Feedback"):
+            col1, col2 = st.columns(2)
+
+            with col1:
+                st.markdown("**🅰️ Experiment A**")
+                feedback_a_df = feedback_manager.load_feedback(experiment_a_id)
+                if feedback_a_df is not None and len(feedback_a_df) > 0:
+                    reject_a_df = feedback_a_df[feedback_a_df['feedback_type'] == 'reject']
+
+                    if len(reject_a_df) > 0:
+                        display_a_df = reject_a_df[[
+                            'user_id', 'stage', 'rejection_reason', 'rejection_text', 'timestamp'
+                        ]].copy()
+
+                        display_a_df['rejection_reason'] = display_a_df['rejection_reason'].apply(
+                            lambda x: feedback_manager.get_rejection_reason_label(x) if pd.notna(x) else 'N/A'
+                        )
+
+                        st.dataframe(display_a_df, use_container_width=True)
+                    else:
+                        st.info("No rejection feedback")
+                else:
+                    st.info("No feedback data")
+
+            with col2:
+                st.markdown("**🅱️ Experiment B**")
+                feedback_b_df = feedback_manager.load_feedback(experiment_b_id)
+                if feedback_b_df is not None and len(feedback_b_df) > 0:
+                    reject_b_df = feedback_b_df[feedback_b_df['feedback_type'] == 'reject']
+
+                    if len(reject_b_df) > 0:
+                        display_b_df = reject_b_df[[
+                            'user_id', 'stage', 'rejection_reason', 'rejection_text', 'timestamp'
+                        ]].copy()
+
+                        display_b_df['rejection_reason'] = display_b_df['rejection_reason'].apply(
+                            lambda x: feedback_manager.get_rejection_reason_label(x) if pd.notna(x) else 'N/A'
+                        )
+
+                        st.dataframe(display_b_df, use_container_width=True)
+                    else:
+                        st.info("No rejection feedback")
+                else:
+                    st.info("No feedback data")
+    else:
+        st.info("ℹ️ No rejection feedback available yet. Reject messages in the Message Viewer to see detailed analysis.")
+
+else:
+    # Single Experiment Mode - Original behavior
+    if len(feedback_stats['rejection_reasons']) > 0:
+        # Create DataFrame for rejection reasons
+        rejection_reasons_df = pd.DataFrame([
+            {"Reason": reason, "Count": count}
+            for reason, count in feedback_stats['rejection_reasons'].items()
+        ]).sort_values('Count', ascending=False)
+
+        col1, col2 = st.columns([1, 1])
+
+        with col1:
+            # Pie chart for rejection reasons
+            fig = px.pie(
+                rejection_reasons_df,
+                names='Reason',
+                values='Count',
+                title="Distribution of Rejection Reasons",
+                color_discrete_sequence=px.colors.qualitative.Set3
+            )
+
+            fig.update_layout(
+                template="plotly_dark",
+                paper_bgcolor='rgba(0,0,0,0)',
+                plot_bgcolor='rgba(0,0,0,0)',
+            )
+
+            st.plotly_chart(fig, use_container_width=True)
+
+        with col2:
+            # Bar chart for rejection reasons
+            fig = px.bar(
+                rejection_reasons_df,
+                x='Reason',
+                y='Count',
+                title="Rejection Reasons Count",
+                color='Count',
+                color_continuous_scale='Reds'
+            )
+
+            fig.update_layout(
+                template="plotly_dark",
+                paper_bgcolor='rgba(0,0,0,0)',
+                plot_bgcolor='rgba(0,0,0,0)',
+                xaxis_tickangle=-45
+            )
+
+            st.plotly_chart(fig, use_container_width=True)
+
+        # Most common issue
+        most_common_reason = rejection_reasons_df.iloc[0]
+        st.info(f"💡 **Most Common Issue:** {most_common_reason['Reason']} ({most_common_reason['Count']} occurrences)")
+
+        # Detailed rejection reasons table
+        with st.expander("📋 View Detailed Rejection Feedback"):
+            feedback_df = feedback_manager.load_feedback(experiment_id)
+            if feedback_df is not None and len(feedback_df) > 0:
+                reject_df = feedback_df[feedback_df['feedback_type'] == 'reject']
+
+                if len(reject_df) > 0:
+                    # Prepare display dataframe
+                    display_df = reject_df[[
+                        'user_id', 'stage', 'rejection_reason', 'rejection_text', 'timestamp'
+                    ]].copy()
+
+                    # Map rejection reason keys to labels
+                    display_df['rejection_reason'] = display_df['rejection_reason'].apply(
+                        lambda x: feedback_manager.get_rejection_reason_label(x) if pd.notna(x) else 'N/A'
+                    )
+
+                    st.dataframe(display_df, use_container_width=True)
+    else:
+        st.info("ℹ️ No rejection feedback available yet. Reject messages in the Message Viewer to see detailed analysis.")
+
+st.markdown("---")
+
+# ============================================================================
+# STATISTICAL COMPARISON (AB Testing Mode Only)
+# ============================================================================
+if is_ab_mode:
+    st.header("📊 Statistical Comparison")
+
+    # Get comparison stats
+    comparison = feedback_manager.compare_experiments(
+        experiment_a_id,
+        experiment_b_id,
+        total_messages_a=len(filtered_messages_a),
+        total_messages_b=len(filtered_messages_b)
+    )
+
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        st.markdown("### 🅰️ Experiment A")
+        st.metric(
+            "Rejection Rate",
+            f"{comparison['experiment_a']['stats']['reject_rate']:.1f}%"
+        )
+        st.metric(
+            "Total Feedback",
+            comparison['experiment_a']['stats']['total_feedback']
+        )
+        st.metric(
+            "Total Messages",
+            len(filtered_messages_a)
+        )
+
+    with col2:
+        st.markdown("### 🅱️ Experiment B")
+        st.metric(
+            "Rejection Rate",
+            f"{comparison['experiment_b']['stats']['reject_rate']:.1f}%"
+        )
+        st.metric(
+            "Total Feedback",
+            comparison['experiment_b']['stats']['total_feedback']
+        )
+        st.metric(
+            "Total Messages",
+            len(filtered_messages_b)
+        )
+
+    with col3:
+        st.markdown("### 📊 Difference")
+        diff = comparison['difference']['reject_rate']
+
+        st.metric(
+            "Rejection Rate Δ",
+            f"{diff:.1f}%",
+            delta=f"{-diff:.1f}%" if diff != 0 else "0%",
+            delta_color="inverse"
+        )
+
+        feedback_diff = comparison['experiment_b']['stats']['total_feedback'] - comparison['experiment_a']['stats']['total_feedback']
+        st.metric(
+            "Feedback Δ",
+            feedback_diff,
+            delta=f"{feedback_diff}" if feedback_diff != 0 else "0"
+        )
+
+    st.markdown("---")
+
+# ============================================================================
+# COMPARATIVE ANALYSIS (if multiple experiments in non-AB mode)
+# ============================================================================
+if not is_ab_mode:
+    st.header("🧪 Comparative Analysis")
+
+    # Check for A/B test experiments
+    experiment_files = list(data_loader.ui_output_path.glob("messages_*_*.csv"))
+    ab_experiments = [f for f in experiment_files if '_a_' in f.stem.lower() or '_b_' in f.stem.lower()]
+
+    if len(ab_experiments) >= 2:
+        st.markdown("**A/B Test Experiments Detected**")
+
+        # Find matching A/B pairs
+        ab_pairs = {}
+        for exp_file in ab_experiments:
+            exp_name = exp_file.stem
+            if '_a_' in exp_name.lower():
+                base_name = exp_name.lower().replace('_a_', '_')
+                if base_name not in ab_pairs:
+                    ab_pairs[base_name] = {}
+                ab_pairs[base_name]['A'] = exp_name
+            elif '_b_' in exp_name.lower():
+                base_name = exp_name.lower().replace('_b_', '_')
+                if base_name not in ab_pairs:
+                    ab_pairs[base_name] = {}
+                ab_pairs[base_name]['B'] = exp_name
+
+        # Display A/B comparisons
+        for base_name, pair in ab_pairs.items():
+            if 'A' in pair and 'B' in pair:
+                with st.expander(f"📊 {base_name.replace('messages_', '').replace('_', ' ').title()}"):
+                    exp_a_id = pair['A']
+                    exp_b_id = pair['B']
+
+                    # Load messages to get total counts
+                    try:
+                        exp_a_file = data_loader.ui_output_path / f"{exp_a_id}.csv"
+                        exp_b_file = data_loader.ui_output_path / f"{exp_b_id}.csv"
+
+                        messages_a_df = pd.read_csv(exp_a_file, encoding='utf-8-sig') if exp_a_file.exists() else None
+                        messages_b_df = pd.read_csv(exp_b_file, encoding='utf-8-sig') if exp_b_file.exists() else None
+
+                        total_messages_a = len(messages_a_df) if messages_a_df is not None else None
+                        total_messages_b = len(messages_b_df) if messages_b_df is not None else None
+                    except:
+                        total_messages_a = None
+                        total_messages_b = None
+
+                    # Get comparison stats
+                    comparison = feedback_manager.compare_experiments(
+                        exp_a_id,
+                        exp_b_id,
+                        total_messages_a=total_messages_a,
+                        total_messages_b=total_messages_b
+                    )
+
+                    col1, col2, col3 = st.columns(3)
+
+                    with col1:
+                        st.markdown("### 🅰️ Experiment A")
+                        st.metric(
+                            "Rejection Rate",
+                            f"{comparison['experiment_a']['stats']['reject_rate']:.1f}%"
+                        )
+                        st.metric(
+                            "Total Feedback",
+                            comparison['experiment_a']['stats']['total_feedback']
+                        )
+
+                    with col2:
+                        st.markdown("### 🅱️ Experiment B")
+                        st.metric(
+                            "Rejection Rate",
+                            f"{comparison['experiment_b']['stats']['reject_rate']:.1f}%"
+                        )
+                        st.metric(
+                            "Total Feedback",
+                            comparison['experiment_b']['stats']['total_feedback']
+                        )
+
+                    with col3:
+                        st.markdown("### 📈 Winner")
+                        diff = comparison['difference']['reject_rate']
+
+                        if diff < -1:
+                            st.success("🏆 Experiment A")
+                            st.metric("Better by", f"{abs(diff):.1f}%")
+                        elif diff > 1:
+                            st.success("🏆 Experiment B")
+                            st.metric("Better by", f"{abs(diff):.1f}%")
+                        else:
+                            st.info("➡️ Similar Performance")
+
+                    # Side-by-side rejection reasons comparison
+                    st.markdown("#### Rejection Reasons Comparison")
+
+                    col1, col2 = st.columns(2)
+
+                    with col1:
+                        reasons_a = comparison['experiment_a']['stats']['rejection_reasons']
+                        if len(reasons_a) > 0:
+                            df_a = pd.DataFrame([
+                                {"Reason": k, "Count": v}
+                                for k, v in reasons_a.items()
+                            ])
+
+                            fig_a = px.bar(
+                                df_a,
+                                x='Reason',
+                                y='Count',
+                                title="Experiment A - Rejection Reasons",
+                                color='Count',
+                                color_continuous_scale='Blues'
+                            )
+
+                            fig_a.update_layout(
+                                template="plotly_dark",
+                                paper_bgcolor='rgba(0,0,0,0)',
+                                plot_bgcolor='rgba(0,0,0,0)',
+                                xaxis_tickangle=-45,
+                                height=300
+                            )
+
+                            st.plotly_chart(fig_a, use_container_width=True)
+                        else:
+                            st.info("No rejection feedback for Experiment A")
+
+                    with col2:
+                        reasons_b = comparison['experiment_b']['stats']['rejection_reasons']
+                        if len(reasons_b) > 0:
+                            df_b = pd.DataFrame([
+                                {"Reason": k, "Count": v}
+                                for k, v in reasons_b.items()
+                            ])
+
+                            fig_b = px.bar(
+                                df_b,
+                                x='Reason',
+                                y='Count',
+                                title="Experiment B - Rejection Reasons",
+                                color='Count',
+                                color_continuous_scale='Reds'
+                            )
+
+                            fig_b.update_layout(
+                                template="plotly_dark",
+                                paper_bgcolor='rgba(0,0,0,0)',
+                                plot_bgcolor='rgba(0,0,0,0)',
+                                xaxis_tickangle=-45,
+                                height=300
+                            )
+
+                            st.plotly_chart(fig_b, use_container_width=True)
+                        else:
+                            st.info("No rejection feedback for Experiment B")
+    else:
+        st.info("ℹ️ Run A/B tests to see comparative analysis here")
+
+st.markdown("---")
+
+# Export options
+st.header("💾 Export Data")
+
+if is_ab_mode:
+    # A/B Testing Mode - Export both experiments
+    st.markdown("##### Export Experiment Data")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.markdown("**🅰️ Experiment A**")
+
+        if st.button("📥 Export Messages A", use_container_width=True):
+            csv = filtered_messages_a.to_csv(index=False, encoding='utf-8')
+            st.download_button(
+                label="⬇️ Download Messages A CSV",
+                data=csv,
+                file_name=f"{brand}_{experiment_a_id}_messages.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+
+        feedback_a_df = feedback_manager.load_feedback(experiment_a_id)
+        if feedback_a_df is not None and len(feedback_a_df) > 0:
+            if st.button("📥 Export Feedback A", use_container_width=True):
+                csv = feedback_a_df.to_csv(index=False, encoding='utf-8')
+                st.download_button(
+                    label="⬇️ Download Feedback A CSV",
+                    data=csv,
+                    file_name=f"{brand}_{experiment_a_id}_feedback.csv",
+                    mime="text/csv",
+                    use_container_width=True
+                )
+
+        if len(stage_feedback_stats_a) > 0:
+            if st.button("📥 Export Analytics A", use_container_width=True):
+                csv = stage_feedback_stats_a.to_csv(index=False, encoding='utf-8')
+                st.download_button(
+                    label="⬇️ Download Analytics A CSV",
+                    data=csv,
+                    file_name=f"{brand}_{experiment_a_id}_analytics.csv",
+                    mime="text/csv",
+                    use_container_width=True
+                )
+
+    with col2:
+        st.markdown("**🅱️ Experiment B**")
+
+        if st.button("📥 Export Messages B", use_container_width=True):
+            csv = filtered_messages_b.to_csv(index=False, encoding='utf-8')
+            st.download_button(
+                label="⬇️ Download Messages B CSV",
+                data=csv,
+                file_name=f"{brand}_{experiment_b_id}_messages.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+
+        feedback_b_df = feedback_manager.load_feedback(experiment_b_id)
+        if feedback_b_df is not None and len(feedback_b_df) > 0:
+            if st.button("📥 Export Feedback B", use_container_width=True):
+                csv = feedback_b_df.to_csv(index=False, encoding='utf-8')
+                st.download_button(
+                    label="⬇️ Download Feedback B CSV",
+                    data=csv,
+                    file_name=f"{brand}_{experiment_b_id}_feedback.csv",
+                    mime="text/csv",
+                    use_container_width=True
+                )
+
+        if len(stage_feedback_stats_b) > 0:
+            if st.button("📥 Export Analytics B", use_container_width=True):
+                csv = stage_feedback_stats_b.to_csv(index=False, encoding='utf-8')
+                st.download_button(
+                    label="⬇️ Download Analytics B CSV",
+                    data=csv,
+                    file_name=f"{brand}_{experiment_b_id}_analytics.csv",
+                    mime="text/csv",
+                    use_container_width=True
+                )
+
+else:
+    # Single Experiment Mode - Original behavior
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        if st.button("📥 Export Messages", use_container_width=True):
+            csv = filtered_messages.to_csv(index=False, encoding='utf-8')
+            st.download_button(
+                label="⬇️ Download Messages CSV",
+                data=csv,
+                file_name=f"{brand}_{experiment_id}_messages.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+
+    with col2:
+        feedback_df = feedback_manager.load_feedback(experiment_id)
+        if feedback_df is not None and len(feedback_df) > 0:
+            if st.button("📥 Export Feedback", use_container_width=True):
+                csv = feedback_df.to_csv(index=False, encoding='utf-8')
+                st.download_button(
+                    label="⬇️ Download Feedback CSV",
+                    data=csv,
+                    file_name=f"{brand}_{experiment_id}_feedback.csv",
+                    mime="text/csv",
+                    use_container_width=True
+                )
+
+    with col3:
+        if len(stage_feedback_stats) > 0:
+            if st.button("📥 Export Analytics", use_container_width=True):
+                csv = stage_feedback_stats.to_csv(index=False, encoding='utf-8')
+                st.download_button(
+                    label="⬇️ Download Analytics CSV",
+                    data=csv,
+                    file_name=f"{brand}_{experiment_id}_analytics.csv",
+                    mime="text/csv",
+                    use_container_width=True
+                )
+
+st.markdown("---")

pages/5_Historical_Analytics.py

@@ -1,24 +1,519 @@
 """
-Historical Analytics Page - HuggingFace Space Wrapper
-Redirects to the actual page in visualization/pages/
+Page 5: Historical Analytics
+View performance metrics and insights from all previous experiments.
 """
 
+import streamlit as st
 import sys
 from pathlib import Path
+import pandas as pd
+from datetime import datetime
 
-# Set up paths
-root_dir = Path(__file__).parent.parent
-visualization_dir = root_dir / "visualization"
+# Try to import plotly with helpful error message
+try:
+    import plotly.express as px
+    import plotly.graph_objects as go
+except ModuleNotFoundError:
+    st.error("""
+    ⚠️ **Missing Dependency: plotly**
 
-# Add directories to path
-sys.path.insert(0, str(root_dir))
-sys.path.insert(0, str(root_dir / "ai_messaging_system_v2"))
-sys.path.insert(0, str(visualization_dir))
+    Plotly is not installed in the current Python environment.
 
-# Import and run the actual page
-import importlib.util
+    **To fix this:**
+    1. Make sure you're running Streamlit from the correct Python environment
+    2. Install plotly: `pip install plotly>=5.17.0`
+    3. Or install all requirements: `pip install -r visualization/requirements.txt`
 
-page_path = visualization_dir / "pages" / "5_Historical_Analytics.py"
-spec = importlib.util.spec_from_file_location("historical_analytics", page_path)
-historical_analytics = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(historical_analytics)
+    **Current Python:** {}
+    """.format(sys.executable))
+    st.stop()
+
+# Add root directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from utils.auth import check_authentication
+from utils.theme import apply_theme, get_brand_emoji, get_brand_theme
+from utils.data_loader import DataLoader
+from utils.feedback_manager import FeedbackManager
+
+# Page configuration
+st.set_page_config(
+    page_title="Historical Analytics",
+    page_icon="📚",
+    layout="wide"
+)
+
+# Check authentication
+if not check_authentication():
+    st.error("🔒 Please login first")
+    st.stop()
+
+# Initialize utilities
+data_loader = DataLoader()
+feedback_manager = FeedbackManager()
+
+# Check if brand is selected
+if "selected_brand" not in st.session_state or not st.session_state.selected_brand:
+    st.error("⚠️ Please select a brand from the home page first")
+    st.stop()
+
+brand = st.session_state.selected_brand
+apply_theme(brand)
+theme = get_brand_theme(brand)
+
+# Page Header
+emoji = get_brand_emoji(brand)
+st.title(f"📚 Historical Analytics - {emoji} {brand.title()}")
+st.markdown("**View performance metrics from all previous experiments**")
+
+st.markdown("---")
+
+# Load all experiment files
+ui_output_path = data_loader.ui_output_path
+experiment_files = list(ui_output_path.glob("messages_*.csv"))
+
+# Filter out current messages.csv and A/B experiment files for separate handling
+regular_experiments = [f for f in experiment_files if f.name != "messages.csv" and "_a_" not in f.name.lower() and "_b_" not in f.name.lower()]
+ab_experiments = [f for f in experiment_files if "_a_" in f.name.lower() or "_b_" in f.name.lower()]
+
+if len(regular_experiments) == 0 and len(ab_experiments) == 0:
+    st.info("ℹ️ No historical experiments found yet. Run experiments in Campaign Builder to see historical data here.")
+    st.stop()
+
+# Sidebar - Filters
+with st.sidebar:
+    st.header("🔍 Filters")
+
+    # Date range filter
+    st.subheader("Date Range")
+    show_all = st.checkbox("Show All Experiments", value=True)
+
+    if not show_all:
+        # Extract dates from filenames for filtering
+        all_dates = []
+        for f in regular_experiments + ab_experiments:
+            # Try to extract date from filename (format: messages_brand_YYYYMMDD_HHMM.csv)
+            try:
+                parts = f.stem.split('_')
+                if len(parts) >= 3:
+                    date_str = parts[-2]  # YYYYMMDD
+                    date_obj = datetime.strptime(date_str, '%Y%m%d')
+                    all_dates.append(date_obj.date())
+            except:
+                continue
+
+        if len(all_dates) > 0:
+            min_date = min(all_dates)
+            max_date = max(all_dates)
+
+            start_date = st.date_input("Start Date", min_date)
+            end_date = st.date_input("End Date", max_date)
+
+    st.markdown("---")
+
+    # Experiment type filter
+    st.subheader("Experiment Type")
+    show_regular = st.checkbox("Regular Experiments", value=True)
+    show_ab = st.checkbox("A/B Tests", value=True)
+
+# ============================================================================
+# OVERVIEW STATISTICS
+# ============================================================================
+st.header("📊 Overview Statistics")
+
+col1, col2, col3, col4 = st.columns(4)
+
+with col1:
+    st.metric("Total Experiments", len(regular_experiments) + (len(ab_experiments) // 2))
+
+with col2:
+    st.metric("Regular Experiments", len(regular_experiments))
+
+with col3:
+    st.metric("A/B Tests", len(ab_experiments) // 2)
+
+with col4:
+    # Calculate total messages across all experiments
+    total_messages = 0
+    for f in regular_experiments + ab_experiments:
+        try:
+            df = pd.read_csv(f, encoding='utf-8-sig')
+            total_messages += len(df)
+        except:
+            continue
+    st.metric("Total Messages Generated", total_messages)
+
+st.markdown("---")
+
+# ============================================================================
+# REGULAR EXPERIMENTS
+# ============================================================================
+if show_regular and len(regular_experiments) > 0:
+    st.header("📈 Regular Experiments")
+
+    # Create summary table
+    experiment_summary = []
+
+    for exp_file in sorted(regular_experiments, key=lambda x: x.stat().st_mtime, reverse=True):
+        try:
+            # Load experiment data
+            messages_df = pd.read_csv(exp_file, encoding='utf-8-sig')
+
+            # Extract experiment info
+            exp_id = exp_file.stem
+            exp_name = exp_file.stem.replace('messages_', '')
+
+            # Get timestamp from file
+            file_timestamp = datetime.fromtimestamp(exp_file.stat().st_mtime)
+
+            # Get feedback stats
+            feedback_stats = feedback_manager.get_feedback_stats(exp_id, total_messages=len(messages_df))
+
+            experiment_summary.append({
+                "Experiment": exp_name,
+                "Date": file_timestamp.strftime('%Y-%m-%d %H:%M'),
+                "Messages": len(messages_df),
+                "Users": messages_df['user_id'].nunique() if 'user_id' in messages_df.columns else 0,
+                "Stages": messages_df['stage'].nunique() if 'stage' in messages_df.columns else 0,
+                "Rejection Rate (%)": round(feedback_stats['reject_rate'], 1),
+                "Total Feedback": feedback_stats['total_feedback'],
+                "exp_id": exp_id,
+                "exp_file": exp_file
+            })
+        except Exception as e:
+            st.warning(f"⚠️ Error loading {exp_file.name}: {str(e)}")
+            continue
+
+    if len(experiment_summary) > 0:
+        summary_df = pd.DataFrame(experiment_summary)
+
+        # Display summary table
+        st.dataframe(
+            summary_df.drop(columns=['exp_id', 'exp_file']),
+            use_container_width=True,
+            hide_index=True
+        )
+
+        st.markdown("---")
+
+        # Rejection rate trend over time
+        st.subheader("📉 Rejection Rate Trend Over Time")
+
+        fig = go.Figure()
+
+        fig.add_trace(go.Scatter(
+            x=summary_df['Date'],
+            y=summary_df['Rejection Rate (%)'],
+            mode='lines+markers',
+            name='Rejection Rate',
+            line=dict(color=theme['accent'], width=3),
+            marker=dict(size=10)
+        ))
+
+        fig.update_layout(
+            xaxis_title="Experiment Date",
+            yaxis_title="Rejection Rate (%)",
+            template="plotly_dark",
+            paper_bgcolor='rgba(0,0,0,0)',
+            plot_bgcolor='rgba(0,0,0,0)',
+            hovermode='x unified'
+        )
+
+        st.plotly_chart(fig, use_container_width=True)
+
+        st.markdown("---")
+
+        # Detailed experiment view
+        st.subheader("🔍 Detailed Experiment View")
+
+        selected_exp = st.selectbox(
+            "Select Experiment to View Details",
+            summary_df['Experiment'].tolist(),
+            key="selected_regular_exp"
+        )
+
+        if selected_exp:
+            # Get selected experiment data
+            selected_row = summary_df[summary_df['Experiment'] == selected_exp].iloc[0]
+            exp_id = selected_row['exp_id']
+            exp_file = selected_row['exp_file']
+
+            # Load messages and feedback
+            messages_df = pd.read_csv(exp_file, encoding='utf-8-sig')
+            feedback_df = feedback_manager.load_feedback(exp_id)
+
+            col1, col2 = st.columns(2)
+
+            with col1:
+                st.markdown("### 📊 Experiment Metrics")
+                st.metric("Total Messages", len(messages_df))
+                st.metric("Unique Users", messages_df['user_id'].nunique() if 'user_id' in messages_df.columns else 0)
+                st.metric("Stages", messages_df['stage'].nunique() if 'stage' in messages_df.columns else 0)
+                st.metric("Rejection Rate", f"{selected_row['Rejection Rate (%)']}%")
+
+            with col2:
+                st.markdown("### 🔍 Rejection Reasons")
+                if feedback_df is not None and len(feedback_df) > 0:
+                    reject_df = feedback_df[feedback_df['feedback_type'] == 'reject']
+
+                    if len(reject_df) > 0:
+                        # Get rejection reasons
+                        reason_counts = reject_df['rejection_reason'].value_counts()
+
+                        # Map to labels
+                        reason_labels = {
+                            feedback_manager.get_rejection_reason_label(k): v
+                            for k, v in reason_counts.items()
+                            if pd.notna(k)
+                        }
+
+                        # Create pie chart
+                        if len(reason_labels) > 0:
+                            fig = px.pie(
+                                names=list(reason_labels.keys()),
+                                values=list(reason_labels.values()),
+                                color_discrete_sequence=px.colors.qualitative.Set3
+                            )
+
+                            fig.update_layout(
+                                template="plotly_dark",
+                                paper_bgcolor='rgba(0,0,0,0)',
+                                plot_bgcolor='rgba(0,0,0,0)',
+                                height=300
+                            )
+
+                            st.plotly_chart(fig, use_container_width=True)
+                    else:
+                        st.info("No rejection feedback for this experiment")
+                else:
+                    st.info("No feedback data available")
+
+            # Stage-by-stage performance
+            st.markdown("### 📈 Stage-by-Stage Performance")
+            stage_stats = feedback_manager.get_stage_feedback_stats(exp_id, messages_df=messages_df)
+
+            if len(stage_stats) > 0:
+                fig = go.Figure()
+
+                fig.add_trace(go.Bar(
+                    x=stage_stats['stage'],
+                    y=stage_stats['reject_rate'],
+                    name='Rejection Rate (%)',
+                    marker_color=theme['accent'],
+                    text=stage_stats['reject_rate'].round(1),
+                    textposition='auto',
+                ))
+
+                fig.update_layout(
+                    xaxis_title="Stage",
+                    yaxis_title="Rejection Rate (%)",
+                    template="plotly_dark",
+                    paper_bgcolor='rgba(0,0,0,0)',
+                    plot_bgcolor='rgba(0,0,0,0)',
+                )
+
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.info("No stage performance data available")
+
+            # Show rejected messages with headers
+            if feedback_df is not None and len(feedback_df) > 0:
+                reject_df = feedback_df[feedback_df['feedback_type'] == 'reject']
+
+                if len(reject_df) > 0 and 'message_header' in reject_df.columns:
+                    st.markdown("### ❌ Rejected Messages")
+
+                    with st.expander("View Rejected Messages"):
+                        display_df = reject_df[[
+                            'user_id', 'stage', 'message_header', 'message_body',
+                            'rejection_reason', 'rejection_text'
+                        ]].copy()
+
+                        # Map rejection reason keys to labels
+                        display_df['rejection_reason'] = display_df['rejection_reason'].apply(
+                            lambda x: feedback_manager.get_rejection_reason_label(x) if pd.notna(x) else 'N/A'
+                        )
+
+                        st.dataframe(display_df, use_container_width=True, hide_index=True)
+
+st.markdown("---")
+
+# ============================================================================
+# A/B TEST EXPERIMENTS
+# ============================================================================
+if show_ab and len(ab_experiments) > 0:
+    st.header("🧪 A/B Test Experiments")
+
+    # Group A/B experiments into pairs
+    ab_pairs = {}
+    for exp_file in ab_experiments:
+        exp_name = exp_file.stem
+        if '_a_' in exp_name.lower():
+            base_name = exp_name.lower().replace('messages_a_', '').replace('_a_', '_')
+            if base_name not in ab_pairs:
+                ab_pairs[base_name] = {}
+            ab_pairs[base_name]['A'] = exp_file
+        elif '_b_' in exp_name.lower():
+            base_name = exp_name.lower().replace('messages_b_', '').replace('_b_', '_')
+            if base_name not in ab_pairs:
+                ab_pairs[base_name] = {}
+            ab_pairs[base_name]['B'] = exp_file
+
+    # Display A/B test pairs
+    for base_name, pair in sorted(ab_pairs.items(), key=lambda x: x[0], reverse=True):
+        if 'A' in pair and 'B' in pair:
+            with st.expander(f"🧪 {base_name.replace('_', ' ').title()}", expanded=False):
+                exp_a_file = pair['A']
+                exp_b_file = pair['B']
+
+                exp_a_id = exp_a_file.stem
+                exp_b_id = exp_b_file.stem
+
+                try:
+                    # Load both experiments
+                    messages_a = pd.read_csv(exp_a_file, encoding='utf-8-sig')
+                    messages_b = pd.read_csv(exp_b_file, encoding='utf-8-sig')
+
+                    # Get feedback stats
+                    stats_a = feedback_manager.get_feedback_stats(exp_a_id, total_messages=len(messages_a))
+                    stats_b = feedback_manager.get_feedback_stats(exp_b_id, total_messages=len(messages_b))
+
+                    # Comparison metrics
+                    col1, col2, col3 = st.columns(3)
+
+                    with col1:
+                        st.markdown("### 🅰️ Experiment A")
+                        st.metric("Messages", len(messages_a))
+                        st.metric("Rejection Rate", f"{stats_a['reject_rate']:.1f}%")
+                        st.metric("Total Feedback", stats_a['total_feedback'])
+
+                    with col2:
+                        st.markdown("### 🅱️ Experiment B")
+                        st.metric("Messages", len(messages_b))
+                        st.metric("Rejection Rate", f"{stats_b['reject_rate']:.1f}%")
+                        st.metric("Total Feedback", stats_b['total_feedback'])
+
+                    with col3:
+                        st.markdown("### 🏆 Winner")
+                        diff = stats_a['reject_rate'] - stats_b['reject_rate']
+
+                        if diff < -1:
+                            st.success("🏆 Experiment A")
+                            st.metric("Better by", f"{abs(diff):.1f}%")
+                        elif diff > 1:
+                            st.success("🏆 Experiment B")
+                            st.metric("Better by", f"{abs(diff):.1f}%")
+                        else:
+                            st.info("➡️ Similar Performance")
+
+                    st.markdown("---")
+
+                    # Side-by-side rejection reasons comparison
+                    st.markdown("#### Rejection Reasons Comparison")
+
+                    col1, col2 = st.columns(2)
+
+                    with col1:
+                        reasons_a = stats_a['rejection_reasons']
+                        if len(reasons_a) > 0:
+                            df_a = pd.DataFrame([
+                                {"Reason": k, "Count": v}
+                                for k, v in reasons_a.items()
+                            ])
+
+                            fig_a = px.bar(
+                                df_a,
+                                x='Reason',
+                                y='Count',
+                                title="Experiment A - Rejection Reasons",
+                                color='Count',
+                                color_continuous_scale='Blues'
+                            )
+
+                            fig_a.update_layout(
+                                template="plotly_dark",
+                                paper_bgcolor='rgba(0,0,0,0)',
+                                plot_bgcolor='rgba(0,0,0,0)',
+                                xaxis_tickangle=-45,
+                                height=300
+                            )
+
+                            st.plotly_chart(fig_a, use_container_width=True)
+                        else:
+                            st.info("No rejection feedback for Experiment A")
+
+                    with col2:
+                        reasons_b = stats_b['rejection_reasons']
+                        if len(reasons_b) > 0:
+                            df_b = pd.DataFrame([
+                                {"Reason": k, "Count": v}
+                                for k, v in reasons_b.items()
+                            ])
+
+                            fig_b = px.bar(
+                                df_b,
+                                x='Reason',
+                                y='Count',
+                                title="Experiment B - Rejection Reasons",
+                                color='Count',
+                                color_continuous_scale='Reds'
+                            )
+
+                            fig_b.update_layout(
+                                template="plotly_dark",
+                                paper_bgcolor='rgba(0,0,0,0)',
+                                plot_bgcolor='rgba(0,0,0,0)',
+                                xaxis_tickangle=-45,
+                                height=300
+                            )
+
+                            st.plotly_chart(fig_b, use_container_width=True)
+                        else:
+                            st.info("No rejection feedback for Experiment B")
+
+                except Exception as e:
+                    st.error(f"Error loading A/B test data: {str(e)}")
+
+st.markdown("---")
+
+# Export options
+st.header("💾 Export Historical Data")
+
+col1, col2 = st.columns(2)
+
+with col1:
+    if st.button("📥 Export All Experiments Summary", use_container_width=True):
+        if len(experiment_summary) > 0:
+            summary_export_df = pd.DataFrame(experiment_summary).drop(columns=['exp_id', 'exp_file'])
+            csv = summary_export_df.to_csv(index=False, encoding='utf-8')
+            st.download_button(
+                label="⬇️ Download Summary CSV",
+                data=csv,
+                file_name=f"{brand}_experiments_summary_{datetime.now().strftime('%Y%m%d')}.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+
+with col2:
+    if st.button("📥 Export All Feedback", use_container_width=True):
+        # Combine all feedback files
+        all_feedback = []
+        for exp_file in regular_experiments + ab_experiments:
+            exp_id = exp_file.stem
+            feedback_df = feedback_manager.load_feedback(exp_id)
+            if feedback_df is not None and len(feedback_df) > 0:
+                all_feedback.append(feedback_df)
+
+        if len(all_feedback) > 0:
+            combined_feedback = pd.concat(all_feedback, ignore_index=True)
+            csv = combined_feedback.to_csv(index=False, encoding='utf-8')
+            st.download_button(
+                label="⬇️ Download All Feedback CSV",
+                data=csv,
+                file_name=f"{brand}_all_feedback_{datetime.now().strftime('%Y%m%d')}.csv",
+                mime="text/csv",
+                use_container_width=True
+            )
+
+st.markdown("---")
+st.markdown("**💡 Tip:** Use historical analytics to track improvements over time and identify patterns in rejection reasons!")

utils/__init__.py

@@ -0,0 +1,28 @@
+"""
+Utility modules for the AI Messaging System Visualization Tool.
+
+Modules:
+- auth: Authentication and access control
+- data_loader: Data loading from Snowflake and CSV files
+- config_manager: Configuration persistence and management
+- theme: Brand-specific theming and styling
+- feedback_manager: Feedback storage and retrieval
+"""
+
+from .auth import verify_login, check_authentication, AUTHORIZED_EMAILS
+from .theme import get_brand_theme, apply_theme, BRAND_COLORS
+from .data_loader import DataLoader
+from .config_manager import ConfigManager
+from .feedback_manager import FeedbackManager
+
+__all__ = [
+    'verify_login',
+    'check_authentication',
+    'AUTHORIZED_EMAILS',
+    'get_brand_theme',
+    'apply_theme',
+    'BRAND_COLORS',
+    'DataLoader',
+    'ConfigManager',
+    'FeedbackManager',
+]

utils/auth.py

@@ -0,0 +1,101 @@
+"""
+Authentication module for the AI Messaging System Visualization Tool.
+
+Handles user authentication and access control.
+"""
+
+import os
+import streamlit as st
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables from .env file in visualization directory
+env_path = Path(__file__).parent.parent / '.env'
+if env_path.exists():
+    load_dotenv(env_path)
+else:
+    # Try parent directory .env
+    parent_env_path = Path(__file__).parent.parent.parent / '.env'
+    if parent_env_path.exists():
+        load_dotenv(parent_env_path)
+
+# Authorized emails - team members only
+AUTHORIZED_EMAILS = {
+    "danial@musora.com",
+    "danial.ebrat@gmail.com",
+    "simon@musora.com",
+    "una@musora.com",
+    "mark@musora.com",
+    "gabriel@musora.com",
+    "nikki@musora.com"
+}
+
+
+def get_credential(key: str) -> str:
+    """
+    Get credential from environment variables.
+
+    Args:
+        key: Credential key
+
+    Returns:
+        str: Credential value
+    """
+    return os.getenv(key, "")
+
+
+def get_valid_token() -> str:
+    """
+    Get the valid access token from environment.
+
+    Returns:
+        str: Valid access token
+    """
+    return get_credential("APP_TOKEN")
+
+
+def verify_login(email: str, token: str) -> bool:
+    """
+    Verify user login credentials.
+
+    Args:
+        email: User email address
+        token: Access token
+
+    Returns:
+        bool: True if credentials are valid, False otherwise
+    """
+    valid_token = get_valid_token()
+    email_normalized = email.lower().strip()
+
+    return (email_normalized in AUTHORIZED_EMAILS) and (token == valid_token)
+
+
+def check_authentication() -> bool:
+    """
+    Check if user is authenticated in current session.
+
+    Returns:
+        bool: True if authenticated, False otherwise
+    """
+    return st.session_state.get("authenticated", False)
+
+
+def get_current_user() -> str:
+    """
+    Get the currently logged-in user's email.
+
+    Returns:
+        str: User email or empty string if not authenticated
+    """
+    return st.session_state.get("user_email", "")
+
+
+def logout():
+    """
+    Log out the current user by clearing session state.
+    """
+    if "authenticated" in st.session_state:
+        del st.session_state["authenticated"]
+    if "user_email" in st.session_state:
+        del st.session_state["user_email"]

utils/config_manager.py

@@ -0,0 +1,313 @@
+"""
+Configuration management module for the AI Messaging System Visualization Tool.
+
+Handles saving, loading, and managing campaign configurations.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Optional
+import streamlit as st
+
+
+class ConfigManager:
+    """
+    Manages campaign configurations including loading defaults and persisting custom configs.
+    """
+
+    def __init__(self):
+        """Initialize ConfigManager."""
+        self.base_path = Path(__file__).parent.parent
+        self.configs_path = self.base_path / "data" / "configs"
+
+        # Create directory if it doesn't exist
+        self.configs_path.mkdir(parents=True, exist_ok=True)
+
+    def load_default_config(self, brand: str, campaign_type: str = "re_engagement") -> Dict:
+        """
+        Load default configuration from local JSON files.
+
+        Args:
+            brand: Brand name
+            campaign_type: Campaign type (default: re_engagement)
+
+        Returns:
+            dict: Campaign configuration
+        """
+        try:
+            # Load from local configs directory
+            filename = f"{brand}_{campaign_type}_test.json"
+            file_path = self.configs_path / filename
+
+            if not file_path.exists():
+                st.error(f"Default config file not found: {filename}")
+                return {}
+
+            with open(file_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+
+            return config
+        except Exception as e:
+            st.error(f"Error loading default config: {e}")
+            return {}
+
+    def save_custom_config(self, brand: str, config_name: str, config: Dict) -> bool:
+        """
+        Save custom configuration to JSON file.
+
+        Args:
+            brand: Brand name
+            config_name: Configuration name
+            config: Configuration dictionary
+
+        Returns:
+            bool: True if saved successfully, False otherwise
+        """
+        try:
+            # Create filename
+            filename = f"{brand}_{config_name}.json"
+            file_path = self.configs_path / filename
+
+            # Save to JSON
+            with open(file_path, 'w', encoding='utf-8') as f:
+                json.dump(config, f, indent=2, ensure_ascii=False)
+
+            return True
+
+        except Exception as e:
+            st.error(f"Error saving config: {e}")
+            return False
+
+    def load_custom_config(self, brand: str, config_name: str) -> Optional[Dict]:
+        """
+        Load custom configuration from JSON file.
+
+        Args:
+            brand: Brand name
+            config_name: Configuration name
+
+        Returns:
+            dict or None: Configuration dictionary or None if not found
+        """
+        try:
+            filename = f"{brand}_{config_name}.json"
+            file_path = self.configs_path / filename
+
+            if not file_path.exists():
+                return None
+
+            with open(file_path, 'r', encoding='utf-8') as f:
+                config = json.load(f)
+
+            return config
+
+        except Exception as e:
+            st.error(f"Error loading config: {e}")
+            return None
+
+    def list_custom_configs(self, brand: str) -> List[str]:
+        """
+        List all custom configurations for a brand.
+
+        Args:
+            brand: Brand name
+
+        Returns:
+            list: List of configuration names
+        """
+        try:
+            # Find all JSON files for this brand
+            pattern = f"{brand}_*.json"
+            config_files = list(self.configs_path.glob(pattern))
+
+            # Extract config names (remove brand prefix and .json extension)
+            config_names = []
+            for file in config_files:
+                name = file.stem  # filename without extension
+                # Remove brand prefix
+                config_name = name.replace(f"{brand}_", "", 1)
+                config_names.append(config_name)
+
+            return sorted(config_names)
+
+        except Exception as e:
+            st.error(f"Error listing configs: {e}")
+            return []
+
+    def delete_custom_config(self, brand: str, config_name: str) -> bool:
+        """
+        Delete a custom configuration.
+
+        Args:
+            brand: Brand name
+            config_name: Configuration name
+
+        Returns:
+            bool: True if deleted successfully, False otherwise
+        """
+        try:
+            filename = f"{brand}_{config_name}.json"
+            file_path = self.configs_path / filename
+
+            if file_path.exists():
+                file_path.unlink()
+                return True
+            return False
+
+        except Exception as e:
+            st.error(f"Error deleting config: {e}")
+            return False
+
+    def config_exists(self, brand: str, config_name: str) -> bool:
+        """
+        Check if a custom configuration exists.
+
+        Args:
+            brand: Brand name
+            config_name: Configuration name
+
+        Returns:
+            bool: True if exists, False otherwise
+        """
+        filename = f"{brand}_{config_name}.json"
+        file_path = self.configs_path / filename
+        return file_path.exists()
+
+    def get_all_configs(self, brand: str) -> Dict[str, Dict]:
+        """
+        Get all configurations (default + custom) for a brand.
+
+        Args:
+            brand: Brand name
+
+        Returns:
+            dict: Dictionary mapping config names to config dictionaries
+        """
+        configs = {}
+
+        # Add default config as "re_engagement_test"
+        default_config = self.load_default_config(brand)
+        if default_config:
+            configs["re_engagement_test"] = default_config
+
+        # Add custom configs
+        custom_names = self.list_custom_configs(brand)
+        for name in custom_names:
+            # Skip re_engagement_test if it's already in the list (avoid duplicates)
+            if name == "re_engagement_test":
+                continue
+            custom_config = self.load_custom_config(brand, name)
+            if custom_config:
+                configs[name] = custom_config
+
+        return configs
+
+    def create_config_from_ui(
+        self,
+        brand: str,
+        campaign_name: str,
+        campaign_type: str,
+        num_stages: int,
+        campaign_instructions: Optional[str],
+        stages_config: Dict[int, Dict]
+    ) -> Dict:
+        """
+        Create a configuration dictionary from UI inputs.
+
+        Args:
+            brand: Brand name
+            campaign_name: Campaign name
+            campaign_type: Campaign type
+            num_stages: Number of stages
+            campaign_instructions: Campaign-wide instructions (optional)
+            stages_config: Dictionary mapping stage numbers to stage configurations
+
+        Returns:
+            dict: Complete configuration dictionary
+        """
+        config = {
+            "brand": brand,
+            "campaign_type": campaign_type,
+            "campaign_name": campaign_name,
+            "campaign_instructions": campaign_instructions,
+        }
+
+        # Add stage configurations
+        for stage_num in range(1, num_stages + 1):
+            if stage_num in stages_config:
+                config[str(stage_num)] = stages_config[stage_num]
+
+        return config
+
+    def extract_stage_config(self, config: Dict, stage: int) -> Dict:
+        """
+        Extract configuration for a specific stage.
+
+        Args:
+            config: Complete configuration dictionary
+            stage: Stage number
+
+        Returns:
+            dict: Stage configuration
+        """
+        return config.get(str(stage), {})
+
+    def validate_config(self, config: Dict) -> tuple[bool, str]:
+        """
+        Validate configuration structure and required fields.
+
+        Args:
+            config: Configuration dictionary
+
+        Returns:
+            tuple: (is_valid, error_message)
+        """
+        required_fields = ["brand", "campaign_name"]
+
+        # Check required top-level fields
+        for field in required_fields:
+            if field not in config:
+                return False, f"Missing required field: {field}"
+
+        # Check if at least stage 1 exists
+        if "1" not in config:
+            return False, "Configuration must have at least stage 1"
+
+        # Validate stage 1 config
+        stage1 = config["1"]
+        required_stage_fields = ["stage", "model"]
+
+        for field in required_stage_fields:
+            if field not in stage1:
+                return False, f"Stage 1 missing required field: {field}"
+
+        return True, ""
+
+    def duplicate_config(self, brand: str, source_name: str, new_name: str) -> bool:
+        """
+        Duplicate an existing configuration with a new name.
+
+        Args:
+            brand: Brand name
+            source_name: Source configuration name
+            new_name: New configuration name
+
+        Returns:
+            bool: True if duplicated successfully, False otherwise
+        """
+        try:
+            # Load source config
+            if source_name == "re_engagement_test":
+                source_config = self.load_default_config(brand)
+            else:
+                source_config = self.load_custom_config(brand, source_name)
+
+            if source_config is None:
+                return False
+
+            # Save as new config
+            return self.save_custom_config(brand, new_name, source_config)
+
+        except Exception as e:
+            st.error(f"Error duplicating config: {e}")
+            return False

utils/data_loader.py

@@ -0,0 +1,230 @@
+"""
+Data loading module for the AI Messaging System Visualization Tool.
+
+Handles data loading from local CSV files only.
+"""
+
+import sys
+import pandas as pd
+from pathlib import Path
+from typing import Optional
+import streamlit as st
+
+# Add parent directory to path to import from ai_messaging_system_v2
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+try:
+    from ai_messaging_system_v2.Messaging_system.Permes import Permes
+except ImportError as e:
+    st.error(f"Error importing AI Messaging System modules: {e}")
+
+
+class DataLoader:
+    """
+    Handles all data loading operations for the visualization tool.
+    """
+
+    def __init__(self):
+        """Initialize DataLoader."""
+        self.base_path = Path(__file__).parent.parent
+        self.ui_users_path = self.base_path / "data" / "UI_users"
+        self.ui_output_path = Path(__file__).parent.parent.parent / "ai_messaging_system_v2" / "Data" / "ui_output"
+
+        # Create directories if they don't exist
+        self.ui_users_path.mkdir(parents=True, exist_ok=True)
+        self.ui_output_path.mkdir(parents=True, exist_ok=True)
+
+    def load_brand_users(self, brand: str) -> Optional[pd.DataFrame]:
+        """
+        Load all users for a brand from UI_users directory.
+
+        Args:
+            brand: Brand name
+
+        Returns:
+            pd.DataFrame or None: All users for the brand or None if file doesn't exist
+        """
+        file_path = self.ui_users_path / f"{brand}_users.csv"
+
+        if not file_path.exists():
+            st.error(f"User file not found: {brand}_users.csv")
+            return None
+
+        try:
+            users_df = pd.read_csv(file_path, encoding='utf-8-sig')
+            return users_df
+        except Exception as e:
+            st.error(f"Error loading users from {brand}_users.csv: {e}")
+            return None
+
+    def sample_users_randomly(self, brand: str, sample_size: int) -> Optional[pd.DataFrame]:
+        """
+        Randomly sample users from the brand's user file.
+
+        Args:
+            brand: Brand name
+            sample_size: Number of users to sample (1-25)
+
+        Returns:
+            pd.DataFrame or None: Sampled users or None if error
+        """
+        try:
+            # Load all users for the brand
+            all_users = self.load_brand_users(brand)
+
+            if all_users is None or len(all_users) == 0:
+                st.error(f"No users available for {brand}")
+                return None
+
+            # Validate sample size
+            if sample_size < 1:
+                sample_size = 1
+            if sample_size > min(25, len(all_users)):
+                sample_size = min(25, len(all_users))
+
+            # Randomly sample
+            sampled_users = all_users.sample(n=sample_size, random_state=None)
+
+            return sampled_users
+
+        except Exception as e:
+            st.error(f"Error sampling users: {e}")
+            return None
+
+    def has_brand_users(self, brand: str) -> bool:
+        """
+        Check if user file exists for a brand.
+
+        Args:
+            brand: Brand name
+
+        Returns:
+            bool: True if file exists, False otherwise
+        """
+        file_path = self.ui_users_path / f"{brand}_users.csv"
+        return file_path.exists()
+
+    def get_brand_user_count(self, brand: str) -> int:
+        """
+        Get the total number of users available for a brand.
+
+        Args:
+            brand: Brand name
+
+        Returns:
+            int: Number of users available
+        """
+        users_df = self.load_brand_users(brand)
+        if users_df is not None:
+            return len(users_df)
+        return 0
+
+    def load_generated_messages(self) -> Optional[pd.DataFrame]:
+        """
+        Load generated messages from UI output folder.
+
+        Returns:
+            pd.DataFrame or None: Generated messages or None if file doesn't exist
+        """
+        messages_file = self.ui_output_path / "messages.csv"
+
+        if messages_file.exists():
+            return pd.read_csv(messages_file, encoding='utf-8-sig')
+        return None
+
+    def clear_ui_output(self):
+        """
+        Clear UI output files (messages and costs).
+        """
+        try:
+            Permes.clear_ui_output()
+            st.success("UI output cleared successfully!")
+        except Exception as e:
+            st.error(f"Error clearing UI output: {e}")
+
+    def get_ui_output_path(self) -> Path:
+        """
+        Get path to UI output directory.
+
+        Returns:
+            Path: UI output directory path
+        """
+        return self.ui_output_path
+
+
+    def get_message_stats(self) -> dict:
+        """
+        Get statistics about generated messages.
+
+        Returns:
+            dict: Statistics including total messages, stages, users, etc.
+        """
+        messages_df = self.load_generated_messages()
+
+        if messages_df is None or len(messages_df) == 0:
+            return {
+                "total_messages": 0,
+                "total_users": 0,
+                "total_stages": 0,
+                "campaigns": []
+            }
+
+        stats = {
+            "total_messages": len(messages_df),
+            "total_users": messages_df['user_id'].nunique() if 'user_id' in messages_df.columns else 0,
+            "total_stages": messages_df['stage'].nunique() if 'stage' in messages_df.columns else 0,
+            "campaigns": messages_df['campaign_name'].unique().tolist() if 'campaign_name' in messages_df.columns else []
+        }
+
+        return stats
+
+    def filter_messages_by_stage(self, messages_df: pd.DataFrame, stage: int) -> pd.DataFrame:
+        """
+        Filter messages by stage number.
+
+        Args:
+            messages_df: Messages DataFrame
+            stage: Stage number
+
+        Returns:
+            pd.DataFrame: Filtered messages
+        """
+        if 'stage' in messages_df.columns:
+            return messages_df[messages_df['stage'] == stage]
+        return pd.DataFrame()
+
+    def filter_messages_by_user(self, messages_df: pd.DataFrame, user_id: int) -> pd.DataFrame:
+        """
+        Filter messages by user ID.
+
+        Args:
+            messages_df: Messages DataFrame
+            user_id: User ID
+
+        Returns:
+            pd.DataFrame: Filtered messages
+        """
+        if 'user_id' in messages_df.columns:
+            return messages_df[messages_df['user_id'] == user_id]
+        return pd.DataFrame()
+
+    def search_messages(self, messages_df: pd.DataFrame, search_term: str) -> pd.DataFrame:
+        """
+        Search messages by keyword in message content.
+
+        Args:
+            messages_df: Messages DataFrame
+            search_term: Search keyword
+
+        Returns:
+            pd.DataFrame: Filtered messages containing the search term
+        """
+        if len(search_term) == 0:
+            return messages_df
+
+        # Search in message column (which contains JSON)
+        if 'message' in messages_df.columns:
+            mask = messages_df['message'].astype(str).str.contains(search_term, case=False, na=False)
+            return messages_df[mask]
+
+        return pd.DataFrame()

utils/feedback_manager.py

@@ -0,0 +1,414 @@
+"""
+Feedback management module for the AI Messaging System Visualization Tool.
+
+Handles storage and retrieval of user feedback on generated messages.
+"""
+
+import pandas as pd
+from pathlib import Path
+from datetime import datetime
+from typing import Optional, List, Dict
+import streamlit as st
+
+
+# Rejection reason categories
+REJECTION_REASONS = {
+    "poor_header": "Poor Header",
+    "poor_body": "Poor Body/Content",
+    "grammar_issues": "Grammar Issues",
+    "emoji_problems": "Emoji Problems",
+    "recommendation_issues": "Recommendation Issues",
+    "wrong_information": "Wrong/Inaccurate Information",
+    "tone_issues": "Tone Issues",
+    "similarity": "Similar To Previous Header/Messages",
+    "other": "Other"
+}
+
+
+class FeedbackManager:
+    """
+    Manages feedback storage and retrieval for generated messages.
+    """
+
+    def __init__(self):
+        """Initialize FeedbackManager."""
+        self.base_path = Path(__file__).parent.parent
+        self.feedback_path = self.base_path / "data" / "feedback"
+
+        # Create directory if it doesn't exist
+        self.feedback_path.mkdir(parents=True, exist_ok=True)
+
+    def get_feedback_file_path(self, experiment_id: str) -> Path:
+        """
+        Get path to feedback file for an experiment.
+
+        Args:
+            experiment_id: Experiment ID
+
+        Returns:
+            Path: Feedback file path
+        """
+        return self.feedback_path / f"{experiment_id}_feedback.csv"
+
+    def save_feedback(
+        self,
+        experiment_id: str,
+        user_id: int,
+        stage: int,
+        feedback_type: str,
+        rejection_reason: Optional[str] = None,
+        rejection_text: Optional[str] = None,
+        campaign_name: Optional[str] = None,
+        message_header: Optional[str] = None,
+        message_body: Optional[str] = None
+    ) -> bool:
+        """
+        Save feedback for a message.
+
+        Args:
+            experiment_id: Experiment ID
+            user_id: User ID
+            stage: Stage number
+            feedback_type: 'reject' (we focus on rejects)
+            rejection_reason: Category of rejection (optional)
+            rejection_text: Additional text for rejection (optional)
+            campaign_name: Campaign name (optional)
+            message_header: Message header text (optional)
+            message_body: Message body text (optional)
+
+        Returns:
+            bool: True if saved successfully, False otherwise
+        """
+        try:
+            feedback_file = self.get_feedback_file_path(experiment_id)
+
+            # Create feedback record
+            feedback_record = {
+                "experiment_id": experiment_id,
+                "user_id": user_id,
+                "stage": stage,
+                "feedback_type": feedback_type,
+                "rejection_reason": rejection_reason,
+                "rejection_text": rejection_text,
+                "campaign_name": campaign_name,
+                "message_header": message_header,
+                "message_body": message_body,
+                "timestamp": datetime.now().isoformat()
+            }
+
+            # Convert to DataFrame
+            new_feedback = pd.DataFrame([feedback_record])
+
+            # Append to existing file or create new
+            if feedback_file.exists():
+                existing_feedback = pd.read_csv(feedback_file, encoding='utf-8-sig')
+
+                # Check if this exact feedback already exists
+                duplicate = existing_feedback[
+                    (existing_feedback['user_id'] == user_id) &
+                    (existing_feedback['stage'] == stage) &
+                    (existing_feedback['experiment_id'] == experiment_id)
+                ]
+
+                if len(duplicate) > 0:
+                    # Update existing feedback
+                    existing_feedback.loc[
+                        (existing_feedback['user_id'] == user_id) &
+                        (existing_feedback['stage'] == stage) &
+                        (existing_feedback['experiment_id'] == experiment_id),
+                        ['feedback_type', 'rejection_reason', 'rejection_text', 'message_header', 'message_body', 'timestamp']
+                    ] = [feedback_type, rejection_reason, rejection_text, message_header, message_body, datetime.now().isoformat()]
+
+                    updated_feedback = existing_feedback
+                else:
+                    # Append new feedback
+                    updated_feedback = pd.concat([existing_feedback, new_feedback], ignore_index=True)
+            else:
+                updated_feedback = new_feedback
+
+            # Save to CSV
+            updated_feedback.to_csv(feedback_file, index=False, encoding='utf-8-sig')
+            return True
+
+        except Exception as e:
+            st.error(f"Error saving feedback: {e}")
+            return False
+
+    def load_feedback(self, experiment_id: str) -> Optional[pd.DataFrame]:
+        """
+        Load feedback for an experiment.
+
+        Args:
+            experiment_id: Experiment ID
+
+        Returns:
+            pd.DataFrame or None: Feedback DataFrame or None if not found
+        """
+        try:
+            feedback_file = self.get_feedback_file_path(experiment_id)
+
+            if not feedback_file.exists():
+                return pd.DataFrame(columns=[
+                    'experiment_id', 'user_id', 'stage', 'feedback_type',
+                    'rejection_reason', 'rejection_text', 'campaign_name',
+                    'message_header', 'message_body', 'timestamp'
+                ])
+
+            return pd.read_csv(feedback_file, encoding='utf-8-sig')
+
+        except Exception as e:
+            st.error(f"Error loading feedback: {e}")
+            return None
+
+    def get_feedback_for_message(
+        self,
+        experiment_id: str,
+        user_id: int,
+        stage: int
+    ) -> Optional[Dict]:
+        """
+        Get feedback for a specific message.
+
+        Args:
+            experiment_id: Experiment ID
+            user_id: User ID
+            stage: Stage number
+
+        Returns:
+            dict or None: Feedback record or None if not found
+        """
+        feedback_df = self.load_feedback(experiment_id)
+
+        if feedback_df is None or len(feedback_df) == 0:
+            return None
+
+        # Filter for specific message
+        message_feedback = feedback_df[
+            (feedback_df['user_id'] == user_id) &
+            (feedback_df['stage'] == stage) &
+            (feedback_df['experiment_id'] == experiment_id)
+        ]
+
+        if len(message_feedback) > 0:
+            return message_feedback.iloc[0].to_dict()
+
+        return None
+
+    def delete_feedback(
+        self,
+        experiment_id: str,
+        user_id: int,
+        stage: int
+    ) -> bool:
+        """
+        Delete feedback for a specific message.
+
+        Args:
+            experiment_id: Experiment ID
+            user_id: User ID
+            stage: Stage number
+
+        Returns:
+            bool: True if deleted successfully, False otherwise
+        """
+        try:
+            feedback_df = self.load_feedback(experiment_id)
+
+            if feedback_df is None or len(feedback_df) == 0:
+                return False
+
+            # Remove the feedback
+            updated_feedback = feedback_df[
+                ~((feedback_df['user_id'] == user_id) &
+                  (feedback_df['stage'] == stage) &
+                  (feedback_df['experiment_id'] == experiment_id))
+            ]
+
+            # Save updated feedback
+            feedback_file = self.get_feedback_file_path(experiment_id)
+            updated_feedback.to_csv(feedback_file, index=False, encoding='utf-8-sig')
+
+            return True
+
+        except Exception as e:
+            st.error(f"Error deleting feedback: {e}")
+            return False
+
+    def get_feedback_stats(self, experiment_id: str, total_messages: int = None) -> Dict:
+        """
+        Get feedback statistics for an experiment.
+
+        Args:
+            experiment_id: Experiment ID
+            total_messages: Total number of messages generated (optional, for accurate rejection rate)
+
+        Returns:
+            dict: Feedback statistics
+        """
+        feedback_df = self.load_feedback(experiment_id)
+
+        if feedback_df is None or len(feedback_df) == 0:
+            return {
+                "total_feedback": 0,
+                "total_rejects": 0,
+                "reject_rate": 0.0,
+                "rejection_reasons": {}
+            }
+
+        total_feedback = len(feedback_df)
+        total_rejects = len(feedback_df[feedback_df['feedback_type'] == 'reject'])
+
+        # Count rejection reasons
+        rejection_reasons = {}
+        if total_rejects > 0:
+            reason_counts = feedback_df[
+                feedback_df['feedback_type'] == 'reject'
+            ]['rejection_reason'].value_counts().to_dict()
+
+            rejection_reasons = {
+                REJECTION_REASONS.get(k, k): v
+                for k, v in reason_counts.items()
+                if k is not None and pd.notna(k)
+            }
+
+        # Calculate rejection rate based on total messages (not total feedback)
+        # Since users only provide feedback for rejected messages
+        if total_messages is not None and total_messages > 0:
+            reject_rate = (total_rejects / total_messages * 100)
+        else:
+            # Fallback to old calculation if total_messages not provided
+            reject_rate = (total_rejects / total_feedback * 100) if total_feedback > 0 else 0.0
+
+        stats = {
+            "total_feedback": total_feedback,
+            "total_rejects": total_rejects,
+            "reject_rate": reject_rate,
+            "rejection_reasons": rejection_reasons
+        }
+
+        return stats
+
+    def get_stage_feedback_stats(self, experiment_id: str, messages_df: pd.DataFrame = None) -> pd.DataFrame:
+        """
+        Get feedback statistics by stage.
+
+        Args:
+            experiment_id: Experiment ID
+            messages_df: DataFrame of all messages (optional, for accurate rejection rate per stage)
+
+        Returns:
+            pd.DataFrame: Stage-wise feedback statistics
+        """
+        feedback_df = self.load_feedback(experiment_id)
+
+        if feedback_df is None or len(feedback_df) == 0:
+            return pd.DataFrame(columns=['stage', 'total_messages', 'total_feedback', 'rejects', 'reject_rate'])
+
+        # Get total messages per stage from messages_df if provided
+        stage_message_counts = {}
+        if messages_df is not None and 'stage' in messages_df.columns:
+            stage_message_counts = messages_df.groupby('stage').size().to_dict()
+
+        # Group by stage
+        stage_stats = []
+        for stage in sorted(feedback_df['stage'].unique()):
+            stage_feedback = feedback_df[feedback_df['stage'] == stage]
+            total_feedback = len(stage_feedback)
+            rejects = len(stage_feedback[stage_feedback['feedback_type'] == 'reject'])
+
+            # Calculate rejection rate based on total messages for this stage
+            total_messages_for_stage = stage_message_counts.get(stage, total_feedback)
+            reject_rate = (rejects / total_messages_for_stage * 100) if total_messages_for_stage > 0 else 0.0
+
+            stage_stats.append({
+                'stage': stage,
+                'total_messages': total_messages_for_stage,
+                'total_feedback': total_feedback,
+                'rejects': rejects,
+                'reject_rate': reject_rate
+            })
+
+        return pd.DataFrame(stage_stats)
+
+    def compare_experiments(
+        self,
+        experiment_id_a: str,
+        experiment_id_b: str,
+        total_messages_a: int = None,
+        total_messages_b: int = None
+    ) -> Dict:
+        """
+        Compare feedback statistics between two experiments.
+
+        Args:
+            experiment_id_a: First experiment ID
+            experiment_id_b: Second experiment ID
+            total_messages_a: Total messages in experiment A (optional, for accurate rejection rate)
+            total_messages_b: Total messages in experiment B (optional, for accurate rejection rate)
+
+        Returns:
+            dict: Comparison statistics
+        """
+        stats_a = self.get_feedback_stats(experiment_id_a, total_messages=total_messages_a)
+        stats_b = self.get_feedback_stats(experiment_id_b, total_messages=total_messages_b)
+
+        comparison = {
+            "experiment_a": {
+                "id": experiment_id_a,
+                "stats": stats_a
+            },
+            "experiment_b": {
+                "id": experiment_id_b,
+                "stats": stats_b
+            },
+            "difference": {
+                "reject_rate": stats_a['reject_rate'] - stats_b['reject_rate']
+            }
+        }
+
+        return comparison
+
+    def export_feedback(self, experiment_id: str, export_path: Path) -> bool:
+        """
+        Export feedback to CSV file.
+
+        Args:
+            experiment_id: Experiment ID
+            export_path: Export file path
+
+        Returns:
+            bool: True if exported successfully, False otherwise
+        """
+        try:
+            feedback_df = self.load_feedback(experiment_id)
+
+            if feedback_df is None:
+                return False
+
+            feedback_df.to_csv(export_path, index=False, encoding='utf-8-sig')
+            return True
+
+        except Exception as e:
+            st.error(f"Error exporting feedback: {e}")
+            return False
+
+    def get_rejection_reason_label(self, reason_key: str) -> str:
+        """
+        Get human-readable label for rejection reason key.
+
+        Args:
+            reason_key: Rejection reason key
+
+        Returns:
+            str: Human-readable label
+        """
+        return REJECTION_REASONS.get(reason_key, reason_key)
+
+    def get_all_rejection_reasons(self) -> Dict[str, str]:
+        """
+        Get all available rejection reasons.
+
+        Returns:
+            dict: Dictionary mapping keys to labels
+        """
+        return REJECTION_REASONS.copy()

utils/theme.py

@@ -0,0 +1,335 @@
+"""
+Brand-specific theming module for the AI Messaging System Visualization Tool.
+
+Provides dynamic color schemes and styling based on selected brand.
+"""
+
+import streamlit as st
+from typing import Dict, Tuple
+
+# Brand color definitions (primary, secondary, accent)
+BRAND_COLORS = {
+    "base": {
+        "primary": "#FFD700",      # Gold
+        "secondary": "#2C2C2C",    # Dark gray
+        "accent": "#1A1A1A",       # Black
+        "text": "#FFFFFF",         # White
+        "background": "#0D0D0D",   # Very dark
+        "sidebar_bg": "#8B7500"    # Darker gold for sidebar
+    },
+    "drumeo": {
+        "primary": "#5DADE2",      # Light blue
+        "secondary": "#FFD700",    # Gold
+        "accent": "#2874A6",       # Darker blue
+        "text": "#FFFFFF",         # White
+        "background": "#1C2833",   # Dark blue-gray
+        "sidebar_bg": "#1A4D6B"    # Darker blue for sidebar
+    },
+    "pianote": {
+        "primary": "#EC7063",      # Light red
+        "secondary": "#FFD700",    # Gold
+        "accent": "#C0392B",       # Darker red
+        "text": "#FFFFFF",         # White
+        "background": "#1C1C1C",   # Dark
+        "sidebar_bg": "#8B2500"    # Darker red for sidebar
+    },
+    "guitareo": {
+        "primary": "#58D68D",      # Light green
+        "secondary": "#FFD700",    # Gold
+        "accent": "#229954",       # Darker green
+        "text": "#FFFFFF",         # White
+        "background": "#1C2E1F",   # Dark green-gray
+        "sidebar_bg": "#1B5E20"    # Darker green for sidebar
+    },
+    "singeo": {
+        "primary": "#BB8FCE",      # Light purple
+        "secondary": "#FFD700",    # Gold
+        "accent": "#7D3C98",       # Darker purple
+        "text": "#FFFFFF",         # White
+        "background": "#1F1926",   # Dark purple-gray
+        "sidebar_bg": "#4A148C"    # Darker purple for sidebar
+    }
+}
+
+# Brand emojis
+BRAND_EMOJIS = {
+    "drumeo": "🥁",
+    "pianote": "🎹",
+    "guitareo": "🎸",
+    "singeo": "🎤"
+}
+
+
+def get_brand_theme(brand: str) -> Dict[str, str]:
+    """
+    Get color theme for specified brand.
+
+    Args:
+        brand: Brand name (drumeo, pianote, guitareo, singeo)
+
+    Returns:
+        dict: Color theme dictionary
+    """
+    brand_lower = brand.lower() if brand else "base"
+    return BRAND_COLORS.get(brand_lower, BRAND_COLORS["base"])
+
+
+def get_brand_emoji(brand: str) -> str:
+    """
+    Get emoji for specified brand.
+
+    Args:
+        brand: Brand name
+
+    Returns:
+        str: Brand emoji
+    """
+    brand_lower = brand.lower() if brand else ""
+    return BRAND_EMOJIS.get(brand_lower, "🎵")
+
+
+def apply_theme(brand: str = None):
+    """
+    Apply brand-specific theme to Streamlit app.
+
+    Args:
+        brand: Brand name (optional, uses session state if not provided)
+    """
+    if brand is None:
+        brand = st.session_state.get("selected_brand", "base")
+
+    theme = get_brand_theme(brand)
+
+    # Custom CSS for brand theming
+    css = f"""
+    <style>
+    /* Global styles */
+    .stApp {{
+        background-color: {theme['background']};
+    }}
+
+    /* Text colors */
+    h1, h2, h3, h4, h5, h6 {{
+        color: {theme['primary']} !important;
+    }}
+
+    p, span, div {{
+        color: {theme['text']} !important;
+    }}
+
+    /* Button styles */
+    .stButton > button {{
+        background-color: {theme['primary']};
+        color: {theme['background']};
+        border: none;
+        border-radius: 8px;
+        padding: 0.5rem 1rem;
+        font-weight: 600;
+        transition: all 0.3s ease;
+    }}
+
+    .stButton > button:hover {{
+        background-color: {theme['secondary']};
+        transform: translateY(-2px);
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
+    }}
+
+    /* Download button */
+    .stDownloadButton > button {{
+        background-color: {theme['accent']};
+        color: {theme['text']};
+        border-radius: 8px;
+        font-weight: 600;
+    }}
+
+    /* Input fields */
+    .stTextInput > div > div > input,
+    .stTextArea > div > div > textarea,
+    .stNumberInput > div > div > input {{
+        background-color: {theme['secondary']};
+        color: {theme['text']};
+        border: 1px solid {theme['primary']};
+        border-radius: 5px;
+    }}
+
+    /* Select boxes */
+    .stSelectbox > div > div {{
+        background-color: {theme['secondary']};
+        color: {theme['text']};
+        border-radius: 5px;
+    }}
+
+    /* Multiselect */
+    .stMultiSelect > div > div {{
+        background-color: {theme['secondary']};
+        border-radius: 5px;
+    }}
+
+    /* Tabs */
+    .stTabs [data-baseweb="tab-list"] {{
+        gap: 8px;
+    }}
+
+    .stTabs [data-baseweb="tab"] {{
+        background-color: {theme['secondary']};
+        color: {theme['text']};
+        border-radius: 5px 5px 0 0;
+        padding: 10px 20px;
+        font-weight: 600;
+    }}
+
+    .stTabs [aria-selected="true"] {{
+        background-color: {theme['primary']};
+        color: {theme['background']};
+    }}
+
+    /* Progress bar */
+    .stProgress > div > div > div {{
+        background-color: {theme['primary']};
+    }}
+
+    /* Expanders */
+    .streamlit-expanderHeader {{
+        background-color: {theme['secondary']};
+        color: {theme['primary']};
+        border-radius: 5px;
+        font-weight: 600;
+    }}
+
+    /* Cards/Containers */
+    .element-container {{
+        background-color: transparent;
+    }}
+
+    /* Sidebar */
+    [data-testid="stSidebar"] {{
+        background-color: {theme['sidebar_bg']};
+    }}
+
+    [data-testid="stSidebar"] h1,
+    [data-testid="stSidebar"] h2,
+    [data-testid="stSidebar"] h3 {{
+        color: {theme['text']} !important;
+    }}
+
+    [data-testid="stSidebar"] p,
+    [data-testid="stSidebar"] span,
+    [data-testid="stSidebar"] div,
+    [data-testid="stSidebar"] label {{
+        color: {theme['text']} !important;
+    }}
+
+    /* Metrics */
+    [data-testid="stMetricValue"] {{
+        color: {theme['primary']} !important;
+        font-size: 2rem;
+        font-weight: bold;
+    }}
+
+    /* Divider */
+    hr {{
+        border-color: {theme['primary']};
+        opacity: 0.3;
+    }}
+
+    /* Checkbox */
+    .stCheckbox {{
+        color: {theme['text']};
+    }}
+
+    /* Radio */
+    .stRadio > div {{
+        color: {theme['text']};
+    }}
+
+    /* Success/Info/Warning/Error boxes */
+    .stSuccess {{
+        background-color: rgba(88, 214, 141, 0.1);
+        color: {theme['text']};
+    }}
+
+    .stInfo {{
+        background-color: rgba(93, 173, 226, 0.1);
+        color: {theme['text']};
+    }}
+
+    .stWarning {{
+        background-color: rgba(255, 215, 0, 0.1);
+        color: {theme['text']};
+    }}
+
+    .stError {{
+        background-color: rgba(236, 112, 99, 0.1);
+        color: {theme['text']};
+    }}
+
+    /* DataFrames */
+    .dataframe {{
+        border: 1px solid {theme['primary']};
+    }}
+
+    /* Custom card styling */
+    .message-card {{
+        background-color: {theme['secondary']};
+        border-left: 4px solid {theme['primary']};
+        border-radius: 8px;
+        padding: 1rem;
+        margin: 0.5rem 0;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
+    }}
+
+    .message-card:hover {{
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
+        transform: translateX(4px);
+        transition: all 0.3s ease;
+    }}
+
+    /* Small text */
+    .small {{
+        font-size: 0.85rem;
+        opacity: 0.7;
+    }}
+
+    /* Badge styles */
+    .badge {{
+        display: inline-block;
+        padding: 0.25rem 0.5rem;
+        border-radius: 12px;
+        font-size: 0.75rem;
+        font-weight: 600;
+        background-color: {theme['accent']};
+        color: {theme['text']};
+    }}
+    </style>
+    """
+
+    st.markdown(css, unsafe_allow_html=True)
+
+
+def create_card(content: str, key: str = None) -> None:
+    """
+    Create a styled card container.
+
+    Args:
+        content: HTML content to display in card
+        key: Optional unique key for the card
+    """
+    st.markdown(
+        f'<div class="message-card">{content}</div>',
+        unsafe_allow_html=True
+    )
+
+
+def create_badge(text: str, color: str = None) -> str:
+    """
+    Create a styled badge element.
+
+    Args:
+        text: Badge text
+        color: Optional custom color
+
+    Returns:
+        str: HTML for badge
+    """
+    style = f'background-color: {color};' if color else ''
+    return f'<span class="badge" style="{style}">{text}</span>'

visualization/check_env.py

@@ -1,85 +0,0 @@
-"""
-Environment Variable Check Script
-Verifies that all required environment variables are set correctly.
-"""
-
-import os
-from pathlib import Path
-from dotenv import load_dotenv
-
-# Load environment variables
-env_path = Path(__file__).parent / '.env'
-if env_path.exists():
-    load_dotenv(env_path)
-    print(f"✅ Found .env file at: {env_path}")
-else:
-    # Try parent directory
-    parent_env_path = Path(__file__).parent.parent / '.env'
-    if parent_env_path.exists():
-        load_dotenv(parent_env_path)
-        print(f"✅ Found .env file at: {parent_env_path}")
-    else:
-        print("❌ No .env file found!")
-        print(f"   Expected locations:")
-        print(f"   - {env_path}")
-        print(f"   - {parent_env_path}")
-        print("\n💡 Create a .env file using .env.example as a template:")
-        print("   cp .env.example .env")
-        exit(1)
-
-print("\n" + "="*60)
-print("Environment Variables Check")
-print("="*60 + "\n")
-
-# Required variables
-required_vars = {
-    "Snowflake": [
-        "SNOWFLAKE_USER",
-        "SNOWFLAKE_PASSWORD",
-        "SNOWFLAKE_ACCOUNT",
-        "SNOWFLAKE_ROLE",
-        "SNOWFLAKE_DATABASE",
-        "SNOWFLAKE_WAREHOUSE",
-        "SNOWFLAKE_SCHEMA"
-    ],
-    "API Keys": [
-        "OPENAI_API_KEY",
-        "GOOGLE_API_KEY"
-    ],
-    "Application": [
-        "APP_TOKEN"
-    ]
-}
-
-all_good = True
-
-for category, vars_list in required_vars.items():
-    print(f"\n{category}:")
-    print("-" * 40)
-
-    for var in vars_list:
-        value = os.getenv(var)
-        if value:
-            # Mask sensitive values
-            if len(value) > 10:
-                masked = value[:4] + "..." + value[-4:]
-            else:
-                masked = "***"
-            print(f"  ✅ {var}: {masked}")
-        else:
-            print(f"  ❌ {var}: NOT SET")
-            all_good = False
-
-print("\n" + "="*60)
-
-if all_good:
-    print("✅ All required environment variables are set!")
-    print("\n🚀 You're ready to run the application:")
-    print("   streamlit run app.py")
-else:
-    print("❌ Some environment variables are missing!")
-    print("\n💡 Please edit your .env file and set all required variables.")
-    print("   Use .env.example as a reference.")
-    exit(1)
-
-print("="*60 + "\n")