update viz

config_page.py

@@ -7,7 +7,7 @@ import streamlit as st
 import datetime
 import sys
 import os
-from config import optimization_config
+from src.config import optimization_config
 from src.config.constants import ShiftType, LineType
 
 # Add src directory to path for imports
@@ -24,7 +24,7 @@ def render_config_page():
     initialize_session_state()
     
     # Create tabs for better organization
-    tab1, tab2, tab3, tab4 = st.tabs(["📅 Schedule", "👥 Workforce", "🏭 Operations", "💰 Cost"])
+    tab1, tab2, tab3, tab4, tab5 = st.tabs(["📅 Schedule", "👥 Workforce", "🏭 Operations", "💰 Cost", "📊 Data Selection"])
     
     with tab1:
         render_schedule_config()
@@ -38,6 +38,9 @@ def render_config_page():
     with tab4:
         render_cost_config()
     
+    with tab5:
+        render_data_selection_config()
+    
     # Save configuration button
     st.markdown("---")
     col1, col2, col3 = st.columns([1, 1, 1])
@@ -45,6 +48,8 @@ def render_config_page():
         if st.button("💾 Save Settings", type="primary", use_container_width=True):
             config = save_configuration()
             st.success("✅ Settings saved successfully!")
+            # Trigger demand validation after saving settings
+            st.session_state.show_validation_after_save = True
     
     # Display settings summary at full width (outside columns)
     st.markdown("---")
@@ -52,15 +57,60 @@ def render_config_page():
         with st.expander("📋 Settings Summary", expanded=False):
             display_user_friendly_summary(st.session_state.optimization_config)
     
+    # Show demand validation after saving settings
+    if st.session_state.get('show_validation_after_save', False):
+        st.markdown("---")
+        st.header("📋 Data Validation Results")
+        st.markdown("Analyzing your demand data to identify potential optimization issues...")
+        
+        try:
+            from src.demand_validation import display_demand_validation
+            display_demand_validation()
+            
+            # Show validation reminder before optimization
+            st.info("💡 **Review validation results above before running optimization.** " +
+                   "Fix any critical issues (especially missing line assignments) to improve optimization success.")
+            
+        except Exception as e:
+            st.error(f"❌ Error in demand validation: {str(e)}")
+            st.info("💡 You can still proceed with optimization, but data issues may cause problems.")
+        
+        # Reset the flag so validation doesn't show every time
+        if st.button("✅ Validation Reviewed - Continue to Optimization"):
+            st.session_state.show_validation_after_save = False
+            st.rerun()
+    
     # Optimization section
     st.markdown("---")
     st.header("🚀 Run Optimization")
     st.markdown("Once you've configured your settings, run the optimization to generate the optimal workforce schedule.")
+    st.markdown("**💡 Tip:** Optimization automatically clears all previous cache and results to ensure fresh calculations with your current settings.")
     
     col1, col2, col3 = st.columns([1, 1, 1])
+    with col1:
+        if st.button("🧹 Clear Cache", use_container_width=True):
+            clear_all_cache_and_results()
     with col2:
         if st.button("🚀 Optimize Schedule", type="primary", use_container_width=True):
-            run_optimization()
+            # Quick validation check before optimization
+            validation_warnings = check_critical_data_issues()
+            if validation_warnings:
+                st.warning("⚠️ **Data validation warnings detected:**")
+                for warning in validation_warnings:
+                    st.warning(f"• {warning}")
+                st.warning("**These issues may cause optimization to fail. Consider fixing them first.**")
+                
+                # Give user option to proceed anyway
+                if st.button("⚠️ Proceed with Optimization Anyway", type="secondary"):
+                    run_optimization()
+            else:
+                run_optimization()
+    with col3:
+        # Show status of current results
+        if 'optimization_results' in st.session_state and st.session_state.optimization_results is not None:
+            st.success("✅ Results Available")
+        else:
+            st.info("⏳ No Results Yet")
     
     # Display optimization results if available
     if 'optimization_results' in st.session_state and st.session_state.optimization_results is not None:
@@ -81,14 +131,13 @@ def initialize_session_state():
             MAX_PARALLEL_WORKERS, COST_LIST_PER_EMP_SHIFT,
             PAYMENT_MODE_CONFIG, LINE_CNT_PER_TYPE,
             MAX_EMPLOYEE_PER_TYPE_ON_DAY, start_date, end_date,
-            shift_code_to_name, FIXED_MIN_UNICEF_PER_DAY
+            shift_code_to_name, line_code_to_name, FIXED_MIN_UNICEF_PER_DAY
         )
         
         # Get the actual computed default values from optimization_config.py
         defaults = {
             # Schedule configuration - from optimization_config.py
             'start_date': start_date.date() if hasattr(start_date, 'date') else start_date,
-            'end_date': end_date.date() if hasattr(end_date, 'date') else end_date,
             'schedule_type': DAILY_WEEKLY_SCHEDULE,
             
             # Shift configuration - from optimization_config.py
@@ -128,7 +177,12 @@ def initialize_session_state():
             'unicef_rate_shift_3': COST_LIST_PER_EMP_SHIFT.get("UNICEF Fixed term", {}).get(ShiftType.OVERTIME),
             'humanizer_rate_shift_1': COST_LIST_PER_EMP_SHIFT.get("Humanizer", {}).get(ShiftType.REGULAR),
             'humanizer_rate_shift_2': COST_LIST_PER_EMP_SHIFT.get("Humanizer", {}).get(ShiftType.EVENING),
-            'humanizer_rate_shift_3': COST_LIST_PER_EMP_SHIFT.get("Humanizer", {}).get(ShiftType.OVERTIME),  
+            'humanizer_rate_shift_3': COST_LIST_PER_EMP_SHIFT.get("Humanizer", {}).get(ShiftType.OVERTIME),
+            
+            # Data Selection defaults - reasonable defaults, not ALL available
+            'selected_employee_types': ["UNICEF Fixed term", "Humanizer"],
+            'selected_shifts': [1, 3],  # Regular and Overtime by default, not evening
+            'selected_lines': [6, 7],   # Both Long Line and Mini Load
         }
         
     except Exception as e:
@@ -151,21 +205,14 @@ def render_schedule_config():
         st.session_state.start_date = st.date_input(
             "Start Date",
             value=st.session_state.start_date,
-            help="Start date for the optimization period"
+            help="Exact start date to filter demand data - will only use orders that start on this specific date"
         )
     
     with col2:
-        st.session_state.end_date = st.date_input(
-            "End Date", 
-            value=st.session_state.end_date,
-            help="End date for the optimization period"
-        )
-    
-    # Validate date range
-    if st.session_state.start_date > st.session_state.end_date:
-        st.error("⚠️ Start date must be before or equal to end date!")
+        st.info("💡 **Date Filtering**: System will use only demand data that starts on the exact date you select.")
     
     # Schedule type
+    st.subheader("📅 Scheduling Options")
     st.session_state.schedule_type = st.selectbox(
         "Schedule Type",
         options=['daily', 'weekly'],
@@ -514,11 +561,49 @@ def render_data_selection_config():
 def save_configuration():
     """Save current configuration to session state and potentially to file"""
     
+    # Get available demand dates from data to determine the actual date range
+    try:
+        sys.path.append('src')
+        import src.etl.extract as extract
+        import pandas as pd
+        from datetime import datetime
+        
+        # Get data for the exact start date only
+        start_datetime = datetime.combine(st.session_state.start_date, datetime.min.time())
+        demand_data = extract.read_orders_data(start_date=start_datetime)
+        
+        if not demand_data.empty:
+            # Get the unique finish dates for this start date
+            finish_dates = pd.to_datetime(demand_data["Basic finish date"]).dt.date.unique()
+            finish_dates = sorted(finish_dates)
+            
+            if finish_dates:
+                calculated_end_date = max(finish_dates)
+                calculated_days = (calculated_end_date - st.session_state.start_date).days + 1
+                st.info(f"📊 Found demand data starting on {st.session_state.start_date} ending on {calculated_end_date} ({calculated_days} days, {len(demand_data)} orders)")
+            else:
+                calculated_end_date = st.session_state.start_date
+                calculated_days = 1
+        else:
+            calculated_end_date = st.session_state.start_date
+            calculated_days = 1
+            st.warning(f"⚠️ No demand data found for start date {st.session_state.start_date}")
+    except Exception as e:
+        st.warning(f"Could not determine date range from data: {e}. Using default 5-day period.")
+        from datetime import timedelta
+        calculated_end_date = st.session_state.start_date + timedelta(days=4)
+        calculated_days = 5
+    
+    # Store calculated values in session state for compatibility
+    st.session_state.end_date = calculated_end_date
+    st.session_state.planning_days = calculated_days
+    
     # Create comprehensive configuration dictionary
     config = {
         'date_range': {
             'start_date': st.session_state.start_date,
-            'end_date': st.session_state.end_date,
+            'end_date': calculated_end_date,
+            'planning_days': calculated_days,
         },
         'schedule_type': st.session_state.schedule_type,
         'evening_shift_mode': st.session_state.evening_shift_mode,
@@ -571,13 +656,17 @@ def save_configuration():
         }
     }
     
+    # Calculate date span for proper employee limits (use calculated planning_days)
+    date_span_length = calculated_days
+    date_span = list(range(1, date_span_length + 1))
+    
     # Store individual items in session state for optimization_config.py to access
     st.session_state.line_counts = config['operations']['line_counts']
     st.session_state.cost_list_per_emp_shift = config['cost_rates']
     st.session_state.payment_mode_config = config['payment_mode_config']
     st.session_state.max_employee_per_type_on_day = {
-        "UNICEF Fixed term": {t: st.session_state.max_unicef_per_day for t in range(1, 6)},
-        "Humanizer": {t: st.session_state.max_humanizer_per_day for t in range(1, 6)}
+        "UNICEF Fixed term": {t: st.session_state.max_unicef_per_day for t in date_span},
+        "Humanizer": {t: st.session_state.max_humanizer_per_day for t in date_span}
     }
     
     # Store complete configuration
@@ -595,15 +684,21 @@ def display_user_friendly_summary(config):
     with col1:
         st.write(f"**Start Date:** {config['date_range']['start_date']}")
     with col2:
-        st.write(f"**End Date:** {config['date_range']['end_date']}")
+        st.write(f"**Planning Period:** {config['date_range']['planning_days']} days")
     with col3:
-        st.write(f"**Schedule Type:** {config['schedule_type'].title()}")
+        st.write(f"**End Date:** {config['date_range']['end_date']}")
     with col4:
+        st.write(f"**Schedule Type:** {config['schedule_type'].title()}")
+    
+    # Add evening shift mode in new row
+    col1, col2, col3, col4 = st.columns(4)
+    with col1:
         st.write(f"**Evening Shift Mode:** {config['evening_shift_mode'].replace('_', ' ').title()}")
     
     # Show additional schedule details if evening shift threshold is relevant
     if config['evening_shift_mode'] == 'activate_evening':
-        st.write(f"**Evening Shift Threshold:** {config['evening_shift_threshold']:.0%} demand capacity")
+        with col2:
+            st.write(f"**Evening Shift Threshold:** {config['evening_shift_threshold']:.0%} demand capacity")
     
     # Workforce Settings
     st.subheader("👥 Workforce Settings")
@@ -693,7 +788,7 @@ def display_user_friendly_summary(config):
     col1, col2, col3, col4 = st.columns(4)
     
     with col1:
-        duration = (config['date_range']['end_date'] - config['date_range']['start_date']).days + 1
+        duration = config['date_range']['planning_days']
         st.metric("Planning Period", f"{duration} days")
     
     with col2:
@@ -707,13 +802,161 @@ def display_user_friendly_summary(config):
     with col4:
         avg_unicef_rate = sum(config['cost_rates']['UNICEF Fixed term'].values()) / 3
         st.metric("Avg UNICEF Rate", f"€{avg_unicef_rate:.2f}/hr")
+    
+    # Demand Data Preview
+    st.subheader("📊 Demand Data Preview")
+    try:
+        sys.path.append('src')
+        import src.etl.extract as extract
+        from datetime import datetime
+        
+        # Get demand data for the configured start date
+        start_date = config['date_range']['start_date']
+        start_datetime = datetime.combine(start_date, datetime.min.time())
+        demand_data = extract.read_orders_data(start_date=start_datetime)
+        
+        if not demand_data.empty:
+            # Show summary statistics
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                st.metric("📦 Total Orders", len(demand_data))
+            
+            with col2:
+                total_quantity = demand_data['Order quantity (GMEIN)'].sum()
+                st.metric("📊 Total Quantity", total_quantity)
+            
+            with col3:
+                unique_products = demand_data['Material Number'].nunique()
+                st.metric("🏷️ Unique Products", unique_products)
+            
+            with col4:
+                # Calculate date range
+                if 'Basic finish date' in demand_data.columns:
+                    import pandas as pd
+                    finish_dates = pd.to_datetime(demand_data['Basic finish date']).dt.date
+                    min_finish = finish_dates.min()
+                    max_finish = finish_dates.max()
+                    if min_finish == max_finish:
+                        date_range = f"{min_finish}"
+                    else:
+                        date_range = f"{min_finish} to {max_finish}"
+                else:
+                    date_range = "N/A"
+                st.metric("📅 Finish Dates for the start date orders", date_range)
+            
+            # Show top products
+            if 'Material' in demand_data.columns and 'Quantity' in demand_data.columns:
+                with st.expander("🔝 Top 10 Products by Quantity", expanded=False):
+                    top_products = demand_data.groupby('Material')['Quantity'].sum().sort_values(ascending=False).head(10)
+                    
+                    if not top_products.empty:
+                        # Create a nice table
+                        import pandas as pd
+                        top_products_df = pd.DataFrame({
+                            'Product': top_products.index,
+                            'Total Quantity': top_products.values
+                        }).reset_index(drop=True)
+                        top_products_df.index = top_products_df.index + 1  # Start index from 1
+                        st.dataframe(top_products_df, use_container_width=True)
+                    else:
+                        st.info("No product quantity data available.")
+            
+        else:
+            st.warning(f"⚠️ No demand data found for {start_date}. Please select a different date or check your data files.")
+            
+    except Exception as e:
+        st.error(f"❌ Error loading demand data: {e}")
+
+def clear_all_cache_and_results():
+    """Clear all cached data, modules, and results from previous runs"""
+    import importlib
+    import sys
+    
+    st.info("🧹 Clearing all cached data and previous results...")
+    
+    # 1. Clear all optimization-related session state
+    keys_to_clear = [
+        'optimization_results',
+        'demand_dictionary',
+        'per_product_speed',
+        'kit_hierarchy_data',
+        'team_requirements'
+    ]
+    
+    cleared_keys = []
+    for key in keys_to_clear:
+        if key in st.session_state:
+            del st.session_state[key]
+            cleared_keys.append(key)
+    
+    if cleared_keys:
+        st.write(f"🗑️ Cleared session state: {', '.join(cleared_keys)}")
+    
+    # 2. Force reload all related modules to clear any module-level caches
+    modules_to_reload = [
+        'src.etl.extract',
+        'src.etl.transform',
+        'src.config.optimization_config',
+        'src.models.optimizer_real'
+    ]
+    
+    reloaded_modules = []
+    for module_name in modules_to_reload:
+        if module_name in sys.modules:
+            importlib.reload(sys.modules[module_name])
+            reloaded_modules.append(module_name)
+    
+    if reloaded_modules:
+        st.write(f"🔄 Reloaded modules: {', '.join(reloaded_modules)}")
+    
+    # 3. Get end date from session state (calculated during save) and update global dates
+    if 'end_date' in st.session_state and 'planning_days' in st.session_state:
+        calculated_end_date = st.session_state.end_date
+        planning_days = st.session_state.planning_days
+    else:
+        # Fallback - use start date only for now, will be recalculated
+        from datetime import timedelta
+        calculated_end_date = st.session_state.start_date + timedelta(days=4)
+        planning_days = 5
+    
+    sys.path.append('src')
+    import src.etl.extract as extract
+    extract.set_global_dates(st.session_state.start_date, calculated_end_date)
+    st.write(f"📅 Updated global dates: {st.session_state.start_date} to {calculated_end_date} ({planning_days} days)")
+    
+    st.success("✅ All caches and previous results cleared!")
 
 def run_optimization():
     """Run the optimization model and store results"""
     try:
         st.info("🔄 Running optimization... This may take a few moments.")
         
-        # Import and run the optimization
+        # Always clear everything first for clean slate
+        clear_all_cache_and_results()
+        
+        # Show brief validation summary
+        st.info("📋 Performing pre-optimization data validation...")
+        validation_warnings = check_critical_data_issues()
+        if validation_warnings:
+            with st.expander("⚠️ Data Validation Warnings", expanded=True):
+                for warning in validation_warnings:
+                    st.warning(f"• {warning}")
+                st.warning("**Optimization may fail due to these issues. Consider fixing them first.**")
+        else:
+            st.success("✅ Data validation passed - no critical issues detected")
+        
+        # Show current configuration being used  
+        if 'end_date' in st.session_state and 'planning_days' in st.session_state:
+            calculated_end_date = st.session_state.end_date
+            planning_days = st.session_state.planning_days
+            st.info(f"🗓️ Planning period: {st.session_state.start_date} to {calculated_end_date} ({planning_days} days)")
+        else:
+            st.info(f"🗓️ Start date: {st.session_state.start_date} (will determine end date from demand data)")
+        
+        st.info(f"👥 Max UNICEF/day: {st.session_state.max_unicef_per_day}, Max Humanizer/day: {st.session_state.max_humanizer_per_day}")
+        
+        # Import and run the optimization (after clearing)
         sys.path.append('src')
         from models.optimizer_real import solve_fixed_team_weekly
         
@@ -723,6 +966,8 @@ def run_optimization():
         
         if results is None:
             st.error("❌ Optimization failed! The problem may be infeasible with current settings.")
+            if validation_warnings:
+                st.error("💡 **Likely cause:** Data validation warnings detected above. Fix missing line assignments and other data issues first.")
             st.error("Try adjusting your workforce limits, line counts, or evening shift settings.")
             return
         
@@ -735,6 +980,54 @@ def run_optimization():
         st.error(f"❌ Error during optimization: {str(e)}")
         st.error("Please check your settings and data files.")
 
+def check_critical_data_issues():
+    """
+    Quick check for critical data issues that could cause optimization failure
+    Returns list of warning messages
+    """
+    warnings = []
+    
+    try:
+        # Add src to path if needed
+        import sys
+        import os
+        src_path = os.path.join(os.path.dirname(__file__), 'src')
+        if src_path not in sys.path:
+            sys.path.append(src_path)
+            
+        from src.demand_validation import DemandValidator
+        
+        # Initialize validator and load data
+        validator = DemandValidator()
+        if not validator.load_data():
+            warnings.append("Failed to load validation data")
+            return warnings
+        
+        # Quick validation check
+        validation_df = validator.validate_all_products()
+        summary_stats = validator.get_summary_statistics(validation_df)
+        
+        # Check for critical issues
+        if summary_stats['no_line_assignment'] > 0:
+            warnings.append(f"{summary_stats['no_line_assignment']} products missing line assignments")
+        
+        if summary_stats['no_staffing'] > 0:
+            warnings.append(f"{summary_stats['no_staffing']} products missing staffing requirements")
+        
+        if summary_stats['no_speed'] > 0:
+            warnings.append(f"{summary_stats['no_speed']} products missing production speed data")
+        
+        # Calculate failure risk
+        invalid_ratio = summary_stats['invalid_products'] / summary_stats['total_products']
+        if invalid_ratio > 0.5:
+            warnings.append(f"High failure risk: {invalid_ratio:.0%} of products have data issues")
+        
+        return warnings
+        
+    except Exception as e:
+        warnings.append(f"Validation check failed: {str(e)}")
+        return warnings
+
 def display_optimization_results(results):
     """Import and display optimization results"""
     from optimization_results import display_optimization_results as display_results

optimization_results.py

@@ -45,12 +45,14 @@ def display_optimization_results(results):
     st.header("📊 Optimization Results")
     
     # Create tabs for different views
-    tab1, tab2, tab3, tab4, tab5 = st.tabs([
+    tab1, tab2, tab3, tab4, tab5, tab6, tab7 = st.tabs([
         "📈 Weekly Summary", 
         "📅 Daily Deep Dive", 
         "🏭 Line Schedules", 
         "📦 Kit Production", 
-        "💰 Cost Analysis"
+        "💰 Cost Analysis",
+        "🔍 Input Data",
+        "📋 Demand Validation"
     ])
     
     with tab1:
@@ -67,6 +69,12 @@ def display_optimization_results(results):
     
     with tab5:
         display_cost_analysis(results)
+    
+    with tab6:
+        display_input_data_inspection()
+    
+    with tab7:
+        display_demand_validation_tab()
 
 def display_weekly_summary(results):
     """Display weekly summary with key metrics and charts"""
@@ -213,11 +221,10 @@ def display_daily_deep_dive(results):
         try:
             from src.config.optimization_config import MAX_EMPLOYEE_PER_TYPE_ON_DAY
             
-            # Add capacity columns
+            # Add capacity columns (removed utilization percentage)
             for emp_type in ['UNICEF Fixed term', 'Humanizer']:
                 if emp_type in summary_pivot.columns:
                     capacity_col = f'{emp_type} Capacity'
-                    utilization_col = f'{emp_type} Utilization %'
                     
                     # Extract day number from 'Day X' format
                     summary_pivot['Day_Num'] = summary_pivot['Day'].str.extract(r'(\d+)').astype(int)
@@ -226,15 +233,6 @@ def display_daily_deep_dive(results):
                     summary_pivot[capacity_col] = summary_pivot['Day_Num'].apply(
                         lambda day: MAX_EMPLOYEE_PER_TYPE_ON_DAY.get(emp_type, {}).get(day, 0)
                     )
-                    
-                    # Calculate utilization percentage
-                    summary_pivot[utilization_col] = (
-                        summary_pivot[emp_type] / summary_pivot[capacity_col] * 100
-                    ).round(1)
-                    
-                    # Replace inf and NaN with 0
-                    summary_pivot[utilization_col] = summary_pivot[utilization_col].fillna(0)
-                    summary_pivot.loc[summary_pivot[capacity_col] == 0, utilization_col] = 0
             
             # Drop temporary column
             summary_pivot = summary_pivot.drop('Day_Num', axis=1)
@@ -681,4 +679,279 @@ def display_cost_analysis(results):
         df_costs_with_total = pd.concat([df_costs, total_row], ignore_index=True)
         
         st.subheader("📋 Detailed Cost Breakdown")
-        st.dataframe(df_costs_with_total, use_container_width=True)
+        st.dataframe(df_costs_with_total, use_container_width=True)
+
+
+def display_input_data_inspection():
+    """
+    Display comprehensive input data inspection showing what was fed into the optimizer
+    """
+    st.subheader("🔍 Input Data Inspection")
+    st.markdown("This section shows all the input data and parameters that were fed into the optimization model.")
+    
+    # Import the optimization config to get current values
+    try:
+        from src.config import optimization_config
+        from src.config.constants import ShiftType, LineType, KitLevel
+        
+        # Create expandable sections for different data categories
+        with st.expander("📅 **Schedule & Time Parameters**", expanded=True):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("**Date Range:**")
+                date_span = optimization_config.get_date_span()
+                st.write(f"• Planning Period: {len(date_span)} days")
+                st.write(f"• Date Span: {list(date_span)}")
+                
+                st.write("**Shift Configuration:**")
+                shift_list = optimization_config.get_shift_list()
+                for shift in shift_list:
+                    shift_name = ShiftType.get_name(shift)
+                    st.write(f"• {shift_name} (ID: {shift})")
+            
+            with col2:
+                st.write("**Work Hours Configuration:**")
+                max_hours_shift = optimization_config.get_max_hour_per_shift_per_person()
+                for shift_id, hours in max_hours_shift.items():
+                    shift_name = ShiftType.get_name(shift_id)
+                    st.write(f"• {shift_name}: {hours} hours/shift")
+                
+                max_daily_hours = optimization_config.get_max_hour_per_person_per_day()
+                st.write(f"• Maximum daily hours per person: {max_daily_hours}")
+        
+        with st.expander("👥 **Workforce Parameters**", expanded=False):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("**Employee Types:**")
+                emp_types = optimization_config.get_employee_type_list()
+                for emp_type in emp_types:
+                    st.write(f"• {emp_type}")
+                
+                st.write("**Daily Workforce Capacity:**")
+                max_emp_per_day = optimization_config.get_max_employee_per_type_on_day()
+                for emp_type, daily_caps in max_emp_per_day.items():
+                    st.write(f"**{emp_type}:**")
+                    for day, count in daily_caps.items():
+                        st.write(f"  - Day {day}: {count} employees")
+            
+            with col2:
+                st.write("**Team Requirements per Product:**")
+                team_req = optimization_config.get_team_req_per_product()
+                st.write("*Sample products:*")
+                # Show first few products as examples
+                sample_products = list(team_req.get('UNICEF Fixed term', {}).keys())[:5]
+                for product in sample_products:
+                    st.write(f"**{product}:**")
+                    for emp_type in emp_types:
+                        req = team_req.get(emp_type, {}).get(product, 0)
+                        if req > 0:
+                            st.write(f"  - {emp_type}: {req}")
+                
+                if len(team_req.get('UNICEF Fixed term', {})) > 5:
+                    remaining = len(team_req.get('UNICEF Fixed term', {})) - 5
+                    st.write(f"... and {remaining} more products")
+        
+        with st.expander("🏭 **Production & Line Parameters**", expanded=False):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("**Line Configuration:**")
+                line_list = optimization_config.get_line_list()
+                line_cnt = optimization_config.get_line_cnt_per_type()
+                
+                for line_type in line_list:
+                    line_name = LineType.get_name(line_type)
+                    count = line_cnt.get(line_type, 0)
+                    st.write(f"• {line_name} (ID: {line_type}): {count} lines")
+                
+                st.write("**Maximum Workers per Line:**")
+                max_workers = optimization_config.get_max_parallel_workers()
+                for line_type, max_count in max_workers.items():
+                    line_name = LineType.get_name(line_type)
+                    st.write(f"• {line_name}: {max_count} workers max")
+            
+            with col2:
+                st.write("**Product-Line Matching:**")
+                kit_line_match = optimization_config.get_kit_line_match_dict()
+                st.write("*Sample mappings:*")
+                sample_items = list(kit_line_match.items())[:10]
+                for product, line_type in sample_items:
+                    line_name = LineType.get_name(line_type)
+                    st.write(f"• {product}: {line_name}")
+                
+                if len(kit_line_match) > 10:
+                    remaining = len(kit_line_match) - 10
+                    st.write(f"... and {remaining} more product mappings")
+        
+        with st.expander("📦 **Product & Demand Data**", expanded=False):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("**Product List:**")
+                product_list = optimization_config.get_product_list()
+                st.write(f"• Total products: {len(product_list)}")
+                st.write("*Sample products:*")
+                for product in product_list[:10]:
+                    st.write(f"  - {product}")
+                if len(product_list) > 10:
+                    st.write(f"  ... and {len(product_list) - 10} more")
+                
+                st.write("**Production Speed (units/hour):**")
+                speed_data = optimization_config.get_per_product_speed()
+                st.write("*Sample speeds:*")
+                sample_speeds = list(speed_data.items())[:5]
+                for product, speed in sample_speeds:
+                    st.write(f"• {product}: {speed:.1f} units/hour")
+                if len(speed_data) > 5:
+                    remaining = len(speed_data) - 5
+                    st.write(f"... and {remaining} more products")
+            
+            with col2:
+                st.write("**Weekly Demand:**")
+                demand_dict = optimization_config.get_demand_dictionary()
+                st.write(f"• Total products with demand: {len(demand_dict)}")
+                
+                # Calculate total demand
+                total_demand = sum(demand_dict.values())
+                st.write(f"• Total weekly demand: {total_demand:,.0f} units")
+                
+                st.write("*Sample demands:*")
+                # Sort by demand to show highest first
+                sorted_demands = sorted(demand_dict.items(), key=lambda x: x[1], reverse=True)[:10]
+                for product, demand in sorted_demands:
+                    st.write(f"• {product}: {demand:,.0f} units")
+                
+                if len(demand_dict) > 10:
+                    remaining = len(demand_dict) - 10
+                    st.write(f"... and {remaining} more products")
+        
+        with st.expander("🏗️ **Kit Hierarchy & Dependencies**", expanded=False):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("**Kit Levels:**")
+                kit_levels = optimization_config.get_kit_levels()
+                
+                # Count by level
+                level_counts = {}
+                for kit, level in kit_levels.items():
+                    level_name = KitLevel.get_name(level)
+                    if level_name not in level_counts:
+                        level_counts[level_name] = 0
+                    level_counts[level_name] += 1
+                
+                for level_name, count in level_counts.items():
+                    st.write(f"• {level_name}: {count} kits")
+                
+                st.write("*Sample kit levels:*")
+                sample_levels = list(kit_levels.items())[:10]
+                for kit, level in sample_levels:
+                    level_name = KitLevel.get_name(level)
+                    st.write(f"  - {kit}: {level_name}")
+                
+                if len(kit_levels) > 10:
+                    remaining = len(kit_levels) - 10
+                    st.write(f"  ... and {remaining} more kits")
+            
+            with col2:
+                st.write("**Dependencies:**")
+                kit_deps = optimization_config.get_kit_dependencies()
+                
+                # Count dependencies
+                total_deps = sum(len(deps) for deps in kit_deps.values())
+                kits_with_deps = len([k for k, deps in kit_deps.items() if deps])
+                
+                st.write(f"• Total dependency relationships: {total_deps}")
+                st.write(f"• Kits with dependencies: {kits_with_deps}")
+                
+                st.write("*Sample dependencies:*")
+                sample_deps = [(k, deps) for k, deps in kit_deps.items() if deps][:5]
+                for kit, deps in sample_deps:
+                    st.write(f"• {kit}:")
+                    for dep in deps[:3]:  # Show max 3 deps per kit
+                        st.write(f"  - depends on: {dep}")
+                    if len(deps) > 3:
+                        st.write(f"  - ... and {len(deps) - 3} more")
+                
+                if len(sample_deps) > 5:
+                    remaining = len([k for k, deps in kit_deps.items() if deps]) - 5
+                    st.write(f"... and {remaining} more kits with dependencies")
+        
+        with st.expander("💰 **Cost & Payment Configuration**", expanded=False):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("**Hourly Cost Rates:**")
+                cost_rates = optimization_config.get_cost_list_per_emp_shift()
+                
+                for emp_type, shift_costs in cost_rates.items():
+                    st.write(f"**{emp_type}:**")
+                    for shift_id, cost in shift_costs.items():
+                        shift_name = ShiftType.get_name(shift_id)
+                        st.write(f"  - {shift_name}: €{cost:.2f}/hour")
+            
+            with col2:
+                st.write("**Payment Mode Configuration:**")
+                payment_config = optimization_config.get_payment_mode_config()
+                
+                payment_descriptions = {
+                    'bulk': 'Full shift payment (even for partial hours)',
+                    'partial': 'Pay only for actual hours worked'
+                }
+                
+                for shift_id, mode in payment_config.items():
+                    shift_name = ShiftType.get_name(shift_id)
+                    description = payment_descriptions.get(mode, mode)
+                    st.write(f"• **{shift_name}:** {mode.title()}")
+                    st.caption(f"  {description}")
+        
+        with st.expander("⚙️ **Additional Configuration**", expanded=False):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("**Schedule Mode:**")
+                schedule_mode = optimization_config.get_daily_weekly_schedule()
+                st.write(f"• Planning mode: {schedule_mode}")
+                
+                st.write("**Evening Shift Mode:**")
+                evening_mode = optimization_config.get_evening_shift_mode()
+                evening_threshold = optimization_config.get_evening_shift_demand_threshold()
+                st.write(f"• Mode: {evening_mode}")
+                st.write(f"• Activation threshold: {evening_threshold:.1%}")
+            
+            with col2:
+                st.write("**Fixed Staffing:**")
+                fixed_min_unicef = optimization_config.get_fixed_min_unicef_per_day()
+                st.write(f"• Minimum UNICEF staff per day: {fixed_min_unicef}")
+                
+                st.write("**Data Sources:**")
+                st.write("• Kit hierarchy: kit_hierarchy.json")
+                st.write("• Production orders: CSV files")
+                st.write("• Personnel data: WH_Workforce CSV")
+                st.write("• Speed data: Kits_Calculation CSV")
+        
+    except Exception as e:
+        st.error(f"❌ Error loading input data inspection: {str(e)}")
+        st.info("💡 This may happen if the optimization configuration is not properly loaded. Please check the Settings page first.")
+    
+    # Add refresh button
+    st.markdown("---")
+    if st.button("🔄 Refresh Input Data", help="Reload the current configuration data"):
+        st.rerun()
+
+
+def display_demand_validation_tab():
+    """
+    Display demand validation in the optimization results tab
+    """
+    try:
+        from src.demand_validation import display_demand_validation
+        display_demand_validation()
+    except ImportError as e:
+        st.error(f"❌ Error loading demand validation module: {str(e)}")
+        st.info("💡 Please ensure the demand validation module is properly installed.")
+    except Exception as e:
+        st.error(f"❌ Error in demand validation: {str(e)}")
+        st.info("💡 Please check the data files and configuration.")