app.py

import gradio as gr
import requests
import folium
import os
import json
from datetime import datetime, timedelta
import pandas as pd

# Get API key from environment
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")

def create_map(lat=40.7128, lon=-74.0060):
    """Create a Folium map centered at given coordinates"""
    m = folium.Map(
        location=[lat, lon],
        zoom_start=10,
        tiles="OpenStreetMap"
    )
    
    # Add a marker for the selected location
    folium.Marker(
        [lat, lon],
        popup=f"Selected Location: {lat:.4f}, {lon:.4f}",
        tooltip="Click to select this location",
        icon=folium.Icon(color='red', icon='info-sign')
    ).add_to(m)
    
    return m._repr_html_()

def get_pollen_data(lat, lon, days=5):
    """Fetch pollen data from Google Pollen API"""
    if not GOOGLE_API_KEY:
        return "Error: Google API key not found. Please set GOOGLE_API_KEY as a secret."
    
    # Google Pollen API endpoint
    url = "https://pollen.googleapis.com/v1/forecast:lookup"
    
    # Calculate date range
    start_date = datetime.now()
    end_date = start_date + timedelta(days=days-1)
    
    params = {
        "key": GOOGLE_API_KEY,
        "location.longitude": lon,
        "location.latitude": lat,
        "days": days,
        "plantsDescription": True
    }
    
    try:
        response = requests.get(url, params=params)
        response.raise_for_status()
        data = response.json()
        
        # Debug: Print the structure to understand the API response
        print(f"API Response keys: {data.keys()}")
        if "dailyInfo" in data and len(data["dailyInfo"]) > 0:
            print(f"First day info keys: {data['dailyInfo'][0].keys()}")
            print(f"Date structure: {data['dailyInfo'][0].get('date', 'No date field')}")
        
        return data
    except requests.exceptions.RequestException as e:
        error_msg = f"Error fetching pollen data: {str(e)}"
        if hasattr(e, 'response') and e.response is not None:
            error_msg += f" (Status: {e.response.status_code})"
        return error_msg
    except json.JSONDecodeError as e:
        return f"Error parsing response: {str(e)}"
    except Exception as e:
        return f"Unexpected error: {str(e)}"

def format_pollen_data(data):
    """Format pollen data for display"""
    if isinstance(data, str):  # Error message
        return data, None
    
    if "dailyInfo" not in data:
        return "No pollen data available for this location.", None
    
    # Create formatted output
    output = []
    output.append("# 🌸 Pollen Forecast Report\n")
    
    # Location info if available
    if "regionInfo" in data:
        region = data["regionInfo"]
        output.append(f"**Location:** {region.get('displayName', 'Unknown')}\n")
    
    # Daily pollen data
    daily_data = []
    for day_info in data["dailyInfo"]:
        # Handle different date formats from the API
        date_info = day_info.get("date", {})
        
        if isinstance(date_info, dict):
            # If date is a dict, try to extract the date string
            if "year" in date_info and "month" in date_info and "day" in date_info:
                year = date_info["year"]
                month = date_info["month"]
                day = date_info["day"]
                date_obj = datetime(year, month, day)
            else:
                # Fallback to today's date if we can't parse
                date_obj = datetime.now()
        elif isinstance(date_info, str):
            # If it's already a string, parse it
            try:
                date_obj = datetime.strptime(date_info, "%Y-%m-%d")
            except ValueError:
                date_obj = datetime.now()
        else:
            # Fallback
            date_obj = datetime.now()
            
        formatted_date = date_obj.strftime("%B %d, %Y")
        
        output.append(f"## 📅 {formatted_date}\n")
        
        if "pollenTypeInfo" in day_info:
            pollen_types = day_info["pollenTypeInfo"]
            
            # Create a row for the dataframe
            row_data = {"Date": formatted_date}
            
            for pollen in pollen_types:
                pollen_type = pollen["code"].replace("_", " ").title()
                index_info = pollen.get("indexInfo", {})
                index_value = index_info.get("value", "N/A")
                category = index_info.get("category", "Unknown")
                
                # Add color coding based on category
                color_map = {
                    "VERY_LOW": "🟢",
                    "LOW": "🟡", 
                    "MEDIUM": "🟠",
                    "HIGH": "🔴",
                    "VERY_HIGH": "🟣"
                }
                color = color_map.get(category, "⚪")
                
                output.append(f"**{pollen_type}:** {color} {category} (Index: {index_value})")
                row_data[pollen_type] = f"{category} ({index_value})"
                
                # Add plant descriptions if available
                if "plantDescription" in pollen:
                    plants = pollen["plantDescription"]
                    if "plants" in plants:
                        plant_list = [plant["displayName"] for plant in plants["plants"][:3]]  # Show top 3
                        output.append(f"  - *Main sources: {', '.join(plant_list)}*")
                
                output.append("")
            
            daily_data.append(row_data)
        
        output.append("---\n")
    
    # Create DataFrame for tabular view
    df = None
    if daily_data:
        df = pd.DataFrame(daily_data)
    
    # Add legend
    output.append("\n## 📊 Pollen Index Legend")
    output.append("🟢 Very Low | 🟡 Low | 🟠 Medium | 🔴 High | 🟣 Very High\n")
    
    # Add tips
    output.append("## 💡 Tips")
    output.append("- Check pollen levels before outdoor activities")
    output.append("- Take allergy medications during high pollen days")
    output.append("- Keep windows closed during peak pollen times")
    output.append("- Shower and change clothes after being outdoors")
    
    return "\n".join(output), df

def update_location(lat, lon):
    """Update the map and fetch pollen data for new location"""
    if lat is None or lon is None:
        return create_map(), "Please select a location on the map.", None
    
    # Create new map
    new_map = create_map(lat, lon)
    
    # Get pollen data
    pollen_data = get_pollen_data(lat, lon)
    formatted_data, df = format_pollen_data(pollen_data)
    
    return new_map, formatted_data, df

# Create the Gradio interface
with gr.Blocks(title="🌸 Pollen Forecast Map", theme=gr.themes.Soft()) as app:
    gr.HTML("""
    <div style="text-align: center; padding: 20px;">
        <h1>🌸 Pollen Forecast Map</h1>
        <p>Click on the map to select a location and get detailed pollen forecasts powered by Google Pollen API</p>
    </div>
    """)
    
    with gr.Row():
        with gr.Column(scale=1):
            gr.HTML("<h3>📍 Location Selection</h3>")
            
            # Coordinate inputs
            lat_input = gr.Number(
                label="Latitude", 
                value=40.7128, 
                precision=6,
                info="Enter latitude or click on map"
            )
            lon_input = gr.Number(
                label="Longitude", 
                value=-74.0060, 
                precision=6,
                info="Enter longitude or click on map"
            )
            
            update_btn = gr.Button("🔄 Update Location", variant="primary")
            
            # Preset locations
            gr.HTML("<h4>📍 Quick Locations</h4>")
            with gr.Row():
                nyc_btn = gr.Button("🏙️ NYC", size="sm")
                la_btn = gr.Button("🌴 LA", size="sm") 
                chicago_btn = gr.Button("🌬️ Chicago", size="sm")
                miami_btn = gr.Button("🏖️ Miami", size="sm")
        
        with gr.Column(scale=2):
            # Map display
            map_html = gr.HTML(
                value=create_map(),
                label="Interactive Map"
            )
    
    with gr.Row():
        with gr.Column():
            # Pollen data output
            pollen_output = gr.Markdown(
                value="Select a location to view pollen forecast.",
                label="Pollen Forecast"
            )
            
            # Data table
            pollen_table = gr.Dataframe(
                label="Pollen Data Summary",
                visible=False
            )
    
    # Event handlers
    def set_nyc():
        return 40.7128, -74.0060
    
    def set_la():
        return 34.0522, -118.2437
    
    def set_chicago():
        return 41.8781, -87.6298
    
    def set_miami():
        return 25.7617, -80.1918
    
    # Button events
    update_btn.click(
        fn=update_location,
        inputs=[lat_input, lon_input],
        outputs=[map_html, pollen_output, pollen_table]
    )
    
    nyc_btn.click(
        fn=set_nyc,
        outputs=[lat_input, lon_input]
    ).then(
        fn=update_location,
        inputs=[lat_input, lon_input],
        outputs=[map_html, pollen_output, pollen_table]
    )
    
    la_btn.click(
        fn=set_la,
        outputs=[lat_input, lon_input]
    ).then(
        fn=update_location,
        inputs=[lat_input, lon_input],
        outputs=[map_html, pollen_output, pollen_table]
    )
    
    chicago_btn.click(
        fn=set_chicago,
        outputs=[lat_input, lon_input]
    ).then(
        fn=update_location,
        inputs=[lat_input, lon_input],
        outputs=[map_html, pollen_output, pollen_table]
    )
    
    miami_btn.click(
        fn=set_miami,
        outputs=[lat_input, lon_input]
    ).then(
        fn=update_location,
        inputs=[lat_input, lon_input],
        outputs=[map_html, pollen_output, pollen_table]
    )
    
    # Auto-update when coordinates change
    lat_input.change(
        fn=update_location,
        inputs=[lat_input, lon_input],
        outputs=[map_html, pollen_output, pollen_table]
    )
    
    lon_input.change(
        fn=update_location,
        inputs=[lat_input, lon_input],
        outputs=[map_html, pollen_output, pollen_table]
    )
    
    # Load initial data
    app.load(
        fn=update_location,
        inputs=[lat_input, lon_input],
        outputs=[map_html, pollen_output, pollen_table]
    )

if __name__ == "__main__":
    app.launch()