Update app.py

app.py

@@ -1,7 +1,8 @@
 # ============================================================
 #   ENERGYGURU – POWER CALCULUS
-#   Streamlit Dashboard  |  dashboard.py
-#   Run: streamlit run dashboard.py
+#   Streamlit Dashboard  |  app.py
+#   Hugging Face Spaces compatible
+#   Run locally : streamlit run app.py
 # ============================================================
 
 import streamlit as st
@@ -9,14 +10,20 @@ import pandas as pd
 import numpy as np
 import plotly.graph_objects as go
 import plotly.express as px
-import serial
-import serial.tools.list_ports
 import time
 import math
 import random
 from datetime import datetime, timedelta
 
-# ── Page config (MUST be first Streamlit call) ───────────────
+# Optional serial (not available on HF Spaces cloud)
+try:
+    import serial
+    import serial.tools.list_ports
+    SERIAL_AVAILABLE = True
+except ImportError:
+    SERIAL_AVAILABLE = False
+
+# ── Page config ──────────────────────────────────────────────
 st.set_page_config(
     page_title="EnergyGuru – Power Calculus",
     page_icon="⚡",
@@ -34,10 +41,8 @@ html, body, [class*="css"] {
     background-color: #080c14;
 }
 
-/* Hide default Streamlit elements */
 #MainMenu, footer, header { visibility: hidden; }
 
-/* Metric cards */
 .eg-card {
     background: linear-gradient(145deg, #0d1422, #111827);
     border: 1px solid #1e3a52;
@@ -68,8 +73,6 @@ html, body, [class*="css"] {
     text-transform: uppercase;
     letter-spacing: 1.5px;
 }
-
-/* Section headers */
 .eg-section {
     font-family: 'Share Tech Mono', monospace;
     color: #00c8ff;
@@ -80,13 +83,10 @@ html, body, [class*="css"] {
     padding-left: 10px;
     margin: 18px 0 10px 0;
 }
-
-/* Status badge */
 .status-live  { color: #00ff99; font-size: 0.75rem; }
 .status-demo  { color: #ffcc00; font-size: 0.75rem; }
 .status-off   { color: #ff4466; font-size: 0.75rem; }
 
-/* Sidebar styling */
 section[data-testid="stSidebar"] {
     background: #080c14;
     border-right: 1px solid #1a2840;
@@ -94,6 +94,10 @@ section[data-testid="stSidebar"] {
 </style>
 """, unsafe_allow_html=True)
 
+# ── Is this running on Hugging Face Spaces? ──────────────────
+import os
+ON_HF = os.environ.get("SPACE_ID") is not None
+
 # ── Constants ────────────────────────────────────────────────
 CITY_LOCATIONS = {
     "Rawalpindi City Model": {"lat": 33.6007, "lon": 73.0679, "desc": "Punjab, Pakistan"},
@@ -103,15 +107,6 @@ CITY_LOCATIONS = {
     "Custom Location":       {"lat": 33.6007, "lon": 73.0679, "desc": "User-defined"},
 }
 
-ACCENT_COLORS = {
-    "voltage":  "#00c8ff",
-    "current":  "#ff9500",
-    "power":    "#ff4466",
-    "energy":   "#00ff99",
-    "bill":     "#ffd700",
-    "carbon":   "#88ff00",
-}
-
 # ── Session State Init ───────────────────────────────────────
 COLS = ['timestamp', 'voltage', 'current', 'power',
         'energy_kwh', 'bill_pkr', 'carbon_kg', 'runtime_hrs']
@@ -146,31 +141,39 @@ with st.sidebar:
     """, unsafe_allow_html=True)
 
     st.markdown('<div class="eg-section">Connection</div>', unsafe_allow_html=True)
-    demo_mode = st.toggle("🎮 Demo Mode (No Hardware)", value=st.session_state.demo_mode)
-    st.session_state.demo_mode = demo_mode
-
-    if not demo_mode:
-        ports = [p.device for p in serial.tools.list_ports.comports()]
-        sel_port = st.selectbox("Serial Port", ports if ports else ["No ports found"])
-        baud     = st.selectbox("Baud Rate", [9600, 115200], index=0)
-        c1, c2 = st.columns(2)
-        with c1:
-            if st.button("▶ Connect", use_container_width=True):
-                try:
-                    st.session_state.serial_conn = serial.Serial(sel_port, baud, timeout=1)
-                    st.session_state.connected = True
-                    st.success("Connected!")
-                except Exception as e:
-                    st.error(str(e))
-        with c2:
-            if st.button("■ Disconnect", use_container_width=True):
-                if st.session_state.serial_conn:
-                    try: st.session_state.serial_conn.close()
-                    except: pass
-                st.session_state.connected = False
-                st.session_state.serial_conn = None
-
-    # Status indicator
+
+    if ON_HF:
+        st.info("Running on Hugging Face Spaces — demo mode only. To use real Arduino hardware, run this app locally.", icon="ℹ️")
+        st.session_state.demo_mode = True
+        demo_mode = True
+    else:
+        demo_mode = st.toggle("🎮 Demo Mode (No Hardware)", value=st.session_state.demo_mode)
+        st.session_state.demo_mode = demo_mode
+
+    if not demo_mode and not ON_HF:
+        if SERIAL_AVAILABLE:
+            ports = [p.device for p in serial.tools.list_ports.comports()]
+            sel_port = st.selectbox("Serial Port", ports if ports else ["No ports found"])
+            baud     = st.selectbox("Baud Rate", [9600, 115200], index=0)
+            c1, c2   = st.columns(2)
+            with c1:
+                if st.button("▶ Connect", use_container_width=True):
+                    try:
+                        st.session_state.serial_conn = serial.Serial(sel_port, baud, timeout=1)
+                        st.session_state.connected = True
+                        st.success("Connected!")
+                    except Exception as e:
+                        st.error(str(e))
+            with c2:
+                if st.button("■ Disconnect", use_container_width=True):
+                    if st.session_state.serial_conn:
+                        try: st.session_state.serial_conn.close()
+                        except: pass
+                    st.session_state.connected = False
+                    st.session_state.serial_conn = None
+        else:
+            st.warning("pyserial not installed. Run: pip install pyserial")
+
     if demo_mode:
         st.markdown('<p class="status-demo">◉ DEMO MODE ACTIVE</p>', unsafe_allow_html=True)
     elif st.session_state.connected:
@@ -178,32 +181,6 @@ with st.sidebar:
     else:
         st.markdown('<p class="status-off">◉ DISCONNECTED</p>', unsafe_allow_html=True)
 
-    st.markdown('<div class="eg-section">Manual Override</div>', unsafe_allow_html=True)
-    manual_override = st.toggle("✏️ Set Voltage & Current Manually", value=False)
-    if manual_override:
-        ov1, ov2 = st.columns(2)
-        with ov1:
-            manual_v = st.number_input(
-                "Voltage (V)", min_value=0.0, max_value=260.0,
-                value=220.0, step=0.5,
-                help="Overrides simulated / sensor voltage"
-            )
-        with ov2:
-            manual_i = st.number_input(
-                "Current (A)", min_value=0.0, max_value=30.0,
-                value=1.80, step=0.01,
-                help="Overrides simulated / sensor current"
-            )
-        st.markdown(
-            f'<div style="font-size:0.70rem;color:#00ff99;margin:-6px 0 4px 0;">'
-            f'P = {manual_v:.1f} V × {manual_i:.3f} A = <strong style="color:#ff4466">'
-            f'{manual_v * manual_i:.1f} W</strong></div>',
-            unsafe_allow_html=True
-        )
-    else:
-        manual_v = None
-        manual_i = None
-
     st.markdown('<div class="eg-section">Settings</div>', unsafe_allow_html=True)
     rate   = st.number_input("💰 Tariff (PKR / kWh)", 1.0, 500.0, 50.0, 1.0)
     carbon = st.number_input("🌱 Carbon Factor (kg CO₂ / kWh)", 0.1, 3.0, 0.82, 0.01)
@@ -224,48 +201,39 @@ with st.sidebar:
         st.session_state.demo_tick   = 0
         st.success("Cleared!")
 
-    # Buffer info
     n = len(st.session_state.data_log)
     st.markdown(f'<div style="color:#4a6080;font-size:0.72rem;margin-top:8px;">Buffer: {n}/500 readings</div>',
                 unsafe_allow_html=True)
 
+    if ON_HF:
+        st.markdown("""
+        <div style="margin-top:16px;padding:8px;background:#0d1422;border-radius:6px;
+                    font-size:0.68rem;color:#4a6080;line-height:1.7;">
+            <strong style="color:#00c8ff;">Local hardware setup</strong><br>
+            Arduino Uno + ACS712 + voltage divider.<br>
+            Clone repo and run locally to connect real sensors.
+        </div>
+        """, unsafe_allow_html=True)
+
 # ── Data Functions ───────────────────────────────────────────
 def _demo_reading():
-    """Simulate a realistic city-model reading.
-    If manual override is active, centres the reading on the user-supplied
-    voltage and current (with a tiny noise floor so charts stay alive).
-    """
-    t     = st.session_state.demo_tick
+    t = st.session_state.demo_tick
     st.session_state.demo_tick += 1
-
-    if manual_override and manual_v is not None and manual_i is not None:
-        # Use manual values — add ±0.5 V / ±0.005 A noise so the chart isn't flat
-        v = manual_v + random.uniform(-0.5, 0.5)
-        i = max(0.0, manual_i + random.uniform(-0.005, 0.005))
-    else:
-        # AC voltage ~220 V with ±6 V fluctuation
-        v = 220 + 5 * math.sin(t * 0.07) + random.uniform(-2, 2)
-        # Load current varies 0.8–2.8 A (city model lamps + motors)
-        i = 1.8 + 0.6 * math.sin(t * 0.04) + 0.2 * math.sin(t * 0.13) + random.uniform(-0.05, 0.05)
-        i = max(0.1, i)
-
+    v = 220 + 5 * math.sin(t * 0.07) + random.uniform(-2, 2)
+    i = 1.8 + 0.6 * math.sin(t * 0.04) + 0.2 * math.sin(t * 0.13) + random.uniform(-0.05, 0.05)
+    i = max(0.1, i)
     p = v * i
-
     dt_h = 1 / 3600
     st.session_state.demo_energy += (p / 1000) * dt_h
-
     e   = st.session_state.demo_energy
     b   = e * rate
     co2 = e * carbon
     rth = t / 3600
-
-    return dict(voltage=round(v,2), current=round(i,3),
-                power=round(p,2),  energy_kwh=round(e,6),
-                bill_pkr=round(b,4), carbon_kg=round(co2,6),
-                runtime_hrs=round(rth,5))
+    return dict(voltage=round(v,2), current=round(i,3), power=round(p,2),
+                energy_kwh=round(e,6), bill_pkr=round(b,4),
+                carbon_kg=round(co2,6), runtime_hrs=round(rth,5))
 
 def _arduino_reading():
-    """Read one CSV line from Arduino serial."""
     conn = st.session_state.serial_conn
     if not conn or not st.session_state.connected:
         return None
@@ -274,23 +242,21 @@ def _arduino_reading():
         if ',' in raw:
             p = raw.split(',')
             if len(p) == 7:
-                return dict(voltage=float(p[0]),    current=float(p[1]),
-                            power=float(p[2]),       energy_kwh=float(p[3]),
-                            bill_pkr=float(p[4]),    carbon_kg=float(p[5]),
+                return dict(voltage=float(p[0]),  current=float(p[1]),
+                            power=float(p[2]),     energy_kwh=float(p[3]),
+                            bill_pkr=float(p[4]),  carbon_kg=float(p[5]),
                             runtime_hrs=float(p[6]))
     except Exception:
         pass
     return None
 
 def _log(data):
-    """Append to session log; keep last 500 rows."""
     row = pd.DataFrame([{"timestamp": datetime.now(), **data}])
     st.session_state.data_log = pd.concat(
         [st.session_state.data_log, row], ignore_index=True
     ).tail(500)
     st.session_state.latest = data
 
-# ── Fetch current reading ────────────────────────────────────
 if st.session_state.demo_mode:
     _log(_demo_reading())
 elif st.session_state.connected:
@@ -314,27 +280,22 @@ st.markdown("""
 <hr style="border-color:#1a2840; margin:6px 0 14px 0;">
 """, unsafe_allow_html=True)
 
-# ── Tabs ─────────────────────────────────────────────────────
 tab1, tab2, tab3, tab4 = st.tabs([
-    "⚡  Live Dashboard",
-    "🗺️  City Map",
-    "📈  Analytics",
-    "📄  Report",
+    "⚡  Live Dashboard", "🗺️  City Map", "📈  Analytics", "📄  Report",
 ])
 
 # ════════════════════════════════════════════════════════════
 # TAB 1 – LIVE DASHBOARD
 # ════════════════════════════════════════════════════════════
 with tab1:
-    # ── 6 metric cards ──────────────────────────────────────
     mc = st.columns(6)
     cards = [
-        ("⚡ VOLTAGE",  f"{latest['voltage']:.1f} V",   "#00c8ff"),
-        ("🔌 CURRENT",  f"{latest['current']:.3f} A",   "#ff9500"),
-        ("💡 POWER",    f"{latest['power']:.1f} W",     "#ff4466"),
+        ("⚡ VOLTAGE",  f"{latest['voltage']:.1f} V",      "#00c8ff"),
+        ("🔌 CURRENT",  f"{latest['current']:.3f} A",      "#ff9500"),
+        ("💡 POWER",    f"{latest['power']:.1f} W",        "#ff4466"),
         ("🔋 ENERGY",   f"{latest['energy_kwh']:.5f} kWh", "#00ff99"),
-        ("💰 BILL",     f"₨ {latest['bill_pkr']:.3f}", "#ffd700"),
-        ("🌱 CO₂",      f"{latest['carbon_kg']:.5f} kg", "#88ff00"),
+        ("💰 BILL",     f"Rs {latest['bill_pkr']:.3f}",    "#ffd700"),
+        ("🌱 CO2",      f"{latest['carbon_kg']:.5f} kg",   "#88ff00"),
     ]
     for col, (lbl, val, clr) in zip(mc, cards):
         with col:
@@ -346,11 +307,9 @@ with tab1:
 
     st.markdown("<br>", unsafe_allow_html=True)
 
-    # ── 3 gauges ────────────────────────────────────────────
     def gauge(value, title, max_v, color, unit, threshold=0.85):
         fig = go.Figure(go.Indicator(
-            mode="gauge+number",
-            value=value,
+            mode="gauge+number", value=value,
             title={'text': title, 'font': {'color': '#8a9ab0', 'size': 12,
                                             'family': 'Share Tech Mono'}},
             number={'suffix': f' {unit}', 'font': {'color': color, 'size': 20,
@@ -359,12 +318,11 @@ with tab1:
                 'axis': {'range': [0, max_v], 'tickcolor': '#2a3a50',
                          'tickfont': {'size': 9, 'color': '#4a6080'}},
                 'bar':  {'color': color, 'thickness': 0.25},
-                'bgcolor': '#0d1422',
-                'bordercolor': '#1a2840', 'borderwidth': 1,
+                'bgcolor': '#0d1422', 'bordercolor': '#1a2840', 'borderwidth': 1,
                 'steps': [
-                    {'range': [0, max_v * 0.5],        'color': '#0d1422'},
-                    {'range': [max_v * 0.5, max_v * threshold], 'color': '#111d2e'},
-                    {'range': [max_v * threshold, max_v],       'color': '#1a1020'},
+                    {'range': [0, max_v*0.5],          'color': '#0d1422'},
+                    {'range': [max_v*0.5, max_v*threshold], 'color': '#111d2e'},
+                    {'range': [max_v*threshold, max_v], 'color': '#1a1020'},
                 ],
                 'threshold': {'line': {'color': '#ff4466', 'width': 2},
                               'thickness': 0.75, 'value': max_v * threshold}
@@ -376,273 +334,211 @@ with tab1:
 
     g1, g2, g3 = st.columns(3)
     with g1: st.plotly_chart(gauge(latest['voltage'], "VOLTAGE (V)", 260, "#00c8ff", "V"), use_container_width=True)
-    with g2: st.plotly_chart(gauge(latest['current'], "CURRENT (A)", 5, "#ff9500", "A"), use_container_width=True)
-    with g3: st.plotly_chart(gauge(latest['power'],   "POWER (W)",   1100, "#ff4466", "W"), use_container_width=True)
+    with g2: st.plotly_chart(gauge(latest['current'], "CURRENT (A)", 5,   "#ff9500", "A"), use_container_width=True)
+    with g3: st.plotly_chart(gauge(latest['power'],   "POWER (W)",   1100,"#ff4466", "W"), use_container_width=True)
 
-    # ── Real-time charts ────────────────────────────────────
     if len(df) > 1:
         rc1, rc2 = st.columns(2)
-
         with rc1:
             st.markdown('<div class="eg-section">Voltage & Current — Live</div>', unsafe_allow_html=True)
             fig_vc = go.Figure()
-            fig_vc.add_trace(go.Scatter(
-                x=df['timestamp'], y=df['voltage'],
-                name='Voltage (V)', line=dict(color='#00c8ff', width=1.8), yaxis='y1'
-            ))
-            fig_vc.add_trace(go.Scatter(
-                x=df['timestamp'], y=df['current'],
-                name='Current (A)', line=dict(color='#ff9500', width=1.8), yaxis='y2'
-            ))
+            fig_vc.add_trace(go.Scatter(x=df['timestamp'], y=df['voltage'],
+                name='Voltage (V)', line=dict(color='#00c8ff', width=1.8), yaxis='y1'))
+            fig_vc.add_trace(go.Scatter(x=df['timestamp'], y=df['current'],
+                name='Current (A)', line=dict(color='#ff9500', width=1.8), yaxis='y2'))
             fig_vc.update_layout(
-                paper_bgcolor='#080c14', plot_bgcolor='#0d1422',
-                font_color='white', height=260,
+                paper_bgcolor='#080c14', plot_bgcolor='#0d1422', font_color='white', height=260,
                 yaxis=dict(title='V', color='#00c8ff', gridcolor='#0d1e2e'),
-                yaxis2=dict(title='A', overlaying='y', side='right',
-                            color='#ff9500', gridcolor='#0d1e2e'),
+                yaxis2=dict(title='A', overlaying='y', side='right', color='#ff9500'),
                 legend=dict(bgcolor='#0d1422', font=dict(size=10)),
-                margin=dict(l=8,r=8,t=8,b=8),
-            )
+                margin=dict(l=8,r=8,t=8,b=8))
             st.plotly_chart(fig_vc, use_container_width=True)
-
         with rc2:
             st.markdown('<div class="eg-section">Power — Live</div>', unsafe_allow_html=True)
             fig_pw = go.Figure()
-            fig_pw.add_trace(go.Scatter(
-                x=df['timestamp'], y=df['power'],
+            fig_pw.add_trace(go.Scatter(x=df['timestamp'], y=df['power'],
                 fill='tozeroy', name='Power (W)',
                 line=dict(color='#ff4466', width=1.8),
-                fillcolor='rgba(255,68,102,0.15)'
-            ))
+                fillcolor='rgba(255,68,102,0.15)'))
             fig_pw.update_layout(
-                paper_bgcolor='#080c14', plot_bgcolor='#0d1422',
-                font_color='white', height=260,
+                paper_bgcolor='#080c14', plot_bgcolor='#0d1422', font_color='white', height=260,
                 yaxis=dict(title='Watts', gridcolor='#0d1e2e'),
-                margin=dict(l=8,r=8,t=8,b=8),
-            )
+                margin=dict(l=8,r=8,t=8,b=8))
             st.plotly_chart(fig_pw, use_container_width=True)
     else:
-        st.info("📡 Collecting readings… Charts will appear after a few seconds.")
-
+        st.info("Collecting readings — charts appear after a few seconds.")
 
 # ════════════════════════════════════════════════════════════
 # TAB 2 – CITY MAP
 # ════════════════════════════════════════════════════════════
 with tab2:
     map_col, info_col = st.columns([3, 1])
-
     with map_col:
-        st.markdown('<div class="eg-section">City Energy Monitor — Location</div>',
-                    unsafe_allow_html=True)
-
-        # Build coverage ring
-        ring_lats = [loc['lat'] + 0.012 * math.cos(math.radians(i)) for i in range(361)]
-        ring_lons = [loc['lon'] + 0.018 * math.sin(math.radians(i)) for i in range(361)]
-
+        st.markdown('<div class="eg-section">City Energy Monitor — Location</div>', unsafe_allow_html=True)
+        ring_lats = [loc['lat'] + 0.012*math.cos(math.radians(i)) for i in range(361)]
+        ring_lons = [loc['lon'] + 0.018*math.sin(math.radians(i)) for i in range(361)]
         fig_map = go.Figure()
-
-        # Coverage ring
-        fig_map.add_trace(go.Scattermapbox(
-            lat=ring_lats, lon=ring_lons,
-            mode='lines',
-            line=dict(color='rgba(0,200,255,0.4)', width=2),
-            name='Monitor Zone', showlegend=False,
-        ))
-
-        # Main marker
-        fig_map.add_trace(go.Scattermapbox(
-            lat=[loc['lat']], lon=[loc['lon']],
-            mode='markers+text',
-            marker=dict(size=18, color='#00c8ff',
-                        symbol='circle', opacity=0.9),
-            text=[f"⚡  {city_choice}"],
-            textposition='top right',
+        fig_map.add_trace(go.Scattermapbox(lat=ring_lats, lon=ring_lons,
+            mode='lines', line=dict(color='rgba(0,200,255,0.4)', width=2),
+            name='Monitor Zone', showlegend=False))
+        fig_map.add_trace(go.Scattermapbox(lat=[loc['lat']], lon=[loc['lon']],
+            mode='markers+text', marker=dict(size=18, color='#00c8ff'),
+            text=[f"  {city_choice}"], textposition='top right',
             textfont=dict(color='white', size=13, family='Share Tech Mono'),
-            name=city_choice,
-        ))
-
+            name=city_choice))
         fig_map.update_layout(
-            mapbox=dict(
-                style='open-street-map',
-                center=dict(lat=loc['lat'], lon=loc['lon']),
-                zoom=13,
-            ),
-            paper_bgcolor='#080c14',
-            font_color='white',
-            height=480,
-            margin=dict(l=0, r=0, t=0, b=0),
-            showlegend=False,
-        )
+            mapbox=dict(style='open-street-map',
+                        center=dict(lat=loc['lat'], lon=loc['lon']), zoom=13),
+            paper_bgcolor='#080c14', font_color='white',
+            height=480, margin=dict(l=0,r=0,t=0,b=0), showlegend=False)
         st.plotly_chart(fig_map, use_container_width=True)
 
     with info_col:
         st.markdown('<div class="eg-section">Location</div>', unsafe_allow_html=True)
         st.markdown(f"""
-        <div style="font-family:'Share Tech Mono',monospace; font-size:0.78rem;
-                    color:#8a9ab0; line-height:1.9;">
-            <div style="color:#00c8ff; font-size:0.95rem; margin-bottom:4px;">{city_choice}</div>
-            {loc['desc']}<br>
-            LAT: {loc['lat']:.4f}°<br>
-            LON: {loc['lon']:.4f}°
-        </div>
-        """, unsafe_allow_html=True)
-
+        <div style="font-family:'Share Tech Mono',monospace;font-size:0.78rem;color:#8a9ab0;line-height:1.9;">
+            <div style="color:#00c8ff;font-size:0.95rem;margin-bottom:4px;">{city_choice}</div>
+            {loc['desc']}<br>LAT: {loc['lat']:.4f}°<br>LON: {loc['lon']:.4f}°
+        </div>""", unsafe_allow_html=True)
         st.markdown('<div class="eg-section">Live Readings</div>', unsafe_allow_html=True)
-        st.metric("Voltage",  f"{latest['voltage']:.1f} V")
-        st.metric("Current",  f"{latest['current']:.3f} A")
-        st.metric("Power",    f"{latest['power']:.1f} W")
-
+        st.metric("Voltage", f"{latest['voltage']:.1f} V")
+        st.metric("Current", f"{latest['current']:.3f} A")
+        st.metric("Power",   f"{latest['power']:.1f} W")
         st.markdown('<div class="eg-section">Totals</div>', unsafe_allow_html=True)
-        st.metric("Energy",   f"{latest['energy_kwh']:.5f} kWh")
-        st.metric("Bill",     f"₨ {latest['bill_pkr']:.3f}")
-        st.metric("CO₂",      f"{latest['carbon_kg']:.5f} kg")
-
-        # Voltage health check
+        st.metric("Energy", f"{latest['energy_kwh']:.5f} kWh")
+        st.metric("Bill",   f"Rs {latest['bill_pkr']:.3f}")
+        st.metric("CO2",    f"{latest['carbon_kg']:.5f} kg")
         st.markdown('<div class="eg-section">Power Quality</div>', unsafe_allow_html=True)
         v = latest['voltage']
-        if 210 <= v <= 240:
-            st.success("✅ Voltage Normal")
-        elif 195 <= v < 210 or 240 < v <= 255:
-            st.warning("⚠️ Voltage Borderline")
-        else:
-            st.error("❌ Voltage Abnormal")
-
+        if 210 <= v <= 240:   st.success("Voltage Normal")
+        elif 195 <= v < 210 or 240 < v <= 255: st.warning("Voltage Borderline")
+        else:                  st.error("Voltage Abnormal")
 
 # ════════════════════════════════════════════════════════════
 # TAB 3 – ANALYTICS
 # ════════════════════════════════════════════════════════════
 with tab3:
     if len(df) < 5:
-        st.info("📡 Need at least 5 readings — collecting data…")
+        st.info("Need at least 5 readings — collecting data...")
     else:
-        # Summary row
         st.markdown('<div class="eg-section">Summary Statistics</div>', unsafe_allow_html=True)
         s1,s2,s3,s4,s5 = st.columns(5)
-        s1.metric("Avg Voltage",  f"{df['voltage'].mean():.2f} V",  f"σ={df['voltage'].std():.2f}")
-        s2.metric("Avg Current",  f"{df['current'].mean():.3f} A",  f"σ={df['current'].std():.3f}")
+        s1.metric("Avg Voltage",  f"{df['voltage'].mean():.2f} V",  f"s={df['voltage'].std():.2f}")
+        s2.metric("Avg Current",  f"{df['current'].mean():.3f} A",  f"s={df['current'].std():.3f}")
         s3.metric("Avg Power",    f"{df['power'].mean():.1f} W")
         s4.metric("Peak Power",   f"{df['power'].max():.1f} W")
         s5.metric("Total Energy", f"{df['energy_kwh'].iloc[-1]:.5f} kWh")
 
         st.markdown('<div class="eg-section">Energy & Bill Trends</div>', unsafe_allow_html=True)
         ac1, ac2 = st.columns(2)
-
         with ac1:
             fig_e = px.area(df, x='timestamp', y='energy_kwh',
                             color_discrete_sequence=['#00ff99'],
-                            labels={'energy_kwh': 'kWh', 'timestamp': ''})
+                            labels={'energy_kwh':'kWh','timestamp':''})
             fig_e.update_layout(paper_bgcolor='#080c14', plot_bgcolor='#0d1422',
-                                 font_color='white', height=260,
-                                 margin=dict(l=8,r=8,t=8,b=8))
+                                 font_color='white', height=260, margin=dict(l=8,r=8,t=8,b=8))
             st.plotly_chart(fig_e, use_container_width=True)
-
         with ac2:
             fig_bc = go.Figure()
             fig_bc.add_trace(go.Scatter(x=df['timestamp'], y=df['bill_pkr'],
-                                        name='Bill (PKR)', yaxis='y1',
-                                        line=dict(color='#ffd700', width=1.8)))
+                name='Bill (PKR)', yaxis='y1', line=dict(color='#ffd700', width=1.8)))
             fig_bc.add_trace(go.Scatter(x=df['timestamp'], y=df['carbon_kg'],
-                                        name='CO₂ (kg)', yaxis='y2',
-                                        line=dict(color='#88ff00', width=1.8)))
+                name='CO2 (kg)', yaxis='y2', line=dict(color='#88ff00', width=1.8)))
             fig_bc.update_layout(
-                paper_bgcolor='#080c14', plot_bgcolor='#0d1422', font_color='white',
-                height=260,
+                paper_bgcolor='#080c14', plot_bgcolor='#0d1422', font_color='white', height=260,
                 yaxis=dict(title='PKR', color='#ffd700', gridcolor='#0d1e2e'),
-                yaxis2=dict(title='kg CO₂', overlaying='y', side='right',
-                            color='#88ff00'),
+                yaxis2=dict(title='kg CO2', overlaying='y', side='right', color='#88ff00'),
                 legend=dict(bgcolor='#0d1422', font=dict(size=10)),
-                margin=dict(l=8,r=8,t=8,b=8),
-            )
+                margin=dict(l=8,r=8,t=8,b=8))
             st.plotly_chart(fig_bc, use_container_width=True)
 
-        # Power histogram
         st.markdown('<div class="eg-section">Power Distribution</div>', unsafe_allow_html=True)
         fig_h = px.histogram(df, x='power', nbins=30,
                              color_discrete_sequence=['#ff4466'],
-                             labels={'power': 'Power (W)', 'count': 'Frequency'})
+                             labels={'power':'Power (W)','count':'Frequency'})
         fig_h.update_layout(paper_bgcolor='#080c14', plot_bgcolor='#0d1422',
-                             font_color='white', height=240,
-                             margin=dict(l=8,r=8,t=8,b=8))
+                             font_color='white', height=240, margin=dict(l=8,r=8,t=8,b=8))
         st.plotly_chart(fig_h, use_container_width=True)
 
-        # AI Prediction (linear regression on energy)
-        if len(df) >= 15:
+        reg_df = df.copy()
+        reg_df['energy_kwh'] = pd.to_numeric(reg_df['energy_kwh'], errors='coerce')
+        reg_df['timestamp']  = pd.to_datetime(reg_df['timestamp'],  errors='coerce')
+        reg_df = reg_df.dropna(subset=['energy_kwh', 'timestamp']).reset_index(drop=True)
+
+        if len(reg_df) >= 15:
             st.markdown('<div class="eg-section">AI Energy Prediction (Linear Regression)</div>',
                         unsafe_allow_html=True)
-            x = np.arange(len(df))
-            y = df['energy_kwh'].values
+            x      = np.arange(len(reg_df), dtype=np.float64)
+            y      = pd.to_numeric(reg_df['energy_kwh'], errors='coerce').fillna(0).to_numpy(dtype=np.float64)
             coeffs = np.polyfit(x, y, 1)
-
-            n_future = 60
-            fx = np.arange(len(df), len(df) + n_future)
-            fy = np.polyval(coeffs, fx)
-            ft = [df['timestamp'].iloc[-1] + timedelta(seconds=i) for i in range(1, n_future+1)]
-
+            n_f    = 60
+            fx     = np.arange(len(reg_df), len(reg_df)+n_f, dtype=float)
+            fy     = np.polyval(coeffs, fx)
+            ft     = [reg_df['timestamp'].iloc[-1]+timedelta(seconds=i) for i in range(1, n_f+1)]
             fig_pr = go.Figure()
-            fig_pr.add_trace(go.Scatter(x=df['timestamp'], y=df['energy_kwh'],
-                                        name='Actual', line=dict(color='#00ff99', width=2)))
+            fig_pr.add_trace(go.Scatter(x=reg_df['timestamp'], y=reg_df['energy_kwh'],
+                name='Actual', line=dict(color='#00ff99', width=2)))
             fig_pr.add_trace(go.Scatter(x=ft, y=fy,
-                                        name='Predicted (60 s)', yaxis='y1',
-                                        line=dict(color='#ffd700', width=1.8, dash='dot')))
+                name='Predicted (60 s)', line=dict(color='#ffd700', width=1.8, dash='dot')))
             fig_pr.update_layout(paper_bgcolor='#080c14', plot_bgcolor='#0d1422',
                                   font_color='white', height=260,
                                   yaxis=dict(title='kWh', gridcolor='#0d1e2e'),
                                   legend=dict(bgcolor='#0d1422'),
                                   margin=dict(l=8,r=8,t=8,b=8))
             st.plotly_chart(fig_pr, use_container_width=True)
-
-            # Extrapolate
-            rate_kwh_per_s = coeffs[0]
-            daily   = rate_kwh_per_s * 86400
+            rate_s  = coeffs[0]
+            daily   = rate_s * 86400
             monthly = daily * 30
-
             p1,p2,p3,p4 = st.columns(4)
-            p1.metric("⏱ Rate",         f"{rate_kwh_per_s*3600:.4f} kWh/hr")
-            p2.metric("📅 Daily Est.",   f"{daily:.4f} kWh",   f"₨ {daily*rate:.2f}")
-            p3.metric("📅 Monthly Est.", f"{monthly:.3f} kWh", f"₨ {monthly*rate:.2f}")
-            p4.metric("🌱 Monthly CO₂",  f"{monthly*carbon:.3f} kg")
-
-        # Data table
-        st.markdown('<div class="eg-section">Data Log (last 50 readings)</div>',
-                    unsafe_allow_html=True)
+            p1.metric("Rate",          f"{rate_s*3600:.4f} kWh/hr")
+            p2.metric("Daily Est.",    f"{daily:.4f} kWh",   f"Rs {daily*rate:.2f}")
+            p3.metric("Monthly Est.",  f"{monthly:.3f} kWh", f"Rs {monthly*rate:.2f}")
+            p4.metric("Monthly CO2",   f"{monthly*carbon:.3f} kg")
+
+        st.markdown('<div class="eg-section">Data Log (last 50 readings)</div>', unsafe_allow_html=True)
         disp = df.tail(50).copy()
-        disp['timestamp'] = disp['timestamp'].dt.strftime('%H:%M:%S')
+        disp['timestamp'] = pd.to_datetime(disp['timestamp'], errors='coerce').dt.strftime('%H:%M:%S').fillna('--:--:--')
         st.dataframe(disp, use_container_width=True, height=260)
-
         csv_bytes = df.to_csv(index=False).encode()
-        st.download_button("⬇️  Download CSV", csv_bytes,
+        st.download_button("Download CSV", csv_bytes,
                            f"energyguru_{datetime.now():%Y%m%d_%H%M%S}.csv",
                            "text/csv", use_container_width=True)
 
-
 # ════════════════════════════════════════════════════════════
-# TAB 4 – REPORT GENERATOR
+# TAB 4 – REPORT
 # ════════════════════════════════════════════════════════════
 with tab4:
     st.markdown('<div class="eg-section">Report Configuration</div>', unsafe_allow_html=True)
-
     rc1, rc2 = st.columns(2)
     with rc1:
-        rpt_title   = st.text_input("Report Title",    "EnergyGuru – Power Calculus Report")
-        institution = st.text_input("Institution",     "Smart Energy Lab")
-        operator    = st.text_input("Operator",        "")
-        project_id  = st.text_input("Project ID",      "ENERGYGURU-2025-001")
+        rpt_title   = st.text_input("Report Title",  "EnergyGuru – Power Calculus Report")
+        institution = st.text_input("Institution",   "Smart Energy Lab")
+        operator    = st.text_input("Operator",      "")
+        project_id  = st.text_input("Project ID",    "ENERGYGURU-2025-001")
     with rc2:
         notes = st.text_area("Notes / Remarks",
                              "Generated by EnergyGuru Power Calculus System.\n"
                              "Arduino-based IoT Energy Monitoring | City Model.")
 
-    generate_btn = st.button("📊  Generate PDF Report", type="primary",
-                             use_container_width=True)
-
-    if generate_btn:
+    if st.button("Generate PDF Report", type="primary", use_container_width=True):
         if len(df) < 2:
-            st.error("⚠️ Not enough data — collect at least 2 readings first.")
+            st.error("Not enough data — collect at least 2 readings first.")
         else:
             try:
-                from fpdf import FPDF  # pip install fpdf2
+                from fpdf import FPDF
+
+                def pdf_safe(text):
+                    if text is None:
+                        return ""
+                    normalized = str(text).translate(str.maketrans({
+                        "\u2013": "-", "\u2014": "-",
+                        "\u2022": "|", "\u00b0": " deg",
+                        "\u2082": "2", "\u20a8": "Rs",
+                        "\u2713": "[+]", "\u26a0": "[!]",
+                        "\u2192": "->", "\u03c3": "s",
+                    }))
+                    return normalized.encode("latin-1", "replace").decode("latin-1")
 
-                # ── Compute summary stats ───────────────────
                 avg_v   = df['voltage'].mean()
                 avg_i   = df['current'].mean()
                 avg_p   = df['power'].mean()
@@ -652,55 +548,41 @@ with tab4:
                 tot_b   = df['bill_pkr'].iloc[-1]
                 tot_co2 = df['carbon_kg'].iloc[-1]
                 n_reads = len(df)
-                dur_s   = n_reads   # 1 reading per second
 
-                # ── AI Recommendations ──────────────────────
                 recs = []
                 if avg_p > 500:
                     recs.append("HIGH load detected — consider switching off idle appliances.")
                 if avg_v < 210 or avg_v > 235:
-                    recs.append("Voltage outside safe range (210–235 V) — check power supply.")
+                    recs.append("Voltage outside safe range (210-235V) — check power supply.")
                 if df['voltage'].std() > 8:
                     recs.append("High voltage fluctuation — consider a voltage stabiliser.")
                 recs.append("Use LED lighting to reduce city model consumption by ~70%.")
-                recs.append("Schedule high-load demos during off-peak hours (22:00–06:00).")
+                recs.append("Schedule high-load demos during off-peak hours (22:00-06:00).")
                 recs.append("Install capacitor banks to improve power factor.")
                 recs.append("Regular maintenance reduces standby losses significantly.")
 
-                # ── Build PDF ───────────────────────────────
                 class EnergyPDF(FPDF):
                     def header(self):
-                        # Dark top bar
                         self.set_fill_color(8, 12, 20)
                         self.rect(0, 0, 210, 297, 'F')
-
                         self.set_fill_color(0, 40, 60)
                         self.rect(0, 0, 210, 22, 'F')
-
                         self.set_fill_color(0, 200, 255)
                         self.rect(0, 0, 4, 22, 'F')
-
                         self.set_font('Helvetica', 'B', 14)
                         self.set_text_color(0, 200, 255)
                         self.set_xy(8, 4)
-                        self.cell(100, 7, 'ENERGYGURU – POWER CALCULUS', ln=False)
-
+                        self.cell(100, 7, pdf_safe('ENERGYGURU - POWER CALCULUS'))
                         self.set_font('Helvetica', '', 7)
                         self.set_text_color(80, 120, 160)
                         self.set_xy(8, 13)
-                        self.cell(0, 5,
-                                  f'AI-Assisted Energy Usage Analyzer  |  '
-                                  f'Generated: {datetime.now():%Y-%m-%d %H:%M:%S}')
+                        self.cell(0, 5, pdf_safe(f'AI-Assisted Energy Usage Analyzer | Generated: {datetime.now():%Y-%m-%d %H:%M:%S}'))
                         self.ln(14)
-
                     def footer(self):
                         self.set_y(-14)
                         self.set_font('Helvetica', 'I', 7)
                         self.set_text_color(50, 70, 100)
-                        self.cell(0, 8,
-                                  f'EnergyGuru Power Calculus  |  {institution}  |  Page {self.page_no()}',
-                                  align='C')
-
+                        self.cell(0, 8, pdf_safe(f'EnergyGuru Power Calculus | {institution} | Page {self.page_no()}'), align='C')
                     def section_title(self, txt):
                         self.set_fill_color(0, 30, 50)
                         self.set_draw_color(0, 200, 255)
@@ -708,177 +590,128 @@ with tab4:
                         self.rect(self.get_x(), self.get_y(), 185, 8, 'DF')
                         self.set_font('Helvetica', 'B', 9)
                         self.set_text_color(0, 200, 255)
-                        self.cell(0, 8, f'  {txt}', ln=True)
+                        self.cell(0, 8, pdf_safe(f'  {txt}'), ln=True)
                         self.ln(2)
-
                     def kv_row(self, label, value, fill_idx):
-                        if fill_idx % 2 == 0:
-                            self.set_fill_color(13, 20, 34)
-                        else:
-                            self.set_fill_color(10, 16, 28)
+                        self.set_fill_color(13, 20, 34) if fill_idx%2==0 else self.set_fill_color(10, 16, 28)
                         self.set_text_color(100, 140, 180)
                         self.set_font('Helvetica', '', 9)
-                        self.cell(90, 7, f'  {label}', fill=True)
+                        self.cell(90, 7, pdf_safe(f'  {label}'), fill=True)
                         self.set_text_color(220, 230, 240)
                         self.set_font('Helvetica', 'B', 9)
-                        self.cell(95, 7, f'  {value}', fill=True, ln=True)
+                        self.cell(95, 7, pdf_safe(f'  {value}'), fill=True, ln=True)
 
                 pdf = EnergyPDF()
                 pdf.set_auto_page_break(auto=True, margin=18)
                 pdf.add_page()
 
-                # Title block
                 pdf.set_font('Helvetica', 'B', 17)
                 pdf.set_text_color(0, 200, 255)
-                pdf.cell(0, 10, rpt_title, ln=True, align='C')
+                pdf.cell(0, 10, pdf_safe(rpt_title), ln=True, align='C')
                 pdf.ln(1)
-
                 pdf.set_font('Helvetica', '', 9)
                 pdf.set_text_color(80, 120, 160)
-                pdf.cell(0, 6, f'Institution: {institution}    |    Project: {project_id}', ln=True, align='C')
-                pdf.cell(0, 6, f'Location: {city_choice}   •   Lat {loc["lat"]:.4f}°  Lon {loc["lon"]:.4f}°', ln=True, align='C')
+                pdf.cell(0, 6, pdf_safe(f'Institution: {institution}  |  Project: {project_id}'), ln=True, align='C')
+                pdf.cell(0, 6, pdf_safe(f'Location: {city_choice}  -  Lat {loc["lat"]:.4f}  Lon {loc["lon"]:.4f}'), ln=True, align='C')
                 if operator:
-                    pdf.cell(0, 6, f'Operator: {operator}', ln=True, align='C')
-                pdf.cell(0, 6, f'Date: {datetime.now():%B %d, %Y}    Time: {datetime.now():%H:%M:%S}', ln=True, align='C')
+                    pdf.cell(0, 6, pdf_safe(f'Operator: {operator}'), ln=True, align='C')
+                pdf.cell(0, 6, pdf_safe(f'Date: {datetime.now():%B %d, %Y}  Time: {datetime.now():%H:%M:%S}'), ln=True, align='C')
                 pdf.ln(4)
-
-                # Divider
                 pdf.set_draw_color(0, 60, 90)
                 pdf.set_line_width(0.4)
                 pdf.line(15, pdf.get_y(), 195, pdf.get_y())
                 pdf.ln(5)
 
-                # ── Section 1: Measurements ──────────────────
                 pdf.section_title('1.  MEASUREMENT SUMMARY')
-                rows = [
-                    ("Average Voltage",        f"{avg_v:.2f} V"),
-                    ("Average Current",         f"{avg_i:.3f} A"),
-                    ("Average Power",           f"{avg_p:.2f} W"),
-                    ("Peak Power",              f"{max_p:.2f} W"),
-                    ("Minimum Power",           f"{min_p:.2f} W"),
-                    ("Total Energy Consumed",   f"{tot_e:.6f} kWh"),
-                    ("Electricity Bill",        f"PKR {tot_b:.4f}"),
-                    ("Carbon Footprint",        f"{tot_co2:.6f} kg CO₂"),
-                    ("Tariff Rate",             f"PKR {rate:.2f} / kWh"),
-                    ("Carbon Factor",           f"{carbon:.2f} kg CO₂ / kWh"),
-                    ("Total Readings",          f"{n_reads}"),
-                    ("Monitoring Duration",     f"{dur_s} seconds  ({dur_s/60:.1f} min)"),
-                ]
-                for idx, (lbl, val) in enumerate(rows):
+                for idx, (lbl, val) in enumerate([
+                    ("Average Voltage",      f"{avg_v:.2f} V"),
+                    ("Average Current",      f"{avg_i:.3f} A"),
+                    ("Average Power",        f"{avg_p:.2f} W"),
+                    ("Peak Power",           f"{max_p:.2f} W"),
+                    ("Minimum Power",        f"{min_p:.2f} W"),
+                    ("Total Energy",         f"{tot_e:.6f} kWh"),
+                    ("Electricity Bill",     f"PKR {tot_b:.4f}"),
+                    ("Carbon Footprint",     f"{tot_co2:.6f} kg CO2"),
+                    ("Tariff Rate",          f"PKR {rate:.2f} / kWh"),
+                    ("Carbon Factor",        f"{carbon:.2f} kg CO2 / kWh"),
+                    ("Total Readings",       f"{n_reads}"),
+                ]):
                     pdf.kv_row(lbl, val, idx)
                 pdf.ln(5)
 
-                # ── Section 2: Arduino Calculations ─────────
                 pdf.section_title('2.  ARDUINO CALCULATIONS')
                 pdf.set_fill_color(8, 16, 26)
                 pdf.set_font('Courier', '', 8)
                 pdf.set_text_color(0, 220, 120)
-                calc_lines = [
-                    '',
-                    f'  // Instantaneous Power',
-                    f'  power_W = voltage_V * current_A',
-                    f'         = {avg_v:.2f} V  *  {avg_i:.3f} A  =  {avg_p:.2f} W',
-                    '',
-                    f'  // Energy accumulation (per interval)',
-                    f'  energy_kWh += (power_W / 1000.0) * dt_hours',
-                    f'  total_energy = {tot_e:.6f} kWh',
+                for ln_text in [
                     '',
-                    f'  // Electricity Bill',
-                    f'  bill_PKR = energy_kWh * tariff',
-                    f'          = {tot_e:.6f}  *  {rate:.2f}  =  PKR {tot_b:.4f}',
+                    f'  power_W = voltage_V * current_A = {avg_v:.2f} * {avg_i:.3f} = {avg_p:.2f} W',
+                    f'  energy_kWh += (power_W / 1000.0) * dt_hours  -->  {tot_e:.6f} kWh',
+                    f'  bill_PKR = energy_kWh * tariff = {tot_e:.6f} * {rate:.2f} = PKR {tot_b:.4f}',
+                    f'  carbon_kg = energy_kWh * carbon_factor = {tot_e:.6f} * {carbon:.2f} = {tot_co2:.6f} kg',
+                    f'  apparent_VA = {avg_v:.2f} * {avg_i:.3f} = {avg_v*avg_i:.2f} VA',
                     '',
-                    f'  // Carbon Footprint',
-                    f'  carbon_kg = energy_kWh * carbon_factor',
-                    f'           = {tot_e:.6f}  *  {carbon:.2f}  =  {tot_co2:.6f} kg CO2',
-                    '',
-                    f'  // Apparent Power',
-                    f'  S (VA) = {avg_v:.2f} V  *  {avg_i:.3f} A  =  {avg_v*avg_i:.2f} VA',
-                    '',
-                ]
-                for ln_text in calc_lines:
-                    pdf.cell(0, 6, ln_text, fill=True, ln=True)
+                ]:
+                    pdf.cell(0, 6, pdf_safe(ln_text), fill=True, ln=True)
                 pdf.ln(4)
 
-                # ── Section 3: Last 20 readings ──────────────
-                pdf.section_title('3.  RECENT READINGS  (last 20)')
-                hdrs   = ['Time',    'V (V)',  'I (A)',  'P (W)',
-                          'kWh',     'Bill ₨', 'CO₂ kg']
-                c_widths = [26, 22, 22, 25, 32, 30, 28]
-
-                # Table header
-                pdf.set_fill_color(0, 40, 60)
-                pdf.set_text_color(0, 200, 255)
-                pdf.set_font('Helvetica', 'B', 8)
-                for h, w in zip(hdrs, c_widths):
-                    pdf.cell(w, 7, h, fill=True, align='C')
+                pdf.section_title('3.  RECENT READINGS (last 20)')
+                hdrs = ['Time','V (V)','I (A)','P (W)','kWh','Bill Rs','CO2 kg']
+                cw   = [26,22,22,25,32,30,28]
+                pdf.set_fill_color(0,40,60)
+                pdf.set_text_color(0,200,255)
+                pdf.set_font('Helvetica','B',8)
+                for h,w in zip(hdrs,cw): pdf.cell(w,7,h,fill=True,align='C')
                 pdf.ln()
-
-                pdf.set_font('Helvetica', '', 8)
-                recent = df.tail(20)
-                for idx, (_, row) in enumerate(recent.iterrows()):
-                    bg = (13, 20, 34) if idx % 2 == 0 else (10, 16, 28)
-                    pdf.set_fill_color(*bg)
-                    pdf.set_text_color(180, 200, 220)
-                    ts = row['timestamp'].strftime('%H:%M:%S') if hasattr(row['timestamp'], 'strftime') else str(row['timestamp'])[:8]
-                    vals = [ts,
-                            f"{row['voltage']:.1f}",
-                            f"{row['current']:.3f}",
-                            f"{row['power']:.1f}",
-                            f"{row['energy_kwh']:.6f}",
-                            f"{row['bill_pkr']:.4f}",
-                            f"{row['carbon_kg']:.6f}"]
-                    for v, w in zip(vals, c_widths):
-                        pdf.cell(w, 6, v, fill=True, align='C')
+                pdf.set_font('Helvetica','',8)
+                for idx,(_, row) in enumerate(df.tail(20).iterrows()):
+                    pdf.set_fill_color(*(13,20,34) if idx%2==0 else (10,16,28))
+                    pdf.set_text_color(180,200,220)
+                    ts = row['timestamp'].strftime('%H:%M:%S') if hasattr(row['timestamp'],'strftime') else str(row['timestamp'])[:8]
+                    for v,w in zip([ts,f"{row['voltage']:.1f}",f"{row['current']:.3f}",
+                                    f"{row['power']:.1f}",f"{row['energy_kwh']:.6f}",
+                                    f"{row['bill_pkr']:.4f}",f"{row['carbon_kg']:.6f}"],cw):
+                        pdf.cell(w,6,pdf_safe(v),fill=True,align='C')
                     pdf.ln()
                 pdf.ln(4)
 
-                # ── Section 4: AI Recommendations ───────────
                 pdf.section_title('4.  AI ENERGY RECOMMENDATIONS')
-                pdf.set_font('Helvetica', '', 9)
-                for i, rec in enumerate(recs):
-                    icon = '⚠' if rec.startswith('HIGH') or rec.startswith('Voltage') or rec.startswith('High') else '✓'
-                    clr = (255, 180, 60) if icon == '⚠' else (100, 220, 130)
-                    pdf.set_text_color(*clr)
-                    pdf.cell(0, 8, f'  {icon}  {rec}', ln=True)
-                pdf.ln(3)
-
-                # ── Notes ────────────────────────────────────
+                pdf.set_font('Helvetica','',9)
+                for rec in recs:
+                    ok = not (rec.startswith('HIGH') or rec.startswith('Voltage') or rec.startswith('High'))
+                    pdf.set_text_color(*(100,220,130) if ok else (255,180,60))
+                    pdf.cell(0,8,pdf_safe(f'  {"+" if ok else "!"}  {rec}'),ln=True)
+
                 if notes.strip():
-                    pdf.set_draw_color(0, 60, 90)
-                    pdf.line(15, pdf.get_y(), 195, pdf.get_y())
+                    pdf.set_draw_color(0,60,90)
+                    pdf.line(15,pdf.get_y(),195,pdf.get_y())
                     pdf.ln(3)
-                    pdf.set_font('Helvetica', 'B', 9)
-                    pdf.set_text_color(60, 100, 140)
-                    pdf.cell(0, 7, 'NOTES:', ln=True)
-                    pdf.set_font('Helvetica', '', 8)
-                    pdf.set_text_color(140, 160, 180)
+                    pdf.set_font('Helvetica','B',9)
+                    pdf.set_text_color(60,100,140)
+                    pdf.cell(0,7,'NOTES:',ln=True)
+                    pdf.set_font('Helvetica','',8)
+                    pdf.set_text_color(140,160,180)
                     for ln_text in notes.split('\n'):
-                        pdf.cell(0, 6, ln_text, ln=True)
+                        pdf.cell(0,6,pdf_safe(ln_text),ln=True)
 
-                # ── Output ───────────────────────────────────
                 pdf_bytes = bytes(pdf.output())
-                st.success("✅ Report generated successfully!")
-                filename = f"EnergyGuru_Report_{datetime.now():%Y%m%d_%H%M%S}.pdf"
-                st.download_button("⬇️  Download PDF Report", pdf_bytes,
-                                   filename, "application/pdf",
-                                   type="primary", use_container_width=True)
-
-                # Quick preview
-                st.markdown('<div class="eg-section">Report Preview</div>',
-                            unsafe_allow_html=True)
+                st.success("Report generated!")
+                st.download_button("Download PDF Report", pdf_bytes,
+                                   f"EnergyGuru_Report_{datetime.now():%Y%m%d_%H%M%S}.pdf",
+                                   "application/pdf", type="primary", use_container_width=True)
+
                 pc = st.columns(4)
-                pc[0].metric("Total Energy",  f"{tot_e:.6f} kWh")
-                pc[1].metric("Total Bill",    f"₨ {tot_b:.4f}")
-                pc[2].metric("CO₂",           f"{tot_co2:.6f} kg")
-                pc[3].metric("Peak Power",    f"{max_p:.1f} W")
+                pc[0].metric("Total Energy", f"{tot_e:.6f} kWh")
+                pc[1].metric("Total Bill",   f"Rs {tot_b:.4f}")
+                pc[2].metric("CO2",          f"{tot_co2:.6f} kg")
+                pc[3].metric("Peak Power",   f"{max_p:.1f} W")
 
             except ImportError:
-                st.error("⚠️ `fpdf2` is not installed.  Run:  **pip install fpdf2**")
+                st.error("fpdf2 not installed. Run: pip install fpdf2")
             except Exception as ex:
                 st.error(f"Error: {ex}")
-                st.exception(ex)
 
-# ── Auto refresh (live updates) ──────────────────────────────
+# ── Auto refresh ─────────────────────────────────────────────
 if st.session_state.demo_mode or st.session_state.connected:
     time.sleep(1)
     st.rerun()