app.py

"""
Space Weather - Weather Intelligence Application
Built with Gradio, LiteLLM, Open-Meteo, and Gemini
Compatible with Gradio 6.x
Browser-cache version: SINGLE ENTRY (overwrite old data)
"""

import os
import json
import re
import html
import uuid
from datetime import datetime, timezone
from typing import Dict, List, Optional, Tuple, Any
from dataclasses import dataclass
import logging

import gradio as gr
import requests
from litellm import completion
from gemini_key_manager import GeminiKeyManager, classify_gemini_error   

# Suppress Gradio 6.x internal warnings
import warnings
warnings.filterwarnings("ignore", category=RuntimeWarning, message="coroutine.*was never awaited")
warnings.filterwarnings("ignore", category=RuntimeWarning, message=".*event loop.*")



# ------------------------------------------------------------------
# FILE LOADERS
# ------------------------------------------------------------------
def load_text(path: str) -> str:
    try:
        with open(path, "r", encoding="utf-8") as f:
            return f.read()
    except Exception as e:
        logger.error(f"Failed to load {path}: {e}")
        return ""

def load_json(path: str) -> dict:
    try:
        with open(path, "r", encoding="utf-8") as f:
            return json.load(f)
    except Exception as e:
        logger.error(f"Failed to load {path}: {e}")
        return {}




# ------------------------------------------------------------------
# CONFIGURATION
# ------------------------------------------------------------------
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

OPEN_METEO_URL = "https://api.open-meteo.com/v1/forecast"

# Directory to write user-downloadable JSON export files
EXPORT_DIR = "/tmp/weather_exports"


# Definisikan link Shopee Affiliate di sini agar mudah diubah
SHOPEE_LINK = "https://shopee.co.id/"

# Gemini API key rotation manager (baca GEMINI_API_KEY_1..N dari secrets)
key_manager = GeminiKeyManager()   # <-- BARU



# ------------------------------------------------------------------
# STATE MACHINE CONSTANTS
# ------------------------------------------------------------------
STATE_READY = "READY"
STATE_LOCATING = "LOCATING"
STATE_LOCATION_READY = "LOCATION_READY"
STATE_ANALYZING = "ANALYZING"
STATE_FETCHING_WEATHER = "FETCHING_WEATHER"
STATE_PROCESSING_DATA = "PROCESSING_DATA"
STATE_GENERATING_INSIGHT = "GENERATING_INSIGHT"
STATE_VALIDATING_OUTPUT = "VALIDATING_OUTPUT"
STATE_COMPLETED = "COMPLETED"
STATE_ERROR = "ERROR"
STATE_LOCKED_TODAY = "LOCKED_TODAY"

PROGRESS_STEPS = {
    STATE_FETCHING_WEATHER:   ("Step 1/5", "Getting weather data..."),
    STATE_PROCESSING_DATA:    ("Step 2/5", "Processing weather data..."),
    STATE_GENERATING_INSIGHT: ("Step 3/5", "Generating weather insight..."),
    STATE_VALIDATING_OUTPUT:  ("Step 4/5", "Validating analysis..."),
    STATE_COMPLETED:          ("Step 5/5", "Analysis complete"),
}

STEP_ORDER = [
    STATE_FETCHING_WEATHER,
    STATE_PROCESSING_DATA,
    STATE_GENERATING_INSIGHT,
    STATE_VALIDATING_OUTPUT,
    STATE_COMPLETED,
]
STEP_LABELS = ["Weather Data", "Processing", "Insight", "Validation", "Complete"]

STATUS_VARIANTS = {
    STATE_READY: ("neutral", "Ready"),
    STATE_LOCATION_READY: ("info", "Location ready"),
    STATE_ANALYZING: ("active", "Analyzing"),
    STATE_ERROR: ("error", "Error"),
    STATE_LOCKED_TODAY: ("info", "Locked"),
    STATE_COMPLETED: ("success", "Complete"),
}

VALID_SEVERITY   = {"low", "medium", "high"}
VALID_CONFIDENCE = {"low", "medium", "high"}
VALID_PRIORITY   = {"low", "medium", "high"}

WEATHER_VARIABLES = [
    "temperature_2m_max", "temperature_2m_min", "rain_sum", "precipitation_sum",
    "wind_gusts_10m_max", "shortwave_radiation_sum", "temperature_2m_mean",
    "cloud_cover_mean", "et0_fao_evapotranspiration",
    "growing_degree_days_base_0_limit_50", "leaf_wetness_probability_mean",
    "vapour_pressure_deficit_max"
]


# ------------------------------------------------------------------
# DATA CLASSES
# ------------------------------------------------------------------
@dataclass
class AppState:
    state: str = STATE_READY
    is_analyzing: bool = False
    location: Optional[Dict] = None
    client_date: Optional[str] = None
    client_timezone: Optional[str] = None
    browser_date: Optional[str] = None
    browser_timezone: Optional[str] = None
    cache: Optional[Dict] = None  # Now a SINGLE entry, not a dict of dates

    def to_dict(self):
        return {
            "state": self.state,
            "is_analyzing": self.is_analyzing,
            "location": self.location,
            "client_date": self.client_date,
            "client_timezone": self.client_timezone,
            "browser_date": self.browser_date,
            "browser_timezone": self.browser_timezone,
            "cache": self.cache,
        }

    @classmethod
    def from_dict(cls, d):
        return cls(
            state=d.get("state", STATE_READY),
            is_analyzing=d.get("is_analyzing", False),
            location=d.get("location"),
            client_date=d.get("client_date"),
            client_timezone=d.get("client_timezone"),
            browser_date=d.get("browser_date"),
            browser_timezone=d.get("browser_timezone"),
            cache=d.get("cache"),
        )


# ------------------------------------------------------------------
# UTILITY FORMATTERS
# ------------------------------------------------------------------
def validate_coordinates(lat: Any, lon: Any) -> Tuple[bool, str]:
    if lat is None or lon is None:
        return False, "Invalid location. Please enter a valid latitude and longitude."
    try:
        lat_f = float(lat)
        lon_f = float(lon)
    except (ValueError, TypeError):
        return False, "Invalid location. Please enter a valid latitude and longitude."

    if not (-90 <= lat_f <= 90):
        return False, "Invalid location. Latitude must be between -90 and 90."
    if not (-180 <= lon_f <= 180):
        return False, "Invalid location. Longitude must be between -180 and 180."

    return True, ""


def validate_coordinates_ui(lat, lon, state_dict):
    state = AppState.from_dict(state_dict)
    if state.state == STATE_LOCKED_TODAY:
        return gr.update(interactive=False)
    if (lat is None or lat == 0) or (lon is None or lon == 0):
        return gr.update(interactive=False)
    return gr.update(interactive=True)



def esc(value: Any) -> str:
    if value is None:
        return ""
    return html.escape(str(value))


def format_status(state: str, message: str = "") -> str:
    if state in PROGRESS_STEPS and state not in STATUS_VARIANTS:
        variant = "active"
        label = PROGRESS_STEPS[state][1]
    else:
        variant, label = STATUS_VARIANTS.get(state, ("neutral", state.replace("_", " ").title()))

    detail = f'<span class="status-detail">{esc(message)}</span>' if message else ""
    return (
        f'<div class="status-pill status-pill--{variant}">'
        f'<span class="status-dot"></span>'
        f'<span class="status-label">{esc(label)}</span>'
        f'{detail}'
        f'</div>'
    )


def format_location_status(source: str, accuracy: Optional[float]) -> str:
    source_label = {"gps": "GPS", "ip": "IP geolocation"}.get(source, source or "Manual")
    accuracy_str = f" &plusmn;{accuracy:.0f}m" if accuracy else ""
    return (
        f'<div class="status-pill status-pill--info">'
        f'<span class="status-dot"></span>'
        f'<span class="status-label">Location ready</span>'
        f'<span class="status-detail">{esc(source_label)}{accuracy_str}</span>'
        f'</div>'
    )


def render_step_tracker(state: str, error: bool = False) -> str:
    if state not in STEP_ORDER:
        return ""
    idx = STEP_ORDER.index(state)

    items = []
    for i, label in enumerate(STEP_LABELS):
        is_done = i < idx or (i == idx and state == STATE_COMPLETED)
        if error and i == idx:
            cls, marker = "is-error", "&times;"
        elif is_done:
            cls, marker = "is-done", "&check;"
        elif i == idx:
            cls, marker = "is-active", f"{i + 1:02d}"
        else:
            cls, marker = "is-pending", f"{i + 1:02d}"

        items.append(
            f'<div class="step {cls}">'
            f'<span class="step-marker">{marker}</span>'
            f'<span class="step-label">{esc(label)}</span>'
            f'</div>'
        )
        if i < len(STEP_LABELS) - 1:
            filled = "filled" if is_done else ""
            items.append(f'<div class="step-connector {filled}"></div>')

    return f'<div class="step-tracker">{"".join(items)}</div>'


def format_progress(state: str, error: bool = False) -> str:
    return render_step_tracker(state, error=error)


def format_cache_info(cache_entry: Optional[Dict]) -> str:
    if not cache_entry:
        return ""

    # --- Tanggal analisis (sudah browser_date dari handle_weather_and_analyze) ---
    client_date = cache_entry.get("client_date", "Unknown")
    if client_date != "Unknown":
        try:
            client_date = datetime.strptime(client_date, "%Y-%m-%d").strftime("%d %b %Y")
        except Exception:
            pass

    # --- Waktu generated: konversi UTC → browser timezone ---
    created = cache_entry.get("created_at", "Unknown")
    browser_tz = cache_entry.get("browser_timezone") or cache_entry.get("client_timezone") or "UTC"

    if created != "Unknown":
        try:
            dt = datetime.fromisoformat(created)
            # Pastikan aware (UTC)
            if dt.tzinfo is None:
                dt = dt.replace(tzinfo=timezone.utc)
            
            if browser_tz and browser_tz != "UTC":
                try:
                    from zoneinfo import ZoneInfo
                    dt_local = dt.astimezone(ZoneInfo(browser_tz))
                    created = dt_local.strftime("%d %b %Y, %H:%M") + f" · {browser_tz}"
                except Exception:
                    # Fallback kalau ZoneInfo tidak kenal timezone
                    created = dt.strftime("%d %b %Y, %H:%M UTC")
            else:
                created = dt.strftime("%d %b %Y, %H:%M UTC")
        except Exception:
            pass

    location = cache_entry.get("location", {}) or {}
    source = location.get("source", "manual")
    source_label = {"gps": "GPS", "ip": "IP Geolocation", "manual": "Manual"}.get(source, source)

    return (
        f'<div class="cache-card">'
        f'<div class="cache-card-icon">&check;</div>'
        f'<div class="cache-card-body">'
        f'<div class="cache-card-title">Today&rsquo;s analysis is ready</div>'
        f'<div class="cache-card-meta">'
        f'<span>{esc(client_date)}</span><span class="dot-sep">&middot;</span><span>{esc(source_label)}</span>'
        f'</div>'
        f'<div class="cache-card-meta cache-card-meta--faint">Generated {esc(created)}</div>'
        f'</div>'
        f'</div>'
    )


def render_placeholder(title: str, message: str, variant: str = "neutral") -> str:
    return (
        f'<div class="placeholder-card placeholder-card--{variant}">'
        f'<div class="placeholder-mark"></div>'
        f'<div class="placeholder-title">{esc(title)}</div>'
        f'<div class="placeholder-message">{esc(message)}</div>'
        f'</div>'
    )
    

def render_sponsors_html(sponsors: List[Dict]) -> str:
    if not sponsors:
        return '<div class="sponsor-empty">No sponsors listed.</div>'
    items = []
    for s in sponsors:
        items.append(
            f'<a class="sponsor-item" href="{esc(s.get("link", "#"))}" '
            f'target="_blank" rel="noopener noreferrer" title="{esc(s.get("name", ""))}">'
            f'<img class="sponsor-img" src="{esc(s.get("image", ""))}" '
            f'alt="{esc(s.get("name", ""))}" loading="lazy">'
            f'</a>'
        )
    return f'<div class="sponsor-grid">{"".join(items)}</div>'



def severity_badge(sev: Optional[str]) -> str:
    sev_l = (sev or "unknown").lower()
    cls = {"low": "badge--good", "medium": "badge--warn", "high": "badge--bad"}.get(sev_l, "badge--neutral")
    return f'<span class="badge {cls}">{esc(sev_l.upper())}</span>'


def priority_badge(pri: Optional[str]) -> str:
    pri_l = (pri or "unknown").lower()
    cls = {"low": "badge--good", "medium": "badge--warn", "high": "badge--bad"}.get(pri_l, "badge--neutral")
    return f'<span class="badge {cls}">{esc(pri_l.upper())} PRI.</span>'


def confidence_badge(conf: Optional[str]) -> str:
    conf_l = (conf or "unknown").lower()
    cls = {"high": "badge--good", "medium": "badge--warn", "low": "badge--neutral"}.get(conf_l, "badge--neutral")
    return f'<span class="badge {cls} badge--outline">{esc(conf_l.upper())} CONF.</span>'


def render_summary_tab(analysis: Dict) -> str:
    if not analysis:
        return render_placeholder("No analysis yet", "Enter coordinates and select Analyze to generate today's insight.")
    parts = ['<div class="insight-card">']
    parts.append(f'<p class="insight-summary">{esc(analysis.get("summary", "No summary available."))}</p>')
    overall = analysis.get("overall_confidence", "")
    if overall:
        parts.append(f'<div class="insight-footer">Overall confidence&nbsp;{confidence_badge(overall)}</div>')
    parts.append('</div>')
    return "".join(parts)

def render_historical_tab(analysis: Dict) -> str:
    if not analysis:
        return render_placeholder("No data yet", "Run analysis to view historical records.")
    hist = analysis.get("historical", {}) or {}
    parts = ['<div class="insight-card">']
    parts.append('<div class="insight-section">')
    parts.append('<div class="section-eyebrow">Historical &middot; Last 7 Days</div>')
    # New format: condition + impact
    if hist.get("condition"):
        parts.append(f'<p class="section-text"><strong>Kondisi:</strong> {esc(hist["condition"])}</p>')
    if hist.get("impact"):
        parts.append(f'<p class="section-text"><strong>Dampak:</strong> {esc(hist["impact"])}</p>')
    # Old format: summary + key_conditions (backward-compatible)
    if hist.get("summary"):
        parts.append(f'<p class="section-text">{esc(hist["summary"])}</p>')
    conds = hist.get("key_conditions") or []
    if conds:
        parts.append('<ul class="condition-list">' + "".join(f'<li>{esc(c)}</li>' for c in conds) + '</ul>')
    # Fallback if nothing found
    if not hist.get("condition") and not hist.get("impact") and not hist.get("summary") and not conds:
        parts.append('<p class="section-text">No historical data recorded.</p>')
    parts.append('</div></div>')
    return "".join(parts)



def render_forecast_tab(analysis: Dict) -> str:
    if not analysis:
        return render_placeholder("No data yet", "Run analysis to view forecast records.")
    fcst = analysis.get("forecast", {}) or {}
    parts = ['<div class="insight-card">']
    parts.append('<div class="insight-section">')
    parts.append('<div class="section-eyebrow">Forecast &middot; Next 7 Days</div>')
    # New format: condition + impact
    if fcst.get("condition"):
        parts.append(f'<p class="section-text"><strong>Kondisi:</strong> {esc(fcst["condition"])}</p>')
    if fcst.get("impact"):
        parts.append(f'<p class="section-text"><strong>Dampak:</strong> {esc(fcst["impact"])}</p>')
    # Old format: summary + key_conditions (backward-compatible)
    if fcst.get("summary"):
        parts.append(f'<p class="section-text">{esc(fcst["summary"])}</p>')
    conds = fcst.get("key_conditions") or []
    if conds:
        parts.append('<ul class="condition-list">' + "".join(f'<li>{esc(c)}</li>' for c in conds) + '</ul>')
    # Fallback if nothing found
    if not fcst.get("condition") and not fcst.get("impact") and not fcst.get("summary") and not conds:
        parts.append('<p class="section-text">No forecast data recorded.</p>')
    parts.append('</div></div>')
    return "".join(parts)


def render_risks_tab(analysis: Dict) -> str:
    if not analysis:
        return render_placeholder("No data yet", "Run analysis to view risk signals.")
    risks = analysis.get("risks") or []
    parts = ['<div class="insight-card">']
    parts.append('<div class="insight-section">')
    parts.append('<div class="section-eyebrow">Risk Signals</div>')
    if risks:
        parts.append('<div class="risk-list">')
        for risk in risks:
            # Backward-compatible: old data uses "type", new data uses "title"
            title = str(risk.get("title") or risk.get("type", "Unknown Risk"))
            # Old data uses "confidence", new data doesn't have it — just show severity
            badges = severity_badge(risk.get("severity"))
            parts.append('<div class="risk-item">')
            parts.append(
                f'<div class="risk-item-head">'
                f'<span class="risk-item-title">{esc(title)}</span>'
                f'<span class="risk-item-badges">{badges}</span>'
                f'</div>'
            )
            # New format has "description", old format doesn't
            if risk.get("description"):
                parts.append(f'<p class="section-text" style="margin:6px 0 4px;font-size:13px;">{esc(risk["description"])}</p>')
            if risk.get("evidence"):
                parts.append(f'<p class="risk-item-evidence">{esc(risk["evidence"])}</p>')
            # New format has "period", old format doesn't
            if risk.get("period"):
                parts.append(f'<p class="risk-item-evidence" style="color:var(--info);margin-top:4px;">&#128197; {esc(risk["period"])}</p>')
            parts.append('</div>')
        parts.append('</div>')
    else:
        parts.append('<p class="section-text">No significant weather risks detected.</p>')
    parts.append('</div></div>')
    return "".join(parts)


def render_recommendations_tab(analysis: Dict) -> str:
    if not analysis:
        return render_placeholder("No data yet", "Run analysis to view recommendations.")
    parts = ['<div class="insight-card">']
    parts.append('<div class="insight-section insight-section--recommendation" style="margin-bottom:0;">')
    parts.append('<div class="section-eyebrow">Recommendation</div>')
    recs = analysis.get("recommendations") or []
    if recs:
        parts.append('<div class="risk-list">')
        for rec in recs:
            # Backward-compatible: handle old string format AND new object format
            if isinstance(rec, str):
                # Old format: just a string
                action = rec
                reason = ""
                priority = ""
            else:
                # New format: object with action, reason, priority
                action = str(rec.get("action", ""))
                reason = str(rec.get("reason", ""))
                priority = rec.get("priority", "")
            parts.append('<div class="risk-item" style="border-color:rgba(232,163,61,0.25);">')
            parts.append(
                f'<div class="risk-item-head">'
                f'<span class="risk-item-title">{esc(action)}</span>'
                f'<span class="risk-item-badges">{priority_badge(priority)}</span>'
                f'</div>'
            )
            if reason:
                parts.append(f'<p class="risk-item-evidence">{esc(reason)}</p>')
            parts.append('</div>')
        parts.append('</div>')
    else:
        parts.append('<p class="section-text">No immediate action indicated.</p>')
    parts.append('</div></div>')
    return "".join(parts)


# ------------------------------------------------------------------
# 3. WEATHER SERVICE
# ------------------------------------------------------------------
def fetch_weather_data(lat: float, lon: float) -> Tuple[Optional[Dict], str]:
    variables_str = ",".join(WEATHER_VARIABLES)
    url = (
        f"{OPEN_METEO_URL}?latitude={lat}&longitude={lon}"
        f"&daily={variables_str}"
        f"&timezone=auto&past_days=7&forecast_days=7"
    )

    try:
        resp = requests.get(url, timeout=30)
        if resp.status_code != 200:
            return None, f"Weather data unavailable. Please try again later. (HTTP {resp.status_code})"

        data = resp.json()
        if not isinstance(data, dict):
            return None, "Weather data unavailable. Please try again later. (Invalid JSON)"

        if "daily" not in data:
            return None, "Weather data unavailable. Please try again later. (Missing daily data)"

        daily = data["daily"]
        required_vars = ["time"] + WEATHER_VARIABLES
        for var in required_vars:
            if var not in daily:
                return None, f"Weather data unavailable. Please try again later. (Missing variable: {var})"

        dates = daily["time"]
        if not isinstance(dates, list) or len(dates) == 0:
            return None, "Weather data unavailable. Please try again later. (Invalid date array)"

        if len(dates) < 8:
            return None, f"Weather data unavailable. Please try again later. (Insufficient data: {len(dates)} days)"

        return data, ""

    except requests.Timeout:
        return None, "Weather data unavailable. Request timed out. Please try again later."
    except Exception as e:
        logger.error(f"Weather fetch error: {e}")
        return None, "Weather data unavailable. Please try again later."









def handle_weather_and_analyze(weather_json_str: str, lat: float, lon: float, crop: str, phenology: str, notes: str, current_concern: str, state_dict: Dict):
    state = AppState.from_dict(state_dict)
    cache_entry = state.cache

    if not weather_json_str:
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_READY),
            format_progress(STATE_READY),
            format_cache_info(cache_entry),
            gr.update(visible=True),
            gr.update(visible=False),
            gr.update(visible=False),
            render_summary_tab({}),
            render_historical_tab({}),
            render_forecast_tab({}),
            render_risks_tab({}),
            render_recommendations_tab({}),
            json.dumps(cache_entry) if cache_entry else ""
        )
        return

    try:
        raw_weather = json.loads(weather_json_str)
    except Exception as exc:
        err_msg = f"Failed to parse weather data: {exc}"
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, err_msg),
            format_progress(STATE_FETCHING_WEATHER, error=True), "",
            gr.update(visible=True),
            gr.update(visible=False),
            gr.update(visible=False),
            render_placeholder("Analysis failed", err_msg, "error"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            gr.update(value="")
        )
        return

    if "error" in raw_weather:
        error_msg = raw_weather["error"]
        yield (
            state.to_dict(), gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, error_msg),
            format_progress(STATE_FETCHING_WEATHER, error=True), "",
            gr.update(visible=True),
            gr.update(visible=False),
            gr.update(visible=False),
            render_placeholder("Analysis failed", error_msg, "error"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            gr.update(value="")
        )
        return

    # <-- UBAH: gunakan tanggal browser, fallback ke server
    client_date = state.browser_date or datetime.now().strftime("%Y-%m-%d")
    state.client_date = client_date


    if "error" in raw_weather:
        error_msg = raw_weather["error"]
        yield (
            state.to_dict(), gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, error_msg),
            format_progress(STATE_FETCHING_WEATHER, error=True), "",
            gr.update(visible=True),
            gr.update(visible=False),
            gr.update(visible=False),
            render_placeholder("Analysis failed", error_msg, "error"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            gr.update(value="")
        )
        return

    now = datetime.now()

    state.state = STATE_PROCESSING_DATA
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_PROCESSING_DATA),
        format_progress(STATE_PROCESSING_DATA),
        "",
        gr.update(visible=True),
        gr.update(visible=False),
        gr.update(visible=False),
        render_placeholder("Processing weather data", "Splitting historical and forecast windows and computing derived indices.", "active"),
        render_placeholder("No data yet", "Waiting for processing...", "neutral"),
        render_placeholder("No data yet", "Waiting for processing...", "neutral"),
        render_placeholder("No data yet", "Waiting for processing...", "neutral"),
        render_placeholder("No data yet", "Waiting for processing...", "neutral"),
        gr.update(value="")
    )

    normalized, norm_error = normalize_weather_data(raw_weather, lat, lon, client_date)
    if norm_error:
        failed_step = state.state
        state.is_analyzing = False
        state.state = STATE_ERROR
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, norm_error),
            format_progress(failed_step, error=True), "",
            gr.update(visible=True),
            gr.update(visible=False),
            gr.update(visible=False),
            render_placeholder("Analysis failed", norm_error, "error"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            gr.update(value="")
        )
        return

    state.state = STATE_GENERATING_INSIGHT
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_GENERATING_INSIGHT),
        format_progress(STATE_GENERATING_INSIGHT),
        "",
        gr.update(visible=True),
        gr.update(visible=False),
        gr.update(visible=False),
        render_placeholder("Generating weather insight", "Gemini is interpreting the data for risks and recommendations.", "active"),
        render_placeholder("No data yet", "Waiting for insight...", "neutral"),
        render_placeholder("No data yet", "Waiting for insight...", "neutral"),
        render_placeholder("No data yet", "Waiting for insight...", "neutral"),
        render_placeholder("No data yet", "Waiting for insight...", "neutral"),
        gr.update(value="")
    )

    payload = build_llm_payload(normalized, lat, lon, client_date, crop, phenology, notes, current_concern)
    llm_output, gemini_error = call_gemini(payload)
    
    if gemini_error:
        failed_step = state.state
        state.is_analyzing = False
        state.state = STATE_ERROR
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, gemini_error),
            format_progress(failed_step, error=True), "",
            gr.update(visible=True),
            gr.update(visible=False),
            gr.update(visible=False),
            render_placeholder("Analysis failed", gemini_error, "error"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            gr.update(value="")
        )
        return

    state.state = STATE_VALIDATING_OUTPUT
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_VALIDATING_OUTPUT),
        format_progress(STATE_VALIDATING_OUTPUT),
        "",
        gr.update(visible=True),
        gr.update(visible=False),
        gr.update(visible=False),
        render_placeholder("Validating analysis", "Checking the response against the expected schema.", "active"),
        render_placeholder("No data yet", "Waiting for validation...", "neutral"),
        render_placeholder("No data yet", "Waiting for validation...", "neutral"),
        render_placeholder("No data yet", "Waiting for validation...", "neutral"),
        render_placeholder("No data yet", "Waiting for validation...", "neutral"),
        gr.update(value="")
    )

    valid, val_error = validate_llm_output(llm_output)
    if not valid:
        failed_step = state.state
        state.is_analyzing = False
        state.state = STATE_ERROR
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, val_error),
            format_progress(failed_step, error=True), "",
            gr.update(visible=True),
            gr.update(visible=False),
            gr.update(visible=False),
            render_placeholder("Analysis failed", val_error, "error"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            render_placeholder("No data yet", "Analysis interrupted.", "neutral"),
            gr.update(value="")
        )
        return

    state.state = STATE_COMPLETED
    timezone_str = raw_weather.get("timezone", "UTC")
    location_date = normalized.get("meta", {}).get("location_date", client_date)

    cache_entry = {
        "location": state.location,
        "client_date": client_date,
        "location_date": location_date,
        "location_timezone": timezone_str,
        "client_timezone": state.client_timezone or "UTC",
        "field_context": {
            "crop_type": crop,
            "phenology_phase": phenology,
            "field_notes": notes,
            "current_concern": current_concern,
        },
        "raw_weather": raw_weather,
        "analysis": llm_output,
        "created_at": datetime.now(timezone.utc).isoformat()
    }
    
    state.cache = cache_entry
    state.is_analyzing = False

    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_COMPLETED),
        format_progress(STATE_COMPLETED),
        format_cache_info(cache_entry),
        gr.update(visible=False),       # initial_placeholder hidden
        gr.update(visible=True),        # view_insight_btn visible
        gr.update(visible=False),       # tabs_container hidden until clicked
        render_summary_tab(llm_output),
        render_historical_tab(llm_output),
        render_forecast_tab(llm_output),
        render_risks_tab(llm_output),
        render_recommendations_tab(llm_output),
        json.dumps(cache_entry)
    )

    state.state = STATE_LOCKED_TODAY
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_LOCKED_TODAY, "Today's analysis complete. Return tomorrow for a new analysis."),
        "",
        format_cache_info(cache_entry),
        gr.update(visible=False),       # initial_placeholder hidden
        gr.update(visible=True),        # view_insight_btn visible
        gr.update(visible=False),       # tabs_container hidden until clicked
        render_summary_tab(llm_output),
        render_historical_tab(llm_output),
        render_forecast_tab(llm_output),
        render_risks_tab(llm_output),
        render_recommendations_tab(llm_output),
        json.dumps(cache_entry)
    )





# ------------------------------------------------------------------
# 4. ANALYTICS ENGINE
# ------------------------------------------------------------------
def normalize_weather_data(raw_data: Dict, lat: float, lon: float, client_date: str) -> Tuple[Optional[Dict], str]:
    try:
        timezone_str = raw_data.get("timezone", "UTC")
        dates = raw_data["daily"]["time"]
        location_date = dates[7] if len(dates) > 7 else client_date

        daily = raw_data["daily"]

        historical_dates = dates[:7]
        today_date = [dates[7]] if len(dates) > 7 else []
        forecast_dates = dates[8:] if len(dates) > 8 else []

        def extract_block(date_list):
            if not date_list:
                return {}
            result = {"time": date_list}
            for var in WEATHER_VARIABLES:
                values = daily.get(var, [])
                idx_start = dates.index(date_list[0])
                idx_end = idx_start + len(date_list)
                result[var] = values[idx_start:idx_end]
            return result

        historical = extract_block(historical_dates)
        today = extract_block(today_date)
        forecast = extract_block(forecast_dates)

        units = raw_data.get("daily_units", {})
        units_filtered = {k: v for k, v in units.items() if k != "time"}

        normalized = {
            "meta": {
                "location": {
                    "latitude": raw_data.get("latitude", lat),
                    "longitude": raw_data.get("longitude", lon),
                    "timezone": timezone_str,
                    "elevation_m": raw_data.get("elevation")
                },
                "client_date": client_date,
                "location_date": location_date,
                "analysis_period": {
                    "historical": f"{len(historical_dates)} days",
                    "forecast": f"{len(forecast_dates)} days",
                    "anchor_date": client_date
                }
            },
            "units": units_filtered,
            "historical": historical,
            "today": today,
            "forecast": forecast
        }
        return normalized, ""

    except Exception as e:
        logger.error(f"Normalization error: {e}")
        return None, "Failed to process weather data. Please try again later."


# ------------------------------------------------------------------
# 5. LLM ENGINE
# ------------------------------------------------------------------
def build_llm_payload(normalized_data: Dict, lat: float, lon: float, client_date: str, crop: str = "", phenology: str = "", notes: str = "", current_concern: str = "") -> Dict:
    meta = normalized_data.get("meta", {})
    location = meta.get("location", {})
    return {
        "location": {
            "latitude": lat,
            "longitude": lon,
            "timezone": location.get("timezone", "UTC")
        },
        "field_context": {
            "crop_type": crop or "Tidak ditentukan",
            "phenology_phase": phenology or "Tidak ditentukan",
            "field_notes": notes or "Tidak ada catatan khusus",
            "current_concern": current_concern or "Tidak ada concern khusus"
        },
        "analysis_period": {
            "historical": meta.get("analysis_period", {}).get("historical", "7 days"),
            "forecast": meta.get("analysis_period", {}).get("forecast", "7 days"),
            "anchor_date": client_date,
            "anchor_type": "client_time",
            "location_date": meta.get("location_date", client_date),
            "location_timezone": location.get("timezone", "UTC")
        },
        "units": normalized_data.get("units", {}),
        "historical": {"daily": normalized_data.get("historical", {})},
        "forecast": {"daily": normalized_data.get("forecast", {})}
    }


def call_gemini(payload: Dict) -> Tuple[Optional[Dict], str]:
    system_prompt = load_text("prompts/system_prompt.txt")
    if not system_prompt:
        return None, "System prompt file is missing or empty. Please check prompts/system_prompt.txt"

    user_prompt = f"Weather data for analysis:\n\n{json.dumps(payload, indent=2)}"
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_prompt},
    ]

    candidate_keys = key_manager.get_rotation_order()
    last_error_msg = "Unknown error"

    for key in candidate_keys:
        if not key_manager._is_available(key):
            continue

        try:
            response = completion(
                model="gemini/gemini-3.5-flash",
                messages=messages,
                api_key=key,
                temperature=1.0,
                max_tokens=4000,
                timeout=30,
            )
            content = response.choices[0].message.content

            json_match = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", content)
            if json_match:
                content = json_match.group(1)
            content = content.strip()
            start_idx = content.find("{")
            end_idx = content.rfind("}")
            if start_idx != -1 and end_idx != -1:
                content = content[start_idx:end_idx + 1]

            result = json.loads(content)
            return result, ""

        except json.JSONDecodeError as e:
            logger.error(f"JSON decode error: {e}")
            return None, "Analysis could not be validated. Please try again. (Invalid JSON)"

        except Exception as e:
            kind = classify_gemini_error(e)
            logger.warning(f"Key ...{key[-6:]} gagal ({kind}): {e}")

            if kind == "rpd":
                key_manager.mark_rpd_exhausted(key)
                last_error_msg = "Satu atau lebih API key mencapai limit harian."
                continue
            elif kind == "rpm":
                last_error_msg = "Key sedang sibuk (limit per menit), mencoba key lain."
                continue
            else:
                last_error_msg = str(e)
                continue

    return None, (
        "Weather data was retrieved, but the analysis could not be generated. "
        f"Semua API key gagal atau kena limit. ({last_error_msg})"
    )



# ------------------------------------------------------------------
# 6. OUTPUT + CACHE
# ------------------------------------------------------------------
def build_export_file(cache_entry: Optional[Dict]) -> Optional[str]:
    """
    Rangkai satu file TXT (plain text, mudah dibaca manusia maupun LLM)
    berisi: input pengguna (lokasi & konteks lahan), data cuaca mentah
    (historical + forecast dari Open-Meteo), dan hasil analisis Gemini.
    File ini dimaksudkan agar pengguna bisa memakainya sebagai context
    input di LLM lain untuk analisis lanjutan.
    """
    if not cache_entry:
        return None

    location = cache_entry.get("location", {}) or {}
    field_context = cache_entry.get("field_context", {}) or {}
    analysis = cache_entry.get("analysis", {}) or {}

    lines: List[str] = []
    lines.append("=== EXPORT DATA ANALISIS CUACA ===")
    lines.append(f"Dibuat pada : {datetime.now(timezone.utc).isoformat()}")
    lines.append("Tujuan      : Context data untuk analisis lanjutan")
    lines.append("Sumber App  : DigiTanist/tanam")
    lines.append("")
    lines.append("--- INPUT PENGGUNA ---")
    lines.append(f"Latitude       : {location.get('latitude')}")
    lines.append(f"Longitude      : {location.get('longitude')}")
    lines.append(f"Sumber lokasi  : {location.get('source') or '-'}")
    if location.get("accuracy_m"):
        lines.append(f"Akurasi GPS    : {location.get('accuracy_m')} m")
    lines.append(f"Tanggal analisis    : {cache_entry.get('client_date')}")
    lines.append(f"Timezone lokasi     : {cache_entry.get('location_timezone')}")
    lines.append("")
    lines.append("Konteks Lahan:")
    lines.append(f"- Jenis Tanaman     : {field_context.get('crop_type') or '-'}")
    lines.append(f"- Fase Fenologi     : {field_context.get('phenology_phase') or '-'}")
    lines.append(f"- Catatan Lapangan  : {field_context.get('field_notes') or '-'}")
    lines.append(f"- Current Concern   : {field_context.get('current_concern') or '-'}")
    lines.append("")
    lines.append("--- DATA CUACA MENTAH (Ecwf, historical 7 hari + forecast 7 hari) ---")
    lines.append(json.dumps(cache_entry.get("raw_weather", {}), ensure_ascii=False, indent=2))
    lines.append("")
    lines.append("--- HASIL ANALISIS GEMINI AI ---")
    lines.append(f"Ringkasan: {analysis.get('summary', '-')}")
    lines.append("")

    hist = analysis.get("historical", {}) or {}
    lines.append("Historical (7 hari terakhir):")
    lines.append(f"  Kondisi : {hist.get('condition', '-')}")
    lines.append(f"  Dampak  : {hist.get('impact', '-')}")
    lines.append("")

    fcst = analysis.get("forecast", {}) or {}
    lines.append("Forecast (7 hari ke depan):")
    lines.append(f"  Kondisi : {fcst.get('condition', '-')}")
    lines.append(f"  Dampak  : {fcst.get('impact', '-')}")
    lines.append("")

    risks = analysis.get("risks", []) or []
    lines.append(f"Risiko ({len(risks)}):")
    if risks:
        for i, r in enumerate(risks, 1):
            lines.append(f"  {i}. {r.get('title', '-')} [severity: {r.get('severity', '-')}]")
            lines.append(f"     Deskripsi : {r.get('description', '-')}")
            lines.append(f"     Bukti     : {r.get('evidence', '-')}")
            lines.append(f"     Periode   : {r.get('period', '-')}")
    else:
        lines.append("  Tidak ada risiko signifikan.")
    lines.append("")

    recs = analysis.get("recommendations", []) or []
    lines.append(f"Rekomendasi ({len(recs)}):")
    if recs:
        for i, r in enumerate(recs, 1):
            lines.append(f"  {i}. {r.get('action', '-')} [priority: {r.get('priority', '-')}]")
            lines.append(f"     Alasan : {r.get('reason', '-')}")
    else:
        lines.append("  Tidak ada tindakan khusus diperlukan.")
    lines.append("")
    lines.append(f"Overall Confidence: {analysis.get('overall_confidence', '-')}")

    content = "\n".join(lines)

    try:
        os.makedirs(EXPORT_DIR, exist_ok=True)
        date_tag = (cache_entry.get("client_date") or "unknown").replace("-", "")
        unique_id = uuid.uuid4().hex[:8]  # cegah tabrakan nama file antar-user/klik
        path = os.path.join(EXPORT_DIR, f"weather_analysis_{date_tag}_{unique_id}.txt")
        with open(path, "w", encoding="utf-8") as f:
            f.write(content)
        return path
    except Exception as e:
        logger.error(f"Failed to build export file: {e}")
        return None


def validate_llm_output(output: Dict) -> Tuple[bool, str]:
    required_fields = ["summary", "historical", "forecast", "risks", "recommendations", "overall_confidence"]
    for field in required_fields:
        if field not in output:
            return False, f"Analysis could not be validated. Missing field: {field}"

    # Validate historical structure
    hist = output.get("historical", {})
    if not isinstance(hist, dict):
        return False, "Analysis could not be validated. Invalid historical format."
    if "condition" not in hist or "impact" not in hist:
        return False, "Analysis could not be validated. Historical missing condition or impact."

    # Validate forecast structure
    fcst = output.get("forecast", {})
    if not isinstance(fcst, dict):
        return False, "Analysis could not be validated. Invalid forecast format."
    if "condition" not in fcst or "impact" not in fcst:
        return False, "Analysis could not be validated. Forecast missing condition or impact."

    # Validate risks
    if not isinstance(output["risks"], list):
        return False, "Analysis could not be validated. Invalid risks format."

    for i, risk in enumerate(output["risks"]):
        if not isinstance(risk, dict):
            return False, f"Analysis could not be validated. Invalid risk at index {i}."
        risk_required = ["title", "description", "evidence", "period", "severity"]
        for rf in risk_required:
            if rf not in risk:
                return False, f"Analysis could not be validated. Risk {i} missing field: {rf}"
        if risk.get("severity") not in VALID_SEVERITY:
            return False, f"Analysis could not be validated. Invalid severity: {risk.get('severity')}"

    # Validate recommendations
    if not isinstance(output["recommendations"], list):
        return False, "Analysis could not be validated. Invalid recommendations format."

    for i, rec in enumerate(output["recommendations"]):
        if not isinstance(rec, dict):
            return False, f"Analysis could not be validated. Invalid recommendation at index {i}."
        rec_required = ["action", "reason", "priority"]
        for rf in rec_required:
            if rf not in rec:
                return False, f"Analysis could not be validated. Recommendation {i} missing field: {rf}"
        if rec.get("priority") not in VALID_PRIORITY:
            return False, f"Analysis could not be validated. Invalid priority: {rec.get('priority')}"

    # Validate overall_confidence
    if output.get("overall_confidence") not in VALID_CONFIDENCE:
        return False, f"Analysis could not be validated. Invalid overall_confidence."

    return True, ""


# ------------------------------------------------------------------
# MAIN HANDLERS
# ------------------------------------------------------------------

def init_app(composite_json: str):
    cache_entry = None
    browser_date = None
    browser_timezone = "UTC"

    if composite_json and composite_json.strip() and composite_json != '{}':
        try:
            parsed = json.loads(composite_json)
            if isinstance(parsed, dict):
                # Format BARU: object composite dari JS
                if "browser_date" in parsed:
                    cache_raw = parsed.get("cache", "{}")
                    browser_date = parsed.get("browser_date")
                    browser_timezone = parsed.get("browser_timezone", "UTC")
                    if isinstance(cache_raw, str) and cache_raw.strip() and cache_raw != '{}':
                        cache_parsed = json.loads(cache_raw)
                        if isinstance(cache_parsed, dict) and "analysis" in cache_parsed:
                            cache_entry = cache_parsed
                # Format LAMA: langsung cache entry (backward-compatible)
                elif "analysis" in parsed:
                    cache_entry = parsed
        except Exception:
            cache_entry = None

    # Fallback ke server time jika browser tidak mengirimkan waktu
    if not browser_date:
        now = datetime.now()
        browser_date = now.strftime("%Y-%m-%d")
        browser_timezone = "UTC"

    # <-- KUNCI: bandingkan cache dengan TANGGAL BROWSER, bukan tanggal server
    today_cache = cache_entry if (
        cache_entry and cache_entry.get("client_date") == browser_date
    ) else None

    state = AppState(
        state=STATE_READY,
        is_analyzing=False,
        client_date=browser_date,
        client_timezone=browser_timezone,
        browser_date=browser_date,          # <-- BARU
        browser_timezone=browser_timezone,  # <-- BARU
        cache=today_cache
    )

    if today_cache:
        state.state = STATE_LOCKED_TODAY
        location = today_cache.get("location", {})
        lat = location.get("latitude", 0)
        lon = location.get("longitude", 0)
        analysis = today_cache.get("analysis", {})

        return (
            state.to_dict(), lat, lon,
            gr.update(interactive=False), gr.update(interactive=False),
            format_status(STATE_LOCKED_TODAY, "Today's analysis already exists."),
            "",
            format_cache_info(today_cache),
            gr.update(visible=False),
            gr.update(visible=True),
            gr.update(visible=False),
            render_summary_tab(analysis),
            render_historical_tab(analysis),
            render_forecast_tab(analysis),
            render_risks_tab(analysis),
            render_recommendations_tab(analysis),
            gr.update(value="")
        )
    else:
        return (
            state.to_dict(), 0, 0,
            gr.update(interactive=True),
            gr.update(interactive=False),
            format_status(STATE_READY),
            "",
            "",
            gr.update(visible=True),
            gr.update(visible=False),
            gr.update(visible=False),
            render_summary_tab({}),
            render_historical_tab({}),
            render_forecast_tab({}),
            render_risks_tab({}),
            render_recommendations_tab({}),
            gr.update(value="")
        )



def handle_gps_result(gps_json: str, state_dict: Dict):
    state = AppState.from_dict(state_dict)

    if not gps_json:
        return state.to_dict(), 0, 0, format_status(STATE_ERROR, "No location data received.")

    try:
        data = json.loads(gps_json)
    except Exception:
        return state.to_dict(), 0, 0, format_status(STATE_ERROR, "Invalid location data.")

    if "error" in data:
        return state.to_dict(), 0, 0, format_status(STATE_ERROR, data["error"])

    lat = data.get("latitude")
    lon = data.get("longitude")
    source = data.get("source", "unknown")
    accuracy = data.get("accuracy_m")

    valid, msg = validate_coordinates(lat, lon)
    if not valid:
        return state.to_dict(), 0, 0, format_status(STATE_ERROR, msg)

    state.location = {
        "latitude": lat,
        "longitude": lon,
        "source": source,
        "accuracy_m": accuracy
    }
    state.state = STATE_LOCATION_READY

    status = format_location_status(source, accuracy)

    return state.to_dict(), lat, lon, status


def handle_analyze(lat: float, lon: float, state_dict: Dict):
    state = AppState.from_dict(state_dict)
    cache_entry = state.cache  # Single entry, not a dict

    if state.is_analyzing:
        yield (
            state.to_dict(),
            gr.update(), gr.update(),
            format_status(STATE_ANALYZING, "Analysis already in progress."),
            "", "",
            render_placeholder("Analysis in progress", "Please wait for the current analysis to finish.", "active"),
            gr.update(value="")
        )
        return

    valid, msg = validate_coordinates(lat, lon)
    if not valid:
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, msg),
            "", "",
            render_placeholder("Invalid location", msg, "error"),
            gr.update(value="")
        )
        return

    prev_source = (state.location or {}).get("source", "manual")
    prev_accuracy = (state.location or {}).get("accuracy_m")
    state.location = {
        "latitude": lat,
        "longitude": lon,
        "source": prev_source,
        "accuracy_m": prev_accuracy
    }

    client_date = state.browser_date or datetime.now().strftime("%Y-%m-%d")
    state.client_date = client_date

    # Check if today's analysis already exists in the single cache entry
    if cache_entry and cache_entry.get("client_date") == client_date:
        state.state = STATE_LOCKED_TODAY
        yield (
            state.to_dict(),
            gr.update(interactive=False), gr.update(interactive=False),
            format_status(STATE_LOCKED_TODAY, "Today's analysis already exists."),
            "",
            format_cache_info(cache_entry),
            render_analysis(cache_entry.get("analysis", {})),
            gr.update(value="")
        )
        return

    state.is_analyzing = True
    state.state = STATE_ANALYZING
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_ANALYZING),
        format_progress(STATE_ANALYZING),
        "",
        render_placeholder("Starting analysis", "Preparing to fetch weather data...", "active"),
        gr.update(value="")
    )

    state.state = STATE_FETCHING_WEATHER
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_FETCHING_WEATHER),
        format_progress(STATE_FETCHING_WEATHER),
        "",
        render_placeholder("Fetching weather data", "Retrieving historical and forecast records from Open-Meteo.", "active"),
        gr.update(value="")
    )

    raw_weather, error = fetch_weather_data(lat, lon)
    if error:
        failed_step = state.state
        state.is_analyzing = False
        state.state = STATE_ERROR
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, error),
            format_progress(failed_step, error=True), "",
            render_placeholder("Analysis failed", error, "error"),
            gr.update(value="")
        )
        return

    state.state = STATE_PROCESSING_DATA
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_PROCESSING_DATA),
        format_progress(STATE_PROCESSING_DATA),
        "",
        render_placeholder("Processing weather data", "Splitting historical and forecast windows and computing derived indices.", "active"),
        gr.update(value="")
    )

    normalized, error = normalize_weather_data(raw_weather, lat, lon, client_date)
    if error:
        failed_step = state.state
        state.is_analyzing = False
        state.state = STATE_ERROR
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, error),
            format_progress(failed_step, error=True), "",
            render_placeholder("Analysis failed", error, "error"),
            gr.update(value="")
        )
        return

    state.state = STATE_GENERATING_INSIGHT
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_GENERATING_INSIGHT),
        format_progress(STATE_GENERATING_INSIGHT),
        "",
        render_placeholder("Generating weather insight", "Gemini is interpreting the data for risks and recommendations.", "active"),
        gr.update(value="")
    )

    payload = build_llm_payload(normalized, lat, lon, client_date)
    llm_output, error = call_gemini(payload)
    if error:
        failed_step = state.state
        state.is_analyzing = False
        state.state = STATE_ERROR
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, error),
            format_progress(failed_step, error=True), "",
            render_placeholder("Analysis failed", error, "error"),
            gr.update(value="")
        )
        return

    state.state = STATE_VALIDATING_OUTPUT
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_VALIDATING_OUTPUT),
        format_progress(STATE_VALIDATING_OUTPUT),
        "",
        render_placeholder("Validating analysis", "Checking the response against the expected schema.", "active"),
        gr.update(value="")
    )

    valid, error = validate_llm_output(llm_output)
    if not valid:
        failed_step = state.state
        state.is_analyzing = False
        state.state = STATE_ERROR
        yield (
            state.to_dict(),
            gr.update(interactive=True), gr.update(interactive=True),
            format_status(STATE_ERROR, error),
            format_progress(failed_step, error=True), "",
            render_placeholder("Analysis failed", error, "error"),
            gr.update(value="")
        )
        return

    state.state = STATE_COMPLETED

    timezone_str = raw_weather.get("timezone", "UTC")
    location_date = normalized.get("meta", {}).get("location_date", client_date)

    # SINGLE ENTRY: directly overwrite state.cache
    cache_entry = {
        "location": state.location,
        "client_date": client_date,
        "location_date": location_date,
        "location_timezone": timezone_str,
        "client_timezone": state.client_timezone or "UTC",
        "field_context": {
            "crop_type": crop,
            "phenology_phase": phenology,
            "field_notes": notes,
            "current_concern": current_concern,
        },
        "raw_weather": raw_weather,
        "analysis": llm_output,
        "created_at": datetime.now(timezone.utc).isoformat()
    }

    state.cache = cache_entry
    state.is_analyzing = False

    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_COMPLETED),
        format_progress(STATE_COMPLETED),
        format_cache_info(cache_entry),
        render_analysis(llm_output),
        json.dumps(cache_entry)  # cache_out: save single entry to browser
    )

    state.state = STATE_LOCKED_TODAY
    yield (
        state.to_dict(),
        gr.update(interactive=False), gr.update(interactive=False),
        format_status(STATE_LOCKED_TODAY, "Today's analysis complete. Return tomorrow for a new analysis."),
        "",
        format_cache_info(cache_entry),
        render_analysis(llm_output),
        json.dumps(cache_entry)  # cache_out: save single entry to browser
    )


# ------------------------------------------------------------------
# GRADIO UI (Gradio 6.x compatible)
# ------------------------------------------------------------------

THEME = gr.themes.Base(
    font=[gr.themes.GoogleFont("IBM Plex Sans"), "sans-serif"],
    font_mono=[gr.themes.GoogleFont("IBM Plex Mono"), "monospace"],
).set(
    body_background_fill="#0B1B22",
    body_background_fill_dark="#0B1B22",
    body_text_color="#E7F1F0",
    body_text_color_dark="#E7F1F0",
    body_text_color_subdued="#7E9CA3",
    body_text_color_subdued_dark="#7E9CA3",
    background_fill_primary="#122631",
    background_fill_primary_dark="#122631",
    background_fill_secondary="#0F2229",
    background_fill_secondary_dark="#0F2229",
    border_color_primary="#23414F",
    border_color_primary_dark="#23414F",
    block_background_fill="#122631",
    block_background_fill_dark="#122631",
    block_border_color="#23414F",
    block_border_color_dark="#23414F",
    block_label_text_color="#7E9CA3",
    block_label_text_color_dark="#7E9CA3",
    block_label_background_fill="#122631",
    block_label_background_fill_dark="#122631",
    block_title_text_color="#E7F1F0",
    block_title_text_color_dark="#E7F1F0",
    panel_background_fill="#0F2229",
    panel_background_fill_dark="#0F2229",
    panel_border_color="#23414F",
    panel_border_color_dark="#23414F",
    input_background_fill="#0F2229",
    input_background_fill_dark="#0F2229",
    input_border_color="#23414F",
    input_border_color_dark="#23414F",
    input_border_color_focus="#E8A33D",
    input_border_color_focus_dark="#E8A33D",
    button_primary_background_fill="#E8A33D",
    button_primary_background_fill_dark="#E8A33D",
    button_primary_background_fill_hover="#F2B457",
    button_primary_background_fill_hover_dark="#F2B457",
    button_primary_text_color="#0B1B22",
    button_primary_text_color_dark="#0B1B22",
    button_primary_border_color="#E8A33D",
    button_primary_border_color_dark="#E8A33D",
    button_secondary_background_fill="#16303D",
    button_secondary_background_fill_dark="#16303D",
    button_secondary_background_fill_hover="#1B3945",
    button_secondary_background_fill_hover_dark="#1B3945",
    button_secondary_text_color="#E7F1F0",
    button_secondary_text_color_dark="#E7F1F0",
    button_secondary_border_color="#23414F",
    button_secondary_border_color_dark="#23414F",
    error_background_fill="#2A1714",
    error_background_fill_dark="#2A1714",
    error_border_color="#E2604F",
    error_border_color_dark="#E2604F",
)

# ------------------------------------------------------------------
# EXTERNAL ASSETS
# ------------------------------------------------------------------
CSS = load_text("assets/styles.css")

SPONSORS_RAW = load_json("assets/sponsors.json")
SPONSORS_DATA = [(s["image"], s["name"]) for s in SPONSORS_RAW.get("sponsors", [])]
SPONSOR_LINKS = [s["link"] for s in SPONSORS_RAW.get("sponsors", [])]

SPONSOR_HTML = render_sponsors_html(SPONSORS_RAW.get("sponsors", []))


HEADER_HTML = HEADER_HTML = """
<div class="hero-banner">
    <div class="app-header">
        <div class="eyebrow">Field Telemetry &middot; Weather Intelligence</div>
        <h1>DigiTanist/tanam</h1>
        <p class="subtitle">Cegah kerugian akibat cuaca buruk lebih lewat pantauan risiko harian berbasis rekam jejak dan prakiraan cuaca 14 hari. Ditenagai BMKG dan Gemini AI.</p>
    </div>

    <div class="farmer-counter">
        <span class="farmer-counter-badge">
            <span class="farmer-counter-dot"></span>
            <span><strong id="farmer-count">—</strong> petani sudah menganalisis hari ini</span>
        </span>
    </div>
</div>
"""

FOOTER_HTML = """
<div class="app-footer">DATA &middot; OPEN-METEO&nbsp;&nbsp;|&nbsp;&nbsp;ANALYSIS &middot; GEMINI&nbsp;&nbsp;|&nbsp;&nbsp;ONE READ PER DAY</div>
"""


GA4_HEAD = """
<!-- Google tag (gtag.js) -->
<script async src="https://www.googletagmanager.com/gtag/js?id=G-VWC31N398K"></script>
<script>
  window.dataLayer = window.dataLayer || [];
  function gtag(){dataLayer.push(arguments);}
  gtag('js', new Date());
  gtag('config', 'G-VWC31N398K');
</script>

<script>
function getTodayFarmerCount() {
  // ====================== PENGATURAN ANGKA ======================
  const BASE_MIN = 220;
  const BASE_MAX = 380;
  const INCREASE_PER_10_MIN = 2; // Jumlah penambahan setiap 10 menit (bisa disesuaikan)
  // ==============================================================

  const now = new Date();
  
  const today = now.getFullYear() + '-' + 
                String(now.getMonth() + 1).padStart(2, '0') + '-' + 
                String(now.getDate()).padStart(2, '0');

  let seed = 0;
  for (let i = 0; i < today.length; i++) {
    seed = (seed * 31 + today.charCodeAt(i)) & 0xffff;
  }

  const base = BASE_MIN + (seed % (BASE_MAX - BASE_MIN + 1));
  
  // 1. Hitung total menit yang sudah berlalu sejak pukul 00:00 hari ini
  const totalMinutes = (now.getHours() * 60) + now.getMinutes();
  
  // 2. Hitung berapa banyak blok 10 menit yang sudah terlewati
  const blocksOf10Min = Math.floor(totalMinutes / 10);
  
  // 3. Hitung tambahan angka berdasarkan jumlah blok 10 menit
  const extra = blocksOf10Min * INCREASE_PER_10_MIN;

  return base + extra;
}

function animateCount(el, target, duration = 3300) {
  const start = Math.max(0, target - Math.floor(target * 0.15)); // mulai dari ~85%
  const startTime = performance.now();
  function tick(now) {
    const progress = Math.min((now - startTime) / duration, 1);
    const eased = 1 - Math.pow(1 - progress, 3); // ease-out cubic
    el.innerText = Math.round(start + (target - start) * eased).toLocaleString("id-ID");
    if (progress < 1) requestAnimationFrame(tick);
  }
  requestAnimationFrame(tick);
}

function updateFarmerCount() {
  const el = document.getElementById("farmer-count");
  if (el) {
    animateCount(el, getTodayFarmerCount());
    return true; // berhasil
  }
  return false; // elemen belum ada
}

// Coba terus sampai elemen muncul (maksimal 10 detik)
function tryUpdateCounter(attempts = 0) {
  if (updateFarmerCount() || attempts > 20) return;
  
  setTimeout(() => tryUpdateCounter(attempts + 1), 500);
}

// Mulai mencoba segera
tryUpdateCounter();

// Update rutin setiap 5 menit
setInterval(updateFarmerCount, 5 * 60 * 1000);
</script>
"""


with gr.Blocks(title="Space Weather", head=GA4_HEAD) as demo:

    gr.HTML(HEADER_HTML)

    app_state = gr.State({})
    gps_data = gr.Textbox(visible=False, elem_id="gps_data_input")
    cache_in = gr.Textbox(visible=False, elem_id="browser_cache_in")
    cache_out = gr.Textbox(visible=False, elem_id="browser_cache_out")
    weather_json = gr.Textbox(visible=False, elem_id="weather_json_input")


    with gr.Row(elem_classes=["main-row"]):
        with gr.Column(scale=1, min_width=320, elem_classes=["rail-col"]):
            with gr.Column(elem_classes=["console-panel"]):
                gr.HTML('<div class="panel-eyebrow">Location</div>')

                lat_input = gr.Number(
                    label="Latitude",
                    precision=6,
                    value=0,
                    info="-90 to 90"
                )
                lon_input = gr.Number(
                    label="Longitude",
                    precision=6,
                    value=0,
                    info="-180 to 180"
                )
                
                crop_input = gr.Textbox(
                    label="Jenis Tanaman",
                    placeholder="Contoh: Padi, Jagung, Cabai",
                    lines=1
                )
                phenology_input = gr.Textbox(
                    label="Fase Fenologi",
                    placeholder="Contoh: Vegetatif, Pembungaan, Pematangan",
                    lines=1
                )
                notes_input = gr.Textbox(
                    label="Catatan Lapangan",
                    placeholder="Contoh: Ada genangan air, gejala serangan hama ringan",
                    lines=2
                )
                
                current_concern_input = gr.Textbox(
                    label="Current Concern",
                    placeholder="Contoh: Khawatir kekurangan air atau risiko penyakit jamur",
                    info="Opsional. Masukkan kondisi atau pertanyaan yang ingin diperiksa berdasarkan cuaca.",
                    lines=2
                )

                with gr.Row(elem_classes=["btn-row"]):
                    get_loc_btn = gr.Button("Ambil lokasi dari GPS perangkat", variant="secondary", size="sm")
                    analyze_btn = gr.Button("Analyze", variant="primary", size="sm", interactive=False)


                

                with gr.Column():
                    status_html = gr.HTML("")
                    step_html = gr.HTML("")
                    cache_html = gr.HTML("")

                
        with gr.Column(scale=2, elem_classes=["content-col"]):
            # Placeholder awal sebelum ada analisis atau saat loading
            initial_placeholder = gr.HTML(render_placeholder("Initializing", "Loading today's status..."))
            
            # Tombol View Insight (awalnya disembunyikan)
            view_insight_btn = gr.Button("View Insight", variant="primary", visible=False, size="lg")
            
            # Kontainer Tab dibungkus Column dan disembunyikan secara default (visible=False)
            with gr.Column(visible=False) as tabs_container:
                with gr.Tabs():
                    with gr.TabItem("Summary"):
                        summary_html = gr.HTML()
                    with gr.TabItem("Historical"):
                        historical_html = gr.HTML()
                    with gr.TabItem("Forecast"):
                        forecast_html = gr.HTML()
                    with gr.TabItem("Risks"):
                        risks_html = gr.HTML()
                    with gr.TabItem("Recommendations"):
                        recommendations_html = gr.HTML()
                        
                        
            # Tombol download data mentah (JSON): tersembunyi, muncul
            # bersamaan dengan tabs insight saat "View Insight" diklik.
            download_data_btn = gr.DownloadButton(
                "Download Data Analisis (TXT)",
                visible=False,
                size="md",
                variant="secondary",
                elem_classes=["download-data-btn"]
            )
                        
            
            # Sponsor section (paling bawah)
            gr.HTML('<div style="height: 16px;"></div>')
            with gr.Column(elem_classes=["console-panel"]):
                gr.HTML('<div class="panel-eyebrow" style="padding: 14px 14px 6px;">Supported By</div>')
                gr.HTML(SPONSOR_HTML)

            
            
            
            
            
            
            
    gr.HTML(FOOTER_HTML)

    # 1. Page load: read localStorage into hidden textbox
        # 1. Page load: baca localStorage + waktu browser, kirim sebagai composite JSON
    demo.load(
        fn=None,
        js="""() => {
            let cache = '{}';
            try {
                cache = localStorage.getItem('space_weather_cache') || '{}';
            } catch (e) {
                cache = '{}';
            }
            const now = new Date();
            const browserDate = now.getFullYear() + '-' + 
                String(now.getMonth() + 1).padStart(2, '0') + '-' + 
                String(now.getDate()).padStart(2, '0');
            const browserTz = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
            return JSON.stringify({
                cache: cache,
                browser_date: browserDate,
                browser_timezone: browserTz
            });
        }""",
        outputs=cache_in
    )

    # 2. When cache_in changes, initialize app from browser cache
    cache_in.change(
        fn=init_app,
        inputs=[cache_in],
        outputs=[
            app_state, lat_input, lon_input, get_loc_btn, analyze_btn, 
            status_html, step_html, cache_html, 
            initial_placeholder, view_insight_btn, tabs_container,
            summary_html, historical_html, forecast_html, risks_html, recommendations_html, 
            cache_out
        ]
    )
    
    # 3. Get Current Location -> JS geolocation -> hidden textbox
    get_loc_btn.click(
        fn=None,
        js="""
        async () => {
            return new Promise((resolve) => {
                if (navigator.geolocation) {
                    navigator.geolocation.getCurrentPosition(
                        (position) => {
                            resolve(JSON.stringify({
                                latitude: position.coords.latitude,
                                longitude: position.coords.longitude,
                                source: "gps",
                                accuracy_m: position.coords.accuracy
                            }));
                        },
                        async (error) => {
                            try {
                                const resp = await fetch('https://ipwho.is/');
                                const data = await resp.json();
                                if (data.success) {
                                    resolve(JSON.stringify({
                                        latitude: data.latitude,
                                        longitude: data.longitude,
                                        source: "ip",
                                        accuracy_m: null
                                    }));
                                } else {
                                    resolve(JSON.stringify({
                                        error: "Unable to determine your location. Please enter coordinates manually."
                                    }));
                                }
                            } catch (e) {
                                resolve(JSON.stringify({
                                    error: "Unable to determine your location. Please enter coordinates manually."
                                }));
                            }
                        },
                        {timeout: 10000, maximumAge: 60000}
                    );
                } else {
                    fetch('https://ipwho.is/')
                        .then(r => r.json())
                        .then(data => {
                            if (data.success) {
                                resolve(JSON.stringify({
                                    latitude: data.latitude,
                                    longitude: data.longitude,
                                    source: "ip",
                                    accuracy_m: null
                                }));
                            } else {
                                resolve(JSON.stringify({
                                    error: "Unable to determine your location. Please enter coordinates manually."
                                }));
                            }
                        })
                        .catch(() => {
                            resolve(JSON.stringify({
                                error: "Unable to determine your location. Please enter coordinates manually."
                            }));
                        });
                }
            });
        }
        """,
        outputs=gps_data
    )

    gps_data.change(
        fn=handle_gps_result,
        inputs=[gps_data, app_state],
        outputs=[app_state, lat_input, lon_input, status_html]
    )
    
    

    analyze_btn.click(
        fn=None,
        js="""async (lat, lon) => {
            if (typeof gtag === 'function') {
                gtag('event', 'analyze_click', {
                    'event_category': 'engagement',
                    'latitude': lat,
                    'longitude': lon
                });
            }
            if (lat === null || lon === null || isNaN(lat) || isNaN(lon)) {
                return JSON.stringify({ error: "Invalid coordinates. Please enter a valid latitude and longitude." });
            }

            const variables = [
                "temperature_2m_max", "temperature_2m_min", "rain_sum", "precipitation_sum",
                "wind_gusts_10m_max", "shortwave_radiation_sum", "temperature_2m_mean",
                "cloud_cover_mean", "et0_fao_evapotranspiration",
                "growing_degree_days_base_0_limit_50", "leaf_wetness_probability_mean",
                "vapour_pressure_deficit_max"
            ].join(",");
            const url = `https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${lon}&daily=${variables}&timezone=auto&past_days=7&forecast_days=7`;
            try {
                const resp = await fetch(url);
                if (!resp.ok) {
                    return JSON.stringify({ error: `Weather data unavailable. Please try again later. (HTTP ${resp.status})` });
                }
                const data = await resp.json();
                return JSON.stringify(data);
            } catch (e) {
                return JSON.stringify({ error: "Weather data unavailable. Network error. Please try again later." });
            }
        }""",
        inputs=[lat_input, lon_input],
        outputs=[weather_json]
    )
    
    
    
    
    weather_json.change(
        fn=handle_weather_and_analyze,
        inputs=[weather_json, lat_input, lon_input, crop_input, phenology_input, notes_input, current_concern_input, app_state],
        outputs=[
            app_state, get_loc_btn, analyze_btn, 
            status_html, step_html, cache_html, 
            initial_placeholder, view_insight_btn, tabs_container,
            summary_html, historical_html, forecast_html, risks_html, recommendations_html, 
            cache_out
        ]
    )

    
    
    lat_input.change(
        fn=validate_coordinates_ui,
        inputs=[lat_input, lon_input, app_state],
        outputs=[analyze_btn]
    )
    lon_input.change(
        fn=validate_coordinates_ui,
        inputs=[lat_input, lon_input, app_state],
        outputs=[analyze_btn]
    )
    
    
    def show_insight_view(state_dict):
        # Langkah 1: tampilkan tabs + tombol download TERLEBIH DAHULU,
        # tapi tanpa value/file dulu (href kosong). Ini memastikan
        # elemen tombolnya sudah ter-mount & visible di DOM sebelum
        # kita isi hrefnya di langkah 2 (.then()). Kalau visible=True
        # dan value diisi dalam SATU update yang sama, kadang Gradio
        # sempat me-render ulang elemennya sehingga href belum
        # "nyantol" saat klik pertama -> baru berfungsi di klik kedua.
        state = AppState.from_dict(state_dict)
        has_cache = bool(state.cache)
        return (
            gr.update(visible=False),
            gr.update(visible=True),
            gr.update(visible=has_cache, value=None)
        )

    def prepare_download_file(state_dict):
        # Langkah 2: baru sekarang isi value (href) tombol, SETELAH
        # tombolnya sudah pasti ter-mount & visible dari langkah 1.
        state = AppState.from_dict(state_dict)
        export_path = build_export_file(state.cache)
        return gr.update(value=export_path, visible=bool(export_path))

    view_insight_btn.click(
    fn=show_insight_view,
    inputs=[app_state],
    js=f"""() => {{
        if (typeof gtag === 'function') {{
            gtag('event', 'view_insight_click', {{
                'event_category': 'engagement'
            }});
        }}
        window.open('{SHOPEE_LINK}', '_blank');
    }}""",
    outputs=[view_insight_btn, tabs_container, download_data_btn]
    ).then(
        fn=prepare_download_file,
        inputs=[app_state],
        outputs=[download_data_btn]
    )
    
    # 4. When cache_out changes, save to localStorage (overwrite old data)
    cache_out.change(
        fn=None,
        js="""(data) => {
            if (data && data !== '{}' && data !== '') {
                try {
                    // Always overwrite — never accumulate
                    localStorage.setItem('space_weather_cache', data);
                } catch (e) {
                    console.error('Failed to save cache to localStorage:', e);
                }
            }
            return [];
        }""",
        inputs=[cache_out]
    )


if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        theme=THEME,
        css=CSS,
        allowed_paths=["assets"]
    )