Update app.py

app.py

@@ -1,3 +1,4 @@
+# app.py
 import streamlit as st
 import pandas as pd
 import numpy as np
@@ -126,36 +127,48 @@ def calculate_threshold_metrics(df, threshold_minutes, scope="all"):
             "cancellation_rate": 0.0
         }
     
+    # Join with previous rental data to get actual delay information
+    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"
+    )
+    
     # Calculate blocked rentals (gap < threshold)
     df_with_prev["would_be_blocked"] = df_with_prev["time_delta_with_previous_rental_in_minutes"] < threshold_minutes
     
-    # Calculate current problems (delay > gap)
-    df_with_prev["has_delay_data"] = df_with_prev["delay_at_checkout_in_minutes"].notnull()
+    # 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["has_delay_data"] & 
-        (df_with_prev["clean_delay"] > df_with_prev["time_delta_with_previous_rental_in_minutes"])
+        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
+    # Wait time calculation using actual previous delay
     df_with_prev["wait_time_next_driver"] = np.maximum(
         0, 
-        df_with_prev["clean_delay"] - df_with_prev["time_delta_with_previous_rental_in_minutes"]
+        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
+    # Cancellation analysis - much more accurate now
     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"] = (
+    # 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["likely_cancelled_due_to_delay"] & df_with_prev["would_be_blocked"]
+        df_with_prev["cancelled_due_to_previous_delay"] & df_with_prev["would_be_blocked"]
     )
     
     # Calculate final metrics
@@ -169,8 +182,8 @@ 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())
+    # 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())
     cancellation_rate = (current_cancellations / rentals_with_previous) * 100 if rentals_with_previous > 0 else 0
     
@@ -256,6 +269,287 @@ with st.sidebar:
 
 # ========== PAGE 1: DATA OVERVIEW ==========
 if selected == "📊 Data Overview":
+    st.title("📊 Dataset Overview & Exploratory Analysis")
+    
+    st.markdown('<div class="section-header">📈 Dataset Summary</div>', unsafe_allow_html=True)
+    
+    # Basic statistics
+    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("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():,}", 
+                 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)
+    
+    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)
+    
+    # Delay analysis
+    st.markdown('<div class="section-header">⏰ Delay Analysis</div>', unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Delay status distribution
+        df["delay_status"] = df["delay_at_checkout_in_minutes"].apply(
+            lambda x: "Early Return" if pd.notnull(x) and x < 0 else 
+                     "On Time" if pd.notnull(x) and x == 0 else 
+                     "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="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 (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_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"}
+        )
+        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
+    st.markdown('<div class="section-header">📏 Gap Between Rentals Analysis</div>', unsafe_allow_html=True)
+    
+    col1, col2 = st.columns(2)
+    
+    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)
+    
+    # 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 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 = (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("Due to Previous Delay", f"{delay_related_cancels:,}",
+                     help="Cancelled rentals where the previous rental on same car was late")
+        
+        if total_cancels > 0:
+            delay_cancel_rate = (delay_related_cancels / total_cancels * 100)
+            st.metric("% of Cancellations Due to Previous 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 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.
+    </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)
+    
+    problem_cases = df_problems[df_problems["causes_problem"]]
+    
+    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("""
@@ -346,13 +640,28 @@ if selected == "📊 Data Overview":
         
         # 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["delay_at_checkout_in_minutes"].notnull() & 
-            (df_analysis["clean_delay"] > df_analysis["time_delta_with_previous_rental_in_minutes"])
+            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["clean_delay"] - df_analysis["time_delta_with_previous_rental_in_minutes"]
+            df_analysis["previous_delay_clean"] - df_analysis["time_delta_with_previous_rental_in_minutes"]
         ).fillna(0)
         
         problematic_cases = df_analysis[df_analysis["causes_problem"]]
@@ -494,13 +803,14 @@ if selected == "📊 Data Overview":
         <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)
 
-# ========== PAGE 2: THRESHOLD ANALYSIS ==========
-elif selected == "🕐 Threshold Analysis":
+# ========== PAGE 3: SCOPE ANALYSIS ==========
+elif selected == "🎯 Scope Analysis":
     st.title("🎯 Scope Decision: All Cars vs Connect Cars Only?")
     
     st.markdown("""
@@ -650,9 +960,24 @@ elif selected == "🕐 Threshold Analysis":
         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["delay_at_checkout_in_minutes"].notnull() & 
-            (df_problems["clean_delay"] > df_problems["time_delta_with_previous_rental_in_minutes"])
+            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()
@@ -715,257 +1040,6 @@ elif selected == "🕐 Threshold Analysis":
     </div>
     """, unsafe_allow_html=True)
 
-# ========== 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)
-    
-    # Basic statistics
-    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("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():,}", 
-                 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)
-    
-    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)
-    
-    # Delay analysis
-    st.markdown('<div class="section-header">⏰ Delay Analysis</div>', unsafe_allow_html=True)
-    
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        # Delay status distribution
-        df["delay_status"] = df["delay_at_checkout_in_minutes"].apply(
-            lambda x: "Early Return" if pd.notnull(x) and x < 0 else 
-                     "On Time" if pd.notnull(x) and x == 0 else 
-                     "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="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 (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_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"}
-        )
-        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
-    st.markdown('<div class="section-header">📏 Gap Between Rentals Analysis</div>', unsafe_allow_html=True)
-    
-    col1, col2 = st.columns(2)
-    
-    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)
-    
-    # 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()
-    df_problems["causes_problem"] = (
-        df_problems["delay_at_checkout_in_minutes"].notnull() & 
-        (df_problems["clean_delay"] > df_problems["time_delta_with_previous_rental_in_minutes"])
-    )
-    df_problems["wait_time"] = np.maximum(
-        0, 
-        df_problems["clean_delay"] - df_problems["time_delta_with_previous_rental_in_minutes"]
-    ).fillna(0)
-    
-    problem_cases = df_problems[df_problems["causes_problem"]]
-    
-    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:")
-        buffer = st.empty()
-        with buffer.container():
-            st.text("Dataset shape: " + str(df.shape))
-            st.text("Columns: " + str(list(df.columns)))
-            st.text("Data types:")
-            st.text(str(df.dtypes))
-
 # ========== FOOTER ==========
 st.markdown("---")
 st.markdown("""