app.py

import streamlit as st
import requests
from datetime import datetime, timedelta
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import numpy as np
import os
import folium
from streamlit_folium import st_folium
import json
import time
from geopy.geocoders import Nominatim
from geopy.distance import geodesic
import warnings
warnings.filterwarnings('ignore')

# Secure API key handling
def get_groq_api_key():
    """Securely get GROQ API key from environment variables or Streamlit secrets"""
    # Try to get from Streamlit secrets first
    try:
        return st.secrets["GROQ_API_KEY"]
    except:
        # Fallback to environment variable
        api_key = os.getenv("GROQ_API_KEY")
        if not api_key:
            st.error("🔐 GROQ API key not found. Please configure it in Streamlit secrets or environment variables.")
            st.info("""
            **To configure the API key:**
            1. **For Hugging Face Spaces**: Add `GROQ_API_KEY` in your Space settings under 'Repository secrets'
            2. **For local development**: Set environment variable `GROQ_API_KEY=your_key_here`
            3. **For Streamlit Cloud**: Add to secrets.toml file
            """)
            return None
        return api_key

# Color schemes for different magnitude levels
MAGNITUDE_COLORS = {
    'Low': '#00ff00',      # Green
    'Moderate': '#ffff00', # Yellow
    'High': '#ff8000',     # Orange
    'Severe': '#ff0000',   # Red
    'Extreme': '#800000'   # Dark Red
}

# Risk assessment thresholds
RISK_THRESHOLDS = {
    'low': {'count': 5, 'max_magnitude': 3.0},
    'moderate': {'count': 10, 'max_magnitude': 4.5},
    'high': {'count': 20, 'max_magnitude': 5.5},
    'severe': {'count': 30, 'max_magnitude': 6.5},
    'extreme': {'count': 50, 'max_magnitude': 7.0}
}

# Emergency protocols
EMERGENCY_PROTOCOLS = {
    'low': "Monitor situation. No immediate action required.",
    'moderate': "Stay alert. Review emergency plans.",
    'high': "Prepare emergency kit. Stay informed.",
    'severe': "Follow evacuation orders if issued. Seek shelter.",
    'extreme': "IMMEDIATE EVACUATION. Follow emergency services."
}

def get_groq_summary(prompt, context=""):
    """Enhanced Groq LLM function with secure API key handling"""
    api_key = get_groq_api_key()
    if not api_key:
        return "AI Analysis unavailable - API key not configured"
    
    try:
        # Import Groq only when needed to avoid errors if not installed
        from groq import Groq
        
        client = Groq(api_key=api_key)
        full_prompt = f"{context}\n\n{prompt}" if context else prompt
        response = client.chat.completions.create(
            model="llama-3.3-70b-versatile",
            messages=[
                {"role": "system", "content": "You are an expert seismologist, emergency response specialist, and public safety advisor. Provide detailed, accurate, and actionable information."},
                {"role": "user", "content": full_prompt}
            ],
            max_tokens=2048,
            temperature=0.7,
            top_p=0.9,
            presence_penalty=0.1,
            frequency_penalty=0.1
        )
        return response.choices[0].message.content
    except ImportError:
        return "AI Analysis unavailable - Groq library not installed"
    except Exception as e:
        return f"AI Analysis Error: {str(e)}"

def fetch_earthquakes(min_magnitude=2.5, hours=24, region_bbox=None, detailed=True):
    """Fetch earthquake data with enhanced error handling and data processing"""
    try:
        endtime = datetime.utcnow()
        starttime = endtime - timedelta(hours=hours)

        url = "https://earthquake.usgs.gov/fdsnws/event/1/query"
        params = {
            "format": "geojson",
            "starttime": starttime.strftime('%Y-%m-%dT%H:%M:%S'),
            "endtime": endtime.strftime('%Y-%m-%dT%H:%M:%S'),
            "minmagnitude": min_magnitude,
            "orderby": "time",
            "limit": 500 if detailed else 200
        }

        if region_bbox:
            params.update({
                "minlatitude": region_bbox[1],
                "maxlatitude": region_bbox[3],
                "minlongitude": region_bbox[0],
                "maxlongitude": region_bbox[2],
            })

        response = requests.get(url, params=params, timeout=30)
        response.raise_for_status()
        data = response.json()

        features = data.get('features', [])
        earthquakes = []

        for f in features:
            prop = f['properties']
            geom = f['geometry']

            earthquake = {
                'time': datetime.utcfromtimestamp(prop['time']/1000),
                'place': prop['place'],
                'magnitude': prop['mag'],
                'longitude': geom['coordinates'][0],
                'latitude': geom['coordinates'][1],
                'depth': geom['coordinates'][2],
                'url': prop['url'],
                'type': prop.get('type', 'earthquake'),
                'status': prop.get('status', 'automatic'),
                'tsunami': prop.get('tsunami', 0),
                'felt': prop.get('felt', 0),
                'cdi': prop.get('cdi', 0),
                'mmi': prop.get('mmi', 0),
                'alert': prop.get('alert', ''),
                'sig': prop.get('sig', 0)
            }

            earthquake['risk_level'] = calculate_risk_level(earthquake['magnitude'])
            earthquake['time_ago'] = calculate_time_ago(earthquake['time'])

            earthquakes.append(earthquake)

        df = pd.DataFrame(earthquakes)

        if not df.empty:
            df['magnitude_category'] = df['magnitude'].apply(categorize_magnitude)
            df['depth_category'] = df['depth'].apply(categorize_depth)
            df['hour_of_day'] = df['time'].dt.hour
            df['day_of_week'] = df['time'].dt.day_name()

        return df

    except requests.exceptions.RequestException as e:
        st.error(f"Network error: {e}")
        return pd.DataFrame()
    except Exception as e:
        st.error(f"Data processing error: {e}")
        return pd.DataFrame()

def calculate_risk_level(magnitude):
    """Calculate risk level based on magnitude"""
    if magnitude >= 7.0:
        return 'Extreme'
    elif magnitude >= 6.0:
        return 'Severe'
    elif magnitude >= 5.0:
        return 'High'
    elif magnitude >= 4.0:
        return 'Moderate'
    else:
        return 'Low'

def categorize_magnitude(magnitude):
    """Categorize magnitude for analysis"""
    if magnitude >= 7.0:
        return 'Major (≥7.0)'
    elif magnitude >= 6.0:
        return 'Strong (6.0-6.9)'
    elif magnitude >= 5.0:
        return 'Moderate (5.0-5.9)'
    elif magnitude >= 4.0:
        return 'Light (4.0-4.9)'
    else:
        return 'Minor (<4.0)'

def categorize_depth(depth):
    """Categorize depth for analysis"""
    if depth < 70:
        return 'Shallow (<70km)'
    elif depth < 300:
        return 'Intermediate (70-300km)'
    else:
        return 'Deep (>300km)'

def calculate_time_ago(time):
    """Calculate time ago in human readable format"""
    now = datetime.utcnow()
    diff = now - time

    if diff.days > 0:
        return f"{diff.days} day(s) ago"
    elif diff.seconds >= 3600:
        hours = diff.seconds // 3600
        return f"{hours} hour(s) ago"
    elif diff.seconds >= 60:
        minutes = diff.seconds // 60
        return f"{minutes} minute(s) ago"
    else:
        return "Just now"

def analyze_seismic_patterns(df):
    """Analyze seismic patterns and trends"""
    if df.empty:
        return {}

    analysis = {}

    try:
        # Only calculate distributions if we have data
        if len(df) > 0:
            analysis['hourly_distribution'] = df['hour_of_day'].value_counts().sort_index()
            analysis['daily_distribution'] = df['day_of_week'].value_counts()

        # Magnitude statistics - only if we have magnitude data
        if 'magnitude' in df.columns and len(df) > 0:
            analysis['magnitude_stats'] = {
                'mean': df['magnitude'].mean(),
                'median': df['magnitude'].median(),
                'std': df['magnitude'].std(),
                'max': df['magnitude'].max(),
                'min': df['magnitude'].min()
            }

        # Depth statistics - only if we have depth data
        if 'depth' in df.columns and len(df) > 0:
            analysis['depth_stats'] = {
                'mean': df['depth'].mean(),
                'median': df['depth'].median(),
                'std': df['depth'].std()
            }

        # Risk distribution - only if we have risk level data
        if 'risk_level' in df.columns and len(df) > 0:
            analysis['risk_distribution'] = df['risk_level'].value_counts()

        # Geographic center - only if we have multiple data points
        if len(df) > 1 and 'latitude' in df.columns and 'longitude' in df.columns:
            analysis['geographic_center'] = {
                'lat': df['latitude'].mean(),
                'lon': df['longitude'].mean()
            }

    except Exception as e:
        st.warning(f"Error in pattern analysis: {str(e)}")
        return {}

    return analysis

def calculate_overall_risk(df):
    """Calculate overall risk assessment"""
    if df.empty:
        return 'low', "No recent seismic activity"

    count = len(df)
    max_magnitude = df['magnitude'].max()

    risk_score = 0

    if count >= RISK_THRESHOLDS['extreme']['count']:
        risk_score += 40
    elif count >= RISK_THRESHOLDS['severe']['count']:
        risk_score += 30
    elif count >= RISK_THRESHOLDS['high']['count']:
        risk_score += 20
    elif count >= RISK_THRESHOLDS['moderate']['count']:
        risk_score += 10

    if max_magnitude >= RISK_THRESHOLDS['extreme']['max_magnitude']:
        risk_score += 40
    elif max_magnitude >= RISK_THRESHOLDS['severe']['max_magnitude']:
        risk_score += 30
    elif max_magnitude >= RISK_THRESHOLDS['high']['max_magnitude']:
        risk_score += 20
    elif max_magnitude >= RISK_THRESHOLDS['moderate']['max_magnitude']:
        risk_score += 10

    if risk_score >= 60:
        risk_level = 'extreme'
    elif risk_score >= 40:
        risk_level = 'severe'
    elif risk_score >= 25:
        risk_level = 'high'
    elif risk_score >= 10:
        risk_level = 'moderate'
    else:
        risk_level = 'low'

    return risk_level, f"Risk Score: {risk_score}/80"

def create_advanced_map(df, region_bbox=None):
    """Create an advanced interactive map"""
    if df.empty:
        return None

    center_lat = df['latitude'].mean()
    center_lon = df['longitude'].mean()

    m = folium.Map(
        location=[center_lat, center_lon],
        zoom_start=6,
        tiles='OpenStreetMap'
    )

    for idx, row in df.iterrows():
        if row['magnitude'] >= 6.0:
            color = 'red'
            radius = 15
        elif row['magnitude'] >= 5.0:
            color = 'orange'
            radius = 12
        elif row['magnitude'] >= 4.0:
            color = 'yellow'
            radius = 10
        else:
            color = 'green'
            radius = 8

        popup_content = f"""
        <b>Magnitude {row['magnitude']}</b><br>
        Location: {row['place']}<br>
        Time: {row['time'].strftime('%Y-%m-%d %H:%M:%S')}<br>
        Depth: {row['depth']:.1f} km<br>
        <a href="{row['url']}" target="_blank">USGS Details</a>
        """

        folium.CircleMarker(
            location=[row['latitude'], row['longitude']],
            radius=radius,
            popup=popup_content,
            color=color,
            fill=True,
            fillOpacity=0.7
        ).add_to(m)

    if region_bbox:
        folium.Rectangle(
            bounds=[[region_bbox[1], region_bbox[0]], [region_bbox[3], region_bbox[2]]],
            color='blue',
            weight=2,
            fillOpacity=0.1
        ).add_to(m)

    return m

def create_comprehensive_charts(df, analysis):
    """Create comprehensive visualization charts"""
    if df.empty:
        return []

    charts = []

    # Magnitude over time with trend - with error handling
    fig1 = go.Figure()
    fig1.add_trace(go.Scatter(
        x=df['time'], y=df['magnitude'],
        mode='markers',
        marker=dict(
            size=df['magnitude'] * 2,
            color=df['magnitude'],
            colorscale='Reds',
            showscale=True
        ),
        name='Earthquakes'
    ))

    # Only add trend line if we have enough data points (at least 2)
    if len(df) >= 2:
        try:
            z = np.polyfit(range(len(df)), df['magnitude'], 1)
            p = np.poly1d(z)
            fig1.add_trace(go.Scatter(
                x=df['time'], y=p(range(len(df))),
                mode='lines',
                name='Trend',
                line=dict(color='blue', dash='dash')
            ))
        except (np.linalg.LinAlgError, ValueError) as e:
            # If polynomial fitting fails, just show the scatter plot without trend
            st.warning(f"Trend analysis unavailable: {str(e)}")

    fig1.update_layout(
        title='Earthquake Magnitude Over Time with Trend',
        xaxis_title='Time',
        yaxis_title='Magnitude',
        height=400
    )
    charts.append(fig1)

    # Magnitude distribution histogram - only if we have data
    if len(df) > 0:
        fig2 = px.histogram(
            df, x='magnitude', nbins=min(20, len(df)),  # Limit bins to data size
            title='Magnitude Distribution',
            labels={'magnitude': 'Magnitude', 'count': 'Frequency'}
        )
        fig2.update_layout(height=400)
        charts.append(fig2)

    # Depth vs Magnitude scatter - only if we have data
    if len(df) > 0:
        fig3 = px.scatter(
            df, x='depth', y='magnitude', color='magnitude',
            title='Depth vs Magnitude Relationship',
            labels={'depth': 'Depth (km)', 'magnitude': 'Magnitude'}
        )
        fig3.update_layout(height=400)
        charts.append(fig3)

    # Hourly distribution - only if we have the data
    if 'hourly_distribution' in analysis and len(analysis['hourly_distribution']) > 0:
        fig4 = px.bar(
            x=analysis['hourly_distribution'].index,
            y=analysis['hourly_distribution'].values,
            title='Earthquake Activity by Hour of Day',
            labels={'x': 'Hour', 'y': 'Count'}
        )
        fig4.update_layout(height=400)
        charts.append(fig4)

    # Risk level distribution - only if we have the data
    if 'risk_distribution' in analysis and len(analysis['risk_distribution']) > 0:
        fig5 = px.pie(
            values=analysis['risk_distribution'].values,
            names=analysis['risk_distribution'].index,
            title='Risk Level Distribution'
        )
        fig5.update_layout(height=400)
        charts.append(fig5)

    return charts

def main():
    st.set_page_config(
        page_title="🌍 QuakeGuard AI",
        page_icon="🌍",
        layout="wide",
        initial_sidebar_state="expanded"
    )

    st.markdown("""
    <style>
    .main-header {
        font-size: 3rem;
        font-weight: bold;
        text-align: center;
        color: #1f77b4;
        margin-bottom: 2rem;
    }
    .risk-high { color: #ff4444; font-weight: bold; }
    .risk-moderate { color: #ffaa00; font-weight: bold; }
    .risk-low { color: #44aa44; font-weight: bold; }
    .metric-card {
        background-color: #f0f2f6;
        padding: 1rem;
        border-radius: 0.5rem;
        border-left: 4px solid #1f77b4;
        color: #222 !important;
    }
    </style>
    """, unsafe_allow_html=True)

    st.markdown('<h1 class="main-header">🌍 Advanced Earthquake Warning System</h1>', unsafe_allow_html=True)
    st.markdown("### Real-time seismic monitoring with AI-powered risk assessment and emergency protocols")

    # Check if API key is configured
    if not get_groq_api_key():
        st.stop()

    st.sidebar.header("⚙️ Configuration")

    region = st.sidebar.text_input(
        "🌍 Region (optional)",
        placeholder="e.g., California, Pakistan, Japan"
    )

    col1, col2 = st.sidebar.columns(2)
    with col1:
        min_magnitude = st.slider("📏 Min Magnitude", 1.0, 7.0, 2.5, 0.1)
    with col2:
        hours = st.slider("⏰ Hours", 1, 168, 24)

    with st.sidebar.expander("🔧 Advanced Options"):
        show_detailed_analysis = st.checkbox("Detailed Analysis", value=True)
        show_ai_summary = st.checkbox("AI Summary", value=True)
        show_emergency_protocols = st.checkbox("Emergency Protocols", value=True)

    region_bboxes = {
        "California": [-125, 32, -114, 42],
        "Pakistan": [60, 23, 77, 37],
        "Japan": [129, 31, 146, 45],
        "Chile": [-75, -56, -66, -17],
        "Turkey": [25, 36, 45, 43],
        "Indonesia": [95, -11, 141, 6],
        "India": [68, 6, 97, 37],
        "Mexico": [-118, 14, -86, 33],
        "USA": [-125, 24, -66, 49],
        "World": [-180, -90, 180, 90]
    }

    region_bbox = region_bboxes.get(region.strip().title()) if region else None

    if st.button("🔄 Refresh Data", type="primary"):
        st.rerun()

    with st.spinner("🌐 Fetching earthquake data..."):
        df = fetch_earthquakes(min_magnitude, hours, region_bbox, show_detailed_analysis)

    if df.empty:
        st.warning("⚠️ No recent earthquakes found matching your criteria.")
        st.info("💡 Try reducing the minimum magnitude or increasing the time range.")

        # Show a simple message when no data is available
        st.markdown("""
        <div class="metric-card">
            <h3>🚨 Current Risk Level: <span class="risk-low">LOW</span></h3>
            <p><strong>Risk Score:</strong> 0/80</p>
            <p><strong>Emergency Protocol:</strong> Monitor situation. No immediate action required.</p>
        </div>
        """, unsafe_allow_html=True)

        # Show tabs with appropriate messages
        tab1, tab2, tab3, tab4, tab5 = st.tabs(["🗺️ Map", "📊 Analytics", "📋 Data", "🤖 AI Analysis", "🚨 Emergency"])

        with tab1:
            st.subheader("🌍 Interactive Earthquake Map")
            st.info("No earthquake data available for map visualization")

        with tab2:
            st.subheader("📊 Advanced Analytics")
            st.info("No earthquake data available for analysis")

        with tab3:
            st.subheader("📋 Earthquake Data")
            st.info("No earthquake data available")

        with tab4:
            st.subheader("🤖 AI-Powered Analysis")
            if show_ai_summary:
                st.info("No earthquake data available for AI analysis")
            else:
                st.info("Enable AI Summary in Advanced Options to see AI analysis.")

        with tab5:
            st.subheader("🚨 Emergency Information")
            if show_emergency_protocols:
                st.markdown("""
                ### 🚨 Emergency Response Protocols

                **Immediate Actions During Earthquake:**
                - Drop, Cover, and Hold On
                - Stay indoors if you're inside
                - Move to open area if you're outside
                - Stay away from windows, mirrors, and heavy objects

                **After Earthquake:**
                - Check for injuries and provide first aid
                - Check for gas leaks and electrical damage
                - Listen to emergency broadcasts
                - Be prepared for aftershocks

                **Emergency Contacts:**
                - Emergency Services: 911 (US) / 112 (EU) / 999 (UK)
                - USGS Earthquake Information: https://earthquake.usgs.gov
                - Local Emergency Management: Check your local government website
                """)

                st.markdown("""
                ### 📊 Current Emergency Status
                - **Risk Level**: LOW
                - **Recommended Action**: Monitor situation. No immediate action required.
                - **Monitoring Required**: No
                """)
            else:
                st.info("Enable Emergency Protocols in Advanced Options to see emergency information.")
    else:
        st.success(f"✅ Found {len(df)} earthquakes in the last {hours} hours")
        st.write(f"🕐 Last updated: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')} UTC")

        risk_level, risk_score = calculate_overall_risk(df)

        st.markdown(f"""
        <div class="metric-card">
            <h3>🚨 Current Risk Level: <span class="risk-{risk_level}">{risk_level.upper()}</span></h3>
            <p><strong>Risk Score:</strong> {risk_score}</p>
            <p><strong>Emergency Protocol:</strong> {EMERGENCY_PROTOCOLS[risk_level]}</p>
        </div>
        """, unsafe_allow_html=True)

        col1, col2, col3, col4 = st.columns(4)
        with col1:
            st.metric("Total Earthquakes", len(df))
        with col2:
            st.metric("Max Magnitude", f"{df['magnitude'].max():.1f}")
        with col3:
            st.metric("Avg Magnitude", f"{df['magnitude'].mean():.2f}")
        with col4:
            st.metric("Avg Depth", f"{df['depth'].mean():.1f} km")

        tab1, tab2, tab3, tab4, tab5 = st.tabs(["🗺️ Map", "📊 Analytics", "📋 Data", "🤖 AI Analysis", "🚨 Emergency"])

        with tab1:
            st.subheader("🌍 Interactive Earthquake Map")
            if not df.empty:
                try:
                    map_obj = create_advanced_map(df, region_bbox)
                    if map_obj:
                        st_folium(map_obj, width=800, height=500)
                    else:
                        st.info("Unable to create map visualization")
                except Exception as e:
                    st.error(f"Error creating map: {str(e)}")
                    st.info("Try adjusting your search criteria")
            else:
                st.info("No earthquake data available for map visualization")

        with tab2:
            st.subheader("📊 Advanced Analytics")
            if not df.empty:
                try:
                    analysis = analyze_seismic_patterns(df)

                    charts = create_comprehensive_charts(df, analysis)
                    for i, chart in enumerate(charts):
                        st.plotly_chart(chart, use_container_width=True)

                    if analysis:
                        col1, col2 = st.columns(2)
                        with col1:
                            st.subheader("📈 Magnitude Statistics")
                            if 'magnitude_stats' in analysis:
                                stats_df = pd.DataFrame([analysis['magnitude_stats']]).T
                                stats_df.columns = ['Value']
                                st.dataframe(stats_df)
                            else:
                                st.info("Insufficient data for magnitude statistics")

                        with col2:
                            st.subheader("📊 Risk Distribution")
                            if 'risk_distribution' in analysis and len(analysis['risk_distribution']) > 0:
                                risk_df = pd.DataFrame(analysis['risk_distribution'])
                                risk_df.columns = ['Count']
                                st.dataframe(risk_df)
                            else:
                                st.info("No risk distribution data available")
                except Exception as e:
                    st.error(f"Error in analytics: {str(e)}")
                    st.info("Try adjusting your search criteria or check your internet connection")
            else:
                st.info("No earthquake data available for analysis")

        with tab3:
            st.subheader("📋 Earthquake Data")
            if not df.empty:
                col1, col2 = st.columns(2)
                with col1:
                    magnitude_filter = st.multiselect(
                        "Filter by Magnitude Category",
                        options=df['magnitude_category'].unique(),
                        default=df['magnitude_category'].unique()
                    )
                with col2:
                    risk_filter = st.multiselect(
                        "Filter by Risk Level",
                        options=df['risk_level'].unique(),
                        default=df['risk_level'].unique()
                    )

                filtered_df = df[
                    (df['magnitude_category'].isin(magnitude_filter)) &
                    (df['risk_level'].isin(risk_filter))
                ]

                st.dataframe(
                    filtered_df[['time', 'place', 'magnitude', 'depth', 'risk_level', 'time_ago', 'url']],
                    use_container_width=True
                )

                csv = filtered_df.to_csv(index=False)
                st.download_button(
                    label="📥 Download CSV",
                    data=csv,
                    file_name=f"earthquakes_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
                    mime="text/csv"
                )

        with tab4:
            st.subheader("🤖 AI-Powered Analysis")
            if show_ai_summary and not df.empty:
                with st.spinner("🤖 Generating AI analysis..."):
                    analysis = analyze_seismic_patterns(df)
                    risk_level, risk_score = calculate_overall_risk(df)

                    prompt = f"""
                    As an expert seismologist and emergency response specialist, provide a comprehensive analysis of the following earthquake data:

                    SUMMARY STATISTICS:
                    - Total earthquakes: {len(df)}
                    - Time period: {hours} hours
                    - Magnitude range: {df['magnitude'].min():.1f} - {df['magnitude'].max():.1f}
                    - Average magnitude: {df['magnitude'].mean():.2f}
                    - Risk level: {risk_level.upper()}
                    - Risk score: {risk_score}

                    EARTHQUAKE DATA:
                    {df[['time', 'place', 'magnitude', 'depth']].head(20).to_string(index=False)}

                    Please provide:
                    1. **Risk Assessment**: Detailed evaluation of current seismic risk
                    2. **Pattern Analysis**: Identification of any concerning patterns or trends
                    3. **Regional Impact**: Specific implications for affected areas
                    4. **Safety Recommendations**: Detailed safety advice for the public
                    5. **Emergency Preparedness**: Specific actions people should take
                    6. **Monitoring Recommendations**: What to watch for in coming hours/days

                    Be thorough, specific, and actionable in your response.
                    """

                    summary = get_groq_summary(prompt)
                    st.markdown(summary)
            else:
                st.info("Enable AI Summary in Advanced Options to see AI analysis.")

        with tab5:
            st.subheader("🚨 Emergency Information")
            if show_emergency_protocols:
                st.markdown("""
                ### 🚨 Emergency Response Protocols

                **Immediate Actions During Earthquake:**
                - Drop, Cover, and Hold On
                - Stay indoors if you're inside
                - Move to open area if you're outside
                - Stay away from windows, mirrors, and heavy objects

                **After Earthquake:**
                - Check for injuries and provide first aid
                - Check for gas leaks and electrical damage
                - Listen to emergency broadcasts
                - Be prepared for aftershocks

                **Emergency Contacts:**
                - Emergency Services: 911 (US) / 112 (EU) / 999 (UK)
                - USGS Earthquake Information: https://earthquake.usgs.gov
                - Local Emergency Management: Check your local government website
                """)

                st.markdown(f"""
                ### 📊 Current Emergency Status
                - **Risk Level**: {risk_level.upper()}
                - **Recommended Action**: {EMERGENCY_PROTOCOLS[risk_level]}
                - **Monitoring Required**: {'Yes' if risk_level in ['high', 'severe', 'extreme'] else 'No'}
                """)
            else:
                st.info("Enable Emergency Protocols in Advanced Options to see emergency information.")

if __name__ == "__main__":
    main()