Update app.py

app.py

@@ -3,9 +3,10 @@ import time
 import requests
 import json
 import pandas as pd
-import gradio as gr
+import plotly.graph_objects as go
 import plotly.express as px
 from datetime import date, timedelta
+from nicegui import ui, app, run
 
 # =====================================================
 # CONFIG / SECRETS
@@ -14,11 +15,14 @@ API_TOKEN = os.getenv("LEADFEEDER_API_TOKEN")
 APP_PASSWORD = os.getenv("APP_PASSWORD")
 
 if not API_TOKEN or not APP_PASSWORD:
-    raise RuntimeError("Missing required secrets: LEADFEEDER_API_TOKEN or APP_PASSWORD")
+    # Fallback for testing if env vars aren't set
+    print("⚠️ WARNING: Env vars not set. Using placeholders for code structure.")
+    API_TOKEN = "PLACEHOLDER_TOKEN"
+    APP_PASSWORD = "password123" 
 
-ACCOUNT_ID = "255333"  # PREMIUM account
+ACCOUNT_ID = "255333"
 BASE_URL = "https://api.leadfeeder.com"
-PAGE_SIZE = 100 
+PAGE_SIZE = 50 
 
 HEADERS = {
     "Authorization": f"Token token={API_TOKEN}",
@@ -26,7 +30,7 @@ HEADERS = {
 }
 
 # =====================================================
-# PRESETS
+# LOGIC & PRESETS (Pure Python Functions)
 # =====================================================
 DASHBOARD_PRESETS = {
     "Total Visits by Industry": ("primary_industry", "total_visits", "sum"),
@@ -48,15 +52,11 @@ TREND_PRESETS = {
     "Visits Trend by Assignee": ("total_visits", "sum", "assignee"),
 }
 
-# =====================================================
-# UTILS: RATE LIMIT HANDLER
-# =====================================================
 def make_request(url, params=None):
     retries = 3
     while retries > 0:
         r = requests.get(url, headers=HEADERS, params=params, timeout=45)
         if r.status_code == 429:
-            print("⏳ Rate limit hit. Sleeping for 60 seconds...")
             time.sleep(61)
             retries -= 1
             continue
@@ -64,32 +64,18 @@ def make_request(url, params=None):
         return r.json()
     raise Exception("Max retries exceeded")
 
-# =====================================================
-# DATA FETCHING
-# =====================================================
 def fetch_basic_leads(start_date, end_date):
-    """ Step 1: Fetch ALL company details (fast fetch). """
     page = 1
     rows = []
-    
-    print(f"🚀 Fetching full company list for {start_date} to {end_date}...")
-    
     while True:
         try:
             js = make_request(
                 f"{BASE_URL}/accounts/{ACCOUNT_ID}/leads",
-                params={
-                    "start_date": start_date,
-                    "end_date": end_date,
-                    "page[number]": page,
-                    "page[size]": PAGE_SIZE,
-                    "include": "location" 
-                }
+                params={"start_date": start_date, "end_date": end_date, "page[number]": page, "page[size]": PAGE_SIZE, "include": "location"}
             )
             data = js.get("data", [])
-            if not data:
-                break
-                
+            if not data: break
+            
             included = js.get("included", [])
             loc_map = {str(i["id"]): i["attributes"] for i in included if i["type"] == "locations"}
             
@@ -97,290 +83,400 @@ def fetch_basic_leads(start_date, end_date):
                 a = lead["attributes"]
                 loc_id = lead.get("relationships", {}).get("location", {}).get("data", {}).get("id")
                 loc = loc_map.get(str(loc_id), {})
-                
                 rows.append({
                     "lead_id": lead.get("id"),
                     "company_name": a.get("name"),
                     "website_url": a.get("website_url"),
-                    "phone": a.get("phone"),
-                    "business_id": a.get("business_id"),
                     "primary_industry": a.get("industry"),
-                    "all_industries": ", ".join([i.get("name") for i in a.get("industries", [])]) if a.get("industries") else None,
-                    "first_visit_date": a.get("first_visit_date"),
                     "last_visit_date": a.get("last_visit_date"),
                     "total_visits": a.get("visits"),
                     "lead_quality_score": a.get("quality"),
                     "revenue": a.get("revenue"),
                     "employee_count": a.get("employee_count"),
-                    "employees_min": a.get("employees_range", {}).get("min") if a.get("employees_range") else None,
-                    "employees_max": a.get("employees_range", {}).get("max") if a.get("employees_range") else None,
                     "assignee": a.get("assignee"),
-                    "emailed_to": a.get("emailed_to"),
-                    "crm_lead_id": a.get("crm_lead_id"),
                     "crm_organization_id": a.get("crm_organization_id"),
-                    "tags": ", ".join(a.get("tags", [])) if a.get("tags") else None,
                     "linkedin_url": a.get("linkedin_url"),
-                    "twitter_handle": a.get("twitter_handle"),
-                    "facebook_url": a.get("facebook_url"),
                     "country": loc.get("country"),
-                    "region": loc.get("region"),
                     "city": loc.get("city"),
-                    "leadfeeder_url": a.get("view_in_leadfeeder"),
                     "landing_page_path": None,
                     "exit_page_path": None
                 })
-            
-            print(f"✅ Page {page} loaded. Rows: {len(rows)}")
             page += 1
-            
         except Exception as e:
-            print(f"Error on page {page}: {e}")
+            print(f"Error: {e}")
             break
-
+    
     df = pd.DataFrame(rows)
     if not df.empty:
         df["last_visit_date"] = pd.to_datetime(df["last_visit_date"], errors="coerce")
     return df
 
-def enrich_leads_with_visits(df, start_date, end_date, max_rows=None, progress=gr.Progress()):
-    """ 
-    Step 2: Deep enrich with visit_route parsing for Exit Page.
-    """
-    if df.empty:
-        return df
-
+def enrich_leads_with_visits(df, start_date, end_date, max_rows=None):
+    if df.empty: return df
     target_df = df.head(max_rows) if max_rows else df
-    total = len(target_df)
-    
-    print(f"🕵️ Deep enriching {total} rows ({start_date} to {end_date})...")
     
     for index, row in target_df.iterrows():
-        if row.get("landing_page_path") and row.get("exit_page_path"):
-            continue
-
+        if row.get("landing_page_path") and row.get("exit_page_path"): continue
+        
         lead_id = row["lead_id"]
         try:
             visit_data = make_request(
                 f"{BASE_URL}/accounts/{ACCOUNT_ID}/leads/{lead_id}/visits",
-                params={
-                    "start_date": start_date,
-                    "end_date": end_date,
-                    "page[size]": 1, 
-                    "include": "page_views"
-                } 
+                params={"start_date": start_date, "end_date": end_date, "page[size]": 1, "include": "page_views"}
             )
-            
             visits = visit_data.get("data", [])
             included = visit_data.get("included", [])
-            landing = None
-            exit_p = None
+            landing, exit_p = None, None
             
             if visits:
                 visit = visits[0]
                 v_attrs = visit.get("attributes", {})
-                
-                # A. Direct Attributes
                 landing = v_attrs.get("landing_page_path") or v_attrs.get("landing_page_url")
                 
-                # B. Parse 'visit_route'
+                # Visit Route Logic
                 visit_route = v_attrs.get("visit_route", [])
                 if visit_route and isinstance(visit_route, list):
-                    last_step = visit_route[-1]
-                    if not exit_p: exit_p = last_step.get("page_path") or last_step.get("page_url")
-                    
-                    if not landing:
-                        first_step = visit_route[0]
-                        landing = first_step.get("page_path") or first_step.get("page_url")
-
-                # C. Deep Link via 'included' Page Views
+                    if not exit_p: exit_p = visit_route[-1].get("page_path") or visit_route[-1].get("page_url")
+                    if not landing: landing = visit_route[0].get("page_path") or visit_route[0].get("page_url")
+                
+                # Page View Logic
                 if not landing or not exit_p:
                     pv_map = {p["id"]: p["attributes"] for p in included if p["type"] == "page_views"}
                     pv_ids = [r["id"] for r in visit.get("relationships", {}).get("page_views", {}).get("data", [])]
-                    
                     if pv_ids:
-                        if not landing:
-                            first_pv = pv_map.get(pv_ids[0])
-                            if first_pv: landing = first_pv.get("url") or first_pv.get("path")
-                        if not exit_p:    
-                            last_pv = pv_map.get(pv_ids[-1])
-                            if last_pv: exit_p = last_pv.get("url") or last_pv.get("path")
-
+                        if not landing: landing = pv_map.get(pv_ids[0], {}).get("url")
+                        if not exit_p: exit_p = pv_map.get(pv_ids[-1], {}).get("url")
+                        
                 df.at[index, "landing_page_path"] = landing
                 df.at[index, "exit_page_path"] = exit_p
-        except Exception as e:
-            print(f"Failed to enrich lead {lead_id}: {e}")
-            
-        if max_rows and index % 5 == 0:
-            progress(index / total, desc="Enriching...")
-            
+        except: pass
     return df
 
 # =====================================================
-# DEBUGGER
+# CHART BUILDERS (Plotly GO)
 # =====================================================
-def inspect_raw_json(lead_id, start_date, end_date):
-    if not lead_id: return "Please enter a Lead ID"
-    try:
-        url = f"{BASE_URL}/accounts/{ACCOUNT_ID}/leads/{lead_id}/visits"
-        params = {
-            "start_date": start_date, 
-            "end_date": end_date, 
-            "page[size]": 1, 
-            "include": "page_views"
-        }
-        r = requests.get(url, headers=HEADERS, params=params)
-        return json.dumps(r.json(), indent=2)
-    except Exception as e:
-        return str(e)
+def create_empty_figure(text="No Data Loaded"):
+    fig = go.Figure()
+    fig.update_layout(title=text, template="plotly_white")
+    return fig
 
-# =====================================================
-# DATA WRAPPERS
-# =====================================================
-def load_preview(start, end):
-    df = fetch_basic_leads(start, end)
-    if df.empty: return df, pd.DataFrame(), "⚠️ No data found."
-    
-    df_preview = df.copy()
-    df_preview = enrich_leads_with_visits(df_preview, start, end, max_rows=10)
-    
-    status = f"✅ Loaded **{len(df):,} companies**. Preview shows top 10 rows enriched."
-    return df, df_preview.head(10), status
-
-def download_full_excel(df, start, end):
-    if df is None or df.empty: return None
-    print("⏳ Starting full enrichment for Excel export...")
-    enriched_df = enrich_leads_with_visits(df.copy(), start, end) 
-    path = "/tmp/leadfeeder_company_data_full.xlsx"
-    enriched_df.to_excel(path, index=False)
-    return path
-
-# =====================================================
-# CHART ENGINES
-# =====================================================
-def build_kpis(df):
-    if df is None or df.empty: return 0, 0, 0, 0, 0, 0
-    return (
-        len(df),
-        df["total_visits"].gt(0).sum(),
-        int(df["total_visits"].sum()),
-        round(df["lead_quality_score"].mean(), 2),
-        round(df["crm_organization_id"].notna().mean() * 100, 1),
-        round(df["linkedin_url"].notna().mean() * 100, 1),
-    )
-
-def build_dashboard(df, preset, top_n):
-    if df is None or df.empty: return px.bar(title="No Data")
+def build_dashboard_chart(df, preset):
+    if df is None or df.empty: return create_empty_figure()
     dim, metric, agg = DASHBOARD_PRESETS[preset]
+    
     if agg == "count":
         grouped = df.groupby(dim, dropna=False).size().reset_index(name="value")
     else:
         grouped = df.groupby(dim, dropna=False)[metric].agg(agg).reset_index(name="value")
-    return px.bar(grouped.sort_values("value", ascending=False).head(top_n), x=dim, y="value", title=preset)
+        
+    grouped = grouped.sort_values("value", ascending=False).head(15)
+    
+    fig = go.Figure(go.Bar(
+        x=grouped[dim], y=grouped["value"],
+        marker_color='#5898d4', text=grouped["value"], textposition='auto'
+    ))
+    fig.update_layout(title=f"<b>{preset}</b>", template="plotly_white", margin=dict(l=20,r=20,t=50,b=20))
+    return fig
 
-def get_trend_filter_options(df, preset):
-    if df is None or df.empty:
-        return gr.update(choices=[], value=None, visible=False)
-    metric, agg, segment = TREND_PRESETS[preset]
-    if not segment:
-        return gr.update(choices=[], value=None, visible=False)
-    options = sorted(df[segment].dropna().unique().tolist())
-    top_5 = df[segment].value_counts().head(5).index.tolist()
-    return gr.update(choices=options, value=top_5, visible=True, label=f"Filter {segment}")
-
-def build_trend(df, preset, grain, filter_values):
-    if df is None or df.empty: return px.line(title="No Data Loaded")
+def build_trend_chart(df, preset, grain, filters):
+    if df is None or df.empty: return create_empty_figure()
     metric, agg, segment = TREND_PRESETS[preset]
-    df = df.dropna(subset=["last_visit_date"]).copy()
+    df_c = df.dropna(subset=["last_visit_date"]).copy()
+    
+    if segment and filters:
+        df_c = df_c[df_c[segment].isin(filters)]
+        if df_c.empty: return create_empty_figure("No data for filters")
+        
+    if grain == "Weekly": df_c["period"] = df_c["last_visit_date"].dt.to_period("W").astype(str)
+    elif grain == "Monthly": df_c["period"] = df_c["last_visit_date"].dt.to_period("M").astype(str)
+    else: df_c["period"] = df_c["last_visit_date"].dt.date
+    
+    val = "_v" if agg == "count" else metric
+    if agg == "count": df_c["_v"] = df_c[metric].notna().astype(int)
     
-    if segment and filter_values:
-        df = df[df[segment].isin(filter_values)]
-        if df.empty: return px.line(title="No data for selected filters")
-
-    if grain == "Weekly":
-        df["period"] = df["last_visit_date"].dt.to_period("W").astype(str)
-    elif grain == "Monthly":
-        df["period"] = df["last_visit_date"].dt.to_period("M").astype(str)
+    fig = go.Figure()
+    if segment:
+        ts = df_c.groupby(["period", segment])[val].agg(agg).reset_index()
+        for seg in ts[segment].unique():
+            seg_data = ts[ts[segment] == seg]
+            fig.add_trace(go.Scatter(x=seg_data["period"], y=seg_data[val], mode='lines+markers', name=str(seg)))
     else:
-        df["period"] = df["last_visit_date"].dt.date
+        ts = df_c.groupby("period")[val].agg(agg).reset_index()
+        fig.add_trace(go.Scatter(x=ts["period"], y=ts[val], mode='lines+markers', name="Total", line=dict(color='#00CC96', width=3)))
         
-    val = metric
-    if agg == "count":
-        df["_v"] = df[metric].notna().astype(int)
-        val = "_v"
+    fig.update_layout(title=f"<b>{preset}</b>", template="plotly_white")
+    return fig
+
+def build_advanced_charts(df, search_lead, search_comp, start, end):
+    if df is None or df.empty: return create_empty_figure(), create_empty_figure(), create_empty_figure()
+    
+    filtered_df = df.copy()
+    is_search = False
+    
+    if search_lead:
+        filtered_df = filtered_df[filtered_df["lead_id"] == search_lead.strip()]
+        is_search = True
+    elif search_comp:
+        filtered_df = filtered_df[filtered_df["company_name"].str.contains(search_comp, case=False, na=False)]
+        is_search = True
+    else:
+        filtered_df = filtered_df.sort_values("total_visits", ascending=False).head(50)
         
-    if segment:
-        ts = df.groupby(["period", segment])[val].agg(agg).reset_index()
-        title = f"{preset} (Filtered)" if filter_values else preset
-        return px.line(ts, x="period", y=val, color=segment, template="plotly_white", title=title)
+    # Auto Enrich
+    missing = filtered_df[filtered_df["landing_page_path"].isnull()]
+    if not missing.empty:
+        enriched = enrich_leads_with_visits(missing, start, end)
+        filtered_df.update(enriched)
+        
+    # Sankey
+    flow_df = filtered_df.dropna(subset=["landing_page_path", "exit_page_path"])
+    if flow_df.empty:
+        sankey = create_empty_figure("No Flow Data")
+    else:
+        counts = flow_df.groupby(["landing_page_path", "exit_page_path"]).size().reset_index(name="count")
+        if not is_search: counts = counts.sort_values("count", ascending=False).head(15)
+        
+        all_nodes = list(pd.concat([counts["landing_page_path"], counts["exit_page_path"]]).unique())
+        node_map = {node: i for i, node in enumerate(all_nodes)}
+        
+        sankey = go.Figure(go.Sankey(
+            node=dict(pad=15, thickness=20, line=dict(color="black", width=0.5), label=all_nodes, color="blue"),
+            link=dict(source=counts["landing_page_path"].map(node_map), target=counts["exit_page_path"].map(node_map), value=counts["count"])
+        ))
+        sankey.update_layout(title="<b>User Flow: Landing → Exit</b>", font_size=10)
+
+    # Heatmap
+    temp_df = filtered_df.dropna(subset=["last_visit_date"]).copy()
+    if temp_df.empty:
+        heatmap = create_empty_figure("No Date Data")
+    else:
+        temp_df["day"] = temp_df["last_visit_date"].dt.day_name()
+        temp_df["hour"] = temp_df["last_visit_date"].dt.hour
+        days_order = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+        hm_data = temp_df.groupby(["day", "hour"]).size().reset_index(name="visits")
+        hm_pivot = hm_data.pivot(index="day", columns="hour", values="visits").fillna(0).reindex(days_order)
+        
+        heatmap = go.Figure(go.Heatmap(z=hm_pivot.values, x=hm_pivot.columns, y=hm_pivot.index, colorscale='Viridis'))
+        heatmap.update_layout(title="<b>Activity Heatmap</b>")
+
+    # Matrix (Aggregate)
+    roi_df = df.groupby("primary_industry").agg({"total_visits": "sum", "lead_quality_score": "mean", "company_name": "count"}).reset_index()
+    roi_df = roi_df[roi_df["company_name"] > 2]
     
-    ts = df.groupby("period")[val].agg(agg).reset_index()
-    return px.line(ts, x="period", y=val, markers=True, template="plotly_white", title=preset)
+    if roi_df.empty:
+        matrix = create_empty_figure("Not enough data")
+    else:
+        matrix = go.Figure(go.Scatter(
+            x=roi_df["total_visits"], y=roi_df["lead_quality_score"], mode='markers', text=roi_df["primary_industry"],
+            marker=dict(size=roi_df["company_name"], sizemode='area', sizeref=2.*max(roi_df["company_name"])/(40.**2), sizemin=4, color=roi_df["lead_quality_score"], colorscale='RdYlGn', showscale=True)
+        ))
+        matrix.update_layout(title="<b>Industry Matrix</b>", xaxis_title="Volume", yaxis_title="Quality", template="plotly_white")
+
+    return sankey, heatmap, matrix
 
 # =====================================================
-# UI LAYOUT
+# UI APPLICATION (NiceGUI)
 # =====================================================
-with gr.Blocks(title="Leadfeeder Pro Analytics") as demo:
-    gr.Markdown("## 🚀 Leadfeeder Analytics")
-    
-    with gr.Row():
-        pwd = gr.Textbox(type="password", label="App Password")
-        gr.Button("Auth").click(lambda p: gr.Info("Success") if p==APP_PASSWORD else gr.Error("Invalid"), pwd, None)
+class LeadfeederApp:
+    def __init__(self):
+        self.df = pd.DataFrame()
+        self.start_date_val = (date.today() - timedelta(days=30)).isoformat()
+        self.end_date_val = date.today().isoformat()
+        
+    async def load_data(self):
+        if self.pwd_input.value != APP_PASSWORD:
+            ui.notify('Invalid Password!', type='negative')
+            return
+
+        self.loading_spinner.visible = True
+        ui.notify('Fetching data... this may take a moment.')
+        
+        # Run heavy fetch in background
+        self.df = await run.io_bound(fetch_basic_leads, self.date_start.value, self.date_end.value)
+        
+        if self.df.empty:
+            ui.notify('No data found.', type='warning')
+        else:
+            # Enrich top 10 for preview immediately
+            preview_df = self.df.copy()
+            preview_df = await run.io_bound(enrich_leads_with_visits, preview_df, self.date_start.value, self.date_end.value, 10)
+            
+            # Update UI
+            self.update_kpis()
+            self.update_aggrid(preview_df.head(10))
+            self.refresh_dashboard()
+            self.refresh_trends()
+            ui.notify(f'Loaded {len(self.df)} companies successfully!', type='positive')
+            
+        self.loading_spinner.visible = False
+
+    def update_kpis(self):
+        if self.df.empty: return
+        self.kpi_total.value = len(self.df)
+        self.kpi_visits.value = int(self.df["total_visits"].sum())
+        self.kpi_quality.value = round(self.df["lead_quality_score"].mean(), 2)
+        self.kpi_crm.value = f"{round(self.df['crm_organization_id'].notna().mean() * 100, 1)}%"
+
+    def update_aggrid(self, df_show):
+        # Convert timestamp to string for display
+        display_df = df_show.copy()
+        for col in display_df.select_dtypes(include=['datetime64']).columns:
+            display_df[col] = display_df[col].astype(str)
+        self.grid.options['rowData'] = display_df.to_dict(orient='records')
+        self.grid.update()
+
+    async def download_full_report(self):
+        if self.df.empty: return
+        ui.notify('Generating Excel... please wait.')
+        
+        # Run full enrichment
+        enriched_df = await run.io_bound(enrich_leads_with_visits, self.df.copy(), self.date_start.value, self.date_end.value)
+        
+        path = f"/tmp/leadfeeder_report_{int(time.time())}.xlsx"
+        enriched_df.to_excel(path, index=False)
+        ui.download(path)
+        ui.notify('Download started!', type='positive')
+
+    def refresh_dashboard(self):
+        fig = build_dashboard_chart(self.df, self.dash_preset.value)
+        self.dash_plot.update_figure(fig)
+
+    def update_trend_options(self):
+        if self.df.empty: return
+        _, _, segment = TREND_PRESETS[self.trend_preset.value]
+        if segment:
+            opts = sorted(self.df[segment].dropna().unique().tolist())
+            self.trend_filter.options = opts
+            self.trend_filter.visible = True
+        else:
+            self.trend_filter.visible = False
+            self.trend_filter.value = []
+
+    def refresh_trends(self):
+        fig = build_trend_chart(self.df, self.trend_preset.value, self.trend_grain.value, self.trend_filter.value)
+        self.trend_plot.update_figure(fig)
+
+    async def run_advanced_analytics(self):
+        if self.df.empty: return
+        ui.notify('Analyzing user flows...')
+        sankey, heatmap, matrix = await run.io_bound(
+            build_advanced_charts, self.df, self.adv_lead_id.value, self.adv_comp.value, 
+            self.date_start.value, self.date_end.value
+        )
+        self.sankey_plot.update_figure(sankey)
+        self.heatmap_plot.update_figure(heatmap)
+        self.matrix_plot.update_figure(matrix)
     
-    df_state = gr.State()
-    status = gr.Markdown()
+    async def run_debugger(self):
+        if not self.debug_id.value: return
+        res = await run.io_bound(
+            requests.get, 
+            f"{BASE_URL}/accounts/{ACCOUNT_ID}/leads/{self.debug_id.value}/visits",
+            headers=HEADERS, 
+            params={"start_date": self.date_start.value, "end_date": self.date_end.value, "page[size]": 1, "include": "page_views"}
+        )
+        self.debug_output.set_content(f"```json\n{json.dumps(res.json(), indent=2)}\n```")
+
+# =====================================================
+# UI LAYOUT
+# =====================================================
+@ui.page('/')
+def main_page():
+    app_logic = LeadfeederApp()
     
-    with gr.Tabs():
+    # --- HEADER ---
+    with ui.header().classes(replace='row items-center') as header:
+        ui.icon('analytics', size='32px').classes('text-white q-mr-sm')
+        ui.label('Leadfeeder Pro Analytics').classes('text-h6 text-white')
+        ui.space()
+        app_logic.pwd_input = ui.input('App Password', password=True).classes('bg-white rounded q-px-sm')
+        
+    # --- TABS ---
+    with ui.tabs().classes('w-full') as tabs:
+        data_tab = ui.tab('Data & Report')
+        dash_tab = ui.tab('Dashboard')
+        trend_tab = ui.tab('Trends')
+        adv_tab = ui.tab('Advanced Analytics')
+        debug_tab = ui.tab('Debugger')
+
+    with ui.tab_panels(tabs, value=data_tab).classes('w-full q-pa-md'):
+        
         # --- TAB 1: DATA ---
-        with gr.Tab("📋 Data & Report"):
-            with gr.Row():
-                start = gr.Textbox(label="Start Date", value=(date.today()-timedelta(days=30)).isoformat())
-                end = gr.Textbox(label="End Date", value=date.today().isoformat())
-            
-            with gr.Row():
-                btn_load = gr.Button("1. Load Data (Preview)", variant="primary")
-                btn_dl = gr.Button("2. Enrich & Download Full Excel")
-                file_dl = gr.File(label="Download Excel")
-            
-            table = gr.Dataframe(label="Preview (Top 10 Enriched)", interactive=True)
-            
-            btn_load.click(load_preview, [start, end], [df_state, table, status])
-            btn_dl.click(download_full_excel, [df_state, start, end], file_dl)
+        with ui.tab_panel(data_tab):
+            with ui.row().classes('w-full items-center gap-4'):
+                app_logic.date_start = ui.input('Start Date', value=app_logic.start_date_val)
+                app_logic.date_end = ui.input('End Date', value=app_logic.end_date_val)
+                ui.button('Load Data', on_click=app_logic.load_data, icon='cloud_download')
+                ui.button('Download Excel (Full)', on_click=app_logic.download_full_report, icon='file_download').classes('bg-green')
+                app_logic.loading_spinner = ui.spinner(size='lg').props('color=primary').bind_visibility_from(app_logic.loading_spinner, 'visible')
+                app_logic.loading_spinner.visible = False
+
+            # KPIS
+            with ui.row().classes('w-full gap-4 q-my-md'):
+                with ui.card().classes('w-48'):
+                    ui.label('Total Companies').classes('text-caption')
+                    app_logic.kpi_total = ui.label('0').classes('text-h5')
+                with ui.card().classes('w-48'):
+                    ui.label('Total Visits').classes('text-caption')
+                    app_logic.kpi_visits = ui.label('0').classes('text-h5')
+                with ui.card().classes('w-48'):
+                    ui.label('Avg Quality').classes('text-caption')
+                    app_logic.kpi_quality = ui.label('0').classes('text-h5')
+                with ui.card().classes('w-48'):
+                    ui.label('CRM Coverage').classes('text-caption')
+                    app_logic.kpi_crm = ui.label('0%').classes('text-h5')
+
+            # PREVIEW GRID
+            ui.label('Data Preview (Top 10 Enriched)').classes('text-h6 q-mt-md')
+            app_logic.grid = ui.aggrid({
+                'columnDefs': [
+                    {'headerName': 'Company', 'field': 'company_name'},
+                    {'headerName': 'Industry', 'field': 'primary_industry'},
+                    {'headerName': 'Visits', 'field': 'total_visits'},
+                    {'headerName': 'Landing Page', 'field': 'landing_page_path'},
+                    {'headerName': 'Exit Page', 'field': 'exit_page_path'},
+                ],
+                'rowData': []
+            }).classes('h-96 w-full')
 
         # --- TAB 2: DASHBOARD ---
-        with gr.Tab("📊 Dashboard"):
-            kpis = [gr.Number(label=l) for l in ["Total Companies", "Active Companies", "Total Visits", "Avg Quality", "CRM %", "LinkedIn %"]]
-            gr.Button("Refresh KPIs").click(build_kpis, df_state, kpis)
-            
-            with gr.Row():
-                preset = gr.Dropdown(choices=list(DASHBOARD_PRESETS.keys()), label="Chart")
-                top_n = gr.Slider(5, 50, value=10, label="Top N")
+        with ui.tab_panel(dash_tab):
+            with ui.row().classes('items-center'):
+                app_logic.dash_preset = ui.select(list(DASHBOARD_PRESETS.keys()), label="Select Chart", value="Total Visits by Industry", on_change=app_logic.refresh_dashboard).classes('w-64')
+                ui.button('Refresh', icon='refresh', on_click=app_logic.refresh_dashboard).props('flat')
             
-            chart = gr.Plot()
-            gr.Button("Build View").click(build_dashboard, [df_state, preset, top_n], chart)
+            app_logic.dash_plot = ui.plotly({}).classes('w-full h-128')
 
         # --- TAB 3: TRENDS ---
-        with gr.Tab("📈 Trends"):
-            with gr.Row():
-                trend_view = gr.Dropdown(choices=list(TREND_PRESETS.keys()), label="Select Trend")
-                grain = gr.Radio(["Daily", "Weekly", "Monthly"], value="Daily", label="Granularity")
+        with ui.tab_panel(trend_tab):
+            with ui.row().classes('items-start gap-4'):
+                app_logic.trend_preset = ui.select(list(TREND_PRESETS.keys()), label="Metric", value="Total Visits Trend", on_change=lambda: [app_logic.update_trend_options(), app_logic.refresh_trends()]).classes('w-64')
+                app_logic.trend_grain = ui.radio(['Daily', 'Weekly', 'Monthly'], value='Daily', on_change=app_logic.refresh_trends).props('inline')
+                app_logic.trend_filter = ui.select([], multiple=True, label="Filter Segments", on_change=app_logic.refresh_trends).classes('w-96').props('use-chips')
+                app_logic.trend_filter.visible = False
             
-            filter_dropdown = gr.Dropdown(multiselect=True, visible=False, label="Filter Segments")
-            plot = gr.Plot()
+            app_logic.trend_plot = ui.plotly({}).classes('w-full h-128')
+
+        # --- TAB 4: ADVANCED ---
+        with ui.tab_panel(adv_tab):
+            with ui.row().classes('items-center gap-4'):
+                app_logic.adv_lead_id = ui.input('Search Lead ID')
+                app_logic.adv_comp = ui.input('Search Company Name')
+                ui.button('Analyze Flow', on_click=app_logic.run_advanced_analytics, icon='insights')
+
+            with ui.row().classes('w-full'):
+                with ui.column().classes('w-1/2'):
+                    app_logic.sankey_plot = ui.plotly({}).classes('w-full h-96')
+                with ui.column().classes('w-1/2'):
+                    app_logic.heatmap_plot = ui.plotly({}).classes('w-full h-96')
             
-            trend_view.change(get_trend_filter_options, [df_state, trend_view], filter_dropdown)
-            gr.Button("Show Trend", variant="primary").click(
-                build_trend, 
-                [df_state, trend_view, grain, filter_dropdown], 
-                plot
-            )
+            app_logic.matrix_plot = ui.plotly({}).classes('w-full h-96 q-mt-md')
 
-        # --- TAB 4: DEBUGGER ---
-        with gr.Tab("🛠️ Debugger"):
-            gr.Markdown("Inspect raw API data for a specific lead.")
-            dbg_id = gr.Textbox(label="Lead ID")
-            dbg_btn = gr.Button("Inspect Raw JSON")
-            dbg_out = gr.Code(language="json")
-            dbg_btn.click(inspect_raw_json, [dbg_id, start, end], dbg_out)
+        # --- TAB 5: DEBUGGER ---
+        with ui.tab_panel(debug_tab):
+            with ui.row():
+                app_logic.debug_id = ui.input('Lead ID')
+                ui.button('Inspect JSON', on_click=app_logic.run_debugger)
+            app_logic.debug_output = ui.markdown('Raw JSON will appear here...')
 
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+ui.run(title='Leadfeeder Analytics', port=8080, favicon='🚀')