Update app.py

app.py

@@ -1,4 +1,3 @@
-# app.py
 import streamlit as st
 import pandas as pd
 import numpy as np
@@ -121,7 +120,10 @@ def calculate_threshold_metrics(df, threshold_minutes, scope="all"):
             "problems_solved": 0,
             "problem_solve_rate": 0.0,
             "avg_wait_time": 0.0,
-            "revenue_impact_percent": 0.0
+            "revenue_impact_percent": 0.0,
+            "current_cancellations": 0,
+            "cancellations_prevented": 0,
+            "cancellation_rate": 0.0
         }
     
     # Calculate blocked rentals (gap < threshold)
@@ -143,6 +145,19 @@ def calculate_threshold_metrics(df, threshold_minutes, scope="all"):
     # Problems solved by blocking
     df_with_prev["problem_solved"] = df_with_prev["causes_problem"] & df_with_prev["would_be_blocked"]
     
+    # Cancellation analysis
+    df_with_prev["is_cancelled"] = df_with_prev["state"] == "canceled"
+    
+    # Potential cancellations due to delays (cancelled rentals where previous rental caused problems)
+    df_with_prev["likely_cancelled_due_to_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["likely_cancelled_due_to_delay"] & df_with_prev["would_be_blocked"]
+    )
+    
     # Calculate final metrics
     total_rentals = len(df_filtered)
     rentals_with_previous = len(df_with_prev)
@@ -154,6 +169,11 @@ def calculate_threshold_metrics(df, threshold_minutes, scope="all"):
     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
+    current_cancellations = int(df_with_prev["likely_cancelled_due_to_delay"].sum())
+    cancellations_prevented = int(df_with_prev["cancellation_prevented"].sum())
+    cancellation_rate = (current_cancellations / rentals_with_previous) * 100 if rentals_with_previous > 0 else 0
+    
     return {
         "total_rentals": total_rentals,
         "rentals_with_previous": rentals_with_previous,
@@ -163,7 +183,10 @@ def calculate_threshold_metrics(df, threshold_minutes, scope="all"):
         "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
+        "revenue_impact_percent": revenue_impact_percent,
+        "current_cancellations": current_cancellations,
+        "cancellations_prevented": cancellations_prevented,
+        "cancellation_rate": cancellation_rate
     }
 
 def create_threshold_sweep(df, thresholds, scope="all"):
@@ -174,20 +197,24 @@ def create_threshold_sweep(df, thresholds, scope="all"):
         results.append({"threshold": threshold, **metrics})
     return pd.DataFrame(results)
 
-def find_optimal_threshold(sweep_df, max_blocked_rate=15):
+def find_optimal_threshold(sweep_df, max_blocked_rate=20):
     """Find optimal threshold using business logic"""
     # Only consider thresholds that actually solve problems (> 0 problems solved)
     viable = sweep_df[
         (sweep_df["problems_solved"] > 0) & 
-        (sweep_df["blocked_percentage"] <= max_blocked_rate)
+        (sweep_df["blocked_percentage"] <= max_blocked_rate) &
+        (sweep_df["threshold"] <= 180)  # Don't recommend unreasonably long thresholds
     ]
     
     if len(viable) == 0:
         # If no threshold meets the blocked rate criteria, find the one with best ratio
-        viable = sweep_df[sweep_df["problems_solved"] > 0]
+        viable = sweep_df[
+            (sweep_df["problems_solved"] > 0) &
+            (sweep_df["threshold"] <= 180)
+        ]
         if len(viable) == 0:
-            # If no problems can be solved, return the minimum meaningful threshold
-            return sweep_df[sweep_df["threshold"] == sweep_df["threshold"].min()].iloc[0]
+            # If no problems can be solved, return a reasonable threshold
+            return sweep_df[sweep_df["threshold"] == 60].iloc[0]
     
     # Calculate efficiency and optimize
     viable["efficiency"] = viable["problems_solved"] / viable["blocked_rentals"].replace({0: np.nan})
@@ -212,8 +239,8 @@ with st.sidebar:
     st.markdown("## 🎛️ Navigation")
     selected = option_menu(
         "Analysis Sections",
-        ["🕐 Threshold Analysis", "🎯 Scope Analysis", "📊 Data Overview"],
-        icons=["clock", "target", "bar-chart"],
+        ["📊 Data Overview", "🕐 Threshold Analysis", "🎯 Scope Analysis"],
+        icons=["bar-chart", "clock", "target"],
         menu_icon="cast",
         default_index=0,
     )
@@ -222,13 +249,13 @@ with st.sidebar:
     st.markdown("### 📈 Dataset Info")
     st.info(f"""
     **Total Rentals:** {len(df):,}
-    **With Previous Rental:** {df['has_previous_rental'].sum():,}
+    **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']):,}
     """)
 
-# ========== PAGE 1: THRESHOLD ANALYSIS ==========
-if selected == "🕐 Threshold Analysis":
+# ========== PAGE 1: DATA OVERVIEW ==========
+if selected == "📊 Data Overview":
     st.title("⏰ Threshold Decision: How Long Should the Minimum Delay Be?")
     
     st.markdown("""
@@ -241,23 +268,35 @@ if selected == "🕐 Threshold Analysis":
     # Controls
     col1, col2 = st.columns(2)
     with col1:
-        threshold = st.slider("🕐 Threshold (minutes)", 0, 300, 120, step=15,
+        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 = st.columns(4)
+    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>
         </div>
         """, unsafe_allow_html=True)
     
@@ -266,6 +305,7 @@ if 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>
         </div>
         """, unsafe_allow_html=True)
     
@@ -274,6 +314,7 @@ if 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>
         </div>
         """, unsafe_allow_html=True)
     
@@ -282,6 +323,16 @@ if selected == "🕐 Threshold Analysis":
         <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>
+        </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)
     
@@ -335,12 +386,14 @@ if selected == "🕐 Threshold Analysis":
     
     # Create comprehensive threshold analysis chart
     fig = make_subplots(
-        rows=2, cols=2,
+        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"
+            "Revenue Impact vs Threshold",
+            "Cancellation Rate vs Threshold"
         )
     )
     
@@ -360,6 +413,14 @@ if selected == "🕐 Threshold Analysis":
         row=1, col=2
     )
     
+    # Cancellations prevented
+    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
+    )
+    
     # Efficiency
     fig.add_trace(
         go.Scatter(x=sweep_df["threshold"], y=sweep_df["problem_solve_rate"],
@@ -376,9 +437,17 @@ if selected == "🕐 Threshold Analysis":
         row=2, col=2
     )
     
+    # Cancellation rate
+    fig.add_trace(
+        go.Scatter(x=sweep_df["threshold"], y=sweep_df["cancellation_rate"],
+                  mode="lines+markers", name="Cancellation Rate (%)", 
+                  line=dict(color="#e67e22"), showlegend=False),
+        row=2, col=3
+    )
+    
     # Add current threshold line to all subplots
     for i in range(1, 3):
-        for j 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)
     
@@ -386,8 +455,10 @@ if selected == "🕐 Threshold 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)
     
@@ -419,7 +490,7 @@ if selected == "🕐 Threshold Analysis":
     <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</li>
+        <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>
@@ -427,26 +498,9 @@ if selected == "🕐 Threshold Analysis":
     <p><em>This threshold balances customer satisfaction improvements with minimal impact on availability.</em></p>
     </div>
     """, unsafe_allow_html=True)
-    
-    # Additional insights
-    if optimal['threshold'] > 0:
-        st.markdown("### 📈 Business Impact Analysis")
-        
-        col1, col2, col3 = st.columns(3)
-        with col1:
-            st.metric("Customer Experience", "Improved", 
-                     help=f"Eliminates {optimal['problems_solved']:.0f} cases where next customer waits")
-        with col2:
-            availability_impact = f"-{optimal['blocked_percentage']:.1f}%"
-            st.metric("Availability Impact", availability_impact,
-                     help="Reduction in bookable consecutive rental slots")
-        with col3:
-            efficiency_rating = "High" if optimal['problem_solve_rate'] > 50 else "Medium" if optimal['problem_solve_rate'] > 25 else "Low"
-            st.metric("Implementation Efficiency", efficiency_rating,
-                     help=f"{optimal['problem_solve_rate']:.1f}% of blocked rentals actually solve problems")
 
-# ========== PAGE 2: SCOPE ANALYSIS ==========
-elif selected == "🎯 Scope Analysis":
+# ========== PAGE 2: THRESHOLD ANALYSIS ==========
+elif selected == "🕐 Threshold Analysis":
     st.title("🎯 Scope Decision: All Cars vs Connect Cars Only?")
     
     st.markdown("""
@@ -475,7 +529,8 @@ elif selected == "🎯 Scope Analysis":
         <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}%
+        <strong>Revenue Impact:</strong> {all_metrics['revenue_impact_percent']:.1f}%<br>
+        <strong>Cancellations Prevented:</strong> {all_metrics['cancellations_prevented']:,}
         </div>
         """, unsafe_allow_html=True)
     
@@ -486,7 +541,8 @@ elif selected == "🎯 Scope Analysis":
         <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}%
+        <strong>Revenue Impact:</strong> {connect_metrics['revenue_impact_percent']:.1f}%<br>
+        <strong>Cancellations Prevented:</strong> {connect_metrics['cancellations_prevented']:,}
         </div>
         """, unsafe_allow_html=True)
     
@@ -502,14 +558,16 @@ elif selected == "🎯 Scope Analysis":
     connect_sweep["scope"] = "Connect Only"
     combined_sweep = pd.concat([all_sweep, connect_sweep], ignore_index=True)
     
-    # Create comparison visualizations
+    # Create comparison visualizations (with cancellations)
     fig = make_subplots(
-        rows=2, cols=2,
+        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"
+            "Revenue Impact by Scope",
+            "Cancellation Rate by Scope"
         )
     )
     
@@ -534,6 +592,14 @@ elif selected == "🎯 Scope Analysis":
             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"],
@@ -549,10 +615,18 @@ elif selected == "🎯 Scope Analysis":
                       line=dict(color=colors[scope_name]), legendgroup=scope_name, showlegend=False),
             row=2, col=2
         )
+        
+        # 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
+        )
     
     # Add current threshold line
     for i in range(1, 3):
-        for j 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)
     
@@ -560,8 +634,10 @@ elif selected == "🎯 Scope 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)
     
@@ -634,12 +710,13 @@ elif selected == "🎯 Scope Analysis":
         <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)
 
-# ========== PAGE 3: DATA OVERVIEW ==========
-elif selected == "📊 Data Overview":
+# ========== PAGE 3: SCOPE ANALYSIS ==========
+elif selected == "🎯 Scope Analysis":
     st.title("📊 Dataset Overview & Exploratory Analysis")
     
     st.markdown('<div class="section-header">📈 Dataset Summary</div>', unsafe_allow_html=True)
@@ -651,9 +728,11 @@ elif selected == "📊 Data Overview":
     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']):,}")
+        st.metric("Cancelled Rentals", f"{len(df[df['state'] == 'canceled']):,}",
+                 help="Total cancelled rentals in dataset")
     with col4:
-        st.metric("With Previous Rental", f"{df['has_previous_rental'].sum():,}")
+        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)
@@ -688,22 +767,27 @@ elif selected == "📊 Data Overview":
     with col1:
         # Delay status distribution
         df["delay_status"] = df["delay_at_checkout_in_minutes"].apply(
-            lambda x: "Early" if pd.notnull(x) and x < 0 else 
+            lambda x: "Early Return" if pd.notnull(x) and x < 0 else 
                      "On Time" if pd.notnull(x) and x == 0 else 
-                     "Late" if pd.notnull(x) and x > 0 else "No Data"
+                     "Late Return" if pd.notnull(x) and x > 0 else "Missing Data"
         )
         
         delay_counts = df["delay_status"].value_counts()
         fig_delay_status = px.pie(
             values=delay_counts.values, 
             names=delay_counts.index,
-            title="Delay Status Distribution",
+            title="Return Status Distribution",
             color_discrete_sequence=px.colors.qualitative.Bold
         )
+        fig_delay_status.update_layout(
+            annotations=[dict(text="Missing Data = no checkout delay recorded", 
+                            x=0.5, y=-0.1, xref="paper", yref="paper", 
+                            showarrow=False, font=dict(size=10))]
+        )
         st.plotly_chart(fig_delay_status, use_container_width=True)
     
     with col2:
-        # Delay distribution histogram
+        # 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)]
         
@@ -711,10 +795,14 @@ elif selected == "📊 Data Overview":
             delay_filtered, 
             x="delay_at_checkout_in_minutes",
             nbins=50,
-            title="Delay Distribution (-120 to 300 minutes)",
-            labels={"delay_at_checkout_in_minutes": "Delay (minutes)", "count": "Number of Rentals"}
+            title="Checkout Delay Distribution",
+            labels={"delay_at_checkout_in_minutes": "Minutes (Negative = Early Return)", "count": "Number of 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)
     
     # Gap analysis
@@ -747,8 +835,67 @@ elif selected == "📊 Data Overview":
         )
         st.plotly_chart(fig_gap_box, use_container_width=True)
     
-    # Problem cases analysis
-    st.markdown('<div class="section-header">🚨 Current Problem Cases</div>', unsafe_allow_html=True)
+    # Cancellation analysis
+    st.markdown('<div class="section-header">❌ Cancellation Analysis</div>', unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("### Cancellation by 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(
+                x=cancel_rates.index, 
+                y=cancel_rates.values,
+                title="Cancellation Rate by Checkin 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 potential delay-related cancellations
+        df_analysis = df[df["has_previous_rental"]].copy()
+        df_analysis["causes_problem"] = (
+            df_analysis["delay_at_checkout_in_minutes"].notnull() & 
+            (df_analysis["clean_delay"] > df_analysis["time_delta_with_previous_rental_in_minutes"])
+        )
+        df_analysis["likely_cancelled_due_to_delay"] = (
+            (df_analysis["state"] == "canceled") & df_analysis["causes_problem"]
+        )
+        
+        delay_related_cancels = df_analysis["likely_cancelled_due_to_delay"].sum()
+        total_cancels = (df_analysis["state"] == "canceled").sum()
+        
+        col2_1, col2_2 = st.columns(2)
+        with col2_1:
+            st.metric("Total Cancellations", f"{total_cancels:,}")
+        with col2_2:
+            st.metric("Likely Delay-Related", f"{delay_related_cancels:,}",
+                     help="Cancelled rentals where previous rental caused waiting")
+        
+        if total_cancels > 0:
+            delay_cancel_rate = (delay_related_cancels / total_cancels * 100)
+            st.metric("% of Cancellations Due to Delays", f"{delay_cancel_rate:.1f}%")
+    # Problem cases analysis (including cancellations)
+    st.markdown('<div class="section-header">🚨 Current Problem Cases Analysis</div>', unsafe_allow_html=True)
+    
+    st.markdown("""
+    <div class="insight-box">
+    <strong>What is a "Problem Case"?</strong><br>
+    A problem occurs when a driver returns a car late AND this delay is longer than the planned gap to the next rental.
+    This forces the next customer to either wait beyond their scheduled pickup time or cancel their rental.
+    <br><br>
+    <strong>Formula:</strong> Problem = (checkout_delay > gap_to_next_rental) AND (checkout_delay > 0)<br>
+    <strong>Cancellation Impact:</strong> Some of these problems result in cancellations when waiting becomes unacceptable.
+    </div>
+    """, unsafe_allow_html=True)
     
     # Calculate problem cases
     df_problems = df[df["has_previous_rental"]].copy()
@@ -763,15 +910,23 @@ elif selected == "📊 Data Overview":
     
     problem_cases = df_problems[df_problems["causes_problem"]]
     
-    col1, col2, col3 = st.columns(3)
+    col1, col2, col3, col4 = st.columns(4)
     with col1:
-        st.metric("Total Problem Cases", f"{len(problem_cases):,}")
+        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}%")
+        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")
+        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)
@@ -798,61 +953,6 @@ elif selected == "📊 Data Overview":
             )
             st.plotly_chart(fig_problems_type, use_container_width=True)
     
-    # Data quality insights
-    st.markdown('<div class="section-header">🔍 Data Quality Insights</div>', unsafe_allow_html=True)
-    
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        st.markdown("### Missing Data Analysis")
-        missing_data = df.isnull().sum()
-        missing_pct = (missing_data / len(df) * 100).round(1)
-        missing_df = pd.DataFrame({
-            'Column': missing_data.index,
-            'Missing Count': missing_data.values,
-            'Missing %': missing_pct.values
-        }).sort_values('Missing %', ascending=False)
-        
-        fig_missing = px.bar(
-            missing_df.head(10), 
-            x='Missing %', 
-            y='Column',
-            orientation='h',
-            title="Missing Data by Column (Top 10)"
-        )
-        st.plotly_chart(fig_missing, use_container_width=True)
-    
-    with col2:
-        st.markdown("### Key Statistics")
-        
-        stats_data = {
-            'Metric': [
-                'Total Rentals',
-                'Rentals with Previous',
-                'Connect Rentals',
-                'Mobile Rentals',
-                'Cancelled Rentals',
-                'Rentals with Delay Data',
-                'Problem Cases',
-                'Average Gap (min)',
-                'Average Delay (min)'
-            ],
-            'Value': [
-                f"{len(df):,}",
-                f"{df['has_previous_rental'].sum():,}",
-                f"{len(df[df['checkin_type'].str.lower() == 'connect']):,}",
-                f"{len(df[df['checkin_type'].str.lower() == 'mobile']):,}",
-                f"{len(df[df['state'] == 'canceled']):,}",
-                f"{df['delay_at_checkout_in_minutes'].count():,}",
-                f"{len(problem_cases):,}",
-                f"{df[df['has_previous_rental']]['time_delta_with_previous_rental_in_minutes'].mean():.1f}",
-                f"{df['clean_delay'].mean():.1f}"
-            ]
-        }
-        
-        stats_df = pd.DataFrame(stats_data)
-        st.dataframe(stats_df, use_container_width=True, hide_index=True)
-    
     # Raw data sample
     with st.expander("📋 Raw Data Sample"):
         st.markdown("### First 100 rows of the dataset:")