app.py

import streamlit as st
from groq import Groq
import requests
import pandas as pd
from datetime import datetime, timedelta
import pycountry
from fpdf import FPDF
import io
import base64
from geopy.geocoders import Nominatim
from geopy.exc import GeocoderTimedOut
import plotly.express as px
import plotly.graph_objects as go
import unicodedata
import os
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Get API keys from environment variables
GROQ_API_KEY = os.getenv("GROQ_API_KEY")
AIRVISUAL_API_KEY = os.getenv("AIRVISUAL_API_KEY")
DEFAULT_MODEL = "llama3-70b-8192"

# === INIT Groq CLIENT ===
client = Groq(api_key=GROQ_API_KEY)

# === PAGE CONFIG ===
st.set_page_config(
    page_title="🌱 AI Climate & Smart Farming Assistant",
    page_icon="🌾",
    layout="wide",
    initial_sidebar_state="expanded"
)

# === CSS STYLING ===
st.markdown(
    """
    <style>
    .main {
        background-color: #f9f9f9;
        color: #222;
        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
    }
    .title {
        text-align: center;
        color: #2E7D32;
        font-weight: 800;
    }
    .subtitle {
        text-align: center;
        font-size: 18px;
        margin-bottom: 20px;
        color: #4CAF50;
    }
    .history-box {
        background-color: #e8f5e9;
        padding: 10px;
        margin-bottom: 10px;
        border-radius: 8px;
        border-left: 5px solid #66bb6a;
        color: #000000;
    }
    .ai-response {
        background-color: #c8e6c9;
        padding: 10px;
        margin-bottom: 15px;
        border-radius: 10px;
        white-space: pre-wrap;
        color: #000000;
    }
    .user-input {
        background-color: #dcedc8;
        padding: 8px;
        border-radius: 8px;
        font-weight: bold;
        margin-bottom: 5px;
        color: #000000;
    }
    .download-button {
        background-color: #4CAF50;
        color: white;
        padding: 10px 20px;
        border-radius: 5px;
        text-decoration: none;
        display: inline-block;
        margin: 10px 0;
    }
    .insight-box {
        background-color: #e1f5fe;
        padding: 15px;
        border-radius: 10px;
        margin: 15px 0;
        border-left: 4px solid #0288d1;
        color: #000000;
        font-weight: 500;
        line-height: 1.6;
    }
    </style>
    """,
    unsafe_allow_html=True
)

# === HEADER ===
st.markdown("<h1 class='title'>🌾 AI Climate & Smart Farming Assistant</h1>", unsafe_allow_html=True)
st.markdown("<p class='subtitle'>Real-time AI insights + live weather data</p>", unsafe_allow_html=True)
st.markdown("---")

# === SYSTEM PROMPTS ===
system_prompts = {
    "Track Pollution": (
        "You are an expert environmental scientist. "
        "Help users understand pollution levels in air, water, or soil using scientific reasoning. "
        "Provide actionable recommendations for improvement."
    ),
    "Carbon Emissions": (
        "You are a sustainability advisor. "
        "Estimate and explain carbon emissions, suggest reductions and eco-friendly alternatives. "
        "Include cost-benefit analysis and ROI calculations."
    ),
    "Predict Climate Patterns": (
        "You are a climate researcher. Predict or explain regional climate changes using current and historical data. "
        "Include statistical analysis and confidence intervals."
    ),
    "Smart Farming Advice": (
        "You are an AI-powered farming assistant. Help users with crop selection, irrigation, pest control, and yield optimization. "
        "Focus on sustainable practices and resource efficiency."
    ),
}

# === EXAMPLE QUERIES ===
example_queries = {
    "Track Pollution": "e.g., What's the air quality near Lahore right now?",
    "Carbon Emissions": "e.g., How can a factory reduce CO2 output sustainably?",
    "Predict Climate Patterns": "e.g., What climate changes are expected in sub-Saharan Africa?",
    "Smart Farming Advice": "e.g., Best crops to grow in dry conditions in Uganda?",
}

# === UTILS: API CALLS ===
def get_weather(location: str):
    try:
        # First, get coordinates for the location
        geocoding_url = f"https://geocoding-api.open-meteo.com/v1/search?name={location}&count=1"
        geo_resp = requests.get(geocoding_url, timeout=10)
        geo_resp.raise_for_status()
        geo_data = geo_resp.json()

        if not geo_data.get('results'):
            return None

        lat = geo_data['results'][0]['latitude']
        lon = geo_data['results'][0]['longitude']
        location_name = geo_data['results'][0]['name']

        # Then get weather data for those coordinates
        weather_url = f"https://api.open-meteo.com/v1/forecast?latitude={lat}&longitude={lon}&current=temperature_2m,relative_humidity_2m,wind_speed_10m,weather_code"
        weather_resp = requests.get(weather_url, timeout=10)
        weather_resp.raise_for_status()
        weather_data = weather_resp.json()

        # Weather code to description mapping
        weather_codes = {
            0: "Clear sky",
            1: "Mainly clear",
            2: "Partly cloudy",
            3: "Overcast",
            45: "Foggy",
            48: "Depositing rime fog",
            51: "Light drizzle",
            53: "Moderate drizzle",
            55: "Dense drizzle",
            61: "Slight rain",
            63: "Moderate rain",
            65: "Heavy rain",
            71: "Slight snow",
            73: "Moderate snow",
            75: "Heavy snow",
            77: "Snow grains",
            80: "Slight rain showers",
            81: "Moderate rain showers",
            82: "Violent rain showers",
            85: "Slight snow showers",
            86: "Heavy snow showers",
            95: "Thunderstorm",
            96: "Thunderstorm with slight hail",
            99: "Thunderstorm with heavy hail"
        }

        current = weather_data['current']
        weather_code = current['weather_code']
        weather_desc = weather_codes.get(weather_code, "Unknown")

        return {
            "location": location_name,
            "description": weather_desc,
            "temperature_C": current['temperature_2m'],
            "humidity_%": current['relative_humidity_2m'],
            "wind_speed_m/s": current['wind_speed_10m']
        }
    except Exception as e:
        return None

def get_historical_weather(location: str, days: int = 7):
    try:
        # Get coordinates
        geocoding_url = f"https://geocoding-api.open-meteo.com/v1/search?name={location}&count=1"
        geo_resp = requests.get(geocoding_url, timeout=10)
        geo_resp.raise_for_status()
        geo_data = geo_resp.json()

        if not geo_data.get('results'):
            return None

        lat = geo_data['results'][0]['latitude']
        lon = geo_data['results'][0]['longitude']

        # Get historical data
        end_date = datetime.now()
        start_date = end_date - timedelta(days=days)

        weather_url = (
            f"https://api.open-meteo.com/v1/forecast"
            f"?latitude={lat}&longitude={lon}"
            f"&start_date={start_date.strftime('%Y-%m-%d')}"
            f"&end_date={end_date.strftime('%Y-%m-%d')}"
            f"&daily=temperature_2m_max,temperature_2m_min,precipitation_sum,wind_speed_10m_max"
        )

        weather_resp = requests.get(weather_url, timeout=10)
        weather_resp.raise_for_status()
        return weather_resp.json()
    except Exception as e:
        return None

def get_air_quality(location: str):
    try:
        # First, get coordinates for the location
        geocoding_url = f"https://geocoding-api.open-meteo.com/v1/search?name={location}&count=1"
        geo_resp = requests.get(geocoding_url, timeout=10)
        geo_resp.raise_for_status()
        geo_data = geo_resp.json()

        if not geo_data.get('results'):
            return None

        lat = geo_data['results'][0]['latitude']
        lon = geo_data['results'][0]['longitude']

        # Try Open-Meteo API first
        aq_url = f"https://air-quality-api.open-meteo.com/v1/air-quality?latitude={lat}&longitude={lon}&current=pm10,pm2_5,ozone,nitrogen_dioxide,sulphur_dioxide"
        aq_resp = requests.get(aq_url, timeout=10)

        if aq_resp.status_code == 200:
            aq_data = aq_resp.json()
            if 'current' in aq_data:
                return aq_data

        # If Open-Meteo fails, try AirVisual API
        airvisual_url = f"http://api.airvisual.com/v2/nearest_city?lat={lat}&lon={lon}&key={AIRVISUAL_API_KEY}"
        airvisual_resp = requests.get(airvisual_url, timeout=10)

        if airvisual_resp.status_code == 200:
            airvisual_data = airvisual_resp.json()
            if 'data' in airvisual_data and 'current' in airvisual_data['data']:
                current = airvisual_data['data']['current']['pollution']
                return {
                    'current': {
                        'pm10': current.get('p1'),
                        'pm2_5': current.get('p2'),
                        'ozone': current.get('o3'),
                        'nitrogen_dioxide': None,
                        'sulphur_dioxide': None
                    }
                }

        return None
    except Exception as e:
        print(f"Air quality error: {str(e)}")
        return None

# === UTILS: PDF Generation ===
def clean_text_for_pdf(text):
    """Clean text to be PDF-safe by removing or replacing problematic characters"""
    # Normalize Unicode characters
    text = unicodedata.normalize('NFKD', text)
    # Replace common problematic characters
    replacements = {
        'μ': 'micro',
        '°': ' degrees',
        '℃': 'C',
        '±': '+/-',
        '×': 'x',
        '÷': '/',
        '≤': '<=',
        '≥': '>=',
        '≠': '!=',
        '∞': 'infinity',
        '→': '->',
        '←': '<-',
        '↑': 'up',
        '↓': 'down',
        '↔': '<->',
        '≈': '~=',
        '∑': 'sum',
        '∏': 'product',
        '√': 'sqrt',
        '∫': 'integral',
        '∆': 'delta',
        '∇': 'nabla',
        '∂': 'partial',
        '∝': 'proportional to',
        '∞': 'infinity',
        '∅': 'empty set',
        '∈': 'in',
        '∉': 'not in',
        '⊂': 'subset',
        '⊃': 'superset',
        '∪': 'union',
        '∩': 'intersection',
        '∀': 'for all',
        '∃': 'exists',
        '∄': 'does not exist',
        '∴': 'therefore',
        '∵': 'because'
    }
    for char, replacement in replacements.items():
        text = text.replace(char, replacement)
    return text

def generate_pdf(chat_history, title="AI Climate & Farming Advice"):
    pdf = FPDF()
    pdf.add_page()

    # Use built-in font
    pdf.set_font("helvetica", "B", 16)
    pdf.cell(0, 10, clean_text_for_pdf(title), ln=True, align='C')
    pdf.ln(10)

    # Chat history
    for chat in chat_history:
        # User message
        pdf.set_font("helvetica", "B", 12)
        pdf.cell(0, 10, "User:", ln=True)
        pdf.set_font("helvetica", "", 12)
        # Clean and wrap text
        user_text = clean_text_for_pdf(chat["user"])
        pdf.multi_cell(0, 10, user_text)
        pdf.ln(5)

        # AI response
        pdf.set_font("helvetica", "B", 12)
        pdf.cell(0, 10, "AI Response:", ln=True)
        pdf.set_font("helvetica", "", 12)
        # Clean and wrap text
        ai_text = clean_text_for_pdf(chat["ai"])
        pdf.multi_cell(0, 10, ai_text)
        pdf.ln(10)

    return pdf.output(dest="S").encode("latin-1", "replace")

# === UTILS: Get Country List ===
def get_country_list():
    countries = [country.name for country in pycountry.countries]
    return sorted(countries)

# === SIDEBAR ===
st.sidebar.header("🌟 Features")
page = st.sidebar.radio(
    "Choose your tool:",
    [
        "AI Assistant Chat",
        "Weather Data",
        "Smart Farming CSV Analysis",
    ]
)

# === MULTI-TURN CHAT ===
if page == "AI Assistant Chat":
    st.subheader("🧠 AI Climate & Farming Chat Assistant")
    option = st.selectbox(
        "Choose a use case:",
        list(system_prompts.keys())
    )
    st.markdown(f"💡 *Example*: {example_queries[option]}")

    user_input = st.text_area("Enter your question or describe your situation:")

    if "chat_history" not in st.session_state:
        st.session_state.chat_history = []

    if st.button("Send to AI") and user_input.strip():
        with st.spinner("Thinking..."):
            messages = [
                {"role": "system", "content": system_prompts[option]},
            ]
            # Append chat history for multi-turn
            for chat in st.session_state.chat_history:
                messages.append({"role": "user", "content": chat["user"]})
                messages.append({"role": "assistant", "content": chat["ai"]})
            # Add current user input
            messages.append({"role": "user", "content": user_input})

            response = client.chat.completions.create(
                model=DEFAULT_MODEL,
                messages=messages,
            )
            ai_response = response.choices[0].message.content

            # Save chat
            st.session_state.chat_history.append({"user": user_input, "ai": ai_response})

            # Clear input box
            st.rerun()

    if st.session_state.chat_history:
        st.markdown("### 🕘 Conversation History")
        for chat in reversed(st.session_state.chat_history):
            st.markdown(f"<div class='user-input'>You:</div><div>{chat['user']}</div>", unsafe_allow_html=True)
            st.markdown(f"<div class='ai-response'>{chat['ai']}</div>", unsafe_allow_html=True)

        # Add PDF download button
        if st.button("Download Chat as PDF"):
            pdf_bytes = generate_pdf(st.session_state.chat_history)
            st.download_button(
                label="Click to Download PDF",
                data=pdf_bytes,
                file_name="climate_advice.pdf",
                mime="application/pdf"
            )

    if st.button("Clear Chat History"):
        st.session_state.chat_history = []
        st.rerun()

# === WEATHER DATA PAGE ===
elif page == "Weather Data":
    st.subheader("🌍 Advanced Weather & Environmental Data")

    location_method = st.radio(
        "Choose location input method:",
        ["Enter City", "Select Country"]
    )

    location = None
    if location_method == "Enter City":
        location = st.text_input("Enter a city or location (e.g., Los Angeles, Delhi):")
    elif location_method == "Select Country":
        country = st.selectbox("Select a country:", get_country_list())
        city = st.text_input("Enter city name:")
        location = f"{city}, {country}" if city else None

    if location:
        tab1, tab2, tab3 = st.tabs(["Current Weather", "Historical Data", "Air Quality"])

        with tab1:
            if st.button("Get Current Weather"):
                with st.spinner("Fetching data..."):
                    weather_data = get_weather(location)
                    if weather_data is None:
                        st.error("Failed to fetch weather data for this location.")
                    else:
                        col1, col2 = st.columns(2)

                        with col1:
                            st.markdown(f"### Current Weather in {weather_data['location']}:")
                            st.write(f"- Description: {weather_data['description']}")
                            st.write(f"- Temperature: {weather_data['temperature_C']} °C")
                            st.write(f"- Humidity: {weather_data['humidity_%']} %")
                            st.write(f"- Wind Speed: {weather_data['wind_speed_m/s']} m/s")

                        with col2:
                            fig = go.Figure()
                            fig.add_trace(go.Indicator(
                                mode="gauge+number",
                                value=weather_data['temperature_C'],
                                title={'text': "Temperature (°C)"},
                                gauge={'axis': {'range': [-20, 40]},
                                       'bar': {'color': "darkgreen"}}
                            ))
                            st.plotly_chart(fig)

        with tab2:
            days = st.slider("Select number of days for historical data:", 1, 30, 7)
            if st.button("Get Historical Weather"):
                with st.spinner("Fetching historical data..."):
                    hist_data = get_historical_weather(location, days)
                    if hist_data is None:
                        st.error("Failed to fetch historical weather data.")
                    else:
                        daily = hist_data['daily']
                        df = pd.DataFrame({
                            'Date': pd.date_range(start=daily['time'][0], periods=len(daily['time'])),
                            'Max Temp': daily['temperature_2m_max'],
                            'Min Temp': daily['temperature_2m_min'],
                            'Precipitation': daily['precipitation_sum'],
                            'Wind Speed': daily['wind_speed_10m_max']
                        })

                        # Create temperature range plot
                        fig = go.Figure()
                        fig.add_trace(go.Scatter(
                            x=df['Date'],
                            y=df['Max Temp'],
                            name='Max Temperature',
                            line=dict(color='red')
                        ))
                        fig.add_trace(go.Scatter(
                            x=df['Date'],
                            y=df['Min Temp'],
                            name='Min Temperature',
                            line=dict(color='blue'),
                            fill='tonexty'
                        ))
                        fig.update_layout(
                            title='Temperature Range Over Time',
                            xaxis_title='Date',
                            yaxis_title='Temperature (°C)',
                            hovermode='x unified'
                        )
                        st.plotly_chart(fig)

                        # Create precipitation and wind speed plot
                        fig2 = go.Figure()
                        fig2.add_trace(go.Bar(
                            x=df['Date'],
                            y=df['Precipitation'],
                            name='Precipitation',
                            marker_color='lightblue'
                        ))
                        fig2.add_trace(go.Scatter(
                            x=df['Date'],
                            y=df['Wind Speed'],
                            name='Wind Speed',
                            line=dict(color='orange'),
                            yaxis='y2'
                        ))
                        fig2.update_layout(
                            title='Precipitation and Wind Speed',
                            xaxis_title='Date',
                            yaxis_title='Precipitation (mm)',
                            yaxis2=dict(
                                title='Wind Speed (m/s)',
                                overlaying='y',
                                side='right'
                            )
                        )
                        st.plotly_chart(fig2)

        with tab3:
            if st.button("Get Air Quality Data"):
                with st.spinner("Fetching air quality data..."):
                    aq_data = get_air_quality(location)
                    if aq_data is None:
                        st.error("Failed to fetch air quality data.")
                    else:
                        st.markdown(f"### Air Quality in {location}")
                        current = aq_data['current']

                        # Create air quality gauges
                        col1, col2, col3 = st.columns(3)

                        # Define parameters
                        params = {
                            'pm10': {'name': 'PM10 (μg/m³)', 'range': [0, 100]},
                            'pm2_5': {'name': 'PM2.5 (μg/m³)', 'range': [0, 50]},
                            'ozone': {'name': 'Ozone (μg/m³)', 'range': [0, 100]},
                            'nitrogen_dioxide': {'name': 'Nitrogen Dioxide (μg/m³)', 'range': [0, 100]},
                            'sulphur_dioxide': {'name': 'Sulphur Dioxide (μg/m³)', 'range': [0, 100]}
                        }

                        # Display gauges for first 3 parameters
                        for i, param in enumerate(['pm2_5', 'pm10', 'ozone']):
                            if param in current and current[param] is not None:
                                with [col1, col2, col3][i]:
                                    fig = go.Figure(go.Indicator(
                                        mode="gauge+number",
                                        value=current[param],
                                        title={'text': params[param]['name']},
                                        gauge={'axis': {'range': params[param]['range']},
                                               'bar': {'color': "darkgreen"}}
                                    ))
                                    st.plotly_chart(fig)

                        # Display other pollutants
                        st.markdown("### Other Pollutants")
                        col1, col2 = st.columns(2)
                        with col1:
                            if 'nitrogen_dioxide' in current and current['nitrogen_dioxide'] is not None:
                                st.write(f"- Nitrogen Dioxide: {current['nitrogen_dioxide']} μg/m³")
                        with col2:
                            if 'sulphur_dioxide' in current and current['sulphur_dioxide'] is not None:
                                st.write(f"- Sulphur Dioxide: {current['sulphur_dioxide']} μg/m³")

# === SMART FARMING CSV ANALYSIS PAGE ===
elif page == "Smart Farming CSV Analysis":
    st.subheader("🌱 AI-Powered Farming Data Analysis")
    uploaded_file = st.file_uploader("Upload your farming dataset (CSV)", type=["csv"])

    if uploaded_file:
        try:
            df = pd.read_csv(uploaded_file)
            st.success("✅ Data loaded successfully!")

            # Create tabs for different analyses
            tab1, tab2 = st.tabs(["Data Explorer", "AI Insights"])

            with tab1:
                st.markdown("### Dataset Preview")
                st.dataframe(df.head(5))

                if st.checkbox("Show Summary Statistics"):
                    st.markdown("### Summary Statistics")
                    st.write(df.describe().transpose())

                # Interactive visualizations
                numeric_cols = df.select_dtypes(include=["float64", "int64"]).columns.tolist()
                if numeric_cols:
                    col1, col2 = st.columns(2)
                    with col1:
                        x_axis = st.selectbox("X-Axis", numeric_cols)
                    with col2:
                        y_axis = st.selectbox("Y-Axis", numeric_cols)

                    if x_axis and y_axis:
                        fig = px.scatter(
                            df,
                            x=x_axis,
                            y=y_axis,
                            title=f"{y_axis} vs {x_axis}",
                            trendline="ols",
                            color_discrete_sequence=["#2E7D32"]
                        )
                        st.plotly_chart(fig)

                    # Correlation heatmap
                    if len(numeric_cols) > 1:
                        st.markdown("### Correlation Matrix")
                        corr = df[numeric_cols].corr()
                        fig = px.imshow(corr,
                                        text_auto=True,
                                        aspect="auto",
                                        color_continuous_scale="Greens")
                        st.plotly_chart(fig)

            with tab2:
                st.markdown("### AI-Powered Farming Insights")
                st.info("Ask specific questions about your farming data to get actionable insights")

                analysis_prompt = st.text_area(
                    "What insights would you like? (Examples below):",
                    "Analyze this farming data and provide key insights:",
                    height=100
                )

                st.caption("Examples: 'Suggest optimal crops for this region', 'Identify yield patterns', "
                           "'Recommend irrigation improvements', 'Predict harvest timing'")

                if st.button("Generate AI Insights", type="primary"):
                    with st.spinner("🧠 Analyzing with AI..."):
                        # Prepare data context
                        context = f"Dataset has {len(df)} rows and columns: {', '.join(df.columns)}\n"
                        context += f"First 3 rows:\n{df.head(3).to_string(index=False)}"

                        # Get AI analysis
                        messages = [
                            {
                                "role": "system",
                                "content": (
                                    "You are an expert agricultural data scientist. Analyze farming datasets and provide: "
                                    "1. Actionable insights for improving crop yield "
                                    "2. Recommendations based on climate patterns "
                                    "3. Resource optimization strategies "
                                    "4. Sustainable farming practices "
                                    "Use bullet points and specific numbers when possible."
                                )
                            },
                            {
                                "role": "user",
                                "content": f"{analysis_prompt}\n\n{context}"
                            }
                        ]

                        response = client.chat.completions.create(
                            model=DEFAULT_MODEL,
                            messages=messages,
                            temperature=0.3
                        )
                        insights = response.choices[0].message.content
                        st.markdown(f"<div class='insight-box'>{insights}</div>", unsafe_allow_html=True)

        except Exception as e:
            st.error(f"❌ Error processing data: {str(e)}")
    else:
        st.info("👆 Upload a CSV file containing your farming data to get started")

# === FOOTER ===
st.markdown("---")
st.markdown(
    "<small>🔋 Powered by <b>llama3-70b-8192</b> on Groq • Real-time data from Open-Meteo API</small>",
    unsafe_allow_html=True
)