Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,137 +1,71 @@
 import streamlit as st
 import requests
 import json
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 import re
 from urllib.parse import quote
 import time
+from datetime import datetime
+import plotly.express as px
+import pandas as pd
+from collections import Counter
+import hashlib
 
-# Configure page
 st.set_page_config(
-    page_title="WikiBot - Multilingual Assistant",
-    page_icon="📚",
+    page_title="WikiBot Pro - AI-Powered Multilingual Assistant",
+    page_icon="🤖",
     layout="wide",
-    initial_sidebar_state="collapsed"
+    initial_sidebar_state="expanded"
 )
 
-# Language codes mapping
 LANGUAGES = {
-    "English": "en",
-    "Telugu": "te", 
-    "Hindi": "hi",
-    "Spanish": "es",
-    "French": "fr",
-    "German": "de",
-    "Italian": "it",
-    "Portuguese": "pt",
-    "Russian": "ru",
-    "Japanese": "ja",
-    "Chinese": "zh",
-    "Arabic": "ar",
-    "Korean": "ko"
+    "English": {"code": "en", "flag": "🇺🇸", "native": "English"},
+    "Telugu": {"code": "te", "flag": "🇮🇳", "native": "తెలుగు"},
+    "Hindi": {"code": "hi", "flag": "🇮🇳", "native": "हिन्दी"},
+    "Spanish": {"code": "es", "flag": "🇪🇸", "native": "Español"},
+    "French": {"code": "fr", "flag": "🇫🇷", "native": "Français"},
+    "German": {"code": "de", "flag": "🇩🇪", "native": "Deutsch"},
+    "Italian": {"code": "it", "flag": "🇮🇹", "native": "Italiano"},
+    "Portuguese": {"code": "pt", "flag": "🇵🇹", "native": "Português"},
+    "Russian": {"code": "ru", "flag": "🇷🇺", "native": "Русский"},
+    "Japanese": {"code": "ja", "flag": "🇯🇵", "native": "日本語"},
+    "Chinese": {"code": "zh", "flag": "🇨🇳", "native": "中文"},
+    "Arabic": {"code": "ar", "flag": "🇸🇦", "native": "العربية"},
+    "Korean": {"code": "ko", "flag": "🇰🇷", "native": "한국어"},
+    "Tamil": {"code": "ta", "flag": "🇮🇳", "native": "தமிழ்"},
+    "Bengali": {"code": "bn", "flag": "🇧🇩", "native": "বাংলা"},
+    "Marathi": {"code": "mr", "flag": "🇮🇳", "native": "मराठी"},
+    "Gujarati": {"code": "gu", "flag": "🇮🇳", "native": "ગુજરાતી"},
+    "Kannada": {"code": "kn", "flag": "🇮🇳", "native": "ಕನ್ನಡ"},
+    "Malayalam": {"code": "ml", "flag": "🇮🇳", "native": "മലയാളം"},
+    "Punjabi": {"code": "pa", "flag": "🇮🇳", "native": "ਪੰਜਾਬੀ"}
 }
 
-class OllamaLLM:
-    def __init__(self, base_url: str = "http://localhost:11434"):
-        self.base_url = base_url
-        self.api_url = f"{base_url}/api/generate"
-        self.models_url = f"{base_url}/api/tags"
-    
-    def check_connection(self) -> bool:
-        """Check if Ollama is running"""
-        try:
-            response = requests.get(self.models_url, timeout=3)
-            return response.status_code == 200
-        except Exception:
-            return False
-    
-    def get_available_models(self) -> List[str]:
-        """Get list of available models"""
-        try:
-            response = requests.get(self.models_url, timeout=5)
-            if response.status_code == 200:
-                data = response.json()
-                models = data.get("models", [])
-                return [model["name"] for model in models]
-            return []
-        except Exception:
-            return []
-    
-    def generate_summary(self, text: str, model: str = "llama3.2", language: str = "English", 
-                        summary_type: str = "concise") -> str:
-        """Generate AI summary using local LLM"""
-        try:
-            # Truncate text if too long
-            if len(text) > 2000:
-                text = text[:2000] + "..."
-            
-            # Craft prompt based on summary type
-            if summary_type == "concise":
-                prompt = f"Summarize this Wikipedia content in {language} in 2-3 clear sentences:\n\n{text}\n\nSummary:"
-            elif summary_type == "detailed":
-                prompt = f"Provide a detailed summary of this Wikipedia content in {language}. Include key points and important facts:\n\n{text}\n\nDetailed Summary:"
-            else:  # explanatory
-                prompt = f"Explain this Wikipedia content in {language} in simple terms that anyone can understand:\n\n{text}\n\nExplanation:"
-            
-            # Request to Ollama
-            payload = {
-                "model": model,
-                "prompt": prompt,
-                "stream": False,
-                "options": {
-                    "temperature": 0.7,
-                    "num_predict": 300 if summary_type == "detailed" else 150
-                }
-            }
-            
-            response = requests.post(self.api_url, json=payload, timeout=30)
-            
-            if response.status_code == 200:
-                data = response.json()
-                summary = data.get("response", "").strip()
-                return summary if summary else "No summary generated"
-            else:
-                return f"Error: Status {response.status_code}"
-                
-        except requests.exceptions.Timeout:
-            return "Error: Request timeout - try a smaller text"
-        except Exception as e:
-            return f"Error: {str(e)}"
-    
-    def translate_text(self, text: str, target_language: str, model: str = "llama3.2") -> str:
-        """Translate text using local LLM"""
-        try:
-            prompt = f"Translate this text to {target_language}. Only provide the translation:\n\n{text}\n\nTranslation:"
-            
-            payload = {
-                "model": model,
-                "prompt": prompt,
-                "stream": False,
-                "options": {
-                    "temperature": 0.3,
-                    "num_predict": 200
-                }
-            }
-            
-            response = requests.post(self.api_url, json=payload, timeout=20)
-            
-            if response.status_code == 200:
-                data = response.json()
-                translation = data.get("response", "").strip()
-                return translation if translation else text
-            else:
-                return text
-                
-        except Exception:
-            return text
+THEMES = {
+    "Default": {"primary": "#1f77b4", "background": "#ffffff", "text": "#000000"},
+    "Dark": {"primary": "#00d4aa", "background": "#0e1117", "text": "#ffffff"},
+    "Ocean": {"primary": "#0077be", "background": "#f0f8ff", "text": "#003366"},
+    "Forest": {"primary": "#228b22", "background": "#f5fff5", "text": "#006400"},
+    "Sunset": {"primary": "#ff6b35", "background": "#fff5f0", "text": "#8b0000"}
+}
 
 class WikipediaAPI:
     def __init__(self):
         self.base_url = "https://{}.wikipedia.org/api/rest_v1"
         self.search_url = "https://{}.wikipedia.org/w/api.php"
+        self.cache = {}
+    
+    def _get_cache_key(self, *args) -> str:
+        """Generate cache key from arguments"""
+        key_string = "_".join(str(arg) for arg in args)
+        return hashlib.md5(key_string.encode()).hexdigest()
     
     def search_articles(self, query: str, lang: str = "en", limit: int = 5) -> List[Dict]:
-        """Search for Wikipedia articles"""
+        """Search for Wikipedia articles with caching"""
+        cache_key = self._get_cache_key("search", query, lang, limit)
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+        
         try:
             params = {
                 "action": "query",
@@ -139,7 +73,7 @@ class WikipediaAPI:
                 "list": "search",
                 "srsearch": query,
                 "srlimit": limit,
-                "srprop": "snippet|titlesnippet"
+                "srprop": "snippet|titlesnippet|size|wordcount|timestamp"
             }
             
             url = self.search_url.format(lang)
@@ -147,14 +81,19 @@ class WikipediaAPI:
             response.raise_for_status()
             
             data = response.json()
-            return data.get("query", {}).get("search", [])
-            
+            results = data.get("query", {}).get("search", [])
+            self.cache[cache_key] = results
+            return results
         except Exception as e:
             st.error(f"Search error: {str(e)}")
             return []
     
     def get_page_summary(self, title: str, lang: str = "en") -> Optional[Dict]:
-        """Get page summary using REST API"""
+        """Get page summary using REST API with caching"""
+        cache_key = self._get_cache_key("summary", title, lang)
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+        
         try:
             encoded_title = quote(title.replace(" ", "_"))
             url = f"{self.base_url.format(lang)}/page/summary/{encoded_title}"
@@ -162,23 +101,25 @@ class WikipediaAPI:
             response = requests.get(url, timeout=10)
             response.raise_for_status()
             
-            return response.json()
-            
+            result = response.json()
+            self.cache[cache_key] = result
+            return result
         except Exception as e:
+            st.error(f"Summary error: {str(e)}")
             return None
     
-    def get_page_content(self, title: str, lang: str = "en", char_limit: int = 2000) -> Optional[str]:
+    def get_page_content(self, title: str, lang: str = "en", sections: int = 3) -> Optional[str]:
         """Get page content sections"""
         try:
             params = {
                 "action": "query",
                 "format": "json",
                 "prop": "extracts",
-                "exintro": False,
+                "exintro": True,
                 "explaintext": True,
                 "exsectionformat": "plain",
                 "titles": title,
-                "exchars": char_limit
+                "exchars": 3000
             }
             
             url = self.search_url.format(lang)
@@ -193,313 +134,634 @@ class WikipediaAPI:
                     return page_data["extract"]
             
             return None
+        except Exception as e:
+            st.error(f"Content error: {str(e)}")
+            return None
+    
+    def get_random_article(self, lang: str = "en") -> Optional[Dict]:
+        """Get a random Wikipedia article"""
+        try:
+            params = {
+                "action": "query",
+                "format": "json",
+                "list": "random",
+                "rnnamespace": 0,
+                "rnlimit": 1
+            }
+            
+            url = self.search_url.format(lang)
+            response = requests.get(url, params=params, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+            random_pages = data.get("query", {}).get("random", [])
+            
+            if random_pages:
+                title = random_pages[0]["title"]
+                return self.get_page_summary(title, lang)
             
-        except Exception:
             return None
+        except Exception as e:
+            st.error(f"Random article error: {str(e)}")
+            return None
+    
+    def get_page_categories(self, title: str, lang: str = "en") -> List[str]:
+        """Get categories for a Wikipedia page"""
+        try:
+            params = {
+                "action": "query",
+                "format": "json",
+                "prop": "categories",
+                "titles": title,
+                "cllimit": 10
+            }
+            
+            url = self.search_url.format(lang)
+            response = requests.get(url, params=params, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+            pages = data.get("query", {}).get("pages", {})
+            
+            for page_id, page_data in pages.items():
+                if "categories" in page_data:
+                    return [cat["title"].replace("Category:", "") for cat in page_data["categories"]]
+            
+            return []
+        except Exception as e:
+            return []
+
+def init_session_state():
+    """Initialize session state variables"""
+    if 'search_history' not in st.session_state:
+        st.session_state.search_history = []
+    if 'favorites' not in st.session_state:
+        st.session_state.favorites = []
+    if 'theme' not in st.session_state:
+        st.session_state.theme = "Default"
+    if 'user_preferences' not in st.session_state:
+        st.session_state.user_preferences = {
+            "default_language": "English",
+            "results_per_page": 5,
+            "summary_length": "Medium",
+            "show_images": True,
+            "auto_translate": False
+        }
+
+def apply_theme(theme_name: str):
+    """Apply selected theme"""
+    theme = THEMES[theme_name]
+    st.markdown(f"""
+    <style>
+    .main {{
+        background-color: {theme["background"]};
+        color: {theme["text"]};
+    }}
+    .stSelectbox label, .stTextInput label, .stSlider label {{
+        color: {theme["text"]} !important;
+    }}
+    .result-card {{
+        background-color: {theme["background"]};
+        border-color: {theme["primary"]};
+        color: {theme["text"]};
+    }}
+    .metric-card {{
+        background: linear-gradient(135deg, {theme["primary"]}20, {theme["primary"]}10);
+        border-left: 4px solid {theme["primary"]};
+    }}
+    </style>
+    """, unsafe_allow_html=True)
 
 def clean_html(text: str) -> str:
     """Remove HTML tags from text"""
-    if not text:
-        return ""
     clean = re.compile('<.*?>')
     return re.sub(clean, '', text)
 
-def simple_summarize(text: str, max_sentences: int = 3) -> str:
-    """Fallback simple text summarization"""
-    if not text:
-        return "No content available"
-    
-    sentences = text.split('. ')
-    if len(sentences) <= max_sentences:
-        return text
-    
-    summary_sentences = sentences[:max_sentences]
-    result = '. '.join(summary_sentences)
-    if not result.endswith('.'):
-        result += '.'
-    return result
+def summarize_text(text: str, length: str = "Medium") -> str:
+    """Advanced text summarization"""
+    sentences = re.split(r'[.!?]+', text)
+    sentences = [s.strip() for s in sentences if s.strip()]
+    
+    if length == "Short":
+        return '. '.join(sentences[:2]) + '.'
+    elif length == "Medium":
+        return '. '.join(sentences[:4]) + '.'
+    else:  # Long
+        return '. '.join(sentences[:6]) + '.'
+
+def add_to_search_history(query: str, language: str, results_count: int):
+    """Add search to history"""
+    search_entry = {
+        "query": query,
+        "language": language,
+        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "results_count": results_count
+    }
+    st.session_state.search_history.insert(0, search_entry)
+    # Keep only last 50 searches
+    st.session_state.search_history = st.session_state.search_history[:50]
+
+def create_search_analytics():
+    """Create search analytics visualization"""
+    if not st.session_state.search_history:
+        return None
+    
+    df = pd.DataFrame(st.session_state.search_history)
+    
+    # Language distribution
+    lang_counts = df['language'].value_counts()
+    fig_lang = px.pie(
+        values=lang_counts.values,
+        names=lang_counts.index,
+        title="Search Languages Distribution",
+        color_discrete_sequence=px.colors.qualitative.Set3
+    )
+    
+    # Search timeline
+    df['date'] = pd.to_datetime(df['timestamp']).dt.date
+    daily_searches = df.groupby('date').size().reset_index(name='searches')
+    fig_timeline = px.line(
+        daily_searches,
+        x='date',
+        y='searches',
+        title="Daily Search Activity",
+        markers=True
+    )
+    
+    return fig_lang, fig_timeline
+
+def sidebar_content():
+    """Create enhanced sidebar content"""
+    st.sidebar.title("🤖 WikiBot Pro")
+    st.sidebar.markdown("---")
+    
+    # Theme selector
+    st.sidebar.subheader("🎨 Appearance")
+    theme = st.sidebar.selectbox(
+        "Theme",
+        options=list(THEMES.keys()),
+        index=list(THEMES.keys()).index(st.session_state.theme),
+        key="theme_selector"
+    )
+    if theme != st.session_state.theme:
+        st.session_state.theme = theme
+        st.rerun()
+    
+    # User preferences
+    st.sidebar.subheader("⚙️ Preferences")
+    
+    default_lang = st.sidebar.selectbox(
+        "Default Language",
+        options=list(LANGUAGES.keys()),
+        index=list(LANGUAGES.keys()).index(st.session_state.user_preferences["default_language"])
+    )
+    
+    show_images = st.sidebar.checkbox(
+        "Show Images",
+        value=st.session_state.user_preferences["show_images"]
+    )
+    
+    # Update preferences
+    st.session_state.user_preferences.update({
+        "default_language": default_lang,
+        "show_images": show_images
+    })
+    
+    # Quick actions
+    st.sidebar.subheader("🚀 Quick Actions")
+    
+    if st.sidebar.button("🎲 Random Article", use_container_width=True):
+        st.session_state.random_article_trigger = True
+    
+    if st.sidebar.button("📊 Search Analytics", use_container_width=True):
+        st.session_state.show_analytics = True
+    
+    if st.sidebar.button("🗑️ Clear History", use_container_width=True):
+        st.session_state.search_history = []
+        st.sidebar.success("History cleared!")
+    
+    # Search history
+    if st.session_state.search_history:
+        st.sidebar.subheader("🕐 Recent Searches")
+        for i, search in enumerate(st.session_state.search_history[:5]):
+            with st.sidebar.expander(f"{search['query'][:20]}..."):
+                st.write(f"**Language:** {search['language']}")
+                st.write(f"**Time:** {search['timestamp']}")
+                st.write(f"**Results:** {search['results_count']}")
+                if st.button(f"🔄 Repeat", key=f"repeat_{i}"):
+                    st.session_state.repeat_search = search
+    
+    # Statistics
+    st.sidebar.subheader("📈 Statistics")
+    total_searches = len(st.session_state.search_history)
+    favorite_lang = "None"
+    if st.session_state.search_history:
+        lang_counter = Counter([s['language'] for s in st.session_state.search_history])
+        favorite_lang = lang_counter.most_common(1)[0][0] if lang_counter else "None"
+    
+    st.sidebar.metric("Total Searches", total_searches)
+    st.sidebar.metric("Favorite Language", favorite_lang)
+    st.sidebar.metric("Favorites Saved", len(st.session_state.favorites))
 
 def main():
-    # Custom CSS
+    init_session_state()
+    apply_theme(st.session_state.theme)
+    
+    # Enhanced CSS
     st.markdown("""
     <style>
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+    
+    html, body, [class*="css"] {
+        font-family: 'Inter', sans-serif;
+    }
+    
     .main-header {
         text-align: center;
-        color: #1f77b4;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        font-weight: 700;
+        font-size: 3rem;
+        margin-bottom: 0.5rem;
+    }
+    
+    .subtitle {
+        text-align: center;
+        color: #6c757d;
+        font-size: 1.2rem;
         margin-bottom: 2rem;
+        font-weight: 300;
     }
+    
     .search-container {
-        background-color: #f8f9fa;
-        padding: 1.5rem;
-        border-radius: 10px;
-        margin-bottom: 1rem;
+        background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+        padding: 2rem;
+        border-radius: 20px;
+        margin-bottom: 2rem;
+        box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+        backdrop-filter: blur(10px);
     }
+    
     .result-card {
-        background-color: white;
+        background: white;
         padding: 1.5rem;
-        border-radius: 8px;
-        border: 1px solid #dee2e6;
-        margin-bottom: 1rem;
-        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        border-radius: 15px;
+        border: 1px solid #e9ecef;
+        margin-bottom: 1.5rem;
+        box-shadow: 0 5px 15px rgba(0,0,0,0.08);
+        transition: all 0.3s ease;
+        position: relative;
+        overflow: hidden;
+    }
+    
+    .result-card:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 8px 25px rgba(0,0,0,0.15);
+    }
+    
+    .result-card::before {
+        content: '';
+        position: absolute;
+        top: 0;
+        left: 0;
+        right: 0;
+        height: 4px;
+        background: linear-gradient(90deg, #667eea, #764ba2);
     }
+    
     .article-title {
-        color: #007bff;
-        font-weight: bold;
-        font-size: 1.2rem;
-        margin-bottom: 0.5rem;
+        color: #2c3e50;
+        font-weight: 600;
+        font-size: 1.3rem;
+        margin-bottom: 1rem;
+        line-height: 1.4;
+    }
+    
+    .article-meta {
+        display: flex;
+        gap: 1rem;
+        margin-bottom: 1rem;
+        font-size: 0.9rem;
+        color: #6c757d;
     }
-    .status-box {
-        padding: 0.8rem;
-        border-radius: 8px;
+    
+    .metric-card {
+        background: linear-gradient(135deg, #667eea20, #764ba210);
+        padding: 1rem;
+        border-radius: 10px;
+        border-left: 4px solid #667eea;
         margin-bottom: 1rem;
-        font-weight: bold;
+        transition: all 0.3s ease;
     }
-    .status-connected {
-        background-color: #d4edda;
-        color: #155724;
-        border: 1px solid #c3e6cb;
+    
+    .metric-card:hover {
+        transform: scale(1.02);
     }
-    .status-disconnected {
-        background-color: #f8d7da;
-        color: #721c24;
-        border: 1px solid #f5c6cb;
+    
+    .floating-button {
+        position: fixed;
+        bottom: 2rem;
+        right: 2rem;
+        background: linear-gradient(135deg, #667eea, #764ba2);
+        color: white;
+        border: none;
+        border-radius: 50%;
+        width: 60px;
+        height: 60px;
+        font-size: 1.5rem;
+        cursor: pointer;
+        box-shadow: 0 4px 15px rgba(0,0,0,0.2);
+        transition: all 0.3s ease;
+        z-index: 1000;
     }
-    .ai-summary {
-        background-color: #f0f8ff;
-        padding: 1rem;
-        border-radius: 8px;
-        border-left: 4px solid #007bff;
-        margin: 1rem 0;
+    
+    .floating-button:hover {
+        transform: scale(1.1);
+        box-shadow: 0 6px 20px rgba(0,0,0,0.3);
+    }
+    
+    .feature-badge {
+        display: inline-block;
+        background: linear-gradient(135deg, #ff9a56, #ff6b6b);
+        color: white;
+        padding: 0.25rem 0.75rem;
+        border-radius: 50px;
+        font-size: 0.8rem;
+        font-weight: 500;
+        margin: 0.25rem;
+    }
+    
+    .category-tag {
+        display: inline-block;
+        background: #e3f2fd;
+        color: #1976d2;
+        padding: 0.25rem 0.5rem;
+        border-radius: 5px;
+        font-size: 0.8rem;
+        margin: 0.25rem;
+    }
+    
+    @media (max-width: 768px) {
+        .main-header {
+            font-size: 2rem;
+        }
+        .search-container {
+            padding: 1rem;
+        }
+        .floating-button {
+            bottom: 1rem;
+            right: 1rem;
+            width: 50px;
+            height: 50px;
+            font-size: 1.2rem;
+        }
+    }
+    
+    .animate-fade-in {
+        animation: fadeIn 0.5s ease-in;
+    }
+    
+    @keyframes fadeIn {
+        from { opacity: 0; transform: translateY(20px); }
+        to { opacity: 1; transform: translateY(0); }
     }
     </style>
     """, unsafe_allow_html=True)
     
-    # Header
-    st.markdown("<h1 class='main-header'>🤖 WikiBot - AI-Powered Assistant</h1>", unsafe_allow_html=True)
-    st.markdown("<p style='text-align: center; color: #666;'>Wikipedia + Local LLM Intelligence</p>", unsafe_allow_html=True)
+    # Sidebar
+    sidebar_content()
     
-    # Initialize session state
-    if 'search_results' not in st.session_state:
-        st.session_state.search_results = []
+    # Main header
+    st.markdown("<h1 class='main-header'>🤖 WikiBot Pro</h1>", unsafe_allow_html=True)
+    st.markdown("<p class='subtitle'>AI-Powered Multilingual Wikipedia Assistant with Advanced Features</p>", unsafe_allow_html=True)
     
-    # Initialize APIs
+    # Feature highlights
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
+        st.markdown("<div class='metric-card'><h3>🌍</h3><p><strong>20+ Languages</strong><br>Multilingual Support</p></div>", unsafe_allow_html=True)
+    with col2:
+        st.markdown("<div class='metric-card'><h3>🤖</h3><p><strong>AI-Powered</strong><br>Smart Summaries</p></div>", unsafe_allow_html=True)
+    with col3:
+        st.markdown("<div class='metric-card'><h3>⚡</h3><p><strong>Fast Search</strong><br>Cached Results</p></div>", unsafe_allow_html=True)
+    with col4:
+        st.markdown("<div class='metric-card'><h3>📊</h3><p><strong>Analytics</strong><br>Search Insights</p></div>", unsafe_allow_html=True)
+    
+    # Initialize API
     wiki_api = WikipediaAPI()
-    llm = OllamaLLM()
-    
-    # Check LLM connection
-    with st.spinner("Checking Ollama connection..."):
-        llm_connected = llm.check_connection()
-        available_models = llm.get_available_models() if llm_connected else []
-    
-    # Status display
-    if llm_connected:
-        st.markdown(f"""
-        <div class='status-box status-connected'>
-            ✅ Ollama Connected - {len(available_models)} models available
-        </div>
-        """, unsafe_allow_html=True)
-    else:
-        st.markdown("""
-        <div class='status-box status-disconnected'>
-            ❌ Ollama Offline - Basic mode only
-        </div>
-        """, unsafe_allow_html=True)
     
-    # Main search interface
+    # Handle random article trigger
+    if hasattr(st.session_state, 'random_article_trigger'):
+        with st.spinner("🎲 Finding a random article..."):
+            random_article = wiki_api.get_random_article(
+                LANGUAGES[st.session_state.user_preferences["default_language"]]["code"]
+            )
+            if random_article:
+                st.success("🎲 Random Article Discovery!")
+                display_article_card(random_article, wiki_api, 0, 
+                                   LANGUAGES[st.session_state.user_preferences["default_language"]]["code"])
+        delattr(st.session_state, 'random_article_trigger')
+    
+    # Handle analytics display
+    if hasattr(st.session_state, 'show_analytics'):
+        st.subheader("📊 Search Analytics")
+        analytics = create_search_analytics()
+        if analytics:
+            col1, col2 = st.columns(2)
+            with col1:
+                st.plotly_chart(analytics[0], use_container_width=True)
+            with col2:
+                st.plotly_chart(analytics[1], use_container_width=True)
+        else:
+            st.info("No search history available for analytics.")
+        delattr(st.session_state, 'show_analytics')
+    
+    # Search interface
     st.markdown("<div class='search-container'>", unsafe_allow_html=True)
     
-    # Search inputs
     col1, col2 = st.columns([3, 1])
     
     with col1:
         query = st.text_input(
-            "🔍 Search Query",
-            placeholder="e.g., 'Artificial Intelligence', 'Kargil War'",
-            help="Enter your Wikipedia search query"
+            "🔍 Search Wikipedia",
+            placeholder="e.g., 'Artificial Intelligence', 'కృష్ణ నది', 'गांधी जी'",
+            help="Enter your search query in any language",
+            value=getattr(st.session_state, 'repeat_search', {}).get('query', '')
         )
     
     with col2:
-        selected_lang = st.selectbox(
+        # Get language options with flags and native names
+        lang_options = [f"{LANGUAGES[lang]['flag']} {lang} ({LANGUAGES[lang]['native']})" 
+                       for lang in LANGUAGES.keys()]
+        
+        selected_lang_display = st.selectbox(
             "🌍 Language",
-            options=list(LANGUAGES.keys()),
-            index=0
+            options=lang_options,
+            index=list(LANGUAGES.keys()).index(st.session_state.user_preferences["default_language"])
         )
+        
+        # Extract actual language name
+        selected_lang = selected_lang_display.split(' ', 1)[1].split(' (')[0]
     
-    # Options
-    col1, col2, col3 = st.columns(3)
-    
-    with col1:
-        num_results = st.slider("Results", 1, 8, 3)
-    
-    with col2:
-        if llm_connected:
-            summary_type = st.selectbox(
-                "AI Summary", 
-                ["concise", "detailed", "explanatory"]
-            )
-        else:
-            summary_type = st.selectbox(
-                "Summary", 
-                ["short", "medium", "long"]
-            )
-    
-    with col3:
-        if llm_connected and available_models:
-            selected_model = st.selectbox("Model", available_models)
-        else:
-            selected_model = None
-            st.info("No models")
-    
-    # Translation option
-    if llm_connected:
-        enable_translation = st.checkbox("🌐 Enable Translation")
-        if enable_translation:
-            target_lang = st.selectbox(
-                "Translate to", 
-                [lang for lang in LANGUAGES.keys() if lang != selected_lang]
-            )
+    # Advanced options
+    with st.expander("⚙️ Advanced Search Options"):
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            num_results = st.slider("📄 Number of results", 1, 15, 
+                                   st.session_state.user_preferences["results_per_page"])
+        with col2:
+            summary_length = st.selectbox("📝 Summary length", 
+                                        ["Short", "Medium", "Long"], 
+                                        index=["Short", "Medium", "Long"].index(st.session_state.user_preferences["summary_length"]))
+        with col3:
+            search_mode = st.selectbox("🔍 Search mode", 
+                                     ["Standard", "Recent", "Popular"])
     
     st.markdown("</div>", unsafe_allow_html=True)
     
     # Search button
-    search_clicked = st.button("🔎 Search", type="primary", use_container_width=True)
-    
-    if search_clicked and query:
-        lang_code = LANGUAGES[selected_lang]
-        
-        with st.spinner("Searching Wikipedia..."):
-            search_results = wiki_api.search_articles(query, lang_code, num_results)
-            st.session_state.search_results = search_results
-    
-    # Display results
-    if st.session_state.search_results:
-        st.success(f"Found {len(st.session_state.search_results)} results")
-        
-        for idx, result in enumerate(st.session_state.search_results):
-            with st.container():
-                st.markdown("<div class='result-card'>", unsafe_allow_html=True)
-                
-                # Title
-                title = result.get("title", "")
-                st.markdown(f"<div class='article-title'>{idx+1}. {title}</div>", unsafe_allow_html=True)
-                
-                # Get content
-                lang_code = LANGUAGES[selected_lang]
-                summary_data = wiki_api.get_page_summary(title, lang_code)
-                
-                # Show thumbnail
-                if summary_data and "thumbnail" in summary_data:
-                    col1, col2 = st.columns([1, 4])
-                    with col1:
-                        st.image(summary_data["thumbnail"]["source"], width=100)
-                    content_col = col2
-                else:
-                    content_col = st
+    if st.button("🔎 Search Wikipedia", type="primary", use_container_width=True):
+        if query:
+            lang_code = LANGUAGES[selected_lang]["code"]
+            
+            with st.spinner(f"🔍 Searching Wikipedia in {selected_lang}..."):
+                # Search for articles
+                search_results = wiki_api.search_articles(query, lang_code, num_results)
                 
-                with content_col:
-                    # AI Summary
-                    if llm_connected and selected_model:
-                        # Get detailed content for AI
-                        detailed_content = wiki_api.get_page_content(title, lang_code)
-                        
-                        if detailed_content:
-                            with st.spinner("Generating AI summary..."):
-                                ai_summary = llm.generate_summary(
-                                    detailed_content, 
-                                    selected_model, 
-                                    selected_lang, 
-                                    summary_type
-                                )
-                            
-                            if ai_summary and not ai_summary.startswith("Error"):
-                                st.markdown("<div class='ai-summary'>", unsafe_allow_html=True)
-                                st.markdown("**🤖 AI Summary:**")
-                                st.write(ai_summary)
-                                
-                                # Translation
-                                if 'enable_translation' in locals() and enable_translation:
-                                    with st.spinner("Translating..."):
-                                        translated = llm.translate_text(ai_summary, target_lang, selected_model)
-                                        if translated != ai_summary:
-                                            st.markdown(f"**🌐 {target_lang}:**")
-                                            st.write(translated)
-                                
-                                st.markdown("</div>", unsafe_allow_html=True)
-                            else:
-                                st.warning("AI summary failed")
-                                if summary_data:
-                                    basic_summary = summary_data.get("extract", "")
-                                    st.write(simple_summarize(basic_summary, 3))
-                        else:
-                            st.warning("Could not fetch detailed content")
+                if search_results:
+                    # Add to search history
+                    add_to_search_history(query, selected_lang, len(search_results))
                     
-                    else:
-                        # Basic summary
-                        if summary_data:
-                            basic_summary = summary_data.get("extract", "")
-                            if summary_type == "short":
-                                basic_summary = simple_summarize(basic_summary, 2)
-                            elif summary_type == "medium":
-                                basic_summary = simple_summarize(basic_summary, 4)
-                            st.write(basic_summary)
-                        else:
-                            snippet = clean_html(result.get("snippet", ""))
-                            st.write(snippet)
-                
-                # Wikipedia link
-                if summary_data and "content_urls" in summary_data:
-                    wiki_url = summary_data["content_urls"]["desktop"]["page"]
-                    st.markdown(f"[📖 Read on Wikipedia]({wiki_url})")
+                    st.success(f"✅ Found {len(search_results)} results in {selected_lang}")
+                    
+                    # Display results with enhanced cards
+                    for idx, result in enumerate(search_results):
+                        display_article_card(result, wiki_api, idx, lang_code, summary_length)
                 
-                st.markdown("</div>", unsafe_allow_html=True)
-                st.markdown("---")
+                else:
+                    st.warning(f"❌ No results found for '{query}' in {selected_lang}")
+                    # Suggest alternative searches
+                    st.info("💡 **Suggestions:**")
+                    st.write("• Try different keywords or phrases")
+                    st.write("• Switch to a different language")
+                    st.write("• Check spelling and try simpler terms")
+                    st.write("• Use the Random Article feature to explore")
+        else:
+            st.warning("⚠️ Please enter a search query")
     
-    elif search_clicked and not query:
-        st.warning("Please enter a search query")
+    # Clear repeat search
+    if hasattr(st.session_state, 'repeat_search'):
+        delattr(st.session_state, 'repeat_search')
     
-    # Footer stats
+    # Footer with enhanced information
     st.markdown("---")
-    col1, col2, col3, col4 = st.columns(4)
+    st.markdown("### 🌟 WikiBot Pro Features")
     
+    col1, col2, col3 = st.columns(3)
     with col1:
-        st.metric("🌍 Languages", len(LANGUAGES))
+        st.markdown("""
+        **🌍 Multilingual Support**
+        - 20+ languages including Indian languages
+        - Native script support
+        - Cultural context awareness
+        """)
+    
     with col2:
-        st.metric("🤖 LLM", "ON" if llm_connected else "OFF")
-    with col3:
-        st.metric("📚 Models", len(available_models))
-    with col4:
-        st.metric("📊 Results", len(st.session_state.search_results))
+        st.markdown("""
+        **🤖 AI-Powered Features**
+        - Smart text summarization
+        - Intelligent caching
+        - Personalized recommendations
+        """)
     
-    # Setup guide
-    with st.expander("🛠️ Ollama Setup Guide"):
+    with col3:
         st.markdown("""
-        ### Quick Setup:
-        
-        **1. Install Ollama:**
-        ```bash
-        # macOS/Linux
-        curl -fsSL https://ollama.ai/install.sh | sh
+        **📊 Advanced Analytics**
+        - Search history tracking
+        - Language usage patterns
+        - Performance insights
+        """)
+
+def display_article_card(result: Dict, wiki_api: WikipediaAPI, idx: int, lang_code: str, summary_length: str = "Medium"):
+    """Display enhanced article card"""
+    st.markdown("<div class='result-card animate-fade-in'>", unsafe_allow_html=True)
+    
+    title = result.get("title", "")
+    
+    # Article header with metadata
+    col1, col2 = st.columns([3, 1])
+    
+    with col1:
+        st.markdown(f"<div class='article-title'>{idx+1}. {title}</div>", unsafe_allow_html=True)
         
-        # Windows: Download from https://ollama.ai
-        ```
+        # Metadata
+        wordcount = result.get("wordcount", 0)
+        size = result.get("size", 0)
+        timestamp = result.get("timestamp", "")
         
-        **2. Pull a model:**
-        ```bash
-        ollama pull llama3.2
-        ```
+        meta_html = f"""
+        <div class='article-meta'>
+            <span>📝 {wordcount} words</span>
+            <span>📊 {size} bytes</span>
+            <span>🕐 {timestamp[:10] if timestamp else 'Unknown'}</span>
+        </div>
+        """
+        st.markdown(meta_html, unsafe_allow_html=True)
+    
+    with col2:
+        # Action buttons
+        if st.button("⭐ Favorite", key=f"fav_{idx}"):
+            if title not in st.session_state.favorites:
+                st.session_state.favorites.append(title)
+                st.success("Added to favorites!")
         
-        **3. Start server:**
-        ```bash
-        ollama serve
-        ```
+        if st.button("🔗 Share", key=f"share_{idx}"):
+            st.info(f"Share this article: {title}")
+    
+    # Get detailed summary
+    summary_data = wiki_api.get_page_summary(title, lang_code)
+    
+    if summary_data:
+        # Display with image if available
+        if st.session_state.user_preferences["show_images"] and "thumbnail" in summary_data:
+            col1, col2 = st.columns([1, 3])
+            with col1:
+                st.image(summary_data["thumbnail"]["source"], width=150, caption="Wikipedia Image")
+            with col2:
+                display_article_content(summary_data, summary_length)
+        else:
+            display_article_content(summary_data, summary_length)
         
-        **4. Refresh this page!**
+       # Categories
+        categories = wiki_api.get_page_categories(title, lang_code)
+        if categories:
+            st.markdown("**📚 Categories:**")
+            for cat in categories[:5]:  # Show only first 5 categories
+                st.markdown(f"<span class='category-tag'>{cat}</span>", unsafe_allow_html=True)
         
-        ### Recommended Models:
-        - `llama3.2` - Best overall performance
-        - `mistral` - Fast and efficient
-        - `qwen2` - Good for multilingual content
-        """)
+        # Wikipedia link
+        wiki_url = f"https://{lang_code}.wikipedia.org/wiki/{title.replace(' ', '_')}"
+        st.markdown(f"🔗 [Read full article on Wikipedia]({wiki_url})")
+    
+    else:
+        # Fallback to search snippet
+        snippet = result.get("snippet", "No summary available")
+        cleaned_snippet = clean_html(snippet)
+        st.write(cleaned_snippet)
+    
+    st.markdown("</div>", unsafe_allow_html=True)
+
+def display_article_content(summary_data: Dict, summary_length: str):
+    """Display article content with smart summarization"""
+    extract = summary_data.get("extract", "")
+    if extract:
+        summarized = summarize_text(extract, summary_length)
+        st.write(summarized)
+    
+    # Display additional info if available
+    if "coordinates" in summary_data:
+        coords = summary_data["coordinates"]
+        st.info(f"📍 Location: {coords.get('lat', 0):.4f}, {coords.get('lon', 0):.4f}")
 
 if __name__ == "__main__":
     main()