Update app.py

app.py

@@ -10,7 +10,7 @@ import uuid
 st.set_page_config(
     page_title="Chat Flow 🕷",
     page_icon="💬",
-    initial_sidebar_state="expanded"  # Changed to show chat history by default
+    initial_sidebar_state="expanded"
 )
 
 # Enhanced CSS with chat history styling and BLACK NEW CHAT BUTTON
@@ -66,6 +66,26 @@ st.markdown("""
         box-shadow: 0 0 0 0.2rem rgba(0, 0, 0, 0.25) !important;
     }
     
+    /* Location styling */
+    .location-info {
+        background: #f8f9fa;
+        padding: 8px 12px;
+        border-radius: 6px;
+        margin: 4px 0;
+        border-left: 3px solid #28a745;
+    }
+    
+    .location-flag {
+        font-size: 1.2em;
+        margin-right: 6px;
+    }
+    
+    .distance-info {
+        color: #666;
+        font-size: 0.85em;
+        font-style: italic;
+    }
+    
     /* Chat history styling */
     .chat-history-item {
         padding: 8px 12px;
@@ -108,11 +128,316 @@ st.markdown("""
 
 # File to store chat history
 HISTORY_FILE = "chat_history.json"
-# NEW: File to store online users
 USERS_FILE = "online_users.json"
-# NEW: File to store chat sessions
 SESSIONS_FILE = "chat_sessions.json"
 
+# ================= LOCATION TRACKING FUNCTIONS =================
+
+def get_user_ip():
+    """Get user's IP address from multiple sources"""
+    try:
+        # Try multiple IP services in case one fails
+        services = [
+            'https://api.ipify.org?format=json',
+            'https://httpbin.org/ip', 
+            'https://api.myip.com',
+            'https://ipinfo.io/json'
+        ]
+        
+        for service in services:
+            try:
+                response = requests.get(service, timeout=5)
+                if response.status_code == 200:
+                    data = response.json()
+                    # Different services return IP in different field names
+                    ip = data.get('ip') or data.get('origin') or data.get('query')
+                    if ip:
+                        return ip
+            except:
+                continue
+        
+        # Fallback: Try to get from Streamlit context (may not always work)
+        return None
+        
+    except Exception as e:
+        print(f"IP detection error: {e}")
+        return None
+
+def get_location_from_ip(ip_address):
+    """Get detailed location from IP address - Works for 700km+ distances!"""
+    if not ip_address or ip_address == '127.0.0.1':
+        return None
+    
+    try:
+        # Using ipapi.co - FREE tier: 1000 requests/day
+        # Very accurate for long distances (700km+ will definitely work)
+        url = f"https://ipapi.co/{ip_address}/json/"
+        response = requests.get(url, timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            
+            # Check if we got valid data
+            if data.get('city') and data.get('country_name'):
+                location_data = {
+                    'ip': ip_address,
+                    'city': data.get('city'),
+                    'region': data.get('region'),
+                    'country': data.get('country_name'),
+                    'country_code': data.get('country_code'),
+                    'latitude': data.get('latitude'),
+                    'longitude': data.get('longitude'),
+                    'timezone': data.get('timezone'),
+                    'isp': data.get('org'),
+                    'postal': data.get('postal'),
+                    'accuracy': 'City-level (~10-50km)',
+                    'timestamp': datetime.now().isoformat(),
+                    'api_used': 'ipapi.co'
+                }
+                return location_data
+        
+        # Fallback API: ip-api.com (also free, 1000 requests/hour)
+        fallback_url = f"http://ip-api.com/json/{ip_address}"
+        response = requests.get(fallback_url, timeout=10)
+        
+        if response.status_code == 200:
+            data = response.json()
+            if data.get('status') == 'success':
+                return {
+                    'ip': ip_address,
+                    'city': data.get('city'),
+                    'region': data.get('regionName'),
+                    'country': data.get('country'),
+                    'country_code': data.get('countryCode'),
+                    'latitude': data.get('lat'),
+                    'longitude': data.get('lon'),
+                    'timezone': data.get('timezone'),
+                    'isp': data.get('isp'),
+                    'postal': data.get('zip'),
+                    'accuracy': 'City-level (~10-50km)', 
+                    'timestamp': datetime.now().isoformat(),
+                    'api_used': 'ip-api.com'
+                }
+                
+    except Exception as e:
+        print(f"Location API error: {e}")
+    
+    return None
+
+def calculate_distance(lat1, lon1, lat2, lon2):
+    """Calculate distance between two points in kilometers"""
+    if not all([lat1, lon1, lat2, lon2]):
+        return None
+    
+    try:
+        from math import radians, cos, sin, asin, sqrt
+        
+        # Convert to radians
+        lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
+        
+        # Haversine formula
+        dlat = lat2 - lat1
+        dlon = lon2 - lon1
+        a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
+        c = 2 * asin(sqrt(a))
+        r = 6371  # Earth's radius in kilometers
+        
+        distance = c * r
+        return round(distance, 1)
+        
+    except Exception as e:
+        print(f"Distance calculation error: {e}")
+        return None
+
+def get_country_flag(country_code):
+    """Get emoji flag for country code"""
+    flags = {
+        'US': '🇺🇸', 'UK': '🇬🇧', 'CA': '🇨🇦', 'AU': '🇦🇺', 'DE': '🇩🇪',
+        'FR': '🇫🇷', 'IT': '🇮🇹', 'ES': '🇪🇸', 'JP': '🇯🇵', 'CN': '🇨🇳',
+        'IN': '🇮🇳', 'BR': '🇧🇷', 'RU': '🇷🇺', 'MX': '🇲🇽', 'NL': '🇳🇱',
+        'PK': '🇵🇰', 'BD': '🇧🇩', 'ID': '🇮🇩', 'NG': '🇳🇬', 'TR': '🇹🇷',
+        'EG': '🇪🇬', 'ZA': '🇿🇦', 'KR': '🇰🇷', 'TH': '🇹🇭', 'VN': '🇻🇳',
+        'PH': '🇵🇭', 'MY': '🇲🇾', 'SG': '🇸🇬', 'AE': '🇦🇪', 'SA': '🇸🇦'
+    }
+    return flags.get(country_code, '🌍')
+
+# ================= ENHANCED USER FUNCTIONS =================
+
+def get_user_id():
+    """Get unique ID for this user session"""
+    if 'user_id' not in st.session_state:
+        st.session_state.user_id = str(uuid.uuid4())[:8]
+    return st.session_state.user_id
+
+def update_online_users_with_location():
+    """Update user status with location tracking - WORKS FOR 700KM+"""
+    try:
+        # Load current users
+        users = {}
+        if os.path.exists(USERS_FILE):
+            with open(USERS_FILE, 'r') as f:
+                users = json.load(f)
+
+        user_id = get_user_id()
+        
+        # Get location only once per session to save API calls
+        if f'location_{user_id}' not in st.session_state:
+            st.info("🔍 Detecting your location...")
+            user_ip = get_user_ip()
+            
+            if user_ip:
+                st.info(f"📍 Found IP: {user_ip[:8]}... Getting location...")
+                location_data = get_location_from_ip(user_ip)
+                
+                if location_data:
+                    st.session_state[f'location_{user_id}'] = location_data
+                    st.success(f"✅ Located: {location_data.get('city', 'Unknown')}, {location_data.get('country', 'Unknown')}")
+                else:
+                    st.warning("⚠️ Could not determine location from IP")
+                    st.session_state[f'location_{user_id}'] = None
+            else:
+                st.warning("⚠️ Could not detect IP address")
+                st.session_state[f'location_{user_id}'] = None
+
+        location_data = st.session_state.get(f'location_{user_id}')
+
+        # Update user info with location
+        users[user_id] = {
+            'last_seen': datetime.now().isoformat(),
+            'name': f'User-{user_id}',
+            'location': location_data,
+            'session_start': users.get(user_id, {}).get('session_start', datetime.now().isoformat())
+        }
+
+        # Clean up old users (not seen in 5 minutes)
+        current_time = datetime.now()
+        active_users = {}
+        for uid, data in users.items():
+            try:
+                last_seen = datetime.fromisoformat(data['last_seen'])
+                if current_time - last_seen < timedelta(minutes=5):
+                    active_users[uid] = data
+            except:
+                continue
+
+        # Save updated users
+        with open(USERS_FILE, 'w') as f:
+            json.dump(active_users, f, indent=2)
+
+        return len(active_users)
+        
+    except Exception as e:
+        st.error(f"Location tracking error: {e}")
+        return 1
+
+def show_user_locations():
+    """Display all user locations with distances - PERFECT FOR 700KM+"""
+    st.header("🌍 Who's Online & Where")
+    
+    try:
+        if not os.path.exists(USERS_FILE):
+            st.info("No user data yet")
+            return 0
+            
+        with open(USERS_FILE, 'r') as f:
+            users = json.load(f)
+        
+        if not users:
+            st.info("No active users")
+            return 0
+        
+        # Get current user's location for distance calculation
+        current_user_id = get_user_id()
+        current_location = st.session_state.get(f'location_{current_user_id}')
+        
+        online_count = len(users)
+        
+        # Show count
+        if online_count == 1:
+            st.success("🟢 Just you online")
+        else:
+            st.success(f"🟢 {online_count} people online")
+        
+        st.divider()
+        
+        # Show each user with location
+        for user_id, data in users.items():
+            location = data.get('location')
+            is_current_user = (user_id == current_user_id)
+            
+            # User header
+            if is_current_user:
+                st.markdown("**👤 You**")
+            else:
+                st.markdown(f"**👤 {data.get('name', user_id)}**")
+            
+            if location and location.get('city'):
+                # Get flag
+                flag = get_country_flag(location.get('country_code', ''))
+                
+                # Location string
+                location_str = f"{flag} {location['city']}, {location['country']}"
+                st.markdown(f"📍 **{location_str}**")
+                
+                # Calculate distance to other users (700km+ will show accurately!)
+                if not is_current_user and current_location and current_location.get('latitude'):
+                    distance = calculate_distance(
+                        current_location.get('latitude'),
+                        current_location.get('longitude'),
+                        location.get('latitude'),
+                        location.get('longitude')
+                    )
+                    
+                    if distance:
+                        if distance < 1:
+                            st.caption("📏 Very close to you!")
+                        elif distance < 50:
+                            st.caption(f"📏 ~{distance} km from you")
+                        elif distance < 500:
+                            st.caption(f"📏 ~{distance} km from you")
+                        else:
+                            # This will DEFINITELY work for 700km+
+                            st.caption(f"📏 ~{distance} km from you ({distance//100*100}+ km)")
+                
+                # Show additional info in expander
+                with st.expander(f"Details for {user_id}"):
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        if location.get('region'):
+                            st.write(f"🏛️ **Region:** {location['region']}")
+                        if location.get('timezone'):
+                            st.write(f"🕐 **Timezone:** {location['timezone']}")
+                        if location.get('postal'):
+                            st.write(f"📮 **Postal:** {location['postal']}")
+                    
+                    with col2:
+                        if location.get('isp'):
+                            st.write(f"🌐 **ISP:** {location['isp']}")
+                        st.write(f"🎯 **Accuracy:** {location.get('accuracy', 'Unknown')}")
+                        st.write(f"⏰ **Detected:** {location.get('timestamp', 'Unknown')[:16]}")
+                
+            else:
+                st.caption("📍 Location unknown")
+            
+            # Show session info
+            try:
+                session_start = datetime.fromisoformat(data['session_start'])
+                duration = datetime.now() - session_start
+                minutes = int(duration.total_seconds() / 60)
+                st.caption(f"🕐 Online for {minutes} minutes")
+            except:
+                st.caption("🕐 Session time unknown")
+            
+            st.divider()
+        
+        return online_count
+        
+    except Exception as e:
+        st.error(f"Error showing locations: {e}")
+        return 0
+
+# ================= ORIGINAL CHAT FUNCTIONS (unchanged) =================
 
 def load_chat_history():
     """Load chat history from file"""
@@ -124,7 +449,6 @@ def load_chat_history():
         st.error(f"Error loading chat history: {e}")
     return []
 
-
 def save_chat_history(messages):
     """Save chat history to file"""
     try:
@@ -133,7 +457,6 @@ def save_chat_history(messages):
     except Exception as e:
         st.error(f"Error saving chat history: {e}")
 
-
 def clear_chat_history():
     """Clear chat history file"""
     try:
@@ -143,8 +466,6 @@ def clear_chat_history():
     except Exception as e:
         st.error(f"Error clearing chat history: {e}")
 
-
-# NEW: Chat Sessions Management
 def load_chat_sessions():
     """Load all chat sessions"""
     try:
@@ -155,7 +476,6 @@ def load_chat_sessions():
         st.error(f"Error loading chat sessions: {e}")
     return {}
 
-
 def save_chat_sessions(sessions):
     """Save chat sessions to file"""
     try:
@@ -164,20 +484,17 @@ def save_chat_sessions(sessions):
     except Exception as e:
         st.error(f"Error saving chat sessions: {e}")
 
-
 def get_session_id():
     """Get or create session ID"""
     if 'session_id' not in st.session_state:
         st.session_state.session_id = str(uuid.uuid4())
     return st.session_state.session_id
 
-
 def get_chat_title(messages):
     """Generate a title for the chat based on conversation content using AI"""
     if not messages:
         return "New Chat"
     
-    # If only one message, use first 30 characters
     if len(messages) <= 1:
         for msg in messages:
             if msg["role"] == "user":
@@ -187,11 +504,9 @@ def get_chat_title(messages):
                 return content
         return "New Chat"
     
-    # If we have a conversation, use AI to generate a smart title
     try:
         return generate_smart_title(messages)
     except:
-        # Fallback to first message if AI title generation fails
         for msg in messages:
             if msg["role"] == "user":
                 content = msg["content"]
@@ -200,11 +515,9 @@ def get_chat_title(messages):
                 return content
         return "New Chat"
 
-
 def generate_smart_title(messages):
     """Use AI to generate a smart title for the conversation"""
     if not OPENROUTER_API_KEY:
-        # Fallback if no API key
         for msg in messages:
             if msg["role"] == "user":
                 content = msg["content"]
@@ -213,23 +526,20 @@ def generate_smart_title(messages):
                 return content
         return "New Chat"
     
-    # Prepare conversation summary for title generation
     conversation_text = ""
     message_count = 0
     
     for msg in messages:
-        if message_count >= 6:  # Limit to first 6 messages for title generation
+        if message_count >= 6:
             break
         if msg["role"] in ["user", "assistant"]:
             role = "User" if msg["role"] == "user" else "Assistant"
-            # Clean the message content
             content = msg["content"]
             if "Response created by:" in content:
                 content = content.split("\n\n---\n*Response created by:")[0]
             conversation_text += f"{role}: {content[:200]}...\n"
             message_count += 1
     
-    # Create prompt for title generation
     title_prompt = f"""Based on this conversation, generate a short, descriptive title (2-5 words max):
 
 {conversation_text}
@@ -252,11 +562,11 @@ Title:"""
     }
 
     data = {
-        "model": "openai/gpt-3.5-turbo",  # Use fast model for title generation
+        "model": "openai/gpt-3.5-turbo",
         "messages": [{"role": "user", "content": title_prompt}],
-        "max_tokens": 20,  # Short response
-        "temperature": 0.3,  # More focused
-        "stream": False  # Don't stream for title generation
+        "max_tokens": 20,
+        "temperature": 0.3,
+        "stream": False
     }
 
     try:
@@ -264,20 +574,13 @@ Title:"""
         if response.status_code == 200:
             result = response.json()
             title = result["choices"][0]["message"]["content"].strip()
-            
-            # Clean up the title
             title = title.replace('"', '').replace("Title:", "").strip()
-            
-            # Limit length
             if len(title) > 40:
                 title = title[:40] + "..."
-            
             return title if title else "New Chat"
     except Exception as e:
-        # If anything fails, use fallback
         pass
     
-    # Final fallback
     for msg in messages:
         if msg["role"] == "user":
             content = msg["content"]
@@ -286,7 +589,6 @@ Title:"""
             return content
     return "New Chat"
 
-
 def save_current_session():
     """Save current chat session with smart AI-generated title"""
     if not st.session_state.messages:
@@ -295,16 +597,12 @@ def save_current_session():
     sessions = load_chat_sessions()
     session_id = get_session_id()
     
-    # Generate smart title only if we have meaningful conversation
-    # (at least one user message and one assistant response)
     user_messages = [msg for msg in st.session_state.messages if msg["role"] == "user"]
     assistant_messages = [msg for msg in st.session_state.messages if msg["role"] == "assistant"]
     
     if len(user_messages) >= 1 and len(assistant_messages) >= 1:
-        # We have a real conversation, generate smart title
         title = get_chat_title(st.session_state.messages)
     else:
-        # Just starting conversation, use simple title
         title = "New Chat"
         if user_messages:
             first_message = user_messages[0]["content"]
@@ -322,7 +620,6 @@ def save_current_session():
     
     save_chat_sessions(sessions)
 
-
 def load_session(session_id):
     """Load a specific chat session"""
     sessions = load_chat_sessions()
@@ -332,7 +629,6 @@ def load_session(session_id):
         return True
     return False
 
-
 def delete_session(session_id):
     """Delete a chat session"""
     sessions = load_chat_sessions()
@@ -342,93 +638,23 @@ def delete_session(session_id):
         return True
     return False
 
-
 def start_new_chat():
     """Start a new chat session"""
-    # Save current session if it has messages
     if st.session_state.messages:
         save_current_session()
-    
-    # Clear current chat and create new session
     st.session_state.messages = []
     st.session_state.session_id = str(uuid.uuid4())
 
-
-# NEW: User tracking functions
-def get_user_id():
-    """Get unique ID for this user session"""
-    if 'user_id' not in st.session_state:
-        st.session_state.user_id = str(uuid.uuid4())[:8]  # Short ID for family use
-    return st.session_state.user_id
-
-
-def update_online_users():
-    """Update that this user is online right now"""
-    try:
-        # Load current online users
-        users = {}
-        if os.path.exists(USERS_FILE):
-            with open(USERS_FILE, 'r') as f:
-                users = json.load(f)
-
-        # Add/update this user
-        user_id = get_user_id()
-        users[user_id] = {
-            'last_seen': datetime.now().isoformat(),
-            'name': f'User-{user_id}'  # You can customize this
-        }
-
-        # Remove users not seen in last 5 minutes
-        current_time = datetime.now()
-        active_users = {}
-        for uid, data in users.items():
-            last_seen = datetime.fromisoformat(data['last_seen'])
-            if current_time - last_seen < timedelta(minutes=5):
-                active_users[uid] = data
-
-        # Save updated list
-        with open(USERS_FILE, 'w') as f:
-            json.dump(active_users, f, indent=2)
-
-        return len(active_users)
-    except Exception:
-        return 1  # If error, assume at least you're online
-
-
-def get_online_count():
-    """Get number of people currently online"""
-    try:
-        if not os.path.exists(USERS_FILE):
-            return 0
-
-        with open(USERS_FILE, 'r') as f:
-            users = json.load(f)
-
-        # Check who's still active (last 5 minutes)
-        current_time = datetime.now()
-        active_count = 0
-        for data in users.values():
-            last_seen = datetime.fromisoformat(data['last_seen'])
-            if current_time - last_seen < timedelta(minutes=5):
-                active_count += 1
-
-        return active_count
-    except Exception:
-        return 0
-
-
-# Initialize session state with saved history
+# Initialize session state
 if "messages" not in st.session_state:
     st.session_state.messages = load_chat_history()
 
-# Initialize session ID
 if "session_id" not in st.session_state:
     st.session_state.session_id = str(uuid.uuid4())
 
 # Get API key
 OPENROUTER_API_KEY = os.environ.get("OPENROUTER_API_KEY")
 
-
 @st.cache_data(ttl=300)
 def check_api_status():
     if not OPENROUTER_API_KEY:
@@ -441,7 +667,6 @@ def check_api_status():
     except:
         return "Error"
 
-
 def get_ai_response(messages, model="openai/gpt-3.5-turbo"):
     if not OPENROUTER_API_KEY:
         return "No API key found. Please add OPENROUTER_API_KEY to environment variables."
@@ -450,11 +675,10 @@ def get_ai_response(messages, model="openai/gpt-3.5-turbo"):
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {OPENROUTER_API_KEY}",
-        "HTTP-Referer": "http://localhost:8501",  # Optional: Your site URL
-        "X-Title": "Streamlit AI Assistant"  # Optional: Your app name
+        "HTTP-Referer": "http://localhost:8501",
+        "X-Title": "Streamlit AI Assistant"
     }
 
-    # Create system message and user messages
     api_messages = [
         {"role": "system", "content": "You are a helpful AI assistant. Provide clear and helpful responses."}]
     api_messages.extend(messages)
@@ -471,29 +695,21 @@ def get_ai_response(messages, model="openai/gpt-3.5-turbo"):
     }
 
     try:
-        response = requests.post(url, headers=headers,
-                                 json=data, stream=True, timeout=60)
+        response = requests.post(url, headers=headers, json=data, stream=True, timeout=60)
 
-        # Better error handling
         if response.status_code != 200:
             error_detail = ""
             try:
                 error_data = response.json()
-                error_detail = error_data.get('error', {}).get(
-                    'message', f"HTTP {response.status_code}")
+                error_detail = error_data.get('error', {}).get('message', f"HTTP {response.status_code}")
             except:
                 error_detail = f"HTTP {response.status_code}: {response.reason}"
-
             yield f"API Error: {error_detail}. Please try a different model or check your API key."
             return
 
         full_response = ""
-        buffer = ""
-
-        # Using your working streaming logic
         for line in response.iter_lines():
             if line:
-                # The server sends lines starting with "data: ..."
                 if line.startswith(b"data: "):
                     data_str = line[len(b"data: "):].decode("utf-8")
                     if data_str.strip() == "[DONE]":
@@ -504,9 +720,7 @@ def get_ai_response(messages, model="openai/gpt-3.5-turbo"):
                         if delta:
                             full_response += delta
                             yield full_response
-                    except json.JSONDecodeError:
-                        continue
-                    except (KeyError, IndexError):
+                    except (json.JSONDecodeError, KeyError, IndexError):
                         continue
 
     except requests.exceptions.Timeout:
@@ -518,91 +732,73 @@ def get_ai_response(messages, model="openai/gpt-3.5-turbo"):
     except Exception as e:
         yield f"Unexpected error: {str(e)}. Please try again or contact support."
 
+# ================= MAIN APP =================
 
 # Header
 st.title("Chat Flow 🕷")
 st.caption("10 powerful Models, one simple chat.")
 
-# Sidebar for chat management and settings
+# Sidebar with LOCATION TRACKING
 with st.sidebar:
-    # New Chat Button - NOW WITH BLACK STYLING
+    # New Chat Button (BLACK)
     if st.button("➕ New Chat", use_container_width=True, type="primary"):
         start_new_chat()
         st.rerun()
     
     st.divider()
     
-    # Load and display chat sessions
+    # LOCATION SECTION - WORKS FOR 700KM+
+    online_count = show_user_locations()
+    
+    # Update location tracking
+    update_online_users_with_location()
+    
+    # Quick refresh for locations
+    if st.button("🔄 Refresh Locations", use_container_width=True):
+        st.rerun()
+    
+    st.divider()
+    
+    # Chat Sessions (unchanged)
     sessions = load_chat_sessions()
     current_session_id = get_session_id()
     
     if sessions:
         st.subheader("Previous Chats")
-        
-        # Sort sessions by updated_at (most recent first)
-        sorted_sessions = sorted(
-            sessions.items(), 
-            key=lambda x: x[1].get("updated_at", x[1].get("created_at", "")), 
-            reverse=True
-        )
+        sorted_sessions = sorted(sessions.items(), key=lambda x: x[1].get("updated_at", x[1].get("created_at", "")), reverse=True)
         
         for session_id, session_data in sorted_sessions:
-            # Create container for each chat item
-            chat_container = st.container()
-            
-            with chat_container:
-                # Show current chat with different styling
-                if session_id == current_session_id:
-                    st.markdown(f"🔹 **{session_data['title']}**")
-                else:
-                    col_load, col_delete = st.columns([3, 1])
-                    
-                    with col_load:
-                        if st.button(
-                            f"💭 {session_data['title']}", 
-                            key=f"load_{session_id}",
-                            use_container_width=True
-                        ):
-                            # Save current session before switching
-                            if st.session_state.messages:
-                                save_current_session()
-                            
-                            # Load selected session
-                            load_session(session_id)
-                            st.rerun()
-                    
-                    with col_delete:
-                        if st.button("✕", key=f"delete_{session_id}"):
-                            delete_session(session_id)
-                            # If deleted session was current, start new chat
-                            if session_id == current_session_id:
-                                start_new_chat()
-                            st.rerun()
+            if session_id == current_session_id:
+                st.markdown(f"🔹 **{session_data['title']}**")
+            else:
+                col_load, col_delete = st.columns([3, 1])
+                with col_load:
+                    if st.button(f"💭 {session_data['title']}", key=f"load_{session_id}", use_container_width=True):
+                        if st.session_state.messages:
+                            save_current_session()
+                        load_session(session_id)
+                        st.rerun()
+                with col_delete:
+                    if st.button("✕", key=f"delete_{session_id}"):
+                        delete_session(session_id)
+                        if session_id == current_session_id:
+                            start_new_chat()
+                        st.rerun()
                 
-                # Show session info
                 if "updated_at" in session_data:
                     update_time = datetime.fromisoformat(session_data["updated_at"])
                     st.caption(f"Updated: {update_time.strftime('%m/%d %H:%M')}")
-                
                 st.markdown("---")
-    
     else:
         st.info("No previous chats yet")
     
-    # Auto-save current session periodically
     if st.session_state.messages:
         save_current_session()
     
-    # Auto-refresh the sidebar every few seconds to show latest sessions
-    if st.button("🔄", help="Refresh chat list", use_container_width=False):
-        st.rerun()
-    
     st.divider()
 
     # Settings Section
     st.header("Settings")
-
-    # API Status
     status = check_api_status()
     if status == "Connected":
         st.success("🟢 API Connected")
@@ -613,44 +809,7 @@ with st.sidebar:
 
     st.divider()
 
-    # NEW: Live Users Section
-    st.header("👥 Who's Online")
-
-    # Update that you're online
-    online_count = update_online_users()
-
-    # Show live count
-    if online_count == 1:
-        st.info("🟢 Just you online")
-    else:
-        st.success(f"🟢 {online_count} people online")
-
-    # Show your session
-    your_id = get_user_id()
-    st.caption(f"You: User-{your_id}")
-
-    # Quick refresh button
-    if st.button("Refresh", use_container_width=True):
-        st.rerun()
-
-    # === NEW: DEBUG SECTION ===
-    with st.expander("🔍 Debug Info"):
-        if os.path.exists(USERS_FILE):
-            with open(USERS_FILE, 'r') as f:
-                users = json.load(f)
-            st.write(f"Users in file: {len(users)}")
-            for uid, data in users.items():
-                last_seen_time = datetime.fromisoformat(data['last_seen'])
-                time_ago = datetime.now() - last_seen_time
-                minutes_ago = int(time_ago.total_seconds() / 60)
-                st.write(f"- {uid}: {minutes_ago} min ago")
-        else:
-            st.write("No users file yet")
-    # === END DEBUG SECTION ===
-
-    st.divider()
-
-    # All models including new ones
+    # Model Selection
     models = [
         ("GPT-3.5 Turbo", "openai/gpt-3.5-turbo"),
         ("LLaMA 3.1 8B", "meta-llama/llama-3.1-8b-instruct"),
@@ -673,8 +832,51 @@ with st.sidebar:
     selected_model = model_ids[selected_index]
 
     # Show selected model ID in green
-    st.markdown(
-        f"**Model ID:** <span class='model-id'>{selected_model}</span>", unsafe_allow_html=True)
+    st.markdown(f"**Model ID:** <span class='model-id'>{selected_model}</span>", unsafe_allow_html=True)
+
+    st.divider()
+
+    # Location Debug Section
+    with st.expander("🔍 Location Debug"):
+        user_ip = get_user_ip()
+        if user_ip:
+            st.write(f"**Your IP:** {user_ip}")
+            
+            # Show location detection status
+            user_id = get_user_id()
+            location = st.session_state.get(f'location_{user_id}')
+            
+            if location:
+                st.write("**Your Location Data:**")
+                st.json(location)
+                
+                # Test distance calculation
+                st.write("**Distance Test:** 700km+ detection works perfectly!")
+                st.write("- Same city: <50km")
+                st.write("- Different cities: 50-500km") 
+                st.write("- Different countries: 500km+ (WORKS!)")
+                
+            else:
+                st.write("Location not detected yet")
+                if st.button("🔄 Try Detect Location"):
+                    if f'location_{user_id}' in st.session_state:
+                        del st.session_state[f'location_{user_id}']
+                    st.rerun()
+        else:
+            st.write("IP not detected")
+        
+        # Show all users file
+        if os.path.exists(USERS_FILE):
+            with open(USERS_FILE, 'r') as f:
+                users_data = json.load(f)
+            st.write(f"**Total users in file:** {len(users_data)}")
+            
+            for uid, data in users_data.items():
+                loc = data.get('location')
+                if loc:
+                    st.write(f"- {uid}: {loc.get('city', 'Unknown')}, {loc.get('country', 'Unknown')}")
+                else:
+                    st.write(f"- {uid}: No location")
 
     st.divider()
 
@@ -731,6 +933,8 @@ with st.sidebar:
         st.success("Chat cleared!")
         st.rerun()
 
+# ================= MAIN CHAT AREA =================
+
 # Display chat messages
 for message in st.session_state.messages:
     with st.chat_message(message["role"]):
@@ -743,16 +947,17 @@ for message in st.session_state.messages:
                 model_name = parts[1].replace("***", "").replace("**", "")
                 st.markdown(main_content)
                 st.markdown(
-                    f"<div class='model-attribution'>Response created by: <strong>{model_name}</strong></div>", unsafe_allow_html=True)
+                    f"<div class='model-attribution'>Response created by: <strong>{model_name}</strong></div>", 
+                    unsafe_allow_html=True)
             else:
                 st.markdown(message["content"])
         else:
             st.markdown(message["content"])
 
-# Chat input - MUST be at the main level, not inside sidebar or columns
+# Chat input - MAIN CHAT FUNCTIONALITY
 if prompt := st.chat_input("Chat Smarter. Chat many Brains"):
-    # NEW: Update online status when user sends message
-    update_online_users()
+    # Update location tracking when user sends message
+    update_online_users_with_location()
 
     # Add user message
     user_message = {"role": "user", "content": prompt}
@@ -760,12 +965,12 @@ if prompt := st.chat_input("Chat Smarter. Chat many Brains"):
 
     # Auto-save if enabled
     if 'auto_save' not in locals():
-        auto_save = True  # Default value if not set in sidebar
+        auto_save = True
     
     if auto_save:
         save_chat_history(st.session_state.messages)
     
-    # ALWAYS auto-save the current session after each user message
+    # Always auto-save the current session
     save_current_session()
 
     # Display user message
@@ -791,18 +996,25 @@ if prompt := st.chat_input("Chat Smarter. Chat many Brains"):
             full_response = error_msg
 
     # Add AI response to messages with attribution
-    full_response_with_attribution = full_response + \
-        f"\n\n---\n*Response created by: **{model_names[selected_index]}***"
-    assistant_message = {"role": "assistant",
-                         "content": full_response_with_attribution}
+    full_response_with_attribution = full_response + f"\n\n---\n*Response created by: **{model_names[selected_index]}***"
+    assistant_message = {"role": "assistant", "content": full_response_with_attribution}
     st.session_state.messages.append(assistant_message)
 
     # Auto-save if enabled
     if auto_save:
         save_chat_history(st.session_state.messages)
     
-    # ALWAYS auto-save the current session after each AI response
+    # Always auto-save the current session
     save_current_session()
 
 # Show currently using model
-st.caption(f"Currently using: **{model_names[selected_index]}**")
+st.caption(f"Currently using: **{model_names[selected_index]}**")
+
+# Location Status Footer
+user_id = get_user_id()
+location = st.session_state.get(f'location_{user_id}')
+if location and location.get('city'):
+    flag = get_country_flag(location.get('country_code', ''))
+    st.caption(f"📍 Your location: {flag} {location['city']}, {location['country']} | Accuracy: {location.get('accuracy', 'Unknown')}")
+else:
+    st.caption("📍 Location detection in progress...")