Update app.py

app.py

@@ -2,333 +2,427 @@
 import streamlit as st
 import pandas as pd
 import numpy as np
-from pathlib import Path
 import matplotlib.pyplot as plt
 import seaborn as sns
+from pathlib import Path
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+# Page configuration
+st.set_page_config(
+    page_title="Getaround Delay Analysis Dashboard",
+    page_icon="🚗",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
 
-# ------- Page setup -------
-st.set_page_config(page_title="Getaround — Threshold & Scope Decision", layout="wide")
-sns.set_style("whitegrid")
-
-# ------- Data loading -------
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        font-weight: 700;
+        color: #1f77b4;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .section-header {
+        font-size: 1.8rem;
+        font-weight: 600;
+        color: #2c3e50;
+        margin: 2rem 0 1rem 0;
+        border-bottom: 2px solid #3498db;
+        padding-bottom: 0.5rem;
+    }
+    .metric-card {
+        background-color: #f8f9fa;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 4px solid #3498db;
+    }
+    .insight-box {
+        background-color: #e8f4f8;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border-left: 4px solid #17a2b8;
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Data loading function
 @st.cache_data(show_spinner=False)
 def load_data():
-    for p in ["/mnt/data/get_around_delay_analysis.csv", "get_around_delay_analysis.csv"]:
-        if Path(p).exists():
-            df = pd.read_csv(p)
-            break
-    else:
-        st.error("CSV not found. Put 'get_around_delay_analysis.csv' in the app folder or /mnt/data.")
+    """Load and preprocess the rental data"""
+    # Try multiple possible file locations
+    possible_paths = [
+        "/mnt/data/get_around_delay_analysis.csv",
+        "get_around_delay_analysis.csv",
+        "data/get_around_delay_analysis.csv"
+    ]
+    
+    df = None
+    for path in possible_paths:
+        if Path(path).exists():
+            try:
+                df = pd.read_csv(path)
+                break
+            except Exception as e:
+                continue
+    
+    if df is None:
+        st.error("❌ CSV file not found. Please ensure 'get_around_delay_analysis.csv' is in the correct location.")
         st.stop()
-
-    # drop unnamed artifacts
+    
+    # Clean the data
+    # Remove unnamed columns
     df = df.drop(columns=[c for c in df.columns if c.lower().startswith("unnamed")], errors="ignore")
-
-    # helpers
-    df["has_gap"] = df["time_delta_with_previous_rental_in_minutes"].notnull()
-    clean = df["delay_at_checkout_in_minutes"].copy()
-    clean = clean.where(clean.between(-720, 720))  # cap to +/-12h
-    df["clean_delay"] = clean
-
-    # overlap & wait for next
-    cond = df["has_gap"] & df["clean_delay"].notnull()
-    df["overlap_problem"] = False
-    df.loc[cond, "overlap_problem"] = df.loc[cond, "clean_delay"] > df.loc[cond, "time_delta_with_previous_rental_in_minutes"]
-    df["wait_for_next_minutes"] = 0.0
-    df.loc[cond, "wait_for_next_minutes"] = (df.loc[cond, "clean_delay"] - df.loc[cond, "time_delta_with_previous_rental_in_minutes"]).clip(lower=0)
-
-    # detect a revenue column if available
-    candidates = {"owner_revenue","rental_price","price","price_eur","revenue"}
-    rev_col = next((c for c in df.columns if c.lower() in candidates), None)
-    df.attrs["revenue_col"] = rev_col
+    
+    # Create helper columns
+    df["has_previous_rental"] = df["time_delta_with_previous_rental_in_minutes"].notnull()
+    
+    # Clean delay data (remove extreme outliers - more than 12 hours)
+    df["clean_delay"] = df["delay_at_checkout_in_minutes"].copy()
+    df["clean_delay"] = df["clean_delay"].where(df["clean_delay"].between(-720, 720))
+    
+    # Calculate problematic cases
+    df["is_late"] = (df["clean_delay"] > 0) & df["has_previous_rental"]
+    df["causes_problem"] = False
+    df["wait_time_next_driver"] = 0
+    
+    # For rentals with previous rentals, check if delay causes overlap
+    mask = df["has_previous_rental"] & df["clean_delay"].notnull()
+    df.loc[mask, "causes_problem"] = (
+        df.loc[mask, "clean_delay"] > df.loc[mask, "time_delta_with_previous_rental_in_minutes"]
+    )
+    df.loc[mask, "wait_time_next_driver"] = np.maximum(
+        0, 
+        df.loc[mask, "clean_delay"] - df.loc[mask, "time_delta_with_previous_rental_in_minutes"]
+    )
+    
     return df
 
-df = load_data()
-REVENUE_COL = df.attrs.get("revenue_col")
-
-# ------- Helpers -------
-def filter_scope(data, scope):
+# Analysis functions
+def calculate_impact_metrics(df, threshold_minutes, scope="all"):
+    """Calculate key metrics for given threshold and scope"""
+    
+    # Filter by scope
     if scope == "connect":
-        return data[data["checkin_type"].str.lower() == "connect"]
-    return data
-
-def metrics_for(data, threshold):
-    """Compute all decision metrics for given data scope + threshold."""
-    d = data.copy()
-    d_gap = d[d["has_gap"]].copy()
-    if d_gap.empty:
-        return dict(
-            rentals_with_gap=0, blocked=0, blocked_rate=0.0,
-            problems_today=0, overlap_rate=0.0, solved=0, solve_rate=0.0,
-            avg_wait=np.nan, revenue_share_blocked=np.nan
-        )
-    d_gap["blocked"] = d_gap["time_delta_with_previous_rental_in_minutes"] < threshold
-    d_gap["solved"]  = d_gap["overlap_problem"] & d_gap["blocked"]
-
-    rentals_with_gap = len(d_gap)
-    blocked = int(d_gap["blocked"].sum())
-    blocked_rate = blocked / rentals_with_gap
-    problems_today = int(d_gap["overlap_problem"].sum())
-    overlap_rate = problems_today / rentals_with_gap
-    solved = int(d_gap["solved"].sum())
-    solve_rate = solved / blocked if blocked > 0 else 0.0
-    avg_wait = d_gap.loc[d_gap["overlap_problem"], "wait_for_next_minutes"].mean()
-
-    # revenue share blocked
-    if REVENUE_COL:
-        rev = pd.to_numeric(d[REVENUE_COL], errors="coerce")
-        rev_total = rev.sum(skipna=True)
-        rev_blocked = pd.to_numeric(d_gap.loc[d_gap["blocked"], REVENUE_COL], errors="coerce").sum(skipna=True)
-        revenue_share_blocked = (rev_blocked / rev_total) if rev_total > 0 else np.nan
+        df_filtered = df[df["checkin_type"].str.lower() == "connect"].copy()
     else:
-        revenue_share_blocked = np.nan
-
-    return dict(
-        rentals_with_gap=rentals_with_gap,
-        blocked=blocked,
-        blocked_rate=blocked_rate,
-        problems_today=problems_today,
-        overlap_rate=overlap_rate,
-        solved=solved,
-        solve_rate=solve_rate,
-        avg_wait=avg_wait,
-        revenue_share_blocked=revenue_share_blocked
-    )
+        df_filtered = df.copy()
+    
+    # Only consider rentals with previous rentals
+    df_with_prev = df_filtered[df_filtered["has_previous_rental"]].copy()
+    
+    if len(df_with_prev) == 0:
+        return {
+            "total_rentals": len(df_filtered),
+            "rentals_with_previous": 0,
+            "blocked_rentals": 0,
+            "blocked_percentage": 0.0,
+            "current_problems": 0,
+            "problems_solved": 0,
+            "problem_solve_rate": 0.0,
+            "avg_wait_time": 0.0,
+            "revenue_impact": 0.0
+        }
+    
+    # Calculate blocked rentals
+    df_with_prev["would_be_blocked"] = df_with_prev["time_delta_with_previous_rental_in_minutes"] < threshold_minutes
+    
+    # Calculate solved problems
+    df_with_prev["problem_solved"] = df_with_prev["causes_problem"] & df_with_prev["would_be_blocked"]
+    
+    # Calculate metrics
+    total_rentals = len(df_filtered)
+    rentals_with_previous = len(df_with_prev)
+    blocked_rentals = df_with_prev["would_be_blocked"].sum()
+    blocked_percentage = (blocked_rentals / rentals_with_previous) * 100
+    current_problems = df_with_prev["causes_problem"].sum()
+    problems_solved = df_with_prev["problem_solved"].sum()
+    problem_solve_rate = (problems_solved / blocked_rentals * 100) if blocked_rentals > 0 else 0
+    avg_wait_time = df_with_prev[df_with_prev["causes_problem"]]["wait_time_next_driver"].mean()
+    
+    # Revenue impact (approximate as percentage of blocked rentals)
+    revenue_impact = blocked_percentage
+    
+    return {
+        "total_rentals": total_rentals,
+        "rentals_with_previous": rentals_with_previous,
+        "blocked_rentals": blocked_rentals,
+        "blocked_percentage": blocked_percentage,
+        "current_problems": current_problems,
+        "problems_solved": problems_solved,
+        "problem_solve_rate": problem_solve_rate,
+        "avg_wait_time": avg_wait_time if not pd.isna(avg_wait_time) else 0,
+        "revenue_impact": revenue_impact
+    }
+
+def create_threshold_comparison(df):
+    """Create comparison data for different thresholds"""
+    thresholds = range(0, 301, 30)  # 0 to 300 minutes, step 30
+    
+    results = []
+    for threshold in thresholds:
+        for scope in ["all", "connect"]:
+            metrics = calculate_impact_metrics(df, threshold, scope)
+            results.append({
+                "threshold": threshold,
+                "scope": "All Cars" if scope == "all" else "Connect Only",
+                **metrics
+            })
+    
+    return pd.DataFrame(results)
+
+# Load data
+with st.spinner("Loading data..."):
+    df = load_data()
+
+# Main title
+st.markdown('<h1 class="main-header">🚗 Getaround Delay Analysis Dashboard</h1>', unsafe_allow_html=True)
+
+# Sidebar controls
+st.sidebar.markdown("## 🎛️ Dashboard Controls")
+threshold = st.sidebar.slider(
+    "Minimum Delay Threshold (minutes)", 
+    min_value=0, max_value=300, value=120, step=15,
+    help="Select the minimum delay between consecutive rentals"
+)
 
-def sweep_thresholds(data, thresholds):
-    rows = []
-    for t in thresholds:
-        m = metrics_for(data, t)
-        rows.append({"threshold": t, **m})
-    return pd.DataFrame(rows)
-
-# ------- Sidebar controls -------
-st.sidebar.header("Controls")
-threshold = st.sidebar.slider("Minimum delay (minutes)", 15, 180, step=15, value=90)
-scope = st.sidebar.radio("Scope", options=["all", "connect"], format_func=lambda s: "All cars" if s=="all" else "Connect only", horizontal=True)
-thresholds = list(range(15, 181, 15))
-df_scope = filter_scope(df, scope)
-
-# =========================================================
-# SECTION 1 — THRESHOLD DECISION
-# =========================================================
-st.title("Decision 1 — Threshold (minimum delay between rentals)")
-
-# Current-threshold KPIs
-m_now = metrics_for(df_scope, threshold)
-k1,k2,k3,k4,k5 = st.columns(5)
-k1.metric("Rentals with gap", f"{m_now['rentals_with_gap']:,}")
-k2.metric("Blocked rentals", f"{m_now['blocked']:,}")
-k3.metric("Blocked rate", f"{m_now['blocked_rate']:.1%}")
-k4.metric("Problems solved", f"{m_now['solved']:,}")
-k5.metric("Solve rate (given blocked)", f"{m_now['solve_rate']:.1%}")
-
-k6,k7 = st.columns(2)
-k6.metric("Overlap problems today", f"{m_now['problems_today']:,}")
-k7.metric("Avg wait among impacted (min)", f"{(m_now['avg_wait'] or 0):.1f}")
-
-if REVENUE_COL:
-    st.caption(f"Revenue field detected: **{REVENUE_COL}**")
-    st.metric("Share of owner revenue blocked", f"{(m_now['revenue_share_blocked'] or 0):.1%}")
-else:
-    st.info("No revenue column found. Revenue impact graphs will use **% of rentals blocked** as a proxy.")
-
-# Threshold sweep (current scope)
-st.subheader("How metrics evolve with the threshold (current scope)")
-sweep_df = sweep_thresholds(df_scope, thresholds)
-
-c1, c2 = st.columns(2)
-with c1:
-    fig, ax = plt.subplots(figsize=(6,4))
-    ax.plot(sweep_df["threshold"], sweep_df["blocked_rate"], marker="o", label="Blocked rate (of with-gap)")
-    ax.plot(sweep_df["threshold"], sweep_df["solve_rate"], marker="o", label="Solve rate (given blocked)")
-    ax.set_xlabel("Threshold (minutes)")
-    ax.set_ylabel("Rate")
-    ax.legend()
-    st.pyplot(fig, clear_figure=True)
-
-with c2:
-    fig, ax = plt.subplots(figsize=(6,4))
-    ax.plot(sweep_df["threshold"], sweep_df["solved"], marker="o")
-    ax.set_xlabel("Threshold (minutes)")
-    ax.set_ylabel("Problems solved (count)")
-    ax.set_title("Problems solved vs threshold")
-    st.pyplot(fig, clear_figure=True)
-
-# Required analysis: How often late & impact next driver
-st.subheader("How often are drivers late, and how much does it impact the next driver?")
-d_lat = df_scope[df_scope["overlap_problem"]]
-colA, colB = st.columns(2)
-with colA:
-    rate = (len(d_lat) / max(1, df_scope["has_gap"].sum()))
-    st.metric("Overlap (late beyond gap) rate", f"{rate:.1%}")
-with colB:
-    st.metric("Avg wait for impacted next driver (min)", f"{d_lat['wait_for_next_minutes'].mean():.1f}")
-
-fig, ax = plt.subplots(figsize=(6,4))
-ax.hist(d_lat["wait_for_next_minutes"].dropna(), bins=30)
-ax.set_xlabel("Wait for next driver (minutes)")
-ax.set_ylabel("Count of rentals")
-ax.set_title("Distribution of wait time when overlaps occur")
-st.pyplot(fig, clear_figure=True)
-
-# Required analysis: Share of owner revenue affected (or proxy)
-st.subheader("Which share of owner revenue would be affected?")
-if REVENUE_COL:
-    tmp = []
-    for t in thresholds:
-        m = metrics_for(df_scope, t)
-        tmp.append((t, m["revenue_share_blocked"]))
-    rev_df = pd.DataFrame(tmp, columns=["threshold","revenue_share_blocked"]).dropna()
-    fig, ax = plt.subplots(figsize=(6,4))
-    ax.plot(rev_df["threshold"], rev_df["revenue_share_blocked"], marker="o")
-    ax.set_xlabel("Threshold (minutes)")
-    ax.set_ylabel("Revenue share blocked")
-    st.pyplot(fig, clear_figure=True)
-else:
-    fig, ax = plt.subplots(figsize=(6,4))
-    ax.plot(sweep_df["threshold"], sweep_df["blocked_rate"], marker="o")
-    ax.set_xlabel("Threshold (minutes)")
-    ax.set_ylabel("Share of rentals blocked (proxy)")
-    st.pyplot(fig, clear_figure=True)
-
-# ---- Automatic, data-driven threshold suggestion (transparent rule)
-# Rule: choose threshold maximizing "problems solved" while keeping blocked_rate <= cap.
-# You can tweak cap below; default 15% of with-gap rentals.
-BLOCKED_RATE_CAP = 0.15
-candidates = sweep_df[sweep_df["blocked_rate"] <= BLOCKED_RATE_CAP]
-if not candidates.empty:
-    best_row = candidates.sort_values(["solved","solve_rate","threshold"], ascending=[False,False,True]).iloc[0]
-    suggested_threshold = int(best_row["threshold"])
-else:
-    # If all thresholds exceed the cap, pick the one with best ratio solved/blocked
-    sweep_df["efficiency"] = sweep_df["solved"] / sweep_df["blocked"].replace({0:np.nan})
-    best_row = sweep_df.sort_values(["efficiency","solved"], ascending=False).iloc[0]
-    suggested_threshold = int(best_row["threshold"])
-
-st.markdown("**Threshold Recommendation (based on current scope):**")
-st.success(
-    f"Set the minimum delay to **{suggested_threshold} minutes** — "
-    f"it solves **{int(best_row['solved']):,}** problematic cases while keeping the "
-    f"blocked rate at **{best_row['blocked_rate']:.1%}**."
+scope = st.sidebar.selectbox(
+    "Scope of Implementation",
+    options=["all", "connect"],
+    format_func=lambda x: "All Cars" if x == "all" else "Connect Cars Only",
+    help="Choose whether to apply the delay to all cars or just Connect cars"
 )
 
-st.markdown("---")
+# Data overview
+st.markdown('<div class="section-header">📊 Data Overview</div>', unsafe_allow_html=True)
+
+col1, col2, col3, col4 = st.columns(4)
+with col1:
+    st.metric("Total Rentals", f"{len(df):,}")
+with col2:
+    st.metric("Connect Rentals", f"{len(df[df['checkin_type'].str.lower() == 'connect']):,}")
+with col3:
+    st.metric("Mobile Rentals", f"{len(df[df['checkin_type'].str.lower() == 'mobile']):,}")
+with col4:
+    st.metric("Rentals with Previous", f"{df['has_previous_rental'].sum():,}")
+
+# Current situation analysis
+st.markdown('<div class="section-header">🔍 Current Situation Analysis</div>', unsafe_allow_html=True)
+
+current_metrics = calculate_impact_metrics(df, 0, scope)  # 0 threshold = current situation
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown("### Late Return Frequency")
+    
+    # Calculate late return stats
+    late_returns = df[df["is_late"] & df["has_previous_rental"]]
+    total_with_prev = df[df["has_previous_rental"]]
+    late_percentage = (len(late_returns) / len(total_with_prev)) * 100 if len(total_with_prev) > 0 else 0
+    
+    st.metric("Late Returns", f"{len(late_returns):,} ({late_percentage:.1f}%)")
+    st.metric("Cause Problems", f"{current_metrics['current_problems']:,}")
+    st.metric("Average Wait Time", f"{current_metrics['avg_wait_time']:.1f} min")
+
+with col2:
+    st.markdown("### Delay Distribution")
+    
+    # Create delay distribution plot
+    fig = px.histogram(
+        df[df["clean_delay"].notnull() & df["has_previous_rental"]], 
+        x="clean_delay", 
+        nbins=50,
+        title="Distribution of Checkout Delays",
+        labels={"clean_delay": "Delay at Checkout (minutes)", "count": "Number of Rentals"}
+    )
+    fig.add_vline(x=0, line_dash="dash", line_color="red", annotation_text="On Time")
+    st.plotly_chart(fig, use_container_width=True)
 
-# =========================================================
-# SECTION 2 — SCOPE DECISION (All cars vs Connect only)
-# =========================================================
-st.title("Decision 2 — Scope (apply to all cars or Connect only?)")
-
-# Build threshold sweeps for both scopes
-df_all = filter_scope(df, "all")
-df_conn = filter_scope(df, "connect")
-sweep_all = sweep_thresholds(df_all, thresholds).assign(scope="All cars")
-sweep_con = sweep_thresholds(df_conn, thresholds).assign(scope="Connect only")
-cmp = pd.concat([sweep_all, sweep_con], ignore_index=True)
-
-# Required analysis: rentals affected vs threshold & scope
-st.subheader("How many rentals would be affected by threshold & scope?")
-fig, ax = plt.subplots(figsize=(7,4))
-for label, g in cmp.groupby("scope"):
-    ax.plot(g["threshold"], g["blocked"], marker="o", label=label)
-ax.set_xlabel("Threshold (minutes)")
-ax.set_ylabel("Blocked rentals (count, with-gap only)")
-ax.legend()
-st.pyplot(fig, clear_figure=True)
-
-# Required analysis: problematic cases solved vs threshold & scope
-st.subheader("How many problematic cases will be solved?")
-fig, ax = plt.subplots(figsize=(7,4))
-for label, g in cmp.groupby("scope"):
-    ax.plot(g["threshold"], g["solved"], marker="o", label=label)
-ax.set_xlabel("Threshold (minutes)")
-ax.set_ylabel("Problems solved (count)")
-ax.legend()
-st.pyplot(fig, clear_figure=True)
-
-# Efficiency plot: solved per blocked (avoid harming availability)
-st.subheader("Efficiency: problems solved per blocked rental")
-cmp_eff = cmp.copy()
-cmp_eff["efficiency"] = cmp_eff["solved"] / cmp_eff["blocked"].replace({0:np.nan})
-fig, ax = plt.subplots(figsize=(7,4))
-for label, g in cmp_eff.groupby("scope"):
-    ax.plot(g["threshold"], g["efficiency"], marker="o", label=label)
-ax.set_xlabel("Threshold (minutes)")
-ax.set_ylabel("Solved / Blocked")
-ax.legend()
-st.pyplot(fig, clear_figure=True)
-
-# Revenue share by scope (or proxy)
-st.subheader("Share of owner revenue affected (by scope)")
-if REVENUE_COL:
-    rows = []
-    for sc, dat in [("All cars", df_all), ("Connect only", df_conn)]:
-        for t in thresholds:
-            m = metrics_for(dat, t)
-            rows.append({"scope": sc, "threshold": t, "revenue_share_blocked": m["revenue_share_blocked"]})
-    rev_cmp = pd.DataFrame(rows).dropna()
-    fig, ax = plt.subplots(figsize=(7,4))
-    for label, g in rev_cmp.groupby("scope"):
-        ax.plot(g["threshold"], g["revenue_share_blocked"], marker="o", label=label)
-    ax.set_xlabel("Threshold (minutes)")
-    ax.set_ylabel("Revenue share blocked")
-    ax.legend()
-    st.pyplot(fig, clear_figure=True)
-else:
-    fig, ax = plt.subplots(figsize=(7,4))
-    for label, g in cmp.groupby("scope"):
-        ax.plot(g["threshold"], g["blocked_rate"], marker="o", label=label)
-    ax.set_xlabel("Threshold (minutes)")
-    ax.set_ylabel("Share of rentals blocked (proxy)")
-    ax.legend()
-    st.pyplot(fig, clear_figure=True)
-
-# ---- Scope recommendation (transparent rule)
-# Pick, at your chosen threshold, the scope with (a) more problems solved,
-# and (b) lower or comparable blocked rate; if tie, pick higher efficiency.
-m_all  = metrics_for(df_all, threshold)
-m_conn = metrics_for(df_conn, threshold)
-
-def efficiency(m): 
-    return (m["solved"] / m["blocked"]) if m["blocked"] > 0 else 0.0
-
-choice = "All cars"
-reason = ""
-if (m_conn["solved"] > m_all["solved"]) and (m_conn["blocked_rate"] <= m_all["blocked_rate"]):
-    choice = "Connect only"
-elif (abs(m_conn["solved"] - m_all["solved"]) <= 2) and (m_conn["blocked_rate"] + 0.01 < m_all["blocked_rate"]):
-    choice = "Connect only"
-else:
-    # tie-breaker on efficiency
-    if efficiency(m_conn) > efficiency(m_all) and m_conn["blocked_rate"] <= m_all["blocked_rate"] + 0.01:
-        choice = "Connect only"
-
-if choice == "Connect only":
-    reason = (
-        f"At **{threshold} min**, Connect-only solves **{m_conn['solved']:,}** vs **{m_all['solved']:,}** "
-        f"problems, with a blocked rate of **{m_conn['blocked_rate']:.1%}** vs **{m_all['blocked_rate']:.1%}**."
+# Impact analysis with selected threshold
+st.markdown('<div class="section-header">⚖️ Impact Analysis</div>', unsafe_allow_html=True)
+
+metrics = calculate_impact_metrics(df, threshold, scope)
+
+col1, col2, col3, col4 = st.columns(4)
+with col1:
+    st.metric(
+        "Blocked Rentals", 
+        f"{metrics['blocked_rentals']:,}",
+        help="Number of rentals that would be blocked by the minimum delay"
     )
-else:
-    reason = (
-        f"At **{threshold} min**, All cars solves **{m_all['solved']:,}** vs **{m_conn['solved']:,}** "
-        f"problems, with a blocked rate of **{m_all['blocked_rate']:.1%}** vs **{m_conn['blocked_rate']:.1%}**."
+with col2:
+    st.metric(
+        "Blocked Rate", 
+        f"{metrics['blocked_percentage']:.1f}%",
+        help="Percentage of rentals with previous rental that would be blocked"
+    )
+with col3:
+    st.metric(
+        "Problems Solved", 
+        f"{metrics['problems_solved']:,}",
+        help="Number of current problematic cases that would be prevented"
+    )
+with col4:
+    st.metric(
+        "Solve Efficiency", 
+        f"{metrics['problem_solve_rate']:.1f}%",
+        help="Percentage of blocked rentals that actually solve a problem"
     )
 
-st.markdown("**Scope Recommendation (at your selected threshold):**")
-st.success(f"Apply to **{choice}**. {reason}")
+# Threshold comparison analysis
+st.markdown('<div class="section-header">📈 Threshold Comparison Analysis</div>', unsafe_allow_html=True)
 
-# ------- Method note (expandable) -------
-with st.expander("How we compute metrics (transparency)"):
-    st.markdown("""
-- **Overlap problem (today):** `delay_at_checkout_in_minutes (cleaned) > time_delta_with_previous_rental_in_minutes`
-- **Next-driver wait:** `max(delay - gap, 0)`
-- **Blocked by buffer:** `gap < threshold`
-- **Solved by buffer:** `overlap_problem AND blocked`
-- **Blocked rate:** `blocked / rentals_with_gap`
-- **Solve rate:** `solved / blocked`
-- **Revenue share blocked:** sum(revenue for blocked) / sum(revenue all), if a revenue column exists.
+with st.spinner("Calculating threshold impacts..."):
+    comparison_df = create_threshold_comparison(df)
+
+# Create comparison visualizations
+fig = make_subplots(
+    rows=2, cols=2,
+    subplot_titles=("Blocked Rentals vs Threshold", "Problems Solved vs Threshold", 
+                   "Efficiency (Solve Rate) vs Threshold", "Revenue Impact vs Threshold"),
+    specs=[[{"secondary_y": False}, {"secondary_y": False}],
+           [{"secondary_y": False}, {"secondary_y": False}]]
+)
+
+colors = {"All Cars": "#1f77b4", "Connect Only": "#ff7f0e"}
+
+for scope_name in ["All Cars", "Connect Only"]:
+    scope_data = comparison_df[comparison_df["scope"] == scope_name]
+    
+    # Blocked rentals
+    fig.add_trace(
+        go.Scatter(x=scope_data["threshold"], y=scope_data["blocked_rentals"],
+                  mode="lines+markers", name=f"{scope_name}", 
+                  line=dict(color=colors[scope_name]), legendgroup=scope_name),
+        row=1, col=1
+    )
+    
+    # Problems solved
+    fig.add_trace(
+        go.Scatter(x=scope_data["threshold"], y=scope_data["problems_solved"],
+                  mode="lines+markers", name=f"{scope_name}", 
+                  line=dict(color=colors[scope_name]), legendgroup=scope_name, showlegend=False),
+        row=1, col=2
+    )
+    
+    # Efficiency
+    fig.add_trace(
+        go.Scatter(x=scope_data["threshold"], y=scope_data["problem_solve_rate"],
+                  mode="lines+markers", name=f"{scope_name}", 
+                  line=dict(color=colors[scope_name]), legendgroup=scope_name, showlegend=False),
+        row=2, col=1
+    )
+    
+    # Revenue impact
+    fig.add_trace(
+        go.Scatter(x=scope_data["threshold"], y=scope_data["revenue_impact"],
+                  mode="lines+markers", name=f"{scope_name}", 
+                  line=dict(color=colors[scope_name]), legendgroup=scope_name, showlegend=False),
+        row=2, col=2
+    )
+
+fig.update_xaxes(title_text="Threshold (minutes)")
+fig.update_yaxes(title_text="Count", row=1, col=1)
+fig.update_yaxes(title_text="Count", row=1, col=2)
+fig.update_yaxes(title_text="Percentage (%)", row=2, col=1)
+fig.update_yaxes(title_text="Percentage (%)", row=2, col=2)
+
+fig.update_layout(height=600, showlegend=True)
+st.plotly_chart(fig, use_container_width=True)
+
+# Business recommendations
+st.markdown('<div class="section-header">💡 Business Recommendations</div>', unsafe_allow_html=True)
+
+# Find optimal threshold for each scope
+all_cars_data = comparison_df[comparison_df["scope"] == "All Cars"]
+connect_data = comparison_df[comparison_df["scope"] == "Connect Only"]
+
+# Simple optimization: maximize problems solved while keeping blocked rate reasonable
+def find_optimal_threshold(data, max_blocked_rate=15):
+    """Find optimal threshold balancing problem solving and availability"""
+    viable = data[data["blocked_percentage"] <= max_blocked_rate]
+    if len(viable) == 0:
+        viable = data
+    return viable.loc[viable["problems_solved"].idxmax()]
+
+optimal_all = find_optimal_threshold(all_cars_data)
+optimal_connect = find_optimal_threshold(connect_data)
+
+col1, col2 = st.columns(2)
+
+with col1:
+    st.markdown("### 🎯 Recommended Settings - All Cars")
+    st.markdown(f"""
+    <div class="insight-box">
+    <strong>Optimal Threshold:</strong> {optimal_all['threshold']} minutes<br>
+    <strong>Problems Solved:</strong> {optimal_all['problems_solved']:,.0f}<br>
+    <strong>Blocked Rentals:</strong> {optimal_all['blocked_rentals']:,.0f} ({optimal_all['blocked_percentage']:.1f}%)<br>
+    <strong>Efficiency:</strong> {optimal_all['problem_solve_rate']:.1f}%
+    </div>
+    """, unsafe_allow_html=True)
+
+with col2:
+    st.markdown("### 🔌 Recommended Settings - Connect Only")
+    st.markdown(f"""
+    <div class="insight-box">
+    <strong>Optimal Threshold:</strong> {optimal_connect['threshold']} minutes<br>
+    <strong>Problems Solved:</strong> {optimal_connect['problems_solved']:,.0f}<br>
+    <strong>Blocked Rentals:</strong> {optimal_connect['blocked_rentals']:,.0f} ({optimal_connect['blocked_percentage']:.1f}%)<br>
+    <strong>Efficiency:</strong> {optimal_connect['problem_solve_rate']:.1f}%
+    </div>
+    """, unsafe_allow_html=True)
+
+# Final recommendation
+if optimal_connect['problem_solve_rate'] > optimal_all['problem_solve_rate'] and optimal_connect['blocked_percentage'] < optimal_all['blocked_percentage']:
+    recommendation = "Connect Only"
+    rec_data = optimal_connect
+else:
+    recommendation = "All Cars"
+    rec_data = optimal_all
+
+st.markdown("### 🏆 Final Recommendation")
+st.success(f"""
+**Recommended Strategy:** Apply {rec_data['threshold']:.0f}-minute minimum delay to **{recommendation}**
+
+**Key Benefits:**
+- Solves {rec_data['problems_solved']:.0f} problematic cases
+- Blocks only {rec_data['blocked_percentage']:.1f}% of consecutive rentals
+- Achieves {rec_data['problem_solve_rate']:.1f}% efficiency in problem solving
+- Minimizes impact on rental availability and revenue
 """)
 
+# Detailed analysis section
+with st.expander("📋 Detailed Analysis & Methodology"):
+    st.markdown("""
+    ### Analysis Methodology
+    
+    **Problem Definition:**
+    - A "problematic case" occurs when a driver returns late AND the delay exceeds the gap to the next rental
+    - This causes the next driver to wait or potentially cancel their reservation
+    
+    **Key Metrics:**
+    - **Blocked Rentals:** Consecutive rentals with gap < threshold that would be prevented
+    - **Problems Solved:** Current problematic cases that would be prevented by the threshold  
+    - **Efficiency:** Percentage of blocked rentals that actually solve a problem
+    - **Revenue Impact:** Approximate percentage of rentals affected (proxy for revenue)
+    
+    **Optimization Logic:**
+    - Maximize problems solved while keeping blocked rate reasonable (≤15%)
+    - Balance customer satisfaction improvements vs. availability reduction
+    - Consider implementation scope (all cars vs. Connect only)
+    
+    **Data Quality Notes:**
+    - Extreme delays (>12 hours) filtered out as likely data errors
+    - Only rentals with previous rentals considered for blocking analysis
+    - Revenue impact estimated based on rental volume (actual revenue data not available)
+    """)
+
+# Footer
 st.markdown("---")
-st.caption("Built for Getaround — answers focused on Threshold & Scope only, with transparent calculations.")
+st.markdown("*Dashboard built for Getaround delay analysis and minimum threshold optimization*")