Update app.py

app.py

@@ -13,25 +13,23 @@ from datetime import date, timedelta
 API_TOKEN = os.getenv("LEADFEEDER_API_TOKEN")
 APP_PASSWORD = os.getenv("APP_PASSWORD")
 
-# If testing locally without env vars, uncomment and set manually:
-# API_TOKEN = "your_token_here"
-# APP_PASSWORD = "password"
-
+# Fail-safe for local testing if secrets aren't set
 if not API_TOKEN or not APP_PASSWORD:
-    # Fallback for safe run if secrets missing (prevents crash on immediate launch)
     print("⚠️ WARNING: Secrets missing. App will launch but API calls will fail.")
+    API_TOKEN = "PLACEHOLDER"
+    APP_PASSWORD = "password"
 
-ACCOUNT_ID = "255333" 
+ACCOUNT_ID = "255333"  # PREMIUM account
 BASE_URL = "https://api.leadfeeder.com"
 PAGE_SIZE = 100 
 HEADERS = {
     "Authorization": f"Token token={API_TOKEN}",
     "Accept": "application/json"
 }
-CONFIG_FILE = "campaign_rules.json"
+CAMPAIGN_CONFIG_FILE = "campaign_rules.json"
 
 # =====================================================
-# 1. CAMPAIGN & CONFIG MANAGEMENT
+# 1. CAMPAIGN MANAGER & UTILS
 # =====================================================
 DEFAULT_CAMPAIGNS = {
     "MS Stack": [
@@ -56,132 +54,118 @@ DEFAULT_CAMPAIGNS = {
 }
 
 def load_campaign_rules():
-    """Load rules from JSON or fallback to defaults."""
-    if os.path.exists(CONFIG_FILE):
+    """Load campaign groups from JSON file or use defaults."""
+    if os.path.exists(CAMPAIGN_CONFIG_FILE):
         try:
-            with open(CONFIG_FILE, "r") as f:
+            with open(CAMPAIGN_CONFIG_FILE, "r") as f:
                 return json.load(f)
         except:
             return DEFAULT_CAMPAIGNS
     return DEFAULT_CAMPAIGNS
 
-def save_campaign_rules(rules):
-    """Save rules to JSON."""
-    with open(CONFIG_FILE, "w") as f:
-        json.dump(rules, f, indent=4)
-    return "✅ Settings Saved!"
-
-def get_rules_text(rules):
-    """Convert dict to readable text for UI."""
-    return json.dumps(rules, indent=2)
-
-def update_rules_from_text(text):
-    """Parse text back to dict and save."""
+def save_campaign_rules(rules_text):
+    """Parse JSON text from UI and save to file."""
     try:
-        new_rules = json.loads(text)
-        save_campaign_rules(new_rules)
-        return "✅ Configuration updated successfully!", new_rules
+        rules = json.loads(rules_text)
+        with open(CAMPAIGN_CONFIG_FILE, "w") as f:
+            json.dump(rules, f, indent=4)
+        return "✅ Configuration Saved! (Reload Data to apply changes)", rules
     except json.JSONDecodeError:
-        return "❌ Error: Invalid JSON format. Please check syntax.", None
+        return "❌ Error: Invalid JSON format.", None
 
-# =====================================================
-# 2. DATA PROCESSING LOGIC
-# =====================================================
 def categorize_quality(score):
+    """Classify Lead Quality Score into High/Mid/Low."""
     if pd.isna(score): return "Unknown"
-    s = int(score)
-    if 8 <= s <= 10: return "High Quality (8-10)"
-    if 5 <= s <= 7:  return "Mid Quality (5-7)"
-    if 1 <= s <= 4:  return "Low Quality (1-4)"
-    return "Low Quality (0)"
+    try:
+        s = int(score)
+        if 8 <= s <= 10: return "High Quality (8-10)"
+        if 5 <= s <= 7:  return "Mid Quality (5-7)"
+        if 1 <= s <= 4:  return "Low Quality (1-4)"
+        return "Low Quality (0)"
+    except:
+        return "Unknown"
 
 def assign_campaign(url, rules):
+    """Match URL against campaign keywords."""
     if not url or not isinstance(url, str):
         return "Uncategorized"
     
     url_lower = url.lower()
-    # Check each campaign group
     for campaign_name, keywords in rules.items():
         for kw in keywords:
             if kw.lower() in url_lower:
                 return campaign_name
     return "Other"
 
-def process_business_logic(df):
-    """Apply Quality Grouping and Campaign Logic to the DataFrame."""
-    if df.empty: return df
+def apply_business_logic(df):
+    """Apply Campaign and Quality logic to the DataFrame."""
+    if df is None or df.empty: return df
     
-    # 1. Load Rules
-    rules = load_campaign_rules()
+    # 1. Apply Quality Logic
+    df["Quality_Group"] = df["lead_quality_score"].apply(categorize_quality)
     
-    # 2. Apply Quality Logic
-    df["Quality Group"] = df["lead_quality_score"].apply(categorize_quality)
+    # 2. Apply Campaign Logic
+    rules = load_campaign_rules()
+    # We use landing_page_path primarily.
+    df["Campaign"] = df["landing_page_path"].apply(lambda x: assign_campaign(x, rules))
     
-    # 3. Apply Campaign Logic (Check Landing Page mostly)
-    # We prioritize landing_page_path, fallback to first_visit_url if available? 
-    # For now, strictly landing_page_path or blank.
-    def get_campaign(row):
-        # Check landing page
-        path = row.get("landing_page_path")
-        res = assign_campaign(path, rules)
-        if res != "Other": return res
-        
-        # Optional: Check all industries if landing page fails?
-        # ind = row.get("all_industries", "")
-        # if ind: return assign_campaign(ind, rules)
-        
-        return "Other"
-
-    df["Campaign"] = df.apply(get_campaign, axis=1)
     return df
 
 # =====================================================
-# 3. PRESETS (UPDATED)
+# 2. PRESETS (Original + New)
 # =====================================================
 DASHBOARD_PRESETS = {
-    "Total Visits by Campaign": ("Campaign", "total_visits", "sum"),
+    # -- NEW PRESETS --
+    "Visits by Campaign": ("Campaign", "total_visits", "sum"),
+    "Leads by Campaign": ("Campaign", "company_name", "count"),
+    "Leads by Quality Group": ("Quality_Group", "company_name", "count"),
+    
+    # -- ORIGINAL PRESETS --
     "Total Visits by Industry": ("primary_industry", "total_visits", "sum"),
-    "Lead Quality Breakdown": ("Quality Group", "company_name", "count"),
-    "Campaign Performance (Leads)": ("Campaign", "company_name", "count"),
     "Total Visits by Country": ("country", "total_visits", "sum"),
     "Avg Quality by Industry": ("primary_industry", "lead_quality_score", "mean"),
     "Top Accounts by Visits": ("company_name", "total_visits", "sum"),
+    "Companies by Country": ("country", "company_name", "count"),
+    "Visits by City": ("city", "total_visits", "sum"),
+    "Accounts by Assignee": ("assignee", "company_name", "count"),
+    "Visits by Assignee": ("assignee", "total_visits", "sum"),
 }
 
 TREND_PRESETS = {
-    "Total Visits Trend": ("total_visits", "sum", None),
+    # -- NEW TRENDS --
     "Visits Trend by Campaign": ("total_visits", "sum", "Campaign"),
-    "Visits Trend by Quality": ("total_visits", "sum", "Quality Group"),
+    "Visits Trend by Quality": ("total_visits", "sum", "Quality_Group"),
+    
+    # -- ORIGINAL TRENDS --
+    "Total Visits Trend": ("total_visits", "sum", None),
     "Active Accounts Trend": ("company_name", "count", None),
     "Avg Lead Quality Trend": ("lead_quality_score", "mean", None),
     "Visits Trend by Industry": ("total_visits", "sum", "primary_industry"),
+    "Visits Trend by Country": ("total_visits", "sum", "country"),
+    "Visits Trend by Assignee": ("total_visits", "sum", "assignee"),
 }
 
 # =====================================================
-# 4. API & FETCHER
+# 3. API HANDLING
 # =====================================================
 def make_request(url, params=None):
     retries = 3
     while retries > 0:
-        try:
-            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
-            r.raise_for_status()
-            return r.json()
-        except Exception as e:
-            print(f"Request failed: {e}")
+        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
-            time.sleep(2)
-    raise Exception("Max retries exceeded or API Error")
+            continue
+        r.raise_for_status()
+        return r.json()
+    raise Exception("Max retries exceeded")
 
 def fetch_basic_leads(start_date, end_date):
+    """ Step 1: Fetch ALL company details (fast fetch). """
     page = 1
     rows = []
-    print(f"🚀 Fetching leads {start_date} to {end_date}...")
+    print(f"🚀 Fetching full company list for {start_date} to {end_date}...")
     
     while True:
         try:
@@ -208,19 +192,33 @@ def fetch_basic_leads(start_date, end_date):
                     "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"),
+                    "assignee": a.get("assignee"),
+                    "emailed_to": a.get("emailed_to"),
+                    "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"),
                     "country": loc.get("country"),
+                    "region": loc.get("region"),
                     "city": loc.get("city"),
-                    # Init fields for enrichment
+                    "leadfeeder_url": a.get("view_in_leadfeeder"),
+                    # Placeholders for enrichment
                     "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 page {page}: {e}")
+            print(f"Error on page {page}: {e}")
             break
             
     df = pd.DataFrame(rows)
@@ -229,190 +227,263 @@ def fetch_basic_leads(start_date, end_date):
     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/Landing Page. """
     if df.empty: return df
     target_df = df.head(max_rows) if max_rows else df
     total = len(target_df)
     
-    print(f"🕵️ Enriching {total} rows...")
+    print(f"🕵️ Deep enriching {total} rows ({start_date} to {end_date})...")
     
     for index, row in target_df.iterrows():
-        # Skip if already has landing page
-        if row.get("landing_page_path"): continue
+        if row.get("landing_page_path") and row.get("exit_page_path"): continue
         
         lead_id = row["lead_id"]
         try:
-            # We fetch 1 visit to get landing page
             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}
+                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
+            
             if visits:
-                attrs = visits[0].get("attributes", {})
-                landing = attrs.get("landing_page_path") or attrs.get("landing_page_url")
+                visit = visits[0]
+                v_attrs = visit.get("attributes", {})
                 
-                # Fallback to visit route if top level attr is missing
-                if not landing:
-                    route = attrs.get("visit_route", [])
-                    if route:
-                        landing = route[0].get("page_path")
+                # A. Direct Attributes
+                landing = v_attrs.get("landing_page_path") or v_attrs.get("landing_page_url")
+                
+                # B. Parse 'visit_route'
+                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 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")
                 
                 df.at[index, "landing_page_path"] = landing
-        except:
-            pass
+                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 Visits...")
+            progress(index / total, desc="Enriching...")
             
     return df
 
 # =====================================================
-# 5. WRAPPERS
+# 4. MAIN FUNCTIONS
 # =====================================================
-def load_and_process(start, end):
-    # 1. Fetch Basic
+def load_preview(start, end):
+    # 1. Fetch
     df = fetch_basic_leads(start, end)
     if df.empty: return df, pd.DataFrame(), "⚠️ No data found."
     
-    # 2. Enrich (Preview 20 rows for speed in UI)
-    # We MUST enrich landing pages to get Campaigns working
+    # 2. Enrich top 20 for preview speed
     df_preview = df.copy()
     df_preview = enrich_leads_with_visits(df_preview, start, end, max_rows=20)
     
-    # 3. Apply Business Logic (Campaigns + Quality)
-    df_preview = process_business_logic(df_preview)
+    # 3. Apply New Business Logic (Campaign/Quality)
+    df_preview = apply_business_logic(df_preview)
     
-    # Note: Main DF is NOT enriched yet (too slow), so Campaign column will be empty/Other 
-    # until user clicks "Download" or we force enrichment.
-    # For better UI, we can try to enrich ALL if size < 200, else warn.
-    if len(df) < 300:
-        df = enrich_leads_with_visits(df, start, end) # Enrich all if small
-        df = process_business_logic(df)
-        status = f"✅ Loaded & Enriched {len(df)} companies."
-    else:
-        # Just process logic on what we have (mostly empty landing pages)
-        df = process_business_logic(df)
-        status = f"✅ Loaded {len(df)} companies. (Preview enriched only. Download for full data)."
-
+    status = f"✅ Loaded **{len(df):,} companies**. Preview shows top 20 rows enriched."
     return df, df_preview.head(20), status
 
 def download_full_excel(df, start, end):
     if df is None or df.empty: return None
-    print("⏳ Full Enrichment for Export...")
+    print("⏳ Starting full enrichment for Excel export...")
+    
+    # 1. Enrich ALL rows (Time consuming but necessary for Campaign logic)
+    enriched_df = enrich_leads_with_visits(df.copy(), start, end)
     
-    # Ensure all rows have visits
-    enriched = enrich_leads_with_visits(df.copy(), start, end)
-    # Re-apply logic now that we have landing pages
-    final_df = process_business_logic(enriched)
+    # 2. Apply Business Logic
+    final_df = apply_business_logic(enriched_df)
     
     path = "/tmp/leadfeeder_campaign_data.xlsx"
     final_df.to_excel(path, index=False)
     return path
 
+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)
+
 # =====================================================
-# 6. CHARTING
+# 5. CHART ENGINES
 # =====================================================
+def build_kpis(df):
+    if df is None or df.empty: return 0, 0, 0, 0, 0, 0
+    # Apply logic if not present
+    if "Quality_Group" not in df.columns:
+        df = apply_business_logic(df)
+        
+    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),
+        df[df["Quality_Group"] == "High Quality (8-10)"].shape[0], # Count of High Quality
+    )
+
 def build_dashboard(df, preset, top_n):
     if df is None or df.empty: return px.bar(title="No Data")
     
+    # Ensure columns exist
+    if "Campaign" not in df.columns or "Quality_Group" not in df.columns:
+         # Warn if viewing campaign data without full enrichment
+         if "Campaign" in preset:
+             return px.bar(title="⚠️ Please Download Excel first to enrich Campaigns for all rows.")
+         df = apply_business_logic(df)
+
     dim, metric, agg = DASHBOARD_PRESETS[preset]
     
-    # Check if column exists (Campaign might be missing if not enriched)
-    if dim not in df.columns:
-        return px.bar(title=f"Column '{dim}' not available. Try Downloading Full Data first.")
-
     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")
         
-    fig = px.bar(grouped.sort_values("value", ascending=False).head(top_n), x=dim, y="value", title=preset, color=dim)
-    return fig
+    return px.bar(grouped.sort_values("value", ascending=False).head(top_n), x=dim, y="value", title=preset, color=dim)
 
-def build_trend(df, preset, grain):
-    if df is None or df.empty: return px.line(title="No Data")
+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]
-    df_t = df.dropna(subset=["last_visit_date"]).copy()
+    if not segment: return gr.update(choices=[], value=None, visible=False)
+    
+    # Ensure logic applied
+    if segment not in df.columns: df = apply_business_logic(df)
+        
+    options = sorted(df[segment].astype(str).unique().tolist())
+    return gr.update(choices=options, value=options[: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")
     
+    metric, agg, segment = TREND_PRESETS[preset]
+    df = df.dropna(subset=["last_visit_date"]).copy()
+    
+    if segment:
+        if segment not in df.columns: df = apply_business_logic(df)
+        if filter_values:
+            df = df[df[segment].isin(filter_values)]
+            
     if grain == "Weekly":
-        df_t["period"] = df_t["last_visit_date"].dt.to_period("W").astype(str)
+        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)
     else:
-        df_t["period"] = df_t["last_visit_date"].dt.date
+        df["period"] = df["last_visit_date"].dt.date
         
     val = metric
     if agg == "count":
-        df_t["_v"] = 1
+        df["_v"] = 1
         val = "_v"
         
-    if segment and segment in df_t.columns:
-        ts = df_t.groupby(["period", segment])[val].agg(agg).reset_index()
-        return px.line(ts, x="period", y=val, color=segment, title=preset)
+    if segment:
+        ts = df.groupby(["period", segment])[val].agg(agg).reset_index()
+        return px.line(ts, x="period", y=val, color=segment, template="plotly_white", title=preset)
     
-    ts = df_t.groupby("period")[val].agg(agg).reset_index()
-    return px.line(ts, x="period", y=val, markers=True, title=preset)
+    ts = df.groupby("period")[val].agg(agg).reset_index()
+    return px.line(ts, x="period", y=val, markers=True, template="plotly_white", title=preset)
 
 # =====================================================
-# 7. UI LAYOUT
+# 6. UI LAYOUT
 # =====================================================
-with gr.Blocks(title="Leadfeeder Campaign Analytics") as demo:
-    gr.Markdown("## 🚀 Leadfeeder Analytics + Campaign Manager")
+with gr.Blocks(title="Leadfeeder Campaign Pro") as demo:
+    gr.Markdown("## 🚀 Leadfeeder Analytics & Campaign Manager")
     
-    # Auth
     with gr.Row():
-        pwd_input = gr.Textbox(type="password", label="App Password")
-        auth_btn = gr.Button("Login")
+        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)
+        df_state = gr.State()
     
-    # State
-    df_state = gr.State()
+    status = gr.Markdown()
     
     with gr.Tabs():
         # --- TAB 1: DATA ---
         with gr.Tab("📋 Data & Report"):
             with gr.Row():
-                start_dt = gr.Textbox(label="Start Date", value=(date.today()-timedelta(days=30)).isoformat())
-                end_dt = gr.Textbox(label="End Date", value=date.today().isoformat())
+                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", variant="primary")
-                btn_dl = gr.Button("2. Download Excel (Full Analysis)")
-                file_out = gr.File(label="Exported File")
-            
-            status_txt = gr.Markdown("Ready.")
-            table = gr.Dataframe(label="Preview Data", interactive=True)
-            
-            btn_load.click(load_and_process, [start_dt, end_dt], [df_state, table, status_txt])
-            btn_dl.click(download_full_excel, [df_state, start_dt, end_dt], file_out)
+                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 20 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)
+
         # --- TAB 2: DASHBOARD ---
         with gr.Tab("📊 Dashboard"):
+            kpis = [gr.Number(label=l) for l in ["Total Companies", "Active Companies", "Total Visits", "Avg Quality", "CRM %", "High Quality Leads (8-10)"]]
+            gr.Button("Refresh KPIs").click(build_kpis, df_state, kpis)
+            
             with gr.Row():
-                dash_preset = gr.Dropdown(list(DASHBOARD_PRESETS.keys()), label="Chart Type", value="Total Visits by Campaign")
-                top_n = gr.Slider(5, 50, 10, label="Top N Items")
-            dash_plot = gr.Plot()
-            gr.Button("Refresh Chart").click(build_dashboard, [df_state, dash_preset, top_n], dash_plot)
+                preset = gr.Dropdown(choices=list(DASHBOARD_PRESETS.keys()), label="Chart", value="Visits by Campaign")
+                top_n = gr.Slider(5, 50, value=10, label="Top N")
             
+            chart = gr.Plot()
+            gr.Button("Build View").click(build_dashboard, [df_state, preset, top_n], chart)
+
         # --- TAB 3: TRENDS ---
         with gr.Tab("📈 Trends"):
             with gr.Row():
-                trend_preset = gr.Dropdown(list(TREND_PRESETS.keys()), label="Trend Type", value="Visits Trend by Campaign")
-                grain_opt = gr.Radio(["Daily", "Weekly"], value="Daily", label="Granularity")
-            trend_plot = gr.Plot()
-            gr.Button("Show Trend").click(build_trend, [df_state, trend_preset, grain_opt], trend_plot)
+                trend_view = gr.Dropdown(choices=list(TREND_PRESETS.keys()), label="Select Trend", value="Visits Trend by Campaign")
+                grain = gr.Radio(["Daily", "Weekly", "Monthly"], value="Daily", label="Granularity")
             
-        # --- TAB 4: SETTINGS (CAMPAIGN MANAGER) ---
-        with gr.Tab("⚙️ Campaign Settings"):
-            gr.Markdown("### Manage Campaign Keywords")
-            gr.Markdown("Edit the JSON structure below to add/remove campaigns or keywords. Changes apply on next 'Load Data'.")
+            filter_dropdown = gr.Dropdown(multiselect=True, visible=False, label="Filter Segments")
+            plot = gr.Plot()
             
-            # Load initial settings
-            init_rules = get_rules_text(load_campaign_rules())
+            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)
+
+        # --- TAB 4: SETTINGS (NEW) ---
+        with gr.Tab("⚙️ Campaign Settings"):
+            gr.Markdown("### Manage Campaign Groups & Keywords")
+            gr.Markdown("Modify the JSON below to add new groups or keywords. Click 'Save' to apply changes.")
             
-            json_editor = gr.Code(value=init_rules, language="json", label="Campaign Configuration (JSON)")
-            save_btn = gr.Button("💾 Save Configuration", variant="primary")
+            # Load current rules into text box
+            current_rules = json.dumps(load_campaign_rules(), indent=4)
+            config_editor = gr.Code(value=current_rules, language="json", label="Campaign Configuration")
+            save_config_btn = gr.Button("💾 Save Configuration")
             config_status = gr.Markdown()
             
-            save_btn.click(update_rules_from_text, json_editor, [config_status, gr.State()])
+            save_config_btn.click(save_campaign_rules, config_editor, [config_status, gr.State()])
+
+        # --- TAB 5: 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)
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)