Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,13 +1,11 @@
 """
-Fake Review Detector - Streamlit Application
-Optimized for Hugging Face Spaces deployment
+Review Validator - Final Professional Edition
 """
 
 import os
 import io
+import time
 import numpy as np
-from collections import Counter
-from typing import Dict, Optional, List, Tuple
 import streamlit as st
 from transformers import pipeline, logging as hf_logging
 from PIL import Image
@@ -18,416 +16,353 @@ import urllib.parse
 import math
 import warnings
 
-# -------------------------
-# Log Suppression
-# -------------------------
-# 1. Suppress Python Warnings (Deprecation, UserWarning)
-warnings.filterwarnings("ignore", category=UserWarning, module="transformers")
-warnings.filterwarnings("ignore", category=FutureWarning, module="transformers")
-
-# 2. Suppress Hugging Face Informational Logs (Weights initialization, CPU usage)
+# --- Setup: Silence the technical noise ---
+warnings.filterwarnings("ignore")
 hf_logging.set_verbosity_error()
-
-# 3. Suppress TensorFlow/PyTorch logs if backend triggers them
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
-
-# Set matplotlib backend for server environments
 matplotlib.use('Agg')
 
-# -------------------------
-# Configuration
-# -------------------------
 st.set_page_config(
-    page_title="Review Validator 🍔",
-    page_icon="🍔",
+    page_title="Review Validator",
+    page_icon="🛡️",
     layout="wide",
     initial_sidebar_state="collapsed"
 )
 
-# Constants
-FAKE_MODEL_NAME = "akshit4857/autotrain-razz4-h7crd"
-SENTIMENT_MODEL_NAME = "cardiffnlp/twitter-roberta-base-sentiment-latest"
-EMOTION_MODEL_NAME = "j-hartmann/emotion-english-distilroberta-base"
-# Primary Image Model (High Precision)
-IMAGE_MODEL_PRIMARY = "mikedata/real_vs_fake_image_model_vit_base"
-# Backup Image Model (High Reliability)
-IMAGE_MODEL_BACKUP = "umm-maybe/AI-image-detector"
+# ==========================================
+# 🧠 THE AI BRAINS (High Precision Models)
+# ==========================================
 
-MAX_TEXT_LENGTH = 5000
+# 1. Bot Detector: The gold standard for catching GPT-written text
+MODEL_FAKE = "fakespot-ai/roberta-base-ai-text-detection-v1"
 
-# -------------------------
-# Secrets & Environment Management
-# -------------------------
-def get_secret(key: str, default: str = None) -> Optional[str]:
-    """
-    Robust secret retrieval.
-    Prioritizes Environment Variables (HF Spaces) to avoid Streamlit secrets file errors.
-    """
-    # 1. Priority: Environment Variables (Hugging Face Secrets)
-    if key in os.environ:
-        return os.environ[key]
-    
-    # 2. Fallback: Streamlit Secrets (Local .toml file)
-    try:
-        if hasattr(st, 'secrets') and key in st.secrets:
-            return st.secrets[key]
-    except Exception:
-        # Ignore errors if secrets.toml doesn't exist
-        pass
-    
-    return default
+# 2. Mood Scanner: Checks detailed sentiment
+MODEL_MOOD = "cardiffnlp/twitter-roberta-base-sentiment-latest"
 
-HF_TOKEN = get_secret("HF_TOKEN")
-OPENAI_API_KEY = get_secret("OPENAI_API_KEY")
+# 3. Grammar Checker: Catches unnatural "perfect" bot grammar
+MODEL_GRAMMAR = "textattack/roberta-base-CoLA"
 
-# -------------------------
-# Custom CSS
-# -------------------------
+# 4. Image Checker A: High Precision (Strict)
+MODEL_IMG_A = "dima806/ai_vs_real_image_detection"
+
+# 5. Image Checker B: High Reliability (Broad)
+MODEL_IMG_B = "umm-maybe/AI-image-detector"
+
+# ==========================================
+
+# --- Secrets Management ---
+def get_token():
+    if key := os.environ.get("HF_TOKEN"): return key
+    if hasattr(st, "secrets") and "HF_TOKEN" in st.secrets: return st.secrets["HF_TOKEN"]
+    return None
+
+HF_TOKEN = get_token()
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+
+# --- Custom CSS ---
 def inject_custom_css():
     st.markdown("""
     <style>
-        .stApp { background: linear-gradient(to bottom, #ffffff, #f8f9fa); }
-        h1 { font-family: 'Source Sans Pro', sans-serif; color: #FF4B4B; text-align: center; font-weight: 800; }
-        .stButton>button { border-radius: 50px; border: 2px solid #FF4B4B; background-color: white; color: #FF4B4B; font-weight: bold; transition: all 0.3s ease; }
-        .stButton>button:hover { background-color: #FF4B4B; color: white; transform: scale(1.02); }
-        .stat-card { background-color: white; border-radius: 20px; padding: 15px; box-shadow: 0 4px 15px rgba(0,0,0,0.05); text-align: center; border: 1px solid #f0f0f0; height: 100%; }
-        .stat-value { font-size: 1.8em; font-weight: 900; color: #333; }
-        .stat-label { font-size: 0.8em; color: #888; text-transform: uppercase; letter-spacing: 1px; }
-        .report-box { background-color: #ffffff; padding: 25px; border-radius: 20px; border: 2px dashed #e0e0e0; }
+        /* Modern Clean Look */
+        .stApp { background-color: #FFFFFF; color: #333333; font-family: 'Helvetica Neue', sans-serif; }
+        
+        /* Headings */
+        h1 { color: #2C3E50; font-weight: 800; }
+        h2 { color: #34495E; font-weight: 600; }
+        
+        /* Hero Section */
+        .hero-box {
+            padding: 40px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            border-radius: 20px;
+            color: white;
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        .hero-title { font-size: 3rem; font-weight: bold; margin-bottom: 10px; }
+        .hero-subtitle { font-size: 1.2rem; opacity: 0.9; }
+        
+        /* Feature Cards */
+        .feature-card {
+            background: #F8F9FA;
+            padding: 20px;
+            border-radius: 15px;
+            border: 1px solid #EEEEEE;
+            text-align: center;
+            transition: transform 0.2s;
+        }
+        .feature-card:hover { transform: translateY(-5px); border-color: #764ba2; }
+        .emoji-icon { font-size: 3rem; margin-bottom: 10px; display: block; }
+        
+        /* Result Stats */
+        .stat-box {
+            text-align: center;
+            padding: 15px;
+            border-radius: 12px;
+            background: white;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.05);
+            border: 1px solid #EEE;
+        }
+        .stat-num { font-size: 24px; font-weight: 900; color: #333; }
+        .stat-txt { font-size: 12px; text-transform: uppercase; color: #777; letter-spacing: 1px; }
+        
+        /* Custom Button */
+        .stButton>button {
+            border-radius: 30px;
+            font-weight: bold;
+            border: none;
+            padding: 0.5rem 2rem;
+            transition: all 0.3s;
+        }
     </style>
     """, unsafe_allow_html=True)
 
-# -------------------------
-# Model Loading (Ensemble)
-# -------------------------
+# --- Load Models ---
 @st.cache_resource(show_spinner=False)
-def load_models() -> Tuple[Dict, List[str]]:
-    """
-    Load all models for the ensemble with individual error handling.
-    Returns: (models_dictionary, list_of_error_messages)
-    """
-    models = {}
-    errors = []
-    
-    # 1. Fake Detector (Critical)
-    try:
-        models['fake'] = pipeline("text-classification", model=FAKE_MODEL_NAME, token=HF_TOKEN)
-    except Exception as e:
-        errors.append(f"Fake Detector: {str(e)}")
-
-    # 2. Sentiment
+def load_ai_squad():
+    squad = {}
     try:
-        models['sentiment'] = pipeline("sentiment-analysis", model=SENTIMENT_MODEL_NAME, tokenizer=SENTIMENT_MODEL_NAME, token=HF_TOKEN)
-    except Exception as e:
-        errors.append(f"Sentiment Model: {str(e)}")
-
-    # 3. Emotion
-    try:
-        # top_k=None replaces deprecated return_all_scores=True
-        models['emotion'] = pipeline("text-classification", model=EMOTION_MODEL_NAME, top_k=None, token=HF_TOKEN)
-    except Exception as e:
-        errors.append(f"Emotion Model: {str(e)}")
-
-    # 4. Image (With Failover Strategy)
-    models['image_engine'] = "Offline"
-    try:
-        # Try primary precision model first
-        models['img_a'] = pipeline("image-classification", model=IMAGE_MODEL_PRIMARY, token=HF_TOKEN)
-        # Try backup model
-        models['img_b'] = pipeline("image-classification", model=IMAGE_MODEL_BACKUP, token=HF_TOKEN)
-        models['image_engine'] = "Dual-Core"
-    except Exception as e:
-        print(f"Dual engine load failed: {e}")
+        squad['fake'] = pipeline("text-classification", model=MODEL_FAKE, token=HF_TOKEN)
+        squad['mood'] = pipeline("sentiment-analysis", model=MODEL_MOOD, tokenizer=MODEL_MOOD, token=HF_TOKEN)
+        squad['grammar'] = pipeline("text-classification", model=MODEL_GRAMMAR, token=HF_TOKEN)
+        
         try:
-            if 'img_a' not in models:
-                 models['img_a'] = pipeline("image-classification", model=IMAGE_MODEL_PRIMARY, token=HF_TOKEN)
-            models['image_engine'] = "Single-Core"
-            errors.append("Note: Running in reduced precision mode (one image model failed).")
-        except Exception as e2:
-            models['image_engine'] = "Failed"
-            errors.append(f"Image Checker failed completely: {str(e2)}")
-
-    return models, errors
-
-# Initialize models
-inject_custom_css()
-with st.spinner("🍳 Prepping the Kitchen..."):
-    ensemble, load_errors = load_models()
-
-# Handle Critical Errors
-if 'fake' not in ensemble:
-    st.error("❌ Critical Error: Failed to load the core Fake Detection model.")
-    if load_errors: 
-        st.error(f"Details: {load_errors}")
-    st.stop()
-
-if load_errors:
-    with st.expander("⚠️ System Warnings", expanded=False):
-        for err in load_errors:
-            st.warning(err)
-
-# -------------------------
-# Advanced Feature Extraction
-# -------------------------
-def calculate_complexity_score(text: str) -> float:
-    """Calculate linguistic complexity (0-100)"""
-    words = text.split()
-    if not words: return 0
-    avg_len = sum(len(w) for w in words) / len(words)
-    ttr = len(set(words)) / len(words)
-    score = (avg_len * 5) + (ttr * 50)
-    return min(100, max(0, score))
+            squad['img_a'] = pipeline("image-classification", model=MODEL_IMG_A, token=HF_TOKEN)
+            squad['img_b'] = pipeline("image-classification", model=MODEL_IMG_B, token=HF_TOKEN)
+            squad['img_status'] = "Active"
+        except:
+            if 'img_a' not in squad:
+                squad['img_a'] = pipeline("image-classification", model=MODEL_IMG_A, token=HF_TOKEN)
+            squad['img_status'] = "Partial"
+            
+    except Exception as e:
+        return None, str(e)
+    return squad, None
 
-def extract_deep_features(text: str, models: dict) -> Dict:
-    """Run multi-model analysis"""
-    sent_label = "Unknown"
-    sent_score = 0.0
-    top_emo = {'label': 'Unknown', 'score': 0.0}
+# --- Logic: Analyze Text ---
+def check_text(text, squad):
+    # 1. Bot Check
+    res_fake = squad['fake'](text[:512])[0]
+    bot_score = res_fake['score'] if res_fake['label'] == 'Fake' else (1 - res_fake['score'])
 
-    # 1. Fake Detection
-    fake_res = models['fake'](text[:512])[0]
-    is_fake_prob = fake_res['score'] if fake_res['label'] == 'Fake' else (1 - fake_res['score'])
-    
-    # 2. Sentiment
-    if 'sentiment' in models:
-        try:
-            sent_res = models['sentiment'](text[:512])[0]
-            sent_score = sent_res['score']
-            sent_label = sent_res['label']
-        except Exception: pass
-    
-    # 3. Emotion
-    if 'emotion' in models:
-        try:
-            emo_res = models['emotion'](text[:512])[0]
-            top_emo = max(emo_res, key=lambda x: x['score'])
-        except Exception: pass
+    # 2. Mood Check
+    res_mood = squad['mood'](text[:512])[0]
     
-    complexity = calculate_complexity_score(text)
+    # 3. Grammar Check
+    res_grammar = squad['grammar'](text[:512])[0]
+    grammar_score = res_grammar['score'] if res_grammar['label'] == 'LABEL_1' else (1 - res_grammar['score'])
     
     return {
-        "fake_probability": is_fake_prob * 100,
-        "sentiment_label": sent_label,
-        "sentiment_confidence": sent_score * 100,
-        "primary_emotion": top_emo['label'],
-        "emotion_confidence": top_emo['score'] * 100,
-        "complexity_score": complexity
+        "bot_score": bot_score * 100,
+        "mood_label": res_mood['label'],
+        "grammar_score": grammar_score * 100
     }
 
-# -------------------------
-# AI-Powered Dynamic Explanation
-# -------------------------
-def generate_friendly_report(text: str, features: Dict) -> str:
-    """Generates a simple, friendly explanation"""
-    if not OPENAI_API_KEY:
-        return generate_fallback_report(features)
-        
-    prompt = (
-        f"Analyze this product/food review. Fake Score: {features['fake_probability']:.1f}%. "
-        f"Vibe: {features['primary_emotion']}. Text: {text[:600]}... "
-        "Explain if it sounds like a real customer or a bot. Be simple and helpful."
-    )
-    
-    try:
-        headers = {"Authorization": f"Bearer {OPENAI_API_KEY}", "Content-Type": "application/json"}
-        payload = {
-            "model": "gpt-4o-mini", 
-            "messages": [{"role": "user", "content": prompt}],
-            "temperature": 0.5
-        }
-        response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload, timeout=10)
-        return response.json()["choices"][0]["message"]["content"]
-    except:
-        return generate_fallback_report(features)
-
-def generate_fallback_report(features: Dict) -> str:
-    """Simple rule-based report"""
-    f_prob = features['fake_probability']
+# --- Logic: Analyze Image ---
+def check_image(img, squad):
+    score_a = 0.0
+    score_b = 0.0
+    ai_words = ['fake', 'artificial', 'ai', 'generated']
     
-    if f_prob > 50:
-        return f"⚠️ **Suspicious!** There is a {f_prob:.0f}% chance this review was written by a bot or paid service."
-    else:
-        return "✅ **Looks Good!** This review reads like a genuine customer experience."
-
-# -------------------------
-# Visualization: Radar Chart
-# -------------------------
-def create_radar_chart(features: Dict) -> plt.Figure:
-    """Creates a multi-aspect radar chart"""
-    categories = ['Suspiciousness', 'Feelings', 'Drama', 'Simplicity']
-    inv_comp = 100 - features['complexity_score']
-    
-    values = [
-        features['fake_probability'],
-        features['sentiment_confidence'],
-        features['emotion_confidence'],
-        inv_comp
-    ]
-    
-    # Close the loop
-    values += values[:1]
-    angles = [n / 4 * 2 * math.pi for n in range(4)] + [0]
-    
-    fig, ax = plt.subplots(figsize=(4, 4), subplot_kw=dict(polar=True))
+    if 'img_a' in squad:
+        for r in squad['img_a'](img):
+            if any(w in r['label'].lower() for w in ai_words): score_a = r['score']
     
-    # Styling
-    ax.set_facecolor('#ffffff')
-    plt.gcf().patch.set_facecolor('#ffffff')
-    
-    ax.plot(angles, values, linewidth=2, linestyle='solid', color='#FF4B4B')
-    ax.fill(angles, values, '#FF4B4B', alpha=0.2)
-    
-    ax.set_xticks(angles[:-1])
-    ax.set_xticklabels(categories, size=9)
-    ax.set_yticks([])
-    ax.spines['polar'].set_visible(False)
+    if 'img_b' in squad:
+        for r in squad['img_b'](img):
+            if any(w in r['label'].lower() for w in ai_words): score_b = r['score']
+    else: score_b = score_a 
+        
+    avg_ai = (score_a + score_b) / 2
+    match_level = 1.0 - abs(score_a - score_b)
     
-    return fig
+    return {"ai_chance": avg_ai * 100, "match": match_level}
 
-# -------------------------
-# Image Functions
-# -------------------------
-def get_image_from_url(url: str) -> Optional[Image.Image]:
+def get_image_from_url(url):
     try:
         headers = {'User-Agent': 'Mozilla/5.0'}
-        response = requests.get(url, headers=headers, timeout=10, stream=True)
-        response.raise_for_status()
-        return Image.open(io.BytesIO(response.content)).convert("RGB")
-    except Exception:
-        return None
-
-def analyze_image_dual_engine(img, models) -> Dict:
-    score_a_ai = 0.0
-    score_b_ai = 0.0
-    
-    # Engine A
-    if 'img_a' in models:
-        res_a = models['img_a'](img)
-        for r in res_a:
-            if r['label'].lower() in ['fake', 'artificial', 'ai', 'generated']:
-                score_a_ai = r['score']
-    
-    # Engine B
-    if 'img_b' in models:
-        res_b = models['img_b'](img)
-        for r in res_b:
-            if r['label'].lower() in ['fake', 'artificial', 'ai', 'generated']:
-                score_b_ai = r['score']
-    else:
-        score_b_ai = score_a_ai
-    
-    avg_ai_score = (score_a_ai + score_b_ai) / 2
-    agreement = 1.0 - abs(score_a_ai - score_b_ai)
+        r = requests.get(url, headers=headers, timeout=5, stream=True)
+        return Image.open(io.BytesIO(r.content)).convert("RGB")
+    except: return None
+
+# --- Plotting ---
+def simple_chart(stats):
+    labels = ['Bot Chance', 'Grammar', 'Mood']
+    values = [stats['bot_score'], stats['grammar_score'], 50]
+    values += values[:1]
+    angles = [n / 3 * 2 * math.pi for n in range(3)] + [0]
     
-    return {
-        "avg_ai": avg_ai_score,
-        "avg_real": 1.0 - avg_ai_score,
-        "score_a": score_a_ai,
-        "score_b": score_b_ai,
-        "agreement": agreement
-    }
+    fig, ax = plt.subplots(figsize=(3, 3), subplot_kw=dict(polar=True))
+    ax.set_facecolor('white')
+    plt.gcf().patch.set_facecolor('white')
+    ax.plot(angles, values, color='#764ba2', linewidth=2)
+    ax.fill(angles, values, color='#764ba2', alpha=0.2)
+    ax.set_xticks(angles[:-1]); ax.set_xticklabels(labels, size=8)
+    ax.set_yticks([]); ax.spines['polar'].set_visible(False)
+    return fig
 
-# -------------------------
-# Main UI
-# -------------------------
-def main():
+# --- PAGES ---
+
+def landing_page():
     st.markdown("""
-        <div style='text-align: center; padding-bottom: 20px;'>
-            <h1 style='margin:0;'>🍔 Review & Food Validator</h1>
-            <p style='color: #888;'>Is that burger real? Is that review a bot?</p>
-        </div>
+    <div class="hero-box">
+        <div class="hero-title">🛡️ Review Validator</div>
+        <div class="hero-subtitle">We check if reviews are Real or Fake. We check if product photos are Real or AI.</div>
+    </div>
     """, unsafe_allow_html=True)
+    
+    c1, c2, c3 = st.columns(3)
+    with c1:
+        st.markdown("""
+        <div class="feature-card">
+            <span class="emoji-icon">🤖</span>
+            <h3>Bot Buster</h3>
+            <p>We use AI to catch other AI! If a robot wrote the review, we will know.</p>
+        </div>
+        """, unsafe_allow_html=True)
+    with c2:
+        st.markdown("""
+        <div class="feature-card">
+            <span class="emoji-icon">📸</span>
+            <h3>Fake Photo Finder</h3>
+            <p>Is that burger real or drawn by a computer? We check the pixels.</p>
+        </div>
+        """, unsafe_allow_html=True)
+    with c3:
+        st.markdown("""
+        <div class="feature-card">
+            <span class="emoji-icon">👮</span>
+            <h3>Simple & Fast</h3>
+            <p>No complex words. Just Red (Bad) or Green (Good). Easy for everyone.</p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+    st.write("")
+    st.write("")
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        if st.button("🚀 START CHECKING REVIEWS NOW", type="primary", use_container_width=True):
+            st.session_state['page'] = 'detector'
+            st.rerun()
+
+def detector_page(squad):
+    # Header & Selector
+    c1, c2 = st.columns([3, 1])
+    with c1:
+        st.markdown("### 🛒 Select the Website")
+        platform = st.selectbox("Where is this review from?", ["Amazon", "Flipkart", "Zomato", "Swiggy", "Myntra", "Other"], label_visibility="collapsed")
+    with c2:
+        if st.button("⬅️ Back Home"):
+            st.session_state['page'] = 'landing'
+            st.rerun()
+            
+    st.divider()
+    
+    # Main Tabs
+    tab1, tab2 = st.tabs(["📝 Check Review Text", "📸 Check Product Image"])
 
-    tab1, tab2 = st.tabs(["📝 Review Text", "🍟 Food/Product Image"])
-
-    # --- TAB 1: TEXT ---
+    # --- TEXT ---
     with tab1:
-        col1, col2 = st.columns([3, 1])
+        col1, col2 = st.columns([2, 1])
         with col1:
-            txt = st.text_area("Paste Review:", height=120, placeholder="e.g. 'The pizza was cold and...'")
+            txt = st.text_area("Paste Review Here:", height=150, placeholder="Example: I ordered this yesterday and it is amazing...")
         with col2:
-            st.info("💡 **Tip:** Paste the full text for best results.")
-            if st.button("Scan Text", type="primary", use_container_width=True):
-                if not txt:
-                    st.toast("Please paste some text first!")
-                    st.stop()
-                    
-                with st.spinner("Analysing linguistics..."):
-                    feats = extract_deep_features(txt, ensemble)
-                    rep = generate_friendly_report(txt, feats)
-                    
-                    st.markdown("---")
-                    
-                    # Metrics
-                    c1, c2, c3, c4 = st.columns(4)
-                    c1.metric("Fake-o-Meter", f"{feats['fake_probability']:.0f}%")
-                    c2.metric("Mood", feats['sentiment_label'])
-                    c3.metric("Vibe", feats['primary_emotion'].title())
-                    c4.metric("Vocab", f"{feats['complexity_score']:.0f}/100")
-                    
-                    # Chart & Report
-                    col_c, col_r = st.columns([1, 2])
-                    with col_c:
-                        st.pyplot(create_radar_chart(feats))
-                    with col_r:
-                        st.markdown(f"<div class='report-box'>{rep}</div>", unsafe_allow_html=True)
+            st.info("💡 Tip: Paste the full review for the best result.")
+            if st.button("Analyze Text", type="primary", use_container_width=True):
+                if txt:
+                    res = check_text(txt, squad)
+                    st.session_state['text_res'] = res
+        
+        if 'text_res' in st.session_state:
+            res = st.session_state['text_res']
+            st.markdown("---")
+            
+            k1, k2, k3 = st.columns(3)
+            # Bot Score
+            color = "red" if res['bot_score'] > 50 else "green"
+            k1.markdown(f"""<div class="stat-box"><div class="stat-num" style="color:{color}">{res['bot_score']:.0f}%</div><div class="stat-txt">Bot Chance</div></div>""", unsafe_allow_html=True)
+            # Grammar
+            k2.markdown(f"""<div class="stat-box"><div class="stat-num">{res['grammar_score']:.0f}%</div><div class="stat-txt">Grammar Quality</div></div>""", unsafe_allow_html=True)
+            # Mood
+            k3.markdown(f"""<div class="stat-box"><div class="stat-num">{res['mood_label']}</div><div class="stat-txt">Review Mood</div></div>""", unsafe_allow_html=True)
+            
+            st.write("")
+            v1, v2 = st.columns([1, 2])
+            with v1: st.pyplot(simple_chart(res))
+            with v2:
+                if res['bot_score'] > 70:
+                    st.error("🚨 **FAKE ALERT:** This review looks like it was written by a robot.")
+                elif res['bot_score'] > 40:
+                    st.warning("🤔 **UNSURE:** It looks a bit weird, but could be real.")
+                else:
+                    st.success("✅ **REAL:** This looks like a genuine human review.")
 
-    # --- TAB 2: IMAGE ---
+    # --- IMAGE ---
     with tab2:
-        st.markdown("### 📸 Product & Food Verification")
-        st.caption("Step 1: Check for AI Generation. Step 2: Check if it's stolen from the web.")
-        
-        url = st.text_input("Paste Image URL (Right click image -> Copy Image Address):")
+        col_in, col_view = st.columns([1, 1])
         
-        if st.button("🔍 Validate Image", type="primary"):
-            if not url: st.stop()
+        with col_in:
+            st.markdown("#### Step 1: Provide Image")
+            method = st.radio("Input Method", ["Paste URL", "Upload File"], horizontal=True, label_visibility="collapsed")
             
-            if ensemble['image_engine'] == "Failed":
-                st.error("System Offline")
-                st.stop()
-                
-            with st.spinner("Forensic Scan in progress..."):
-                img = get_image_from_url(url)
+            img = None
+            if method == "Paste URL":
+                url = st.text_input("Paste Image Link:")
+                if url: img = get_image_from_url(url)
+            else:
+                up_file = st.file_uploader("Upload Image", type=['jpg','png','jpeg'])
+                if up_file: 
+                    try: img = Image.open(up_file).convert("RGB")
+                    except: st.error("Error reading file")
+
+            if st.button("Scan Image", type="primary", use_container_width=True):
                 if img:
-                    c_img, c_data = st.columns([1, 1])
-                    with c_img:
-                        st.image(img, use_column_width=True)
-                    
-                    with c_data:
-                        # Dual Engine Analysis
-                        res = analyze_image_dual_engine(img, ensemble)
-                        ai_p = res['avg_ai'] * 100
-                        real_p = res['avg_real'] * 100
-                        
-                        st.subheader("Step 1: AI Detection")
-                        
-                        # Verdict Logic
-                        if res['agreement'] < 0.6:
-                            st.warning("🤔 **Uncertain Result**")
-                            st.markdown("The models disagree. This might be a heavily filtered real photo.")
-                        elif ai_p > 60:
-                            st.error(f"🤖 **Likely AI Generated** ({ai_p:.0f}%)")
-                            st.markdown("Visual patterns suggest this is computer-generated.")
-                        elif real_p > 60:
-                            st.success(f"✅ **Likely Real Camera** ({real_p:.0f}%)")
-                            st.markdown("Visual noise patterns match a real camera sensor.")
-                        else:
-                            st.warning("🤷 **Inconclusive**")
+                    with st.spinner("Scanning for AI patterns..."):
+                        data = check_image(img, squad)
+                        st.session_state['img_res'] = data
+                        st.session_state['current_img'] = img
+                else:
+                    st.error("Please provide a valid image first.")
 
-                        st.progress(res['avg_ai'], text=f"AI Probability: {ai_p:.1f}%")
-                        
-                        st.markdown("---")
-                        st.subheader("Step 2: Internet Check")
-                        st.markdown("Check if this photo was **stolen** from another website (Recipe blog, Stock photo, etc).")
-                        
-                        lens = f"https://lens.google.com/uploadbyurl?url={urllib.parse.quote(url)}"
-                        st.markdown(f"""
-                        <a href="{lens}" target="_blank" style="display:block;text-align:center;background:#4285F4;color:white;padding:10px;border-radius:8px;text-decoration:none;font-weight:bold;">
-                        🌍 Check if image exists online
-                        </a>
-                        """, unsafe_allow_html=True)
+        with col_view:
+            if 'current_img' in st.session_state:
+                st.image(st.session_state['current_img'], use_column_width=True, caption="Analyzed Image")
+                
+            if 'img_res' in st.session_state:
+                data = st.session_state['img_res']
+                ai_score = data['ai_chance']
+                
+                st.markdown("#### Step 2: Results")
+                
+                if data['match'] < 0.6:
+                    st.warning("🤔 **Confusing Image:** Our models disagree. It might be heavily filtered.")
+                elif ai_score > 60:
+                    st.error(f"🤖 **AI GENERATED** ({ai_score:.0f}% sure)")
+                    st.write("We found digital patterns that cameras don't make.")
                 else:
-                    st.error("Could not load image. Check the link!")
+                    st.success(f"📸 **REAL PHOTO** ({100-ai_score:.0f}% sure)")
+                    st.write("This looks like a standard camera photo.")
+                
+                st.progress(ai_score/100, text="AI Probability Bar")
+
+# --- MAIN CONTROLLER ---
+def main():
+    inject_custom_css()
+    
+    if 'page' not in st.session_state:
+        st.session_state['page'] = 'landing'
+        
+    with st.spinner("Loading AI Models..."):
+        squad, err = load_ai_squad()
+        
+    if not squad:
+        st.error("System Error: Could not connect to AI brains.")
+        return
+
+    if st.session_state['page'] == 'landing':
+        landing_page()
+    else:
+        detector_page(squad)
 
 if __name__ == "__main__":
     main()