Update app.py

app.py

@@ -12,7 +12,7 @@ warnings.filterwarnings('ignore')
 
 # ========== PAGE CONFIGURATION ==========
 st.set_page_config(
-    page_title="Getaround Analysis Dashboard",
+    page_title="Getaround Delay Analysis",
     page_icon="🚗",
     layout="wide",
     initial_sidebar_state="expanded"
@@ -60,11 +60,10 @@ st.markdown("""
 </style>
 """, unsafe_allow_html=True)
 
-# ========== DATA LOADING FUNCTION ==========
+# ========== DATA LOADING ==========
 @st.cache_data(show_spinner=False)
 def load_data():
     """Load and preprocess the rental data"""
-    # Try multiple possible file locations
     possible_paths = [
         "get_around_delay_analysis.xlsx",
         "get_around_delay_analysis.csv", 
@@ -80,7 +79,6 @@ def load_data():
                     df = pd.read_excel(path)
                 else:
                     df = pd.read_csv(path)
-                st.sidebar.success(f"✅ Data loaded from: {path}")
                 break
             except Exception as e:
                 continue
@@ -91,16 +89,14 @@ def load_data():
     
     # Clean the data
     df = df.drop(columns=[c for c in df.columns if c.lower().startswith("unnamed")], errors="ignore")
-    
-    # Create helper columns
     df["has_previous_rental"] = df["time_delta_with_previous_rental_in_minutes"].notnull()
-    df["clean_delay"] = df["delay_at_checkout_in_minutes"].clip(-720, 720)  # Cap extreme values
+    df["clean_delay"] = df["delay_at_checkout_in_minutes"].clip(-720, 720)
     
     return df
 
 # ========== ANALYSIS FUNCTIONS ==========
-def calculate_threshold_metrics(df, threshold_minutes, scope="all"):
-    """Calculate metrics for threshold analysis"""
+def calculate_metrics(df, threshold_minutes, scope="all"):
+    """Calculate key metrics for threshold analysis"""
     
     # Filter by scope
     if scope == "connect":
@@ -108,7 +104,6 @@ def calculate_threshold_metrics(df, threshold_minutes, scope="all"):
     else:
         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:
@@ -119,76 +114,36 @@ def calculate_threshold_metrics(df, threshold_minutes, scope="all"):
             "blocked_percentage": 0.0,
             "current_problems": 0,
             "problems_solved": 0,
-            "problem_solve_rate": 0.0,
-            "avg_wait_time": 0.0,
-            "revenue_impact_percent": 0.0,
-            "current_cancellations": 0,
-            "cancellations_prevented": 0,
-            "cancellation_rate": 0.0
+            "solve_efficiency": 0.0,
+            "revenue_impact": 0.0
         }
     
-    # Join with previous rental data to get actual delay information
+    # Join with previous rental data
     prev_rental_data = df[["rental_id", "delay_at_checkout_in_minutes"]].rename(
         columns={"rental_id": "previous_ended_rental_id", 
                 "delay_at_checkout_in_minutes": "previous_delay"}
     )
     
-    df_with_prev = df_with_prev.merge(
-        prev_rental_data, 
-        on="previous_ended_rental_id", 
-        how="left"
-    )
+    df_with_prev = df_with_prev.merge(prev_rental_data, on="previous_ended_rental_id", how="left")
     
-    # Calculate blocked rentals (gap < threshold)
+    # Calculate key metrics
     df_with_prev["would_be_blocked"] = df_with_prev["time_delta_with_previous_rental_in_minutes"] < threshold_minutes
-    
-    # Calculate current problems using ACTUAL previous rental delay
     df_with_prev["previous_delay_clean"] = df_with_prev["previous_delay"].clip(-720, 720)
     df_with_prev["causes_problem"] = (
         df_with_prev["previous_delay"].notnull() & 
         (df_with_prev["previous_delay_clean"] > df_with_prev["time_delta_with_previous_rental_in_minutes"])
     )
-    
-    # Wait time calculation using actual previous delay
-    df_with_prev["wait_time_next_driver"] = np.maximum(
-        0, 
-        df_with_prev["previous_delay_clean"] - df_with_prev["time_delta_with_previous_rental_in_minutes"]
-    ).fillna(0)
-    
-    # Problems solved by blocking
     df_with_prev["problem_solved"] = df_with_prev["causes_problem"] & df_with_prev["would_be_blocked"]
     
-    # Cancellation analysis - much more accurate now
-    df_with_prev["is_cancelled"] = df_with_prev["state"] == "canceled"
-    
-    # Cancellations due to previous rental delays (using actual previous delay data)
-    df_with_prev["cancelled_due_to_previous_delay"] = (
-        df_with_prev["is_cancelled"] & df_with_prev["causes_problem"]
-    )
-    
-    # Cancellations that would be prevented by threshold
-    df_with_prev["cancellation_prevented"] = (
-        df_with_prev["cancelled_due_to_previous_delay"] & df_with_prev["would_be_blocked"]
-    )
-    
-    # Calculate final metrics
+    # Final calculations
     total_rentals = len(df_filtered)
     rentals_with_previous = len(df_with_prev)
     blocked_rentals = int(df_with_prev["would_be_blocked"].sum())
     blocked_percentage = (blocked_rentals / rentals_with_previous) * 100 if rentals_with_previous > 0 else 0
     current_problems = int(df_with_prev["causes_problem"].sum())
     problems_solved = int(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_percent = (blocked_rentals / total_rentals) * 100 if total_rentals > 0 else 0
-    
-    # Cancellation metrics - now much more accurate
-    current_cancellations = int(df_with_prev["cancelled_due_to_previous_delay"].sum())
-    cancellations_prevented = int(df_with_prev["cancellation_prevented"].sum())
-    
-    # Remaining cancellation rate after implementing threshold
-    remaining_cancellations = current_cancellations - cancellations_prevented
-    cancellation_rate = (remaining_cancellations / rentals_with_previous) * 100 if rentals_with_previous > 0 else 0
+    solve_efficiency = (problems_solved / blocked_rentals * 100) if blocked_rentals > 0 else 0
+    revenue_impact = (blocked_rentals / total_rentals) * 100 if total_rentals > 0 else 0
     
     return {
         "total_rentals": total_rentals,
@@ -197,419 +152,201 @@ def calculate_threshold_metrics(df, threshold_minutes, scope="all"):
         "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_percent": revenue_impact_percent,
-        "current_cancellations": current_cancellations,
-        "cancellations_prevented": cancellations_prevented,
-        "cancellation_rate": cancellation_rate
+        "solve_efficiency": solve_efficiency,
+        "revenue_impact": revenue_impact
     }
 
-def create_threshold_sweep(df, thresholds, scope="all"):
-    """Create threshold sweep analysis"""
+def create_threshold_analysis(df, thresholds, scope="all"):
+    """Create threshold analysis data"""
     results = []
     for threshold in thresholds:
-        metrics = calculate_threshold_metrics(df, threshold, scope)
+        metrics = calculate_metrics(df, threshold, scope)
         results.append({"threshold": threshold, **metrics})
     return pd.DataFrame(results)
 
-def find_optimal_threshold(sweep_df, max_blocked_rate=25):
-    """Find optimal threshold using improved business logic"""
-    # Only consider thresholds that actually solve problems (> 0 problems solved)
-    viable = sweep_df[
-        (sweep_df["problems_solved"] > 0) & 
-        (sweep_df["threshold"] >= 30) &  # Minimum reasonable threshold
-        (sweep_df["threshold"] <= 180)  # Don't recommend unreasonably long thresholds
-    ]
-    
-    if len(viable) == 0:
-        # If no viable options, return a reasonable default
-        return sweep_df[sweep_df["threshold"] == 90].iloc[0]
-    
-    # Calculate efficiency and other metrics
-    viable["efficiency"] = viable["problems_solved"] / viable["blocked_rentals"].replace({0: np.nan})
-    viable["problems_per_threshold"] = viable["problems_solved"] / viable["threshold"]
-    
-    # Find the "knee" of the problems solved curve - where gains start diminishing
-    viable = viable.sort_values("threshold")
-    viable["problems_marginal_gain"] = viable["problems_solved"].diff().fillna(0)
-    
-    # Look for thresholds that solve significant problems with reasonable efficiency
-    # Priority: solve at least 70% of max problems solvable, with good efficiency
-    max_problems = viable["problems_solved"].max()
-    good_performers = viable[
-        (viable["problems_solved"] >= max_problems * 0.7) & 
-        (viable["efficiency"] >= 20) &  # At least 20% efficiency
-        (viable["blocked_percentage"] <= max_blocked_rate)
-    ]
-    
-    if len(good_performers) == 0:
-        # Fallback: just find best efficiency among those solving good number of problems
-        good_problems = viable[viable["problems_solved"] >= max_problems * 0.6]
-        if len(good_problems) > 0:
-            optimal = good_problems.sort_values(["efficiency", "problems_solved"], ascending=[False, False]).iloc[0]
-        else:
-            optimal = viable.sort_values(["problems_solved", "efficiency"], ascending=[False, False]).iloc[0]
-    else:
-        # Among good performers, prefer lower threshold with high efficiency
-        optimal = good_performers.sort_values(["efficiency", "threshold"], ascending=[False, True]).iloc[0]
-    
-    return optimal
-
 # ========== LOAD DATA ==========
 df = load_data()
 
-# ========== SIDEBAR NAVIGATION ==========
-st.markdown('<h1 class="main-header">🚗 Getaround Analysis Dashboard</h1>', unsafe_allow_html=True)
+# ========== MAIN DASHBOARD ==========
+st.markdown('<h1 class="main-header">🚗 Getaround Delay Analysis</h1>', unsafe_allow_html=True)
 
+# Sidebar
 with st.sidebar:
-    st.markdown("## 🎛️ Navigation")
+    st.markdown("## 🎛️ Analysis Controls")
+    
     selected = option_menu(
-        "Analysis Sections",
-        ["📊 Data Overview", "🕐 Threshold Analysis", "🎯 Scope Analysis"],
-        icons=["bar-chart", "clock", "target"],
+        "Analysis Focus",
+        ["📊 Overview & Problems", "🎯 Threshold & Scope"],
+        icons=["bar-chart", "target"],
         menu_icon="cast",
         default_index=0,
     )
     
+    if selected == "🎯 Threshold & Scope":
+        st.markdown("### Controls")
+        threshold = st.slider("🕐 Threshold (minutes)", 0, 300, 90, step=30,
+                             help="Minimum delay between consecutive rentals")
+        scope = st.selectbox("🚗 Scope", ["all", "connect"],
+                            format_func=lambda x: "All Cars" if x == "all" else "Connect Cars Only")
+    
     st.markdown("---")
     st.markdown("### 📈 Dataset Info")
     st.info(f"""
     **Total Rentals:** {len(df):,}
-    **With Previous Rental:** {df['has_previous_rental'].sum():,} *(rentals that had another rental on the same car before)*
     **Connect Rentals:** {len(df[df['checkin_type'].str.lower() == 'connect']):,}
-    **Mobile Rentals:** {len(df[df['checkin_type'].str.lower() == 'mobile']):,}
+    **Cancelled Rentals:** {len(df[df['state'] == 'canceled']):,}
+    **With Previous Rental:** {df['has_previous_rental'].sum():,}
     """)
 
-# ========== PAGE 1: DATA OVERVIEW ==========
-if selected == "📊 Data Overview":
-    st.title("📊 Dataset Overview & Exploratory Analysis")
+# ========== PAGE 1: OVERVIEW & PROBLEMS ==========
+if selected == "📊 Overview & Problems":
+    st.title("📊 Understanding the Delay Problem")
     
-    st.markdown('<div class="section-header">📈 Dataset Summary</div>', unsafe_allow_html=True)
+    # Key Problem Analysis
+    st.markdown('<div class="section-header">🚨 Current Problem Scope</div>', unsafe_allow_html=True)
     
-    # Basic statistics
+    # Calculate current problems
+    df_problems = df[df["has_previous_rental"]].copy()
+    prev_rental_data = df[["rental_id", "delay_at_checkout_in_minutes"]].rename(
+        columns={"rental_id": "previous_ended_rental_id", 
+                "delay_at_checkout_in_minutes": "previous_delay"}
+    )
+    df_problems = df_problems.merge(prev_rental_data, on="previous_ended_rental_id", how="left")
+    df_problems["previous_delay_clean"] = df_problems["previous_delay"].clip(-720, 720)
+    df_problems["causes_problem"] = (
+        df_problems["previous_delay"].notnull() & 
+        (df_problems["previous_delay_clean"] > df_problems["time_delta_with_previous_rental_in_minutes"])
+    )
+    df_problems["wait_time"] = np.maximum(
+        0, 
+        df_problems["previous_delay_clean"] - df_problems["time_delta_with_previous_rental_in_minutes"]
+    ).fillna(0)
+    
+    problem_cases = df_problems[df_problems["causes_problem"]]
+    
+    # Key metrics
     col1, col2, col3, col4 = st.columns(4)
     with col1:
-        st.metric("Total Rentals", f"{len(df):,}")
+        st.metric("Problem Cases", f"{len(problem_cases):,}",
+                 help="Rentals where previous delay caused waiting")
     with col2:
-        st.metric("Connect Rentals", f"{len(df[df['checkin_type'].str.lower() == 'connect']):,}")
+        problem_rate = (len(problem_cases) / len(df_problems)) * 100 if len(df_problems) > 0 else 0
+        st.metric("Problem Rate", f"{problem_rate:.1f}%")
     with col3:
-        st.metric("Cancelled Rentals", f"{len(df[df['state'] == 'canceled']):,}",
-                 help="Total cancelled rentals in dataset")
+        avg_wait = problem_cases["wait_time"].mean() if len(problem_cases) > 0 else 0
+        st.metric("Avg Wait Time", f"{avg_wait:.1f} min")
     with col4:
-        st.metric("With Previous Rental", f"{df['has_previous_rental'].sum():,}", 
-                 help="Rentals that had another rental on the same car before (within 12 hours)")
-    
-    # Checkin type distribution
-    st.markdown('<div class="section-header">🚗 Rental Type Distribution</div>', unsafe_allow_html=True)
-    
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        checkin_counts = df["checkin_type"].value_counts()
-        fig_checkin = px.pie(
-            values=checkin_counts.values, 
-            names=checkin_counts.index,
-            title="Distribution by Checkin Type",
-            color_discrete_sequence=px.colors.qualitative.Set3
-        )
-        st.plotly_chart(fig_checkin, use_container_width=True)
+        delay_cancels = problem_cases[problem_cases["state"] == "canceled"]
+        st.metric("Resulting Cancellations", f"{len(delay_cancels):,}")
     
-    with col2:
-        state_counts = df["state"].value_counts()
-        fig_state = px.pie(
-            values=state_counts.values, 
-            names=state_counts.index,
-            title="Distribution by Rental State",
-            color_discrete_sequence=px.colors.qualitative.Pastel
-        )
-        st.plotly_chart(fig_state, use_container_width=True)
+    st.markdown("""
+    <div class="insight-box">
+    <strong>The Problem:</strong> When drivers return cars late, it creates waiting time for the next customer. 
+    In worst cases, customers cancel their rental due to delays.
+    </div>
+    """, unsafe_allow_html=True)
     
-    # Delay analysis
-    st.markdown('<div class="section-header">⏰ Delay Analysis</div>', unsafe_allow_html=True)
+    # Visual analysis
+    st.markdown('<div class="section-header">📈 Delay Patterns</div>', unsafe_allow_html=True)
     
     col1, col2 = st.columns(2)
     
     with col1:
-        # Delay status distribution (excluding missing data)
+        # Return status distribution
         df_with_delay_data = df[df["delay_at_checkout_in_minutes"].notnull()].copy()
         df_with_delay_data["delay_status"] = df_with_delay_data["delay_at_checkout_in_minutes"].apply(
             lambda x: "Early Return" if x < 0 else "On Time" if x == 0 else "Late Return"
         )
         
         delay_counts = df_with_delay_data["delay_status"].value_counts()
-        fig_delay_status = px.pie(
+        fig_status = px.pie(
             values=delay_counts.values, 
             names=delay_counts.index,
-            title="Return Status Distribution (Data Available Only)",
-            color_discrete_sequence=px.colors.qualitative.Bold
-        )
-        fig_delay_status.update_layout(
-            annotations=[dict(text=f"Based on {len(df_with_delay_data):,} rentals with delay data", 
-                            x=0.5, y=-0.1, xref="paper", yref="paper", 
-                            showarrow=False, font=dict(size=10))]
+            title="Return Status Distribution",
+            color_discrete_sequence=px.colors.qualitative.Set3
         )
-        st.plotly_chart(fig_delay_status, use_container_width=True)
+        st.plotly_chart(fig_status, use_container_width=True)
     
     with col2:
-        # Delay distribution histogram (starting from 0, showing early returns clearly)
-        delay_data = df[df["delay_at_checkout_in_minutes"].notnull()]
-        delay_filtered = delay_data[delay_data["delay_at_checkout_in_minutes"].between(-120, 300)]
-        
-        fig_delay_hist = px.histogram(
+        # Delay distribution
+        delay_filtered = df_with_delay_data[df_with_delay_data["delay_at_checkout_in_minutes"].between(-60, 240)]
+        fig_hist = px.histogram(
             delay_filtered, 
             x="delay_at_checkout_in_minutes",
-            nbins=50,
-            title="Checkout Delay Distribution",
-            labels={"delay_at_checkout_in_minutes": "Minutes (Negative = Early Return)", "count": "Number of Rentals"}
+            nbins=30,
+            title="Delay Distribution",
+            labels={"delay_at_checkout_in_minutes": "Delay (minutes)", "count": "Rentals"}
         )
-        fig_delay_hist.add_vline(x=0, line_dash="dash", line_color="red", annotation_text="On Time")
-        fig_delay_hist.add_annotation(x=-60, y=delay_filtered.shape[0]*0.1, text="Early Returns", 
-                                    showarrow=True, arrowhead=2, arrowcolor="blue")
-        fig_delay_hist.add_annotation(x=120, y=delay_filtered.shape[0]*0.1, text="Late Returns", 
-                                    showarrow=True, arrowhead=2, arrowcolor="red")
-        st.plotly_chart(fig_delay_hist, use_container_width=True)
+        fig_hist.add_vline(x=0, line_dash="dash", line_color="red", annotation_text="On Time")
+        st.plotly_chart(fig_hist, use_container_width=True)
     
     # Gap analysis
-    st.markdown('<div class="section-header">📏 Gap Between Rentals Analysis</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-header">📏 Time Gaps Between Rentals</div>', unsafe_allow_html=True)
     
-    col1, col2 = st.columns(2)
+    gap_data = df[df["has_previous_rental"]]
+    gap_filtered = gap_data[gap_data["time_delta_with_previous_rental_in_minutes"].between(0, 480)]
     
-    with col1:
-        # Gap distribution
-        gap_data = df[df["has_previous_rental"]]
-        gap_filtered = gap_data[gap_data["time_delta_with_previous_rental_in_minutes"].between(0, 720)]
-        
-        fig_gap_hist = px.histogram(
-            gap_filtered, 
-            x="time_delta_with_previous_rental_in_minutes",
-            nbins=40,
-            title="Gap Distribution (0 to 720 minutes)",
-            labels={"time_delta_with_previous_rental_in_minutes": "Gap (minutes)", "count": "Number of Rentals"}
-        )
-        st.plotly_chart(fig_gap_hist, use_container_width=True)
-    
-    with col2:
-        # Gap by checkin type
-        fig_gap_box = px.box(
-            gap_filtered, 
-            x="checkin_type", 
-            y="time_delta_with_previous_rental_in_minutes",
-            title="Gap Distribution by Checkin Type",
-            labels={"time_delta_with_previous_rental_in_minutes": "Gap (minutes)"}
-        )
-        st.plotly_chart(fig_gap_box, use_container_width=True)
+    fig_gap = px.histogram(
+        gap_filtered, 
+        x="time_delta_with_previous_rental_in_minutes",
+        nbins=20,
+        title="Gap Distribution Between Consecutive Rentals",
+        labels={"time_delta_with_previous_rental_in_minutes": "Gap (minutes)", "count": "Rentals"}
+    )
+    st.plotly_chart(fig_gap, use_container_width=True)
     
     # Cancellation analysis
-    st.markdown('<div class="section-header">❌ Cancellation Analysis</div>', unsafe_allow_html=True)
+    st.markdown('<div class="section-header">❌ Cancellation Impact</div>', unsafe_allow_html=True)
     
     col1, col2 = st.columns(2)
     
     with col1:
-        st.markdown("### Cancellation by Type")
+        total_cancels_all = (df["state"] == "canceled").sum()
+        delay_related_cancels = (df_problems["state"] == "canceled") & df_problems["causes_problem"]
+        delay_cancel_count = delay_related_cancels.sum()
         
+        st.metric("Total Cancellations", f"{total_cancels_all:,}")
+        st.metric("Due to Previous Delays", f"{delay_cancel_count:,}")
+        if total_cancels_all > 0:
+            delay_cancel_rate = (delay_cancel_count / total_cancels_all * 100)
+            st.metric("% Due to Delays", f"{delay_cancel_rate:.1f}%")
+    
+    with col2:
+        # Cancellation by checkin type
         cancellation_by_type = df.groupby(['checkin_type', 'state']).size().unstack(fill_value=0)
         if 'canceled' in cancellation_by_type.columns:
             cancel_rates = (cancellation_by_type['canceled'] / cancellation_by_type.sum(axis=1) * 100).round(1)
-            
-            fig_cancel_type = px.bar(
+            fig_cancel = px.bar(
                 x=cancel_rates.index, 
                 y=cancel_rates.values,
-                title="Cancellation Rate by Checkin Type",
+                title="Cancellation Rate by Type",
                 labels={"x": "Checkin Type", "y": "Cancellation Rate (%)"}
             )
-            st.plotly_chart(fig_cancel_type, use_container_width=True)
-        else:
-            st.info("No cancellations found in dataset")
-    
-    with col2:
-        st.markdown("### Delay-Related Cancellations")
-        
-        # Calculate accurate delay-related cancellations using previous rental data
-        df_analysis = df[df["has_previous_rental"]].copy()
-        
-        # Join with previous rental delay data
-        prev_rental_data = df[["rental_id", "delay_at_checkout_in_minutes"]].rename(
-            columns={"rental_id": "previous_ended_rental_id", 
-                    "delay_at_checkout_in_minutes": "previous_delay"}
-        )
-        
-        df_analysis = df_analysis.merge(
-            prev_rental_data, 
-            on="previous_ended_rental_id", 
-            how="left"
-        )
-        
-        # Calculate problems using actual previous rental delay
-        df_analysis["previous_delay_clean"] = df_analysis["previous_delay"].clip(-720, 720)
-        df_analysis["causes_problem"] = (
-            df_analysis["previous_delay"].notnull() & 
-            (df_analysis["previous_delay_clean"] > df_analysis["time_delta_with_previous_rental_in_minutes"])
-        )
-        
-        # Cancellations due to previous delay
-        df_analysis["cancelled_due_to_previous_delay"] = (
-            (df_analysis["state"] == "canceled") & df_analysis["causes_problem"]
-        )
-        
-        delay_related_cancels = df_analysis["cancelled_due_to_previous_delay"].sum()
-        total_cancels_with_prev = (df_analysis["state"] == "canceled").sum()
-        total_cancels_all = (df["state"] == "canceled").sum()
-        
-        col2_1, col2_2 = st.columns(2)
-        with col2_1:
-            st.metric("Total Cancellations (All)", f"{total_cancels_all:,}",
-                     help="All cancelled rentals in the dataset")
-        with col2_2:
-            st.metric("Due to Previous Delay", f"{delay_related_cancels:,}",
-                     help="Cancelled rentals where the previous rental on same car was late")
-        
-        if total_cancels_all > 0:
-            delay_cancel_rate = (delay_related_cancels / total_cancels_all * 100)
-            st.metric("% of All Cancellations Due to Previous Delays", f"{delay_cancel_rate:.1f}%")
-            
-        # Additional context
-        st.info(f"Note: {total_cancels_with_prev:,} cancellations had previous rentals (analyzed for delay impact)")
+            st.plotly_chart(fig_cancel, use_container_width=True)
 
-    
-    # Problem cases analysis (including cancellations)
-    st.markdown('<div class="section-header">🚨 Current Problem Cases Analysis</div>', unsafe_allow_html=True)
+# ========== PAGE 2: THRESHOLD & SCOPE ANALYSIS ==========
+elif selected == "🎯 Threshold & Scope":
+    st.title("🎯 Threshold & Scope Decision")
     
     st.markdown("""
     <div class="insight-box">
-    <strong>What is a "Problem Case"?</strong><br>
-    A problem occurs when the PREVIOUS rental on the same car returned late AND this delay exceeds the planned gap to the current rental.
-    This forces the next customer to either wait beyond their scheduled pickup time or cancel their rental.
-    <br><br>
-    <strong>Accurate Formula:</strong> Problem = (previous_rental_delay > gap_to_current_rental) AND (previous_rental_delay > 0)<br>
-    <strong>Data Linking:</strong> Uses previous_ended_rental_id to get actual delay from the previous rental.<br>
-    <strong>Cancellation Impact:</strong> Some of these problems result in cancellations when waiting becomes unacceptable.
+    <strong>Goal:</strong> Find the optimal minimum delay threshold and determine whether to apply it to all cars or just Connect cars.
+    Higher thresholds solve more problems but block more rentals.
     </div>
     """, unsafe_allow_html=True)
     
-    # Calculate problem cases using proper linking to previous rental delays
-    df_problems = df[df["has_previous_rental"]].copy()
-    
-    # Join with previous rental delay data
-    prev_rental_data = df[["rental_id", "delay_at_checkout_in_minutes"]].rename(
-        columns={"rental_id": "previous_ended_rental_id", 
-                "delay_at_checkout_in_minutes": "previous_delay"}
-    )
-    
-    df_problems = df_problems.merge(
-        prev_rental_data, 
-        on="previous_ended_rental_id", 
-        how="left"
-    )
-    
-    # Calculate problems using actual previous rental delay
-    df_problems["previous_delay_clean"] = df_problems["previous_delay"].clip(-720, 720)
-    df_problems["causes_problem"] = (
-        df_problems["previous_delay"].notnull() & 
-        (df_problems["previous_delay_clean"] > df_problems["time_delta_with_previous_rental_in_minutes"])
-    )
-    df_problems["wait_time"] = np.maximum(
-        0, 
-        df_problems["previous_delay_clean"] - df_problems["time_delta_with_previous_rental_in_minutes"]
-    ).fillna(0)
+    # Current impact
+    current_metrics = calculate_metrics(df, threshold, scope)
     
-    problem_cases = df_problems[df_problems["causes_problem"]]
+    st.markdown('<div class="section-header">📊 Impact at Current Settings</div>', unsafe_allow_html=True)
     
     col1, col2, col3, col4 = st.columns(4)
-    with col1:
-        st.metric("Total Problem Cases", f"{len(problem_cases):,}",
-                 help="Number of rentals where late return affected the next customer")
-    with col2:
-        problem_rate = (len(problem_cases) / len(df_problems)) * 100 if len(df_problems) > 0 else 0
-        st.metric("Problem Rate", f"{problem_rate:.1f}%",
-                 help="Percentage of consecutive rentals that create waiting problems")
-    with col3:
-        avg_wait = problem_cases["wait_time"].mean() if len(problem_cases) > 0 else 0
-        st.metric("Avg Wait Time", f"{avg_wait:.1f} min",
-                 help="Average extra wait time for affected next customers (checkout_delay - gap)")
-    with col4:
-        # Add cancellation metric
-        delay_cancels = problem_cases[problem_cases["state"] == "canceled"]
-        st.metric("Resulting Cancellations", f"{len(delay_cancels):,}",
-                 help="Problem cases that resulted in cancellations")
-    
-    if len(problem_cases) > 0:
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # Wait time distribution
-            fig_wait = px.histogram(
-                problem_cases[problem_cases["wait_time"] > 0], 
-                x="wait_time",
-                nbins=30,
-                title="Wait Time Distribution for Problem Cases",
-                labels={"wait_time": "Wait Time (minutes)", "count": "Number of Cases"}
-            )
-            st.plotly_chart(fig_wait, use_container_width=True)
-        
-        with col2:
-            # Problems by checkin type
-            problem_by_type = problem_cases["checkin_type"].value_counts()
-            fig_problems_type = px.bar(
-                x=problem_by_type.index, 
-                y=problem_by_type.values,
-                title="Problem Cases by Checkin Type",
-                labels={"x": "Checkin Type", "y": "Number of Problems"}
-            )
-            st.plotly_chart(fig_problems_type, use_container_width=True)
-    
-    # Raw data sample
-    with st.expander("📋 Raw Data Sample"):
-        st.markdown("### First 100 rows of the dataset:")
-        st.dataframe(df.head(100), use_container_width=True)
-        
-        st.markdown("### Dataset Info:")
-        st.text("Dataset shape: " + str(df.shape))
-        st.text("Columns: " + str(list(df.columns)))
-
-# ========== PAGE 2: THRESHOLD ANALYSIS ==========
-elif selected == "🕐 Threshold Analysis":
-    st.title("⏰ Threshold Decision: How Long Should the Minimum Delay Be?")
-    
-    st.markdown("""
-    <div class="insight-box">
-    <strong>Goal:</strong> Find the optimal minimum delay threshold that balances solving problematic late returns 
-    with maintaining rental availability. A higher threshold solves more problems but blocks more rentals.
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Controls
-    col1, col2 = st.columns(2)
-    with col1:
-        threshold = st.slider("🕐 Threshold (minutes)", 0, 300, 60, step=15,
-                             help="Minimum time gap required between consecutive rentals")
-    with col2:
-        scope_for_threshold = st.selectbox("🚗 Scope for Analysis", ["all", "connect"],
-                                          format_func=lambda x: "All Cars" if x == "all" else "Connect Cars Only")
-    
-    st.markdown("""
-    <div class="insight-box">
-    <strong>How the Metrics Work:</strong><br>
-    • <strong>Blocked Rentals:</strong> Number of current consecutive rentals where gap < threshold (these would be prevented)<br>
-    • <strong>Blocked Rate:</strong> % of consecutive rentals that would be blocked = blocked_rentals / rentals_with_previous<br>
-    • <strong>Problems Solved:</strong> Current problem cases that would be prevented = problems that occur when gap < threshold<br>
-    • <strong>Solve Efficiency:</strong> % of blocked rentals that actually solve a problem = problems_solved / blocked_rentals<br>
-    • <strong>Cancellations Prevented:</strong> Delay-related cancellations that would be avoided with this threshold
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Current metrics at selected threshold
-    current_metrics = calculate_threshold_metrics(df, threshold, scope_for_threshold)
-    
-    st.markdown('<div class="section-header">📊 Current Impact at Selected Threshold</div>', unsafe_allow_html=True)
-    
-    col1, col2, col3, col4, col5 = st.columns(5)
     with col1:
         st.markdown(f"""
         <div class="metric-card">
         <h3 style="color: #e74c3c;">{current_metrics['blocked_rentals']:,}</h3>
         <p>Blocked Rentals</p>
-        <small>Consecutive rentals with gap < {threshold} min</small>
+        <small>Gap < {threshold} min</small>
         </div>
         """, unsafe_allow_html=True)
     
@@ -618,7 +355,7 @@ elif selected == "🕐 Threshold Analysis":
         <div class="metric-card">
         <h3 style="color: #f39c12;">{current_metrics['blocked_percentage']:.1f}%</h3>
         <p>Blocked Rate</p>
-        <small>{current_metrics['blocked_rentals']:,} / {current_metrics['rentals_with_previous']:,} consecutive rentals</small>
+        <small>Of consecutive rentals</small>
         </div>
         """, unsafe_allow_html=True)
     
@@ -627,465 +364,185 @@ elif selected == "🕐 Threshold Analysis":
         <div class="metric-card">
         <h3 style="color: #27ae60;">{current_metrics['problems_solved']:,}</h3>
         <p>Problems Solved</p>
-        <small>Current problems prevented by this threshold</small>
+        <small>Waiting eliminated</small>
         </div>
         """, unsafe_allow_html=True)
     
     with col4:
         st.markdown(f"""
         <div class="metric-card">
-        <h3 style="color: #3498db;">{current_metrics['problem_solve_rate']:.1f}%</h3>
-        <p>Solve Efficiency</p>
-        <small>{current_metrics['problems_solved']:,} / {current_metrics['blocked_rentals']:,} blocked rentals solve problems</small>
+        <h3 style="color: #3498db;">{current_metrics['solve_efficiency']:.1f}%</h3>
+        <p>Efficiency</p>
+        <small>Problems/Blocked</small>
         </div>
         """, unsafe_allow_html=True)
     
-    with col5:
-        st.markdown(f"""
-        <div class="metric-card">
-        <h3 style="color: #9b59b6;">{current_metrics['cancellations_prevented']:,}</h3>
-        <p>Cancellations Prevented</p>
-        <small>Delay-related cancellations avoided</small>
-        </div>
-        """, unsafe_allow_html=True)
-    
-    # Current situation analysis
-    st.markdown('<div class="section-header">🔍 Current Problem Analysis</div>', unsafe_allow_html=True)
-    
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        st.markdown("### Late Return Impact")
-        
-        # Analysis of current problems
-        df_analysis = df[df["has_previous_rental"]].copy()
-        
-        # Join with previous rental delay data
-        prev_rental_data = df[["rental_id", "delay_at_checkout_in_minutes"]].rename(
-            columns={"rental_id": "previous_ended_rental_id", 
-                    "delay_at_checkout_in_minutes": "previous_delay"}
-        )
-        
-        df_analysis = df_analysis.merge(
-            prev_rental_data, 
-            on="previous_ended_rental_id", 
-            how="left"
-        )
-        
-        # Calculate problems using actual previous rental delay
-        df_analysis["previous_delay_clean"] = df_analysis["previous_delay"].clip(-720, 720)
-        df_analysis["causes_problem"] = (
-            df_analysis["previous_delay"].notnull() & 
-            (df_analysis["previous_delay_clean"] > df_analysis["time_delta_with_previous_rental_in_minutes"])
-        )
-        df_analysis["wait_time"] = np.maximum(
-            0, 
-            df_analysis["previous_delay_clean"] - df_analysis["time_delta_with_previous_rental_in_minutes"]
-        ).fillna(0)
-        
-        problematic_cases = df_analysis[df_analysis["causes_problem"]]
-        problem_rate = (len(problematic_cases) / len(df_analysis)) * 100 if len(df_analysis) > 0 else 0
-        avg_wait = problematic_cases["wait_time"].mean() if len(problematic_cases) > 0 else 0
-        
-        st.metric("Current Problems", f"{len(problematic_cases):,} ({problem_rate:.1f}%)")
-        st.metric("Average Wait Time", f"{avg_wait:.1f} min")
-        
-    with col2:
-        st.markdown("### Wait Time Distribution")
-        
-        if len(problematic_cases) > 0:
-            fig_wait = px.histogram(
-                problematic_cases[problematic_cases["wait_time"] > 0], 
-                x="wait_time",
-                nbins=30,
-                title="Distribution of Wait Times (Current Problems)",
-                labels={"wait_time": "Wait Time (minutes)", "count": "Number of Cases"}
-            )
-            fig_wait.update_layout(height=300)
-            st.plotly_chart(fig_wait, use_container_width=True)
-        else:
-            st.info("No problematic cases found in current data")
-    
-    # Threshold sweep analysis
-    st.markdown('<div class="section-header">📈 Threshold Impact Analysis</div>', unsafe_allow_html=True)
+    # Threshold analysis
+    st.markdown('<div class="section-header">📈 Threshold Analysis</div>', unsafe_allow_html=True)
     
     thresholds = list(range(0, 301, 30))
-    sweep_df = create_threshold_sweep(df, thresholds, scope_for_threshold)
+    threshold_data = create_threshold_analysis(df, thresholds, scope)
     
-    # Create comprehensive threshold analysis chart
+    # Create dual-axis chart
     fig = make_subplots(
-        rows=2, cols=3,
-        subplot_titles=(
-            "Blocked Rentals vs Threshold", 
-            "Problems Solved vs Threshold",
-            "Cancellations Prevented vs Threshold",
-            "Efficiency (Solve Rate) vs Threshold", 
-            "Revenue Impact vs Threshold",
-            "Remaining Cancellation Rate vs Threshold"
-        )
-    )
-    
-    # Blocked rentals
-    fig.add_trace(
-        go.Scatter(x=sweep_df["threshold"], y=sweep_df["blocked_rentals"],
-                  mode="lines+markers", name="Blocked Rentals", 
-                  line=dict(color="#e74c3c")),
-        row=1, col=1
-    )
-    
-    # Problems solved
-    fig.add_trace(
-        go.Scatter(x=sweep_df["threshold"], y=sweep_df["problems_solved"],
-                  mode="lines+markers", name="Problems Solved", 
-                  line=dict(color="#27ae60"), showlegend=False),
-        row=1, col=2
+        rows=1, cols=2,
+        subplot_titles=("Problems Solved vs Blocked Rentals", "Efficiency vs Revenue Impact"),
+        specs=[[{"secondary_y": True}, {"secondary_y": True}]]
     )
     
-    # Cancellations prevented
+    # Left chart: Problems vs Blocked
     fig.add_trace(
-        go.Scatter(x=sweep_df["threshold"], y=sweep_df["cancellations_prevented"],
-                  mode="lines+markers", name="Cancellations Prevented", 
-                  line=dict(color="#9b59b6"), showlegend=False),
-        row=1, col=3
+        go.Scatter(x=threshold_data["threshold"], y=threshold_data["problems_solved"],
+                  mode="lines+markers", name="Problems Solved", line=dict(color="green")),
+        row=1, col=1, secondary_y=False
     )
-    
-    # Efficiency
     fig.add_trace(
-        go.Scatter(x=sweep_df["threshold"], y=sweep_df["problem_solve_rate"],
-                  mode="lines+markers", name="Efficiency (%)", 
-                  line=dict(color="#3498db"), showlegend=False),
-        row=2, col=1
+        go.Scatter(x=threshold_data["threshold"], y=threshold_data["blocked_rentals"],
+                  mode="lines+markers", name="Blocked Rentals", line=dict(color="red")),
+        row=1, col=1, secondary_y=True
     )
     
-    # Revenue impact
+    # Right chart: Efficiency vs Impact
     fig.add_trace(
-        go.Scatter(x=sweep_df["threshold"], y=sweep_df["revenue_impact_percent"],
-                  mode="lines+markers", name="Revenue Impact (%)", 
-                  line=dict(color="#f39c12"), showlegend=False),
-        row=2, col=2
+        go.Scatter(x=threshold_data["threshold"], y=threshold_data["solve_efficiency"],
+                  mode="lines+markers", name="Efficiency (%)", line=dict(color="blue")),
+        row=1, col=2, secondary_y=False
     )
-    
-    # Cancellation rate
     fig.add_trace(
-        go.Scatter(x=sweep_df["threshold"], y=sweep_df["cancellation_rate"],
-                  mode="lines+markers", name="Remaining Cancellation Rate (%)", 
-                  line=dict(color="#e67e22"), showlegend=False),
-        row=2, col=3
+        go.Scatter(x=threshold_data["threshold"], y=threshold_data["revenue_impact"],
+                  mode="lines+markers", name="Revenue Impact (%)", line=dict(color="orange")),
+        row=1, col=2, secondary_y=True
     )
     
-    # Add current threshold line to all subplots
-    for i in range(1, 3):
-        for j in range(1, 4):
-            fig.add_vline(x=threshold, line_dash="dash", line_color="red", 
-                         annotation_text=f"Current: {threshold}min", row=i, col=j)
+    # Add current threshold line
+    fig.add_vline(x=threshold, line_dash="dash", line_color="red", 
+                 annotation_text=f"Current: {threshold}min", row=1, col=1)
+    fig.add_vline(x=threshold, line_dash="dash", line_color="red", 
+                 annotation_text=f"Current: {threshold}min", row=1, col=2)
     
-    fig.update_layout(height=600, showlegend=True, title_text="Comprehensive Threshold Analysis")
+    fig.update_layout(height=400, showlegend=True)
     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="Count", row=1, col=3)
-    fig.update_yaxes(title_text="Percentage (%)", row=2, col=1)
-    fig.update_yaxes(title_text="Percentage (%)", row=2, col=2)
-    fig.update_yaxes(title_text="Percentage (%)", row=2, col=3)
+    fig.update_yaxes(title_text="Count", secondary_y=False, row=1, col=1)
+    fig.update_yaxes(title_text="Count", secondary_y=True, row=1, col=1)
+    fig.update_yaxes(title_text="Percentage (%)", secondary_y=False, row=1, col=2)
+    fig.update_yaxes(title_text="Percentage (%)", secondary_y=True, row=1, col=2)
     
     st.plotly_chart(fig, use_container_width=True)
     
-    # Optimal threshold recommendation
-    st.markdown('<div class="section-header">💡 Optimal Threshold Recommendation</div>', unsafe_allow_html=True)
-    
-    optimal = find_optimal_threshold(sweep_df)
-    
-    # Validation check and business sense analysis
-    if optimal['threshold'] < 60:
-        st.warning("⚠️ Recommended threshold seems low. Let's analyze why:")
-        
-        # Show analysis of why this threshold was chosen
-        st.markdown(f"""
-        **Analysis:**
-        - At {optimal['threshold']:.0f} min: Solves {optimal['problems_solved']:.0f} problems with {optimal['problem_solve_rate']:.1f}% efficiency
-        - At 90 min: Solves {sweep_df[sweep_df['threshold']==90]['problems_solved'].iloc[0]:.0f} problems with {sweep_df[sweep_df['threshold']==90]['problem_solve_rate'].iloc[0]:.1f}% efficiency  
-        - At 120 min: Solves {sweep_df[sweep_df['threshold']==120]['problems_solved'].iloc[0]:.0f} problems with {sweep_df[sweep_df['threshold']==120]['problem_solve_rate'].iloc[0]:.1f}% efficiency
-        """)
-        
-        # Suggest alternative if current seems too low
-        alternatives = sweep_df[(sweep_df["threshold"].isin([90, 120])) & (sweep_df["problems_solved"] > 0)]
-        if len(alternatives) > 0:
-            best_alt = alternatives.sort_values(["problems_solved", "problem_solve_rate"], ascending=[False, False]).iloc[0]
-            st.info(f"💡 **Alternative consideration:** {best_alt['threshold']:.0f} minutes might be more practical for operational reasons.")
-    
-    st.markdown(f"""
-    <div class="recommendation-box">
-    <h3>🎯 Recommended Threshold: {optimal['threshold']:.0f} minutes</h3>
-    <p><strong>Why this threshold?</strong></p>
-    <ul>
-        <li>✅ Solves <strong>{optimal['problems_solved']:.0f}</strong> problematic cases (current waiting situations)</li>
-        <li>📉 Blocks only <strong>{optimal['blocked_percentage']:.1f}%</strong> of consecutive rentals</li>
-        <li>⚡ Achieves <strong>{optimal['problem_solve_rate']:.1f}%</strong> efficiency in problem solving</li>
-        <li>💰 Impacts <strong>{optimal['revenue_impact_percent']:.1f}%</strong> of total rental volume</li>
-        <li>❌ Prevents <strong>{optimal['cancellations_prevented']:.0f}</strong> delay-related cancellations</li>
-    </ul>
-    <p><em>This threshold balances customer satisfaction improvements with minimal impact on availability.</em></p>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Additional insight: Show the trade-off analysis
-    st.markdown("### 📊 Threshold Trade-off Analysis")
-    
-    # Create a summary table of key thresholds
-    key_thresholds = [30, 60, 90, 120, 150]
-    comparison_data = []
+    # Scope comparison
+    st.markdown('<div class="section-header">🚗 Scope Comparison: All Cars vs Connect Only</div>', unsafe_allow_html=True)
     
-    for t in key_thresholds:
-        if t in sweep_df["threshold"].values:
-            row = sweep_df[sweep_df["threshold"] == t].iloc[0]
-            comparison_data.append({
-                "Threshold (min)": int(t),
-                "Problems Solved": int(row["problems_solved"]),
-                "Blocked Rentals": int(row["blocked_rentals"]),
-                "Efficiency (%)": f"{row['problem_solve_rate']:.1f}%",
-                "Revenue Impact (%)": f"{row['revenue_impact_percent']:.1f}%",
-                "Cancellations Prevented": int(row["cancellations_prevented"])
-            })
-    
-    comparison_df = pd.DataFrame(comparison_data)
-    st.dataframe(comparison_df, use_container_width=True, hide_index=True)
-
-# ========== PAGE 3: SCOPE ANALYSIS ==========
-elif selected == "🎯 Scope Analysis":
-    st.title("🎯 Scope Decision: All Cars vs Connect Cars Only?")
-    
-    st.markdown("""
-    <div class="insight-box">
-    <strong>Goal:</strong> Determine whether to apply the minimum delay feature to all cars or just Connect cars.
-    Connect cars have better technology for managing transitions, but all cars face the same late return issues.
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Controls for scope analysis
-    threshold_for_scope = st.slider("🕐 Analysis Threshold (minutes)", 0, 300, 120, step=15,
-                                   help="Set threshold for comparing scope options")
-    
-    # Calculate metrics for both scopes
-    all_metrics = calculate_threshold_metrics(df, threshold_for_scope, "all")
-    connect_metrics = calculate_threshold_metrics(df, threshold_for_scope, "connect")
-    
-    st.markdown('<div class="section-header">⚖️ Scope Comparison at Selected Threshold</div>', unsafe_allow_html=True)
+    all_metrics = calculate_metrics(df, threshold, "all")
+    connect_metrics = calculate_metrics(df, threshold, "connect")
     
     col1, col2 = st.columns(2)
     
     with col1:
         st.markdown("### 🚗 All Cars")
         st.markdown(f"""
-        <div style="background-color: #f8f9fa; padding: 1rem; border-radius: 0.5rem; margin: 1rem 0;">
-        <strong>Blocked Rentals:</strong> {all_metrics['blocked_rentals']:,} ({all_metrics['blocked_percentage']:.1f}%)<br>
-        <strong>Problems Solved:</strong> {all_metrics['problems_solved']:,}<br>
-        <strong>Efficiency:</strong> {all_metrics['problem_solve_rate']:.1f}%<br>
-        <strong>Revenue Impact:</strong> {all_metrics['revenue_impact_percent']:.1f}%<br>
-        <strong>Cancellations Prevented:</strong> {all_metrics['cancellations_prevented']:,}
-        </div>
-        """, unsafe_allow_html=True)
+        **Problems Solved:** {all_metrics['problems_solved']:,}  
+        **Blocked Rentals:** {all_metrics['blocked_rentals']:,} ({all_metrics['blocked_percentage']:.1f}%)  
+        **Efficiency:** {all_metrics['solve_efficiency']:.1f}%  
+        **Revenue Impact:** {all_metrics['revenue_impact']:.1f}%
+        """)
     
     with col2:
         st.markdown("### 🔌 Connect Cars Only")
         st.markdown(f"""
-        <div style="background-color: #e8f4f8; padding: 1rem; border-radius: 0.5rem; margin: 1rem 0;">
-        <strong>Blocked Rentals:</strong> {connect_metrics['blocked_rentals']:,} ({connect_metrics['blocked_percentage']:.1f}%)<br>
-        <strong>Problems Solved:</strong> {connect_metrics['problems_solved']:,}<br>
-        <strong>Efficiency:</strong> {connect_metrics['problem_solve_rate']:.1f}%<br>
-        <strong>Revenue Impact:</strong> {connect_metrics['revenue_impact_percent']:.1f}%<br>
-        <strong>Cancellations Prevented:</strong> {connect_metrics['cancellations_prevented']:,}
-        </div>
-        """, unsafe_allow_html=True)
-    
-    # Comprehensive scope comparison
-    st.markdown('<div class="section-header">📊 Comprehensive Scope Analysis</div>', unsafe_allow_html=True)
-    
-    thresholds = list(range(0, 301, 30))
-    all_sweep = create_threshold_sweep(df, thresholds, "all")
-    connect_sweep = create_threshold_sweep(df, thresholds, "connect")
-    
-    # Add scope identifier
-    all_sweep["scope"] = "All Cars"
-    connect_sweep["scope"] = "Connect Only"
-    combined_sweep = pd.concat([all_sweep, connect_sweep], ignore_index=True)
-    
-    # Create comparison visualizations (with cancellations)
-    fig = make_subplots(
-        rows=2, cols=3,
-        subplot_titles=(
-            "Blocked Rentals by Scope", 
-            "Problems Solved by Scope",
-            "Cancellations Prevented by Scope",
-            "Efficiency by Scope", 
-            "Revenue Impact by Scope",
-            "Remaining Cancellation Rate by Scope"
-        )
-    )
+        **Problems Solved:** {connect_metrics['problems_solved']:,}  
+        **Blocked Rentals:** {connect_metrics['blocked_rentals']:,} ({connect_metrics['blocked_percentage']:.1f}%)  
+        **Efficiency:** {connect_metrics['solve_efficiency']:.1f}%  
+        **Revenue Impact:** {connect_metrics['revenue_impact']:.1f}%
+        """)
     
-    colors = {"All Cars": "#1f77b4", "Connect Only": "#ff7f0e"}
+    # Scope comparison chart
+    all_data = create_threshold_analysis(df, thresholds, "all")
+    connect_data = create_threshold_analysis(df, thresholds, "connect")
+    
+    fig_scope = go.Figure()
+    fig_scope.add_trace(go.Scatter(x=all_data["threshold"], y=all_data["problems_solved"],
+                                  mode="lines+markers", name="All Cars - Problems Solved"))
+    fig_scope.add_trace(go.Scatter(x=connect_data["threshold"], y=connect_data["problems_solved"],
+                                  mode="lines+markers", name="Connect Only - Problems Solved"))
+    fig_scope.add_vline(x=threshold, line_dash="dash", line_color="red", 
+                       annotation_text=f"Current: {threshold}min")
+    fig_scope.update_layout(title="Problems Solved by Scope", 
+                           xaxis_title="Threshold (minutes)", 
+                           yaxis_title="Problems Solved")
+    st.plotly_chart(fig_scope, use_container_width=True)
+    
+    # Recommendations
+    st.markdown('<div class="section-header">💡 Recommendations</div>', unsafe_allow_html=True)
+    
+    # Find optimal threshold
+    viable_thresholds = threshold_data[
+        (threshold_data["problems_solved"] > 0) & 
+        (threshold_data["threshold"] >= 60) & 
+        (threshold_data["threshold"] <= 180)
+    ]
     
-    for scope_name in ["All Cars", "Connect Only"]:
-        scope_data = combined_sweep[combined_sweep["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
-        )
-        
-        # Cancellations prevented
-        fig.add_trace(
-            go.Scatter(x=scope_data["threshold"], y=scope_data["cancellations_prevented"],
-                      mode="lines+markers", name=f"{scope_name}", 
-                      line=dict(color=colors[scope_name]), legendgroup=scope_name, showlegend=False),
-            row=1, col=3
-        )
-        
-        # 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_percent"],
-                      mode="lines+markers", name=f"{scope_name}", 
-                      line=dict(color=colors[scope_name]), legendgroup=scope_name, showlegend=False),
-            row=2, col=2
-        )
-        
-        # Remaining cancellation rate  
-        fig.add_trace(
-            go.Scatter(x=scope_data["threshold"], y=scope_data["cancellation_rate"],
-                      mode="lines+markers", name=f"{scope_name}", 
-                      line=dict(color=colors[scope_name]), legendgroup=scope_name, showlegend=False),
-            row=2, col=3
+    if len(viable_thresholds) > 0:
+        # Find sweet spot: good problems solved with reasonable efficiency
+        viable_thresholds["score"] = (
+            viable_thresholds["problems_solved"] / viable_thresholds["problems_solved"].max() * 0.6 +
+            viable_thresholds["solve_efficiency"] / 100 * 0.4
         )
+        optimal = viable_thresholds.sort_values("score", ascending=False).iloc[0]
+        optimal_threshold = int(optimal["threshold"])
+    else:
+        optimal_threshold = 90
     
-    # Add current threshold line
-    for i in range(1, 3):
-        for j in range(1, 4):
-            fig.add_vline(x=threshold_for_scope, line_dash="dash", line_color="red", 
-                         annotation_text=f"Analysis: {threshold_for_scope}min", row=i, col=j)
-    
-    fig.update_layout(height=600, showlegend=True, title_text="Scope Comparison Analysis")
-    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="Count", row=1, col=3)
-    fig.update_yaxes(title_text="Percentage (%)", row=2, col=1)
-    fig.update_yaxes(title_text="Percentage (%)", row=2, col=2)
-    fig.update_yaxes(title_text="Percentage (%)", row=2, col=3)
-    
-    st.plotly_chart(fig, use_container_width=True)
-    
-    # Checkin type analysis
-    st.markdown('<div class="section-header">🔍 Checkin Type Analysis</div>', unsafe_allow_html=True)
+    # Scope recommendation
+    if connect_metrics['solve_efficiency'] > all_metrics['solve_efficiency'] and connect_metrics['problems_solved'] >= all_metrics['problems_solved'] * 0.7:
+        recommended_scope = "Connect Only"
+        scope_reason = "Higher efficiency with most problems solved"
+    else:
+        recommended_scope = "All Cars"
+        scope_reason = "Solves more problems overall"
     
     col1, col2 = st.columns(2)
     
     with col1:
-        st.markdown("### Current Problems by Type")
-        
-        df_problems = df[df["has_previous_rental"]].copy()
-        
-        # Join with previous rental delay data
-        prev_rental_data = df[["rental_id", "delay_at_checkout_in_minutes"]].rename(
-            columns={"rental_id": "previous_ended_rental_id", 
-                    "delay_at_checkout_in_minutes": "previous_delay"}
-        )
-        
-        df_problems = df_problems.merge(
-            prev_rental_data, 
-            on="previous_ended_rental_id", 
-            how="left"
-        )
-        
-        # Calculate problems using actual previous rental delay
-        df_problems["previous_delay_clean"] = df_problems["previous_delay"].clip(-720, 720)
-        df_problems["causes_problem"] = (
-            df_problems["previous_delay"].notnull() & 
-            (df_problems["previous_delay_clean"] > df_problems["time_delta_with_previous_rental_in_minutes"])
-        )
-        
-        problem_by_type = df_problems.groupby("checkin_type")["causes_problem"].agg(["sum", "count"]).reset_index()
-        problem_by_type["rate"] = (problem_by_type["sum"] / problem_by_type["count"] * 100).round(1)
-        
-        fig_problems = px.bar(
-            problem_by_type, 
-            x="checkin_type", 
-            y="sum",
-            title="Current Problems by Checkin Type",
-            labels={"sum": "Number of Problems", "checkin_type": "Checkin Type"}
-        )
-        st.plotly_chart(fig_problems, use_container_width=True)
+        st.markdown(f"""
+        <div class="recommendation-box">
+        <h3>🎯 Recommended Threshold</h3>
+        <h2>{optimal_threshold} minutes</h2>
+        <p>Balances problem solving with availability impact</p>
+        </div>
+        """, unsafe_allow_html=True)
     
     with col2:
-        st.markdown("### Gap Distribution by Type")
-        
-        gap_data = df[df["has_previous_rental"]].copy()
-        gap_data = gap_data[gap_data["time_delta_with_previous_rental_in_minutes"].between(0, 300)]
-        
-        fig_gaps = px.box(
-            gap_data, 
-            x="checkin_type", 
-            y="time_delta_with_previous_rental_in_minutes",
-            title="Gap Distribution by Checkin Type",
-            labels={"time_delta_with_previous_rental_in_minutes": "Gap (minutes)", "checkin_type": "Checkin Type"}
-        )
-        st.plotly_chart(fig_gaps, use_container_width=True)
+        st.markdown(f"""
+        <div class="recommendation-box">
+        <h3>🚗 Recommended Scope</h3>
+        <h2>{recommended_scope}</h2>
+        <p>{scope_reason}</p>
+        </div>
+        """, unsafe_allow_html=True)
     
-    # Final scope recommendation
-    st.markdown('<div class="section-header">🏆 Scope Recommendation</div>', unsafe_allow_html=True)
+    # Summary table
+    st.markdown("### 📋 Key Threshold Options")
+    summary_thresholds = [60, 90, 120, 150]
+    summary_data = []
     
-    # Logic for recommendation
-    if (connect_metrics['problem_solve_rate'] > all_metrics['problem_solve_rate'] and 
-        connect_metrics['revenue_impact_percent'] <= all_metrics['revenue_impact_percent']):
-        recommendation = "Connect Only"
-        rec_metrics = connect_metrics
-        reason = "Connect cars show higher efficiency with lower revenue impact"
-    elif connect_metrics['problems_solved'] >= all_metrics['problems_solved'] * 0.8:
-        recommendation = "Connect Only" 
-        rec_metrics = connect_metrics
-        reason = "Connect cars solve most problems with focused implementation"
-    else:
-        recommendation = "All Cars"
-        rec_metrics = all_metrics
-        reason = "All cars approach solves significantly more problems overall"
+    for t in summary_thresholds:
+        if t in threshold_data["threshold"].values:
+            row = threshold_data[threshold_data["threshold"] == t].iloc[0]
+            summary_data.append({
+                "Threshold": f"{int(t)} min",
+                "Problems Solved": int(row["problems_solved"]),
+                "Blocked Rentals": int(row["blocked_rentals"]),
+                "Efficiency": f"{row['solve_efficiency']:.1f}%",
+                "Revenue Impact": f"{row['revenue_impact']:.1f}%"
+            })
     
-    st.markdown(f"""
-    <div class="recommendation-box">
-    <h3>🎯 Recommended Scope: {recommendation}</h3>
-    <p><strong>Reasoning:</strong> {reason}</p>
-    <p><strong>At {threshold_for_scope} minutes threshold:</strong></p>
-    <ul>
-        <li>✅ Solves <strong>{rec_metrics['problems_solved']:,}</strong> problematic cases</li>
-        <li>📉 Blocks <strong>{rec_metrics['blocked_percentage']:.1f}%</strong> of consecutive rentals</li>
-        <li>⚡ Achieves <strong>{rec_metrics['problem_solve_rate']:.1f}%</strong> efficiency</li>
-        <li>💰 Impacts <strong>{rec_metrics['revenue_impact_percent']:.1f}%</strong> of total rental volume</li>
-        <li>❌ Prevents <strong>{rec_metrics['cancellations_prevented']:,}</strong> delay-related cancellations</li>
-    </ul>
-    </div>
-    """, unsafe_allow_html=True)
+    summary_df = pd.DataFrame(summary_data)
+    st.dataframe(summary_df, use_container_width=True, hide_index=True)
 
 # ========== FOOTER ==========
 st.markdown("---")
 st.markdown("""
 <div style='text-align: center; color: #666; padding: 1rem;'>
-<p>🚗 <strong>Getaround Analysis Dashboard</strong> - Threshold & Scope Decision Support</p>
-<p><em>Built with Streamlit & Plotly for data-driven product decisions</em></p>
+<p>🚗 <strong>Getaround Delay Analysis</strong> - Supporting threshold and scope decisions</p>
 </div>
 """, unsafe_allow_html=True)