Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,765 +1,329 @@
-import streamlit as st
-import google.generativeai as genai
-import tempfile
 import os
 import time
+import tempfile
+import logging
 import json
-from typing import Optional
+from typing import Dict, Any, List, Literal
+
 import pandas as pd
-import logging
-from database import insert_analysis_result
-from dotenv import load_dotenv
-
-load_dotenv()
-
-# Backend API Key Configuration
-GEMINI_API_KEY = os.getenv("GEMINI_KEY")
-
-# Page configuration
-st.set_page_config(
-    page_title="Video Analyser and Script Generator",
-    page_icon="🎥",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Enhanced logging configuration
-logging.basicConfig(
-    level=logging.DEBUG,  # Changed to DEBUG for more detailed logs
-    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
-    handlers=[
-        logging.StreamHandler()
-    ]
-)
+import streamlit as st
+from pydantic import BaseModel, constr
+from google import genai
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()])
 logger = logging.getLogger(__name__)
 
-def configure_gemini():
-    """Configure Gemini API with backend key"""
-    logger.info("Starting Gemini API configuration...")
-    
+st.set_page_config(page_title="Video Ad Analyzer", page_icon="🎬", layout="wide")
+
+GEMINI_API_KEY = os.getenv("GEMINI_KEY", "")
+
+def configure_gemini() -> genai.Client:
     if not GEMINI_API_KEY:
-        error_msg = "GEMINI_KEY not found in environment variables"
-        logger.error(error_msg)
-        st.error(error_msg)
-        return False
-    
-    logger.info(f"API Key found, length: {len(GEMINI_API_KEY)}")
-    logger.debug(f"API Key starts with: {GEMINI_API_KEY[:10]}..." if len(GEMINI_API_KEY) > 10 else "API Key too short")
-    
+        raise RuntimeError("GEMINI_KEY is not set in environment variables.")
+    return genai.Client(api_key=GEMINI_API_KEY)
+
+Timestamp = constr(pattern=r'^\d{2}:\d{2}$')
+RangeTimestamp = constr(pattern=r'^\d{2}:\d{2}-\d{2}:\d{2}$')
+Score010 = constr(pattern=r'^(?:10|[0-9])\/10$')
+
+class Hook(BaseModel):
+    hook_text: str
+    principle: str
+    advantages: List[str]
+
+class StoryboardItem(BaseModel):
+    timeline: Timestamp
+    scene: str
+    visuals: str
+    dialogue: str
+    camera: str
+    sound_effects: str
+
+class ScriptLine(BaseModel):
+    timeline: Timestamp
+    dialogue: str
+
+class VideoMetric(BaseModel):
+    timestamp: RangeTimestamp
+    element: str
+    current_approach: str
+    effectiveness_score: Score010
+    notes: str
+
+class VideoAnalysis(BaseModel):
+    effectiveness_factors: str
+    psychological_triggers: str
+    target_audience: str
+    video_metrics: List[VideoMetric]
+
+class TimestampImprovement(BaseModel):
+    timestamp: RangeTimestamp
+    current_element: str
+    improvement_type: str
+    recommended_change: str
+    expected_impact: str
+    priority: Literal["High", "Medium", "Low"]
+
+class AdAnalysis(BaseModel):
+    brief: str
+    caption_details: str
+    hook: Hook
+    framework_analysis: str
+    storyboard: List[StoryboardItem]
+    script: List[ScriptLine]
+    video_analysis: VideoAnalysis
+    timestamp_improvements: List[TimestampImprovement]
+
+analyser_prompt = """You are an expert video advertisement analyst. Analyze the provided video and give response conforms EXACTLY to the schema below with no extra text or markdown. Populate:
+
+1. **brief** → A concise summary covering visual style, speaker, target audience, and marketing objective.  
+2. **caption_details** → Description of captions (color/style/position) or exactly the string `"None"` if not visible.  
+3. **hook** →  
+   - `"hook_text"`: Exact opening line or, if no speech, the precise description of the opening visual.  
+   - `"principle"`: Psychological/marketing principle that makes this hook effective.  
+   - `"advantages"`: ARRAY of 3–6 concise benefit statements tied to the ad’s value proposition.  
+4. **framework_analysis** → A detailed block identifying copywriting/psychology/storytelling frameworks (e.g., PAS, AIDA). Highlight use of social proof, urgency, fear, authority, scroll-stopping hooks, loop openers, value positioning, and risk reversals.  
+5. **storyboard** → ARRAY of 4–10 objects. Each must include:  
+   - `"timeline"` in `"MM:SS"` (zero-padded)  
+   - `"scene"` (brief)  
+   - `"visuals"` (detailed)  
+   - `"dialogue"` (exact words; use `""` if none)  
+   - `"camera"` (shot/angle)  
+   - `"sound_effects"` (or `"None"`)  
+6. **script** → ARRAY of dialogue objects, each with `"timeline"` (`"MM:SS"`) and `"dialogue"` (exact spoken line).  
+7. **video_analysis** → OBJECT with:  
+   - `"effectiveness_factors"`: Key factors that influence effectiveness  
+   - `"psychological_triggers"`: Triggers used (e.g., scarcity, authority)  
+   - `"target_audience"`: Audience profile inferred  
+   - `"video_metrics"`: ARRAY of objects with:  
+     - `"timestamp"`: `"MM:SS-MM:SS"`  
+     - `"element"`: The aspect being evaluated (e.g., Hook Strategy)  
+     - `"current_approach"`: Description of current execution  
+     - `"effectiveness_score"`: String score `"X/10"` (integer X)  
+     - `"notes"`: Analytical notes  
+8. **timestamp_improvements** → ARRAY of recommendation objects with:  
+   - `"timestamp"`: `"MM:SS-MM:SS"`  
+   - `"current_element"`: Current content of the segment  
+   - `"improvement_type"`: Category (e.g., Hook Enhancement)  
+   - `"recommended_change"`: Specific recommendation  
+   - `"expected_impact"`: Projected effect on metrics or perception  
+   - `"priority"`: `"High"`, `"Medium"`, or `"Low"`
+
+⚠️ The output must be strictly matching field names and types, no additional keys, and all timestamps must be zero-padded (`"MM:SS"` for single points, `"MM:SS-MM:SS"` for ranges).
+"""
+
+def analyze_video_only(video_path: str) -> Dict[str, Any]:
+    client = configure_gemini()
     try:
-        genai.configure(api_key=GEMINI_API_KEY)
-        logger.info("Gemini API configured successfully")
-        
-        # Test API connection
-        logger.info("Testing API connection...")
-        models = list(genai.list_models())
-        logger.info(f"Available models: {[model.name for model in models]}")
-        
-        return True
-    except Exception as e:
-        error_msg = f"Failed to configure Gemini API: {str(e)}"
-        logger.error(error_msg, exc_info=True)
-        st.error(error_msg)
-        return False
-
-# Enhanced system prompt with timestamp-based improvements
-SYSTEM_PROMPT = f"""{os.getenv("SYS_PROMPT", "")}"""
-logger.info(f"System prompt loaded, length: {len(SYSTEM_PROMPT) if SYSTEM_PROMPT else 0}")
-
-def analyze_video_and_generate_script(
-        video_bytes,
-        video_name,
-        offer_details: str = "",
-        target_audience: str = "",
-        specific_hooks: str = "",
-        additional_context: str = ""
-):
-    """
-    Analyze video and generate direct response script variations
-    """
-    logger.info(f"Starting video analysis for: {video_name}")
-    logger.info(f"Video size: {len(video_bytes)} bytes")
-    
-    try:
-        # Save uploaded video to temporary file
-        logger.info("Creating temporary file...")
-        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(video_name)[1]) as tmp_file:
-            tmp_file.write(video_bytes)
-            tmp_file_path = tmp_file.name
-        
-        logger.info(f"Temporary file created: {tmp_file_path}")
-        logger.info(f"File size on disk: {os.path.getsize(tmp_file_path)} bytes")
-        
-        # Configure Gemini
-        logger.info("Configuring Gemini API...")
-        if not configure_gemini():
-            logger.error("Gemini configuration failed")
-            return None
-        
-        # Show upload progress
-        upload_progress = st.progress(0)
-        upload_status = st.empty()
-        
-        upload_status.text("Uploading video to Google AI...")
-        upload_progress.progress(20)
-        logger.info("Starting file upload to Gemini...")
-        
-        try:
-            # Upload video to Gemini
-            video_file_obj = genai.upload_file(tmp_file_path)
-            logger.info(f"File uploaded successfully. File URI: {video_file_obj.uri}")
-            logger.info(f"File state: {video_file_obj.state.name}")
-            upload_progress.progress(40)
-            
-        except Exception as upload_error:
-            error_msg = f"File upload failed: {str(upload_error)}"
-            logger.error(error_msg, exc_info=True)
-            upload_status.error(error_msg)
-            return None
-        
-        upload_status.text("Processing video...")
-        logger.info("Waiting for video processing...")
-        
-        processing_attempts = 0
-        max_processing_attempts = 30  # 1 minute timeout
-        
-        while video_file_obj.state.name == "PROCESSING":
-            processing_attempts += 1
-            logger.debug(f"Processing attempt {processing_attempts}/{max_processing_attempts}")
-            
-            if processing_attempts > max_processing_attempts:
-                error_msg = "Video processing timed out after 1 minute"
-                logger.error(error_msg)
-                upload_status.error(error_msg)
-                return None
-            
+        video_file = client.files.upload(file=video_path)
+        while getattr(video_file.state, "name", "") == "PROCESSING":
             time.sleep(2)
-            try:
-                video_file_obj = genai.get_file(video_file_obj.name)
-                logger.debug(f"Processing state: {video_file_obj.state.name}")
-            except Exception as get_file_error:
-                logger.error(f"Error checking file status: {str(get_file_error)}", exc_info=True)
-                break
-                
-            upload_progress.progress(40 + (processing_attempts * 20 // max_processing_attempts))
-        
-        logger.info(f"Final file state: {video_file_obj.state.name}")
-        
-        if video_file_obj.state.name == "FAILED":
-            error_msg = "Google AI file processing failed. Please try another video."
-            logger.error(error_msg)
-            upload_status.error(error_msg)
-            return None
-        
-        if video_file_obj.state.name != "ACTIVE":
-            error_msg = f"Unexpected file state: {video_file_obj.state.name}"
-            logger.error(error_msg)
-            upload_status.error(error_msg)
-            return None
-        
-        upload_progress.progress(80)
-        upload_status.text("Generating script variations...")
-        logger.info("Starting content generation...")
-            
-        # Build the enhanced user prompt
-        user_prompt = f"""Analyze this reference video and generate 3 high-converting direct response video script variations with detailed timestamp-based improvements.
-
-        IMPORTANT CONTEXT TO FOLLOW WHEN CREATING OUTPUT:
-        - Offer Details: {offer_details}
-        - Target Audience: {target_audience}
-        - Specific Hooks: {specific_hooks}
-
-        ADDITIONAL CONTEXT (MANDATORY TO FOLLOW):
-        {additional_context}
-
-        You must reflect this additional context in:
-        - The script tone, CTA, visuals
-        - Compliance or branding constraints
-        - Any assumptions about audience or product
-
-        Failure to include this will be considered incomplete.
-
-        Please provide a comprehensive analysis including:
-
-        1. DETAILED VIDEO ANALYSIS with timestamp-based metrics:
-           - Break down the video into 5-10 second segments
-           - Rate each segment's effectiveness (1-10 scale)
-           - Identify specific elements (hook, transition, proof, CTA, etc.)
-
-        2. TIMESTAMP-BASED IMPROVEMENTS:
-           - Specific recommendations for each time segment
-           - Priority level for each improvement
-           - Expected impact of implementing changes
-
-        3. SCRIPT VARIATIONS:
-           - Create 2-3 complete script variations
-           - Each with timestamp-by-timestamp breakdown
-           - Different psychological triggers and approaches
-
-        IMPORTANT: Return only valid JSON in the exact format specified in the system prompt. Analyze the video second-by-second for maximum detail."""
-
-        logger.info(f"User prompt length: {len(user_prompt)}")
-        logger.info(f"System prompt length: {len(SYSTEM_PROMPT) if SYSTEM_PROMPT else 0}")
-
-        # Generate response
-        try:
-            logger.info("Creating GenerativeModel instance...")
-            model = genai.GenerativeModel("gemini-2.0-flash-exp")
-            logger.info("Model created successfully")
-            
-            logger.info("Generating content with video and prompts...")
-            full_prompt = user_prompt + "\n\n" + (SYSTEM_PROMPT or "")
-            logger.debug(f"Full prompt length: {len(full_prompt)}")
-            
-            response = model.generate_content([video_file_obj, full_prompt])
-            logger.info("Content generation completed successfully")
-            logger.debug(f"Response text length: {len(response.text) if hasattr(response, 'text') else 'No text attribute'}")
-            
-        except Exception as generation_error:
-            error_msg = f"Error generating content with Gemini: {str(generation_error)}"
-            logger.error(error_msg, exc_info=True)
-            upload_status.error(error_msg)
-            return None
-        
-        upload_progress.progress(100)
-        upload_status.success("Analysis complete!")
-        logger.info("Video analysis completed successfully")
-        
-        # Clean up temporary file
+            video_file = client.files.get(name=video_file.name)
+        if getattr(video_file.state, "name", "") == "FAILED":
+            return {}
+        resp = client.models.generate_content(
+            model="gemini-2.0-flash",
+            contents=[analyser_prompt, video_file],
+            config={"response_mime_type": "application/json"}
+        )
+        raw = getattr(resp, "text", "") or ""
         try:
-            os.unlink(tmp_file_path)
-            logger.info(f"Temporary file deleted: {tmp_file_path}")
-        except Exception as cleanup_error:
-            logger.warning(f"Failed to delete temporary file: {str(cleanup_error)}")
-        
-        # Parse JSON response
-        logger.info("Parsing JSON response...")
+            model_obj = AdAnalysis.model_validate_json(raw)
+            return model_obj.model_dump()
+        except Exception:
+            try:
+                return json.loads(raw)
+            except Exception:
+                return {}
+    except Exception:
+        return {}
+
+def _normalize_list(value: Any) -> List[str]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return [str(v) for v in value]
+    return [s for s in str(value).splitlines() if s.strip()]
+
+def _to_dataframe(items: Any, columns_map: Dict[str, str]) -> pd.DataFrame:
+    if not isinstance(items, list) or not items:
+        return pd.DataFrame(columns=list(columns_map.values()))
+    df = pd.DataFrame(items)
+    df = df.rename(columns=columns_map)
+    ordered_cols = [columns_map[k] for k in columns_map.keys() if columns_map[k] in df.columns]
+    df = df.reindex(columns=ordered_cols)
+    return df
+
+def _mean_effectiveness(metrics: List[Dict[str, Any]]) -> float:
+    if not metrics:
+        return 0.0
+    scores = []
+    for m in metrics:
+        s = str(m.get("effectiveness_score", "0/10")).split("/")[0]
         try:
-            if not hasattr(response, 'text'):
-                error_msg = "Response object has no text attribute"
-                logger.error(error_msg)
-                st.error(error_msg)
-                return None
-                
-            response_text = response.text.strip()
-            logger.debug(f"Raw response text preview: {response_text[:500]}...")
-            
-            if response_text.startswith('```json'):
-                response_text = response_text[7:-3]
-                logger.debug("Removed json code block markers")
-            elif response_text.startswith('```'):
-                response_text = response_text[3:-3]
-                logger.debug("Removed generic code block markers")
-            
-            logger.debug(f"Cleaned response text preview: {response_text[:500]}...")
-            
-            json_response = json.loads(response_text)
-            logger.info("JSON parsing successful")
-            logger.debug(f"JSON keys: {list(json_response.keys()) if isinstance(json_response, dict) else 'Not a dict'}")
-            
-            return json_response
-            
-        except json.JSONDecodeError as json_error:
-            error_msg = f"Error parsing AI response as JSON: {str(json_error)}"
-            logger.error(error_msg)
-            logger.error(f"Response text that failed to parse: {response_text[:1000]}...")
-            st.error(error_msg)
-            st.text_area("Raw Response (for debugging):", response_text, height=200)
-            return None
-        
-    except Exception as e:
-        error_msg = f"Unexpected error processing video: {str(e)}"
-        logger.error(error_msg, exc_info=True)
-        st.error(error_msg)
-        return None
-
-def display_script_variations(json_data):
-    """Display script variations in formatted tables"""
-    logger.info("Displaying script variations...")
-    
-    if not json_data or "script_variations" not in json_data:
-        error_msg = "No script variations found in the response"
-        logger.error(error_msg)
-        logger.debug(f"JSON data keys: {list(json_data.keys()) if isinstance(json_data, dict) else 'Not a dict'}")
-        st.error(error_msg)
+            scores.append(int(s))
+        except Exception:
+            pass
+    return round(sum(scores) / len(scores), 2) if scores else 0.0
+
+def _search_dataframe(df: pd.DataFrame, query: str) -> pd.DataFrame:
+    if not query or df.empty:
+        return df
+    mask = pd.Series([False]*len(df))
+    for col in df.columns:
+        mask = mask | df[col].astype(str).str.contains(query, case=False, na=False)
+    return df[mask]
+
+def render_analyzer_results(analysis: Dict[str, Any]) -> None:
+    if not isinstance(analysis, dict) or not analysis:
+        st.warning("No analysis available.")
         return
-    
-    try:
-        variations = json_data["script_variations"]
-        logger.info(f"Found {len(variations)} script variations")
-        
-        for i, variation in enumerate(variations, 1):
-            variation_name = variation.get("variation_name", f"Variation {i}")
-            logger.debug(f"Processing variation {i}: {variation_name}")
-
-            st.markdown(f"### Variation {i}: {variation_name}")
-
-            # Convert script table to DataFrame for better display
-            script_data = variation.get("script_table")
-            if not script_data:
-                warning_msg = f"No script data for {variation_name}"
-                logger.warning(warning_msg)
-                st.warning(warning_msg)
-                continue
-
-            logger.debug(f"Script data for {variation_name}: {len(script_data)} rows")
-            
-            df = pd.DataFrame(script_data)
-
-            # Rename columns for better display
-            df = df.rename(columns={
-                'timestamp': 'Timestamp',
-                'script_voiceover': 'Script / Voiceover',
-                'visual_direction': 'Visual Direction',
-                'psychological_trigger': 'Psychological Trigger',
-                'cta_action': 'CTA / Action'
-            })
-
-            st.table(df)
-            st.markdown("---")
-            
-        logger.info("Script variations displayed successfully")
-        
-    except Exception as e:
-        error_msg = f"Error displaying script variations: {str(e)}"
-        logger.error(error_msg, exc_info=True)
-        st.error(error_msg)
-
-def display_video_analysis(json_data):
-    """Display video analysis in tabular format"""
-    logger.info("Displaying video analysis...")
-    
-    if not json_data or "video_analysis" not in json_data:
-        error_msg = "No video analysis found in the response"
-        logger.error(error_msg)
-        st.error(error_msg)
-        return
-    
-    try:
-        analysis = json_data["video_analysis"]
-        logger.debug(f"Video analysis type: {type(analysis)}")
-
-        # Display general analysis
-        video_metrics = []
-        if isinstance(analysis, dict):
-            col1, col2 = st.columns(2)
-
-            with col1:
-                st.subheader("Effectiveness Factors")
-                effectiveness = analysis.get('effectiveness_factors', 'N/A')
-                st.write(effectiveness)
-                logger.debug(f"Effectiveness factors: {effectiveness}")
-
-                st.subheader("Target Audience")
-                audience = analysis.get('target_audience', 'N/A')
-                st.write(audience)
-                logger.debug(f"Target audience: {audience}")
-
-            with col2:
-                st.subheader("Psychological Triggers")
-                triggers = analysis.get('psychological_triggers', 'N/A')
-                st.write(triggers)
-                logger.debug(f"Psychological triggers: {triggers}")
-
-            video_metrics = analysis.get("video_metrics", [])
-            logger.debug(f"Video metrics count: {len(video_metrics)}")
 
+    st.markdown("""
+        <style>
+        .metric-card {background: #0f172a; padding: 14px 16px; border-radius: 14px; border: 1px solid #1f2937;}
+        .section-card {background: #0b1220; padding: 18px; border-radius: 14px; border: 1px solid #1f2937;}
+        .label {font-size: 12px; color: #94a3b8; margin-bottom: 6px;}
+        .value {font-size: 16px; color: #e2e8f0;}
+        </style>
+    """, unsafe_allow_html=True)
+
+    va = analysis.get("video_analysis", {}) or {}
+    storyboard = analysis.get("storyboard", []) or []
+    script = analysis.get("script", []) or []
+    metrics = va.get("video_metrics", []) or []
+    mean_score = _mean_effectiveness(metrics)
+
+    mcol1, mcol2, mcol3, mcol4 = st.columns([1,1,1,1])
+    with mcol1:
+        st.markdown(f'<div class="metric-card"><div class="label">Scenes</div><div class="value">{len(storyboard)}</div></div>', unsafe_allow_html=True)
+    with mcol2:
+        st.markdown(f'<div class="metric-card"><div class="label">Dialogue Lines</div><div class="value">{len(script)}</div></div>', unsafe_allow_html=True)
+    with mcol3:
+        st.markdown(f'<div class="metric-card"><div class="label">Avg Effectiveness</div><div class="value">{mean_score}/10</div></div>', unsafe_allow_html=True)
+    with mcol4:
+        st.markdown(f'<div class="metric-card"><div class="label">Improvements</div><div class="value">{len(analysis.get("timestamp_improvements", []) or [])}</div></div>', unsafe_allow_html=True)
+
+    colA, colB = st.columns([1.3,1])
+    with colA:
+        with st.container():
+            st.markdown("### Executive Summary")
+            c1, c2 = st.columns(2)
+            with c1:
+                with st.expander("Brief", expanded=True):
+                    st.write(analysis.get("brief", "N/A"))
+                with st.expander("Caption Details", expanded=False):
+                    st.write(analysis.get("caption_details", "N/A"))
+            with c2:
+                hook = analysis.get("hook", {}) or {}
+                with st.expander("Hook", expanded=True):
+                    st.markdown(f"**Opening:** {hook.get('hook_text','N/A')}")
+                    st.markdown(f"**Principle:** {hook.get('principle','N/A')}")
+                    adv = _normalize_list(hook.get("advantages"))
+                    if adv:
+                        st.markdown("**Advantages:**")
+                        st.markdown("\n".join([f"- {a}" for a in adv]))
+        st.divider()
+        st.markdown("### Narrative & Copy Frameworks")
+        with st.expander("Framework Analysis", expanded=True):
+            st.write(analysis.get("framework_analysis", "N/A"))
+
+    with colB:
+        st.markdown("### Snapshot")
+        with st.container():
+            st.caption("Top Drivers")
+            st.markdown(f'<div class="section-card">{va.get("effectiveness_factors","N/A")}</div>', unsafe_allow_html=True)
+        st.markdown("")
+        with st.container():
+            st.caption("Psychological Triggers")
+            st.markdown(f'<div class="section-card">{va.get("psychological_triggers","N/A")}</div>', unsafe_allow_html=True)
+        st.markdown("")
+        with st.container():
+            st.caption("Target Audience")
+            st.markdown(f'<div class="section-card">{va.get("target_audience","N/A")}</div>', unsafe_allow_html=True)
+
+    st.divider()
+
+    tabs = st.tabs(["Storyboard", "Script", "Scored Metrics", "Improvements", "Raw JSON"])
+
+    with tabs[0]:
+        q = st.text_input("Search storyboard")
+        if storyboard:
+            df = _to_dataframe(storyboard, {"timeline": "Timeline", "scene": "Scene", "visuals": "Visuals", "dialogue": "Dialogue", "camera": "Camera", "sound_effects": "Sound Effects"})
+            df = _search_dataframe(df, q)
+            st.dataframe(df, use_container_width=True, height=480)
         else:
-            warning_msg = "Unexpected format in video_analysis. Skipping metadata."
-            logger.warning(warning_msg)
-            st.warning(warning_msg)
-            if isinstance(analysis, list):
-                video_metrics = analysis
-
-        if video_metrics:
-            logger.info(f"Processing {len(video_metrics)} video metrics")
-            metrics_df = pd.DataFrame(video_metrics)
-            
-            # Rename columns for better display
-            column_mapping = {
-                'timestamp': 'Timestamp',
-                'element': 'Element',
-                'current_approach': 'Current Approach',
-                'effectiveness_score': 'Score',
-                'notes': 'Analysis Notes'
-            }
-            
-            metrics_df = metrics_df.rename(columns=column_mapping)
-            logger.debug(f"Metrics dataframe columns: {list(metrics_df.columns)}")
-            
-            st.dataframe(
-                metrics_df,
-                use_container_width=True,
-                hide_index=True,
-                column_config={
-                    "Timestamp": st.column_config.TextColumn(width="small"),
-                    "Element": st.column_config.TextColumn(width="medium"),
-                    "Current Approach": st.column_config.TextColumn(width="large"),
-                    "Score": st.column_config.TextColumn(width="small"),
-                    "Analysis Notes": st.column_config.TextColumn(width="large")
-                }
-            )
+            st.info("No storyboard available.")
+
+    with tabs[1]:
+        q2 = st.text_input("Search script")
+        if script:
+            df = _to_dataframe(script, {"timeline": "Timeline", "dialogue": "Dialogue"})
+            df = _search_dataframe(df, q2)
+            st.dataframe(df, use_container_width=True, height=480)
         else:
-            warning_msg = "No detailed video metrics available"
-            logger.warning(warning_msg)
-            st.warning(warning_msg)
-            
-        logger.info("Video analysis displayed successfully")
-        
-    except Exception as e:
-        error_msg = f"Error displaying video analysis: {str(e)}"
-        logger.error(error_msg, exc_info=True)
-        st.error(error_msg)
-
-def display_timestamp_improvements(json_data):
-    """Display timestamp-based improvements in tabular format"""
-    logger.info("Displaying timestamp improvements...")
-    
-    improvements = json_data.get("timestamp_improvements")
-
-    if improvements is None:
-        error_msg = "No timestamp improvements found in the response"
-        logger.error(error_msg)
-        st.error(error_msg)
-        return
-
-    if not improvements:
-        warning_msg = "No timestamp improvements available"
-        logger.warning(warning_msg)
-        st.warning(warning_msg)
-        return
-
-    try:
-        st.subheader("Timestamp-by-Timestamp Improvement Recommendations")
-        logger.info(f"Processing {len(improvements)} improvement recommendations")
-        
-        improvements_df = pd.DataFrame(improvements)
-        
-        # Rename columns for better display
-        column_mapping = {
-            'timestamp': 'Timestamp',
-            'current_element': 'Current Element',
-            'improvement_type': 'Improvement Type',
-            'recommended_change': 'Recommended Change',
-            'expected_impact': 'Expected Impact',
-            'priority': 'Priority'
-        }
-        
-        improvements_df = improvements_df.rename(columns=column_mapping)
-        logger.debug(f"Improvements dataframe columns: {list(improvements_df.columns)}")
-        
-        # Color code priority
-        def color_priority(val):
-            if val == 'High':
-                return 'background-color: #ffcccb'
-            elif val == 'Medium':
-                return 'background-color: #ffffcc'
-            elif val == 'Low':
-                return 'background-color: #ccffcc'
-            return ''
-        
-        styled_df = improvements_df.style.applymap(color_priority, subset=['Priority'])
-        
-        st.dataframe(
-            styled_df,
-            use_container_width=True,
-            hide_index=True,
-            column_config={
-                "Timestamp": st.column_config.TextColumn(width="small"),
-                "Current Element": st.column_config.TextColumn(width="medium"),
-                "Improvement Type": st.column_config.TextColumn(width="medium"),
-                "Recommended Change": st.column_config.TextColumn(width="large"),
-                "Expected Impact": st.column_config.TextColumn(width="medium"),
-                "Priority": st.column_config.TextColumn(width="small")
-            }
-        )
-        
-        logger.info("Timestamp improvements displayed successfully")
-        
-    except Exception as e:
-        error_msg = f"Error displaying timestamp improvements: {str(e)}"
-        logger.error(error_msg, exc_info=True)
-        st.error(error_msg)
-
-def create_csv_download(json_data):
-    """Create CSV content with all scripts combined"""
-    logger.info("Creating CSV download...")
-    
-    try:
-        all_scripts_data = []
-        
-        # Combine all script variations into one dataset
-        for i, variation in enumerate(json_data.get("script_variations", []), 1):
-            variation_name = variation.get("variation_name", f"Variation {i}")
-            logger.debug(f"Processing variation for CSV: {variation_name}")
-            
-            for row in variation.get("script_table", []):
-                script_row = {
-                    'Variation': variation_name,
-                    'Timestamp': row.get('timestamp', ''),
-                    'Script_Voiceover': row.get('script_voiceover', ''),
-                    'Visual_Direction': row.get('visual_direction', ''),
-                    'Psychological_Trigger': row.get('psychological_trigger', ''),
-                    'CTA_Action': row.get('cta_action', '')
-                }
-                all_scripts_data.append(script_row)
-        
-        # Convert to DataFrame and then to CSV
-        if all_scripts_data:
-            df = pd.DataFrame(all_scripts_data)
-            csv_content = df.to_csv(index=False)
-            logger.info(f"CSV created successfully with {len(all_scripts_data)} rows")
-            return csv_content
+            st.info("No script breakdown available.")
+
+    with tabs[2]:
+        q3 = st.text_input("Search metrics")
+        if metrics:
+            dfm = _to_dataframe(metrics, {"timestamp": "Timestamp", "element": "Element", "current_approach": "Current Approach", "effectiveness_score": "Effectiveness Score", "notes": "Notes"})
+            dfm = _search_dataframe(dfm, q3)
+            st.dataframe(dfm, use_container_width=True, height=480)
         else:
-            logger.warning("No script data available for CSV")
-            return "No script data available"
-            
-    except Exception as e:
-        error_msg = f"Error creating CSV: {str(e)}"
-        logger.error(error_msg, exc_info=True)
-        return f"Error creating CSV: {error_msg}"
-
-def check_token(user_token):
-    logger.info("Checking access token...")
-    
-    ACCESS_TOKEN = os.getenv("ACCESS_TOKEN")
-    if not ACCESS_TOKEN:
-        error_msg = "ACCESS_TOKEN not set in environment."
-        logger.critical(error_msg)
-        return False, "Server error: Access token not configured."
-    
-    if user_token == ACCESS_TOKEN:
-        logger.info("Access token validated successfully.")
-        return True, ""
-    
-    logger.warning("Invalid access token attempt.")
-    return False, "Invalid token."
+            st.info("No video metrics available.")
+
+    with tabs[3]:
+        improvements = analysis.get("timestamp_improvements", []) or []
+        q4 = st.text_input("Search improvements")
+        if improvements:
+            imp_df = _to_dataframe(improvements, {"timestamp": "Timestamp", "current_element": "Current Element", "improvement_type": "Improvement Type", "recommended_change": "Recommended Change", "expected_impact": "Expected Impact", "priority": "Priority"})
+            if "Priority" in imp_df.columns:
+                order = pd.CategoricalDtype(["High", "Medium", "Low"], ordered=True)
+                imp_df["Priority"] = imp_df["Priority"].astype(order)
+                if "Timestamp" in imp_df.columns:
+                    imp_df = imp_df.sort_values(["Priority", "Timestamp"])
+            imp_df = _search_dataframe(imp_df, q4)
+            st.dataframe(imp_df, use_container_width=True, height=480)
+        else:
+            st.info("No timestamp-based improvements available.")
+
+    with tabs[4]:
+        pretty = json.dumps(analysis, indent=2, ensure_ascii=False)
+        st.code(pretty, language="json")
+        st.download_button("Download JSON", data=pretty.encode("utf-8"), file_name="ad_analysis.json", mime="application/json", use_container_width=True)
+
+def workspace_tab():
+    with st.sidebar:
+        st.header("Input")
+        uploaded_video = st.file_uploader("Upload Video", type=["mp4", "mov", "avi", "mkv"], accept_multiple_files=False)
+        run_btn = st.button("Analyze Video", use_container_width=True)
+        st.markdown("---")
+        st.caption("Session")
+        clear = st.button("Clear Output", use_container_width=True)
+    st.title("🎬 Video Ad Analyzer")
+    if "analysis" not in st.session_state or clear:
+        st.session_state["analysis"] = None
+    if run_btn:
+        if not uploaded_video:
+            st.error("Please upload a video.")
+            return
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(uploaded_video.name)[1]) as tmp:
+            tmp.write(uploaded_video.read())
+            video_path = tmp.name
+        with st.spinner("Analyzing video..."):
+            st.session_state["analysis"] = analyze_video_only(video_path)
+    if st.session_state.get("analysis"):
+        render_analyzer_results(st.session_state["analysis"])
+    else:
+        st.info("Upload a video and click Analyze to see results.")
 
 def main():
-    """Main application function"""
-    logger.info("Starting main application...")
-
-    if "authenticated" not in st.session_state:
-        st.session_state["authenticated"] = False
-        logger.debug("Authentication state initialized")
-
-    if not st.session_state["authenticated"]:
-        logger.info("User not authenticated, showing login screen")
-        st.markdown("## Access Required")
-        token_input = st.text_input("Enter Access Token", type="password")
-        if st.button("Unlock App"):
-            ok, error_msg = check_token(token_input)
-            if ok:
-                st.session_state["authenticated"] = True
-                logger.info("User authenticated successfully")
-                st.rerun()
-            else:
-                logger.warning(f"Authentication failed: {error_msg}")
-                st.error(error_msg)
-        return
-
-    # Add API test button for debugging
-    if st.sidebar.button("🔧 Test API Connection"):
-        logger.info("Testing API connection...")
-        try:
-            genai.configure(api_key=GEMINI_API_KEY)
-            models = list(genai.list_models())
-            st.sidebar.success(f"✅ API Working! Found {len(models)} models")
-            logger.info(f"API test successful, found {len(models)} models")
-            for model in models[:3]:  # Show first 3 models
-                st.sidebar.text(f"• {model.name}")
-        except Exception as e:
-            error_msg = f"❌ API Test Failed: {str(e)}"
-            st.sidebar.error(error_msg)
-            logger.error(f"API test failed: {str(e)}", exc_info=True)
-
-    # Sidebar navigation
-    if st.session_state["authenticated"]:
-        logger.info("User authenticated, showing main interface")
-
-        selected_tab = st.sidebar.radio("Select Mode", ["Script Generator", "History"])
-        logger.debug(f"Selected tab: {selected_tab}")
-
-        # ========== SCRIPT GENERATOR ==========
-        if selected_tab == "Script Generator":
-            logger.info("Script Generator mode selected")
-            
-            with st.expander("How to Use This Tool", expanded=False):
-                st.markdown("""
-                ### Upload Guidelines:
-                - **Best videos to analyze**: Already profitable Facebook/TikTok ads in your niche  
-                - **Video length**: 30–90 seconds work best for analysis  
-                - **Quality**: Clear audio and visuals help with better analysis  
-
-                ### Context Tips:
-                - **Offer details**: Be specific about your main promise and mechanism  
-                - **Audience**: Include demographics, pain points, and desires  
-                - **Hooks**: Mention any specific angles that have worked for you  
-
-                ### Script Optimization:
-                - Generated scripts focus on stopping scroll and driving clicks  
-                - Each variation tests different psychological triggers  
-                - Use the timestamp format for precise video production  
-                - Test multiple variations to find your best performer  
-                """)
-            st.subheader("Input Configuration")
-
-            uploaded_video = st.file_uploader(
-                "Upload Reference Video",
-                type=['mp4', 'mov', 'avi', 'mkv'],
-                help="Upload a profitable ad video to analyze and create variations from"
-            )
-            
-            if uploaded_video is not None:
-                logger.info(f"Video uploaded: {uploaded_video.name}, size: {uploaded_video.size} bytes")
-            else:
-                st.info("Please upload a reference video to begin analysis.")
-
-            st.subheader("Additional Context (Optional)")
-            
-            offer_details = st.text_area(
-                "Offer Details",
-                placeholder="e.g., Solar installation with $0 down payment...",
-                height=80,
-                help="Describe the product/service and main promise"
-            )
-            
-            target_audience = st.text_area(
-                "Target Audience",
-                placeholder="e.g., 40+ homeowners with high electricity bills...",
-                height=80,
-                help="Describe the ideal customer demographics and pain points"
-            )
-            
-            specific_hooks = st.text_area(
-                "Specific Hooks to Test",
-                placeholder="e.g., Government rebate angle, celebrity endorsement...",
-                height=80,
-                help="Any specific angles or hooks you want to incorporate"
-            )
-            
-            additional_context = st.text_area(
-                "Additional Context",
-                placeholder="Any other relevant information...",
-                height=100,
-                help="Compliance requirements, brand guidelines, or other notes"
-            )
-
-            generate_button = st.button("Generate Script Variations", use_container_width=True)
-
-            if "analysis_results" in st.session_state and st.session_state["analysis_results"]:
-                if st.button("Clear Results", use_container_width=True):
-                    del st.session_state["analysis_results"]
-                    logger.info("Analysis results cleared")
-                    st.rerun()
-
-            # Generate & show results
-            if uploaded_video and generate_button:
-                logger.info("Starting video analysis process...")
-                
-                with st.spinner("Analyzing video and generating scripts..."):
-                    video_bytes = uploaded_video.read()
-                    uploaded_video.seek(0)
-
-                    json_response = analyze_video_and_generate_script(
-                        video_bytes,
-                        uploaded_video.name,
-                        offer_details,
-                        target_audience,
-                        specific_hooks,
-                        additional_context
-                    )
-
-                if json_response:
-                    logger.info("Analysis completed successfully, saving to database...")
-                    try:
-                        insert_analysis_result(
-                            video_name=uploaded_video.name,
-                            offer_details=offer_details,
-                            target_audience=target_audience,
-                            specific_hook=specific_hooks,
-                            additional_context=additional_context,
-                            response=json_response
-                        )
-                        logger.info("Results saved to database")
-                    except Exception as db_error:
-                        logger.error(f"Failed to save to database: {str(db_error)}", exc_info=True)
-                        st.warning("Analysis completed but failed to save to database")
-                    
-                    st.session_state["analysis_results"] = json_response
-                else:
-                    logger.error("Analysis failed, no response received")
-
-            if "analysis_results" in st.session_state:
-                logger.info("Displaying analysis results...")
-                json_response = st.session_state["analysis_results"]
-
-                tab1, tab2, tab3 = st.tabs(["Script Variations", "Video Analysis", "Improvement Recommendations"])
-                
-                with tab1:
-                    display_script_variations(json_response)
-                    csv_content = create_csv_download(json_response)
-                    st.download_button("Download All Scripts (CSV)", data=csv_content,
-                                       file_name="video_script_variations.csv", mime="text/csv")
-                with tab2:
-                    display_video_analysis(json_response)
-                with tab3:
-                    display_timestamp_improvements(json_response)
-
-        # ========== HISTORY ==========
-        elif selected_tab == "History":
-            logger.info("History mode selected")
-            
-            try:
-                from database import get_all_results
-                history_items = get_all_results(limit=20)
-                logger.info(f"Retrieved {len(history_items) if history_items else 0} history items")
-
-                if history_items:
-                    video_titles = [
-                        f"{item['video_name']} ({item['created_at'].strftime('%Y-%m-%d %H:%M')})"
-                        for item in history_items
-                    ]
-
-                    selected = st.sidebar.radio("History Items", video_titles, index=0)
-                    selected_index = video_titles.index(selected)
-                    selected_data = history_items[selected_index]
-                    
-                    logger.info(f"Selected history item: {selected_data['video_name']}")
-
-                    st.subheader(f"Analysis for: {selected_data['video_name']}")
-                    json_response = selected_data.get("response")
-
-                    if json_response:
-                        tab1, tab2, tab3 = st.tabs(["Script Variations", "Video Analysis", "Improvement Recommendations"])
-
-                        with tab1:
-                            display_script_variations(json_response)
-                        with tab2:
-                            display_video_analysis(json_response)
-                        with tab3:
-                            display_timestamp_improvements(json_response)
-                    else:
-                        warning_msg = "No valid response data for this analysis."
-                        logger.warning(warning_msg)
-                        st.warning(warning_msg)
-                else:
-                    logger.info("No history items found")
-                    st.sidebar.info("No saved analyses found.")
-                    st.info("No saved history available.")
-                    
-            except Exception as history_error:
-                error_msg = f"Error loading history: {str(history_error)}"
-                logger.error(error_msg, exc_info=True)
-                st.error(error_msg)
+    workspace_tab()
 
 if __name__ == "__main__":
     try:
-        logger.info("=" * 50)
-        logger.info("LAUNCHING VIDEO ANALYZER APPLICATION")
-        logger.info("=" * 50)
+        logger.info("Launching Streamlit app...")
         main()
     except Exception as e:
-        logger.exception("CRITICAL ERROR: Unhandled error during app launch")
-        st.error(f"Critical application error: {str(e)}")
-        st.error("Please check the logs for more details.")
+        logger.exception("Unhandled error during app launch.")