Delete app.py

app.py

@@ -1,2046 +0,0 @@
-"""
-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="sm",
-                variant="secondary"
-            )
-                        
-            
-            # 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 handle_view_insight(state_dict):
-        # Cukup tampilkan tabs + tombol download; file BELUM dibuat di
-        # sini. File baru dirangkai saat tombol download benar-benar
-        # diklik (lihat handle_download_click), supaya tidak ada file
-        # bersama yang bisa tabrakan antar-user yang mengakses bersamaan.
-        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,
-                interactive=True,
-                label="⬇ Download Data Analisis (TXT)"
-            )
-        )
-
-    view_insight_btn.click(
-    fn=handle_view_insight,
-    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]
-    )
-
-    def start_download_loading():
-        # Langkah 1 (instan): kunci tombol & ubah label jadi indikator
-        # loading, supaya user tahu proses berjalan dan tidak klik
-        # berkali-kali sebelum file selesai dirangkai.
-        return gr.update(interactive=False, label="⏳ Menyiapkan file...")
-
-    def handle_download_click(state_dict):
-        # PENTING: gr.DownloadButton hanya memicu auto-download untuk
-        # update value yang terjadi di DALAM event klik yang sama dengan
-        # yang men-trigger-nya. Kalau proses "loading" dan "generate file"
-        # dipecah jadi dua event terpisah (mis. via .then()), auto-download
-        # hanya terpicu di klik BERIKUTNYA (karena value baru baru tersedia
-        # setelah event klik pertama selesai) — itulah sebabnya butuh 2x
-        # klik. Solusinya: satu fungsi generator, dua kali yield, tetap
-        # dalam SATU event klik.
-
-        # Yield 1 (instan): kunci tombol + ubah label jadi indikator
-        # loading, supaya user tahu proses berjalan dan tidak klik lagi.
-        yield gr.update(interactive=False, label="⏳ Menyiapkan file...")
-
-        # Yield 2: file sudah jadi -> set value supaya auto-download
-        # terpicu, lalu kembalikan tombol ke kondisi normal.
-        state = AppState.from_dict(state_dict)
-        export_path = build_export_file(state.cache)
-        if export_path:
-            label = "⬇ Download Data Analisis (TXT)"
-        else:
-            label = "⚠ Gagal membuat file, coba lagi"
-        yield gr.update(value=export_path, interactive=True, label=label)
-
-    download_data_btn.click(
-        fn=handle_download_click,
-        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"]
-    )