Update app.py

app.py

@@ -17,24 +17,52 @@ import tempfile
 import os
 import requests
 
-DESIGN_SYSTEM = {
-    'colors': {
-        'primary': '#1E40AF',
-        'secondary': '#059669',
-        'accent': '#DC2626',
-        'warning': '#D97706',
-        'success': '#10B981',
-        'background': '#F8FAFC',
-        'text': '#1F2937',
-        'border': '#E5E7EB'
-    },
-    'fonts': {
-        'title': 'font-family: "Inter", sans-serif; font-weight: 700;',
-        'subtitle': 'font-family: "Inter", sans-serif; font-weight: 600;',
-        'body': 'font-family: "Inter", sans-serif; font-weight: 400;'
+# Configuration and Constants
+class Config:
+    DESIGN_SYSTEM = {
+        'colors': {
+            'primary': '#1E40AF',
+            'secondary': '#059669',
+            'accent': '#DC2626',
+            'warning': '#D97706',
+            'success': '#10B981',
+            'background': '#F8FAFC',
+            'text': '#1F2937',
+            'border': '#E5E7EB'
+        },
+        'fonts': {
+            'title': 'font-family: "Inter", sans-serif; font-weight: 700;',
+            'subtitle': 'font-family: "Inter", sans-serif; font-weight: 600;',
+            'body': 'font-family: "Inter", sans-serif; font-weight: 400;'
+        }
+    }
+    
+    DATA_URLS = {
+        "2024": "https://huggingface.co/spaces/entropy25/production-data-analysis/resolve/main/2024.csv",
+        "2025": "https://huggingface.co/spaces/entropy25/production-data-analysis/resolve/main/2025.csv"
     }
-}
+    
+    CHART_HEIGHT = 400
+    PDF_CHART_SIZE = (6*inch, 3*inch)
+
+# Utility Functions
+def format_material_name(material):
+    return material.replace('_', ' ').title()
+
+def format_weight(weight):
+    return f"{weight:,.0f} kg"
+
+def format_percentage(percentage):
+    return f"{percentage:.1f}%"
+
+def safe_execute(operation_name, func, *args, **kwargs):
+    try:
+        return func(*args, **kwargs)
+    except Exception as e:
+        st.error(f"❌ {operation_name} failed: {str(e)}")
+        return None
 
+# Page Configuration and CSS
 st.set_page_config(
     page_title="Production Monitor with AI Insights | Nilsen Service & Consulting",
     page_icon="🏭",
@@ -43,68 +71,61 @@ st.set_page_config(
 )
 
 def load_css():
-    st.markdown(f"""
+    colors = Config.DESIGN_SYSTEM['colors']
+    fonts = Config.DESIGN_SYSTEM['fonts']
+    
+    css_styles = f"""
     <style>
     @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+    
     .main-header {{
-        background: linear-gradient(135deg, {DESIGN_SYSTEM['colors']['primary']} 0%, {DESIGN_SYSTEM['colors']['secondary']} 100%);
+        background: linear-gradient(135deg, {colors['primary']} 0%, {colors['secondary']} 100%);
         padding: 1.5rem 2rem;
         border-radius: 12px;
         margin-bottom: 2rem;
         color: white;
         text-align: center;
     }}
-    .main-title {{
-        {DESIGN_SYSTEM['fonts']['title']}
-        font-size: 2.2rem;
-        margin: 0;
-        text-shadow: 0 2px 4px rgba(0,0,0,0.1);
-    }}
-    .main-subtitle {{
-        {DESIGN_SYSTEM['fonts']['body']}
-        font-size: 1rem;
-        opacity: 0.9;
-        margin-top: 0.5rem;
-    }}
-    .metric-card {{
+    .main-title {{ {fonts['title']} font-size: 2.2rem; margin: 0; text-shadow: 0 2px 4px rgba(0,0,0,0.1); }}
+    .main-subtitle {{ {fonts['body']} font-size: 1rem; opacity: 0.9; margin-top: 0.5rem; }}
+    
+    .metric-card, .chart-container {{
         background: white;
-        border: 1px solid {DESIGN_SYSTEM['colors']['border']};
+        border: 1px solid {colors['border']};
         border-radius: 12px;
         padding: 1.5rem;
         box-shadow: 0 1px 3px rgba(0,0,0,0.1);
         transition: transform 0.2s ease;
+        margin-bottom: 1rem;
     }}
+    
     .section-header {{
-        {DESIGN_SYSTEM['fonts']['subtitle']}
-        color: {DESIGN_SYSTEM['colors']['text']};
+        {fonts['subtitle']}
+        color: {colors['text']};
         font-size: 1.4rem;
         margin: 2rem 0 1rem 0;
         padding-bottom: 0.5rem;
-        border-bottom: 2px solid {DESIGN_SYSTEM['colors']['primary']};
-    }}
-    .chart-container {{
-        background: white;
-        border-radius: 12px;
-        padding: 1rem;
-        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
-        margin-bottom: 1rem;
+        border-bottom: 2px solid {colors['primary']};
     }}
-    .alert-success {{
-        background: linear-gradient(135deg, {DESIGN_SYSTEM['colors']['success']}15, {DESIGN_SYSTEM['colors']['success']}25);
-        border: 1px solid {DESIGN_SYSTEM['colors']['success']};
+    
+    .alert {{
         border-radius: 8px;
         padding: 1rem;
-        color: {DESIGN_SYSTEM['colors']['success']};
+        margin: 0.5rem 0;
     }}
-    .alert-warning {{
-        background: linear-gradient(135deg, {DESIGN_SYSTEM['colors']['warning']}15, {DESIGN_SYSTEM['colors']['warning']}25);
-        border: 1px solid {DESIGN_SYSTEM['colors']['warning']};
-        border-radius: 8px;
-        padding: 1rem;
-        color: {DESIGN_SYSTEM['colors']['warning']};
+    .alert-success {{ 
+        background: linear-gradient(135deg, {colors['success']}15, {colors['success']}25);
+        border: 1px solid {colors['success']};
+        color: {colors['success']};
     }}
+    .alert-warning {{ 
+        background: linear-gradient(135deg, {colors['warning']}15, {colors['warning']}25);
+        border: 1px solid {colors['warning']};
+        color: {colors['warning']};
+    }}
+    
     .stButton > button {{
-        background: {DESIGN_SYSTEM['colors']['primary']};
+        background: {colors['primary']};
         color: white;
         border: none;
         border-radius: 8px;
@@ -113,8 +134,10 @@ def load_css():
         transition: all 0.2s ease;
     }}
     </style>
-    """, unsafe_allow_html=True)
+    """
+    st.markdown(css_styles, unsafe_allow_html=True)
 
+# Data Processing Functions
 @st.cache_resource
 def init_ai():
     api_key = st.secrets.get("GOOGLE_API_KEY", "")
@@ -123,44 +146,22 @@ def init_ai():
         return genai.GenerativeModel('gemini-1.5-flash')
     return None
 
-@st.cache_data
-def load_preset_data(year):
-    urls = {
-        "2024": "https://huggingface.co/spaces/entropy25/production-data-analysis/resolve/main/2024.csv",
-        "2025": "https://huggingface.co/spaces/entropy25/production-data-analysis/resolve/main/2025.csv"
-    }
-    try:
-        if year in urls:
-            response = requests.get(urls[year], timeout=10)
-            response.raise_for_status()
-            df = pd.read_csv(io.StringIO(response.text), sep='\t')
-            df['date'] = pd.to_datetime(df['date'], format='%m/%d/%Y')
-            df['day_name'] = df['date'].dt.day_name()
-            return df
-        else:
-            return generate_sample_data(year)
-    except Exception as e:
-        st.warning(f"Could not load remote {year} data: {str(e)}. Loading sample data instead.")
-        return generate_sample_data(year)
-
 def generate_sample_data(year):
     np.random.seed(42 if year == "2024" else 84)
     start_date = f"01/01/{year}"
     end_date = f"12/31/{year}"
     dates = pd.date_range(start=start_date, end=end_date, freq='D')
     weekdays = dates[dates.weekday < 5]
+    
     data = []
     materials = ['steel', 'aluminum', 'plastic', 'copper']
     shifts = ['day', 'night']
+    base_weights = {'steel': 1500, 'aluminum': 800, 'plastic': 600, 'copper': 400}
+    
     for date in weekdays:
         for material in materials:
             for shift in shifts:
-                base_weight = {
-                    'steel': 1500,
-                    'aluminum': 800,
-                    'plastic': 600,
-                    'copper': 400
-                }[material]
+                base_weight = base_weights[material]
                 weight = base_weight + np.random.normal(0, base_weight * 0.2)
                 weight = max(weight, base_weight * 0.3)
                 data.append({
@@ -169,14 +170,29 @@ def generate_sample_data(year):
                     'material_type': material,
                     'shift': shift
                 })
-    df = pd.DataFrame(data)
-    df['date'] = pd.to_datetime(df['date'], format='%m/%d/%Y')
-    df['day_name'] = df['date'].dt.day_name()
-    return df
+    
+    return process_raw_data(pd.DataFrame(data))
+
+@st.cache_data
+def load_preset_data(year):
+    try:
+        if year in Config.DATA_URLS:
+            response = requests.get(Config.DATA_URLS[year], timeout=10)
+            response.raise_for_status()
+            df = pd.read_csv(io.StringIO(response.text), sep='\t')
+            return process_raw_data(df)
+        else:
+            return generate_sample_data(year)
+    except Exception as e:
+        st.warning(f"Could not load remote {year} data: {str(e)}. Loading sample data instead.")
+        return generate_sample_data(year)
 
 @st.cache_data
 def load_data(file):
     df = pd.read_csv(file, sep='\t')
+    return process_raw_data(df)
+
+def process_raw_data(df):
     df['date'] = pd.to_datetime(df['date'], format='%m/%d/%Y')
     df['day_name'] = df['date'].dt.day_name()
     return df
@@ -185,6 +201,7 @@ def get_material_stats(df):
     stats = {}
     total = df['weight_kg'].sum()
     total_work_days = df['date'].nunique()
+    
     for material in df['material_type'].unique():
         data = df[df['material_type'] == material]
         work_days = data['date'].nunique()
@@ -196,6 +213,7 @@ def get_material_stats(df):
             'work_days': work_days,
             'records': len(data)
         }
+    
     stats['_total_'] = {
         'total': total,
         'percentage': 100.0,
@@ -205,69 +223,101 @@ def get_material_stats(df):
     }
     return stats
 
+def detect_outliers(df):
+    outliers = {}
+    for material in df['material_type'].unique():
+        material_data = df[df['material_type'] == material]
+        data = material_data['weight_kg']
+        Q1, Q3 = data.quantile(0.25), data.quantile(0.75)
+        IQR = Q3 - Q1
+        lower, upper = Q1 - 1.5 * IQR, Q3 + 1.5 * IQR
+        outlier_mask = (data < lower) | (data > upper)
+        outlier_dates = material_data[outlier_mask]['date'].dt.strftime('%Y-%m-%d').tolist()
+        outliers[material] = {
+            'count': len(outlier_dates),
+            'range': f"{lower:.0f} - {upper:.0f} kg",
+            'dates': outlier_dates
+        }
+    return outliers
+
+# Chart Functions
 def get_chart_theme():
+    colors = Config.DESIGN_SYSTEM['colors']
     return {
         'layout': {
             'plot_bgcolor': 'white',
             'paper_bgcolor': 'white',
-            'font': {'family': 'Inter, sans-serif', 'color': DESIGN_SYSTEM['colors']['text']},
-            'colorway': [DESIGN_SYSTEM['colors']['primary'], DESIGN_SYSTEM['colors']['secondary'], 
-                        DESIGN_SYSTEM['colors']['accent'], DESIGN_SYSTEM['colors']['warning']],
-            'margin': {'t': 60, 'b': 40, 'l': 40, 'r': 40}
+            'font': {'family': 'Inter, sans-serif', 'color': colors['text']},
+            'colorway': [colors['primary'], colors['secondary'], colors['accent'], colors['warning']],
+            'margin': {'t': 60, 'b': 40, 'l': 40, 'r': 40'}
         }
     }
 
+def prepare_time_data(df, time_period):
+    df_copy = df.copy()
+    if time_period == 'weekly':
+        df_copy['week'] = df_copy['date'].dt.isocalendar().week
+        df_copy['year'] = df_copy['date'].dt.year
+        df_copy['period_label'] = df_copy['year'].astype(str) + '-W' + df_copy['week'].astype(str)
+        return df_copy.groupby(['year', 'week']), 'week_label'
+    elif time_period == 'monthly':
+        df_copy['month'] = df_copy['date'].dt.to_period('M')
+        df_copy['period_label'] = df_copy['month'].astype(str)
+        return df_copy.groupby('month'), 'month'
+    else:  # daily
+        return df_copy.groupby('date'), 'date'
+
 def create_total_production_chart(df, time_period='daily'):
     if time_period == 'daily':
         grouped = df.groupby('date')['weight_kg'].sum().reset_index()
         fig = px.line(grouped, x='date', y='weight_kg', 
                      title='Total Production Trend',
                      labels={'weight_kg': 'Weight (kg)', 'date': 'Date'})
-    elif time_period == 'weekly':
-        df_copy = df.copy()
-        df_copy['week'] = df_copy['date'].dt.isocalendar().week
-        df_copy['year'] = df_copy['date'].dt.year
-        grouped = df_copy.groupby(['year', 'week'])['weight_kg'].sum().reset_index()
-        grouped['week_label'] = grouped['year'].astype(str) + '-W' + grouped['week'].astype(str)
-        fig = px.bar(grouped, x='week_label', y='weight_kg',
-                    title='Total Production Trend (Weekly)',
-                    labels={'weight_kg': 'Weight (kg)', 'week_label': 'Week'})
+        fig.update_layout(showlegend=False)
     else:
-        df_copy = df.copy()
-        df_copy['month'] = df_copy['date'].dt.to_period('M')
-        grouped = df_copy.groupby('month')['weight_kg'].sum().reset_index()
-        grouped['month'] = grouped['month'].astype(str)
-        fig = px.bar(grouped, x='month', y='weight_kg',
-                    title='Total Production Trend (Monthly)',
-                    labels={'weight_kg': 'Weight (kg)', 'month': 'Month'})
-    fig.update_layout(**get_chart_theme()['layout'], height=400, showlegend=False)
+        grouped_data, x_col = prepare_time_data(df, time_period)
+        if time_period == 'weekly':
+            grouped = grouped_data['weight_kg'].sum().reset_index()
+            grouped['week_label'] = grouped['year'].astype(str) + '-W' + grouped['week'].astype(str)
+            x_col = 'week_label'
+        else:
+            grouped = grouped_data['weight_kg'].sum().reset_index()
+            grouped['month'] = grouped['month'].astype(str)
+            x_col = 'month'
+        
+        fig = px.bar(grouped, x=x_col, y='weight_kg',
+                    title=f'Total Production Trend ({time_period.title()})',
+                    labels={'weight_kg': 'Weight (kg)', x_col: time_period.title()})
+    
+    fig.update_layout(**get_chart_theme()['layout'], height=Config.CHART_HEIGHT)
     return fig
 
 def create_materials_trend_chart(df, time_period='daily', selected_materials=None):
     df_copy = df.copy()
     if selected_materials:
         df_copy = df_copy[df_copy['material_type'].isin(selected_materials)]
+    
     if time_period == 'daily':
         grouped = df_copy.groupby(['date', 'material_type'])['weight_kg'].sum().reset_index()
         fig = px.line(grouped, x='date', y='weight_kg', color='material_type',
                      title='Materials Production Trends',
                      labels={'weight_kg': 'Weight (kg)', 'date': 'Date', 'material_type': 'Material'})
-    elif time_period == 'weekly':
-        df_copy['week'] = df_copy['date'].dt.isocalendar().week
-        df_copy['year'] = df_copy['date'].dt.year
-        grouped = df_copy.groupby(['year', 'week', 'material_type'])['weight_kg'].sum().reset_index()
-        grouped['week_label'] = grouped['year'].astype(str) + '-W' + grouped['week'].astype(str)
-        fig = px.bar(grouped, x='week_label', y='weight_kg', color='material_type',
-                    title='Materials Production Trends (Weekly)',
-                    labels={'weight_kg': 'Weight (kg)', 'week_label': 'Week', 'material_type': 'Material'})
     else:
-        df_copy['month'] = df_copy['date'].dt.to_period('M')
-        grouped = df_copy.groupby(['month', 'material_type'])['weight_kg'].sum().reset_index()
-        grouped['month'] = grouped['month'].astype(str)
-        fig = px.bar(grouped, x='month', y='weight_kg', color='material_type',
-                    title='Materials Production Trends (Monthly)',
-                    labels={'weight_kg': 'Weight (kg)', 'month': 'Month', 'material_type': 'Material'})
-    fig.update_layout(**get_chart_theme()['layout'], height=400)
+        grouped_data, x_col = prepare_time_data(df_copy, time_period)
+        if time_period == 'weekly':
+            grouped = grouped_data.agg({'weight_kg': 'sum', 'material_type': 'first'}).reset_index()
+            grouped['week_label'] = grouped['year'].astype(str) + '-W' + grouped['week'].astype(str)
+            x_col = 'week_label'
+        else:
+            grouped = grouped_data.agg({'weight_kg': 'sum', 'material_type': 'first'}).reset_index()
+            grouped['month'] = grouped['month'].astype(str)
+            x_col = 'month'
+        
+        fig = px.bar(grouped, x=x_col, y='weight_kg', color='material_type',
+                    title=f'Materials Production Trends ({time_period.title()})',
+                    labels={'weight_kg': 'Weight (kg)', x_col: time_period.title(), 'material_type': 'Material'})
+    
+    fig.update_layout(**get_chart_theme()['layout'], height=Config.CHART_HEIGHT)
     return fig
 
 def create_shift_trend_chart(df, time_period='daily'):
@@ -275,53 +325,40 @@ def create_shift_trend_chart(df, time_period='daily'):
         grouped = df.groupby(['date', 'shift'])['weight_kg'].sum().reset_index()
         pivot_data = grouped.pivot(index='date', columns='shift', values='weight_kg').fillna(0)
         fig = go.Figure()
+        
         if 'day' in pivot_data.columns:
             fig.add_trace(go.Bar(
                 x=pivot_data.index, y=pivot_data['day'], name='Day Shift',
-                marker_color=DESIGN_SYSTEM['colors']['warning'],
+                marker_color=Config.DESIGN_SYSTEM['colors']['warning'],
                 text=pivot_data['day'].round(0), textposition='inside'
             ))
         if 'night' in pivot_data.columns:
             fig.add_trace(go.Bar(
                 x=pivot_data.index, y=pivot_data['night'], name='Night Shift',
-                marker_color=DESIGN_SYSTEM['colors']['primary'],
+                marker_color=Config.DESIGN_SYSTEM['colors']['primary'],
                 base=pivot_data['day'] if 'day' in pivot_data.columns else 0,
                 text=pivot_data['night'].round(0), textposition='inside'
             ))
+        
         fig.update_layout(
-            **get_chart_theme()['layout'],
             title='Daily Shift Production Trends (Stacked)',
             xaxis_title='Date', yaxis_title='Weight (kg)',
-            barmode='stack', height=400, showlegend=True
+            barmode='stack', showlegend=True
         )
     else:
         grouped = df.groupby(['date', 'shift'])['weight_kg'].sum().reset_index()
         fig = px.bar(grouped, x='date', y='weight_kg', color='shift',
                     title=f'{time_period.title()} Shift Production Trends',
                     barmode='stack')
-        fig.update_layout(**get_chart_theme()['layout'], height=400)
+    
+    fig.update_layout(**get_chart_theme()['layout'], height=Config.CHART_HEIGHT)
     return fig
 
-def detect_outliers(df):
-    outliers = {}
-    for material in df['material_type'].unique():
-        material_data = df[df['material_type'] == material]
-        data = material_data['weight_kg']
-        Q1, Q3 = data.quantile(0.25), data.quantile(0.75)
-        IQR = Q3 - Q1
-        lower, upper = Q1 - 1.5 * IQR, Q3 + 1.5 * IQR
-        outlier_mask = (data < lower) | (data > upper)
-        outlier_dates = material_data[outlier_mask]['date'].dt.strftime('%Y-%m-%d').tolist()
-        outliers[material] = {
-            'count': len(outlier_dates),
-            'range': f"{lower:.0f} - {upper:.0f} kg",
-            'dates': outlier_dates
-        }
-    return outliers
-
+# AI Functions
 def generate_ai_summary(model, df, stats, outliers):
     if not model:
         return "AI analysis unavailable - API key not configured"
+    
     try:
         materials = [k for k in stats.keys() if k != '_total_']
         context_parts = [
@@ -334,20 +371,24 @@ def generate_ai_summary(model, df, stats, outliers):
             "",
             "## Material Breakdown:"
         ]
+        
         for material in materials:
             info = stats[material]
-            context_parts.append(f"- {material.title()}: {info['total']:,.0f} kg ({info['percentage']:.1f}%), avg {info['daily_avg']:,.0f} kg/day")
+            context_parts.append(f"- {format_material_name(material)}: {format_weight(info['total'])} ({format_percentage(info['percentage'])}), avg {format_weight(info['daily_avg'])}/day")
+        
         daily_data = df.groupby('date')['weight_kg'].sum()
         trend_direction = "increasing" if daily_data.iloc[-1] > daily_data.iloc[0] else "decreasing"
         volatility = daily_data.std() / daily_data.mean() * 100
+        
         context_parts.extend([
             "",
             "## Trend Analysis:",
             f"- Overall trend: {trend_direction}",
             f"- Production volatility: {volatility:.1f}% coefficient of variation",
-            f"- Peak production: {daily_data.max():,.0f} kg",
-            f"- Lowest production: {daily_data.min():,.0f} kg"
+            f"- Peak production: {format_weight(daily_data.max())}",
+            f"- Lowest production: {format_weight(daily_data.min())}"
         ])
+        
         total_outliers = sum(info['count'] for info in outliers.values())
         context_parts.extend([
             "",
@@ -355,15 +396,18 @@ def generate_ai_summary(model, df, stats, outliers):
             f"- Total outliers detected: {total_outliers}",
             f"- Materials with quality issues: {sum(1 for info in outliers.values() if info['count'] > 0)}"
         ])
+        
         if 'shift' in df.columns:
             shift_stats = df.groupby('shift')['weight_kg'].sum()
             context_parts.extend([
                 "",
                 "## Shift Performance:",
-                f"- Day shift: {shift_stats.get('day', 0):,.0f} kg",
-                f"- Night shift: {shift_stats.get('night', 0):,.0f} kg"
+                f"- Day shift: {format_weight(shift_stats.get('day', 0))}",
+                f"- Night shift: {format_weight(shift_stats.get('night', 0))}"
             ])
+        
         context_text = "\n".join(context_parts)
+        
         prompt = f"""
 {context_text}
 
@@ -388,6 +432,7 @@ Example Recommendation format:
 
 Keep the entire analysis concise and under 300 words.
 """
+        
         response = model.generate_content(prompt)
         return response.text
     except Exception as e:
@@ -396,28 +441,35 @@ Keep the entire analysis concise and under 300 words.
 def query_ai(model, stats, question, df=None):
     if not model:
         return "AI assistant not available"
+    
     context_parts = [
         "Production Data Summary:",
-        *[f"- {mat.title()}: {info['total']:,.0f}kg ({info['percentage']:.1f}%)" 
+        *[f"- {format_material_name(mat)}: {format_weight(info['total'])} ({format_percentage(info['percentage'])})" 
           for mat, info in stats.items() if mat != '_total_'],
-        f"\nTotal Production: {stats['_total_']['total']:,.0f}kg across {stats['_total_']['work_days']} work days"
+        f"\nTotal Production: {format_weight(stats['_total_']['total'])} across {stats['_total_']['work_days']} work days"
     ]
+    
     if df is not None:
         available_cols = list(df.columns)
         context_parts.append(f"\nAvailable data fields: {', '.join(available_cols)}")
+        
         if 'shift' in df.columns:
             shift_stats = df.groupby('shift')['weight_kg'].sum()
             context_parts.append(f"Shift breakdown: {dict(shift_stats)}")
+        
         if 'day_name' in df.columns:
             day_stats = df.groupby('day_name')['weight_kg'].mean()
             context_parts.append(f"Average daily production: {dict(day_stats.round(0))}")
+    
     context = "\n".join(context_parts) + f"\n\nQuestion: {question}\nAnswer based on available data:"
+    
     try:
         response = model.generate_content(context)
         return response.text
     except:
         return "Error getting AI response"
 
+# PDF Export Functions
 def save_plotly_as_image(fig, filename):
     try:
         temp_dir = tempfile.gettempdir()
@@ -430,6 +482,7 @@ def save_plotly_as_image(fig, filename):
             'margin': dict(t=50, b=40, l=40, r=40)
         })
         fig.update_layout(**theme)
+        
         try:
             pio.write_image(fig, filepath, format='png', width=800, height=400, scale=2, engine='kaleido')
             if os.path.exists(filepath):
@@ -442,51 +495,77 @@ def save_plotly_as_image(fig, filename):
 
 def create_pdf_charts(df, stats):
     charts = {}
+    colors = Config.DESIGN_SYSTEM['colors']
+    
     try:
         materials = [k for k in stats.keys() if k != '_total_']
         values = [stats[mat]['total'] for mat in materials]
-        labels = [mat.replace('_', ' ').title() for mat in materials]
+        labels = [format_material_name(mat) for mat in materials]
+        
         if len(materials) > 0 and len(values) > 0:
+            # Distribution Chart
             try:
                 fig_pie = px.pie(values=values, names=labels, title="Production Distribution by Material")
                 charts['pie'] = save_plotly_as_image(fig_pie, "distribution.png")
             except:
                 pass
-        if len(df) > 0:
-            try:
-                daily_data = df.groupby('date')['weight_kg'].sum().reset_index()
-                if len(daily_data) > 0:
-                    fig_trend = px.line(daily_data, x='date', y='weight_kg', title="Daily Production Trend",
-                                        labels={'date': 'Date', 'weight_kg': 'Weight (kg)'},
-                                        color_discrete_sequence=[DESIGN_SYSTEM['colors']['primary']])
-                    charts['trend'] = save_plotly_as_image(fig_trend, "trend.png")
-            except:
-                pass
-        if len(materials) > 0 and len(values) > 0:
+            
+            # Material Comparison Chart
             try:
                 fig_bar = px.bar(x=labels, y=values, title="Production by Material Type",
                                  labels={'x': 'Material Type', 'y': 'Weight (kg)'},
-                                 color_discrete_sequence=[DESIGN_SYSTEM['colors']['primary']])
+                                 color_discrete_sequence=[colors['primary']])
                 charts['bar'] = save_plotly_as_image(fig_bar, "materials.png")
             except:
                 pass
-        if 'shift' in df.columns and len(df) > 0:
+        
+        if len(df) > 0:
+            # Trend Chart
             try:
-                shift_data = df.groupby('shift')['weight_kg'].sum().reset_index()
-                if len(shift_data) > 0 and shift_data['weight_kg'].sum() > 0:
-                    fig_shift = px.pie(shift_data, values='weight_kg', names='shift', title="Production by Shift")
-                    charts['shift'] = save_plotly_as_image(fig_shift, "shifts.png")
+                daily_data = df.groupby('date')['weight_kg'].sum().reset_index()
+                if len(daily_data) > 0:
+                    fig_trend = px.line(daily_data, x='date', y='weight_kg', title="Daily Production Trend",
+                                        labels={'date': 'Date', 'weight_kg': 'Weight (kg)'},
+                                        color_discrete_sequence=[colors['primary']])
+                    charts['trend'] = save_plotly_as_image(fig_trend, "trend.png")
             except:
                 pass
+            
+            # Shift Chart
+            if 'shift' in df.columns:
+                try:
+                    shift_data = df.groupby('shift')['weight_kg'].sum().reset_index()
+                    if len(shift_data) > 0 and shift_data['weight_kg'].sum() > 0:
+                        fig_shift = px.pie(shift_data, values='weight_kg', names='shift', title="Production by Shift")
+                        charts['shift'] = save_plotly_as_image(fig_shift, "shifts.png")
+                except:
+                    pass
     except Exception as e:
         pass
+    
     return charts
 
+def create_pdf_table(data, headers, col_widths, style_color):
+    """Create a standardized PDF table"""
+    table_data = [headers] + data
+    table = Table(table_data, colWidths=col_widths)
+    table.setStyle(TableStyle([
+        ('BACKGROUND', (0, 0), (-1, 0), style_color),
+        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+        ('GRID', (0, 0), (-1, -1), 1, colors.black),
+        ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.lightgrey])
+    ]))
+    return table
+
 def create_enhanced_pdf_report(df, stats, outliers, model=None):
     buffer = io.BytesIO()
     doc = SimpleDocTemplate(buffer, pagesize=A4, rightMargin=50, leftMargin=50, topMargin=50, bottomMargin=50)
     elements = []
     styles = getSampleStyleSheet()
+    
+    # Custom styles
     title_style = ParagraphStyle(
         'CustomTitle',
         parent=styles['Heading1'],
@@ -510,10 +589,15 @@ def create_enhanced_pdf_report(df, stats, outliers, model=None):
         leftIndent=20,
         textColor=colors.darkgreen
     )
-    elements.append(Spacer(1, 100))
-    elements.append(Paragraph("Production Monitor with AI Insights", title_style))
-    elements.append(Paragraph("Comprehensive Production Analysis Report", styles['Heading3']))
-    elements.append(Spacer(1, 50))
+    
+    # Title Page
+    elements.extend([
+        Spacer(1, 100),
+        Paragraph("Production Monitor with AI Insights", title_style),
+        Paragraph("Comprehensive Production Analysis Report", styles['Heading3']),
+        Spacer(1, 50)
+    ])
+    
     report_info = f"""
     <para alignment="center">
     <b>Nilsen Service &amp; Consulting AS</b><br/>
@@ -523,53 +607,59 @@ def create_enhanced_pdf_report(df, stats, outliers, model=None):
     <b>Total Records:</b> {len(df):,}
     </para>
     """
-    elements.append(Paragraph(report_info, styles['Normal']))
-    elements.append(PageBreak())
+    elements.extend([
+        Paragraph(report_info, styles['Normal']),
+        PageBreak()
+    ])
+    
+    # Executive Summary
     elements.append(Paragraph("Executive Summary", subtitle_style))
     total_production = stats['_total_']['total']
     work_days = stats['_total_']['work_days']
     daily_avg = stats['_total_']['daily_avg']
+    
     exec_summary = f"""
     <para>
     This report analyzes production data spanning <b>{work_days} working days</b>. 
-    Total output achieved: <b>{total_production:,.0f} kg</b> with an average 
-    daily production of <b>{daily_avg:,.0f} kg</b>.
+    Total output achieved: <b>{format_weight(total_production)}</b> with an average 
+    daily production of <b>{format_weight(daily_avg)}</b>.
     <br/><br/>
     <b>Key Highlights:</b><br/>
-    • Total production: {total_production:,.0f} kg<br/>
-    • Daily average: {daily_avg:,.0f} kg<br/>
+    • Total production: {format_weight(total_production)}<br/>
+    • Daily average: {format_weight(daily_avg)}<br/>
     • Materials tracked: {len([k for k in stats.keys() if k != '_total_'])}<br/>
     • Data quality: {len(df):,} records processed
     </para>
     """
-    elements.append(Paragraph(exec_summary, styles['Normal']))
-    elements.append(Spacer(1, 20))
-    elements.append(Paragraph("Production Summary", styles['Heading3']))
-    summary_data = [['Material Type', 'Total (kg)', 'Share (%)', 'Daily Avg (kg)']]
+    elements.extend([
+        Paragraph(exec_summary, styles['Normal']),
+        Spacer(1, 20),
+        Paragraph("Production Summary", styles['Heading3'])
+    ])
+    
+    # Summary Table
+    summary_data = []
     for material, info in stats.items():
         if material != '_total_':
             summary_data.append([
-                material.replace('_', ' ').title(),
-                f"{info['total']:,.0f}",
-                f"{info['percentage']:.1f}%",
-                f"{info['daily_avg']:,.0f}"
+                format_material_name(material),
+                format_weight(info['total']),
+                format_percentage(info['percentage']),
+                format_weight(info['daily_avg'])
             ])
-    summary_table = Table(summary_data, colWidths=[2*inch, 1.5*inch, 1*inch, 1.5*inch])
-    summary_table.setStyle(TableStyle([
-        ('BACKGROUND', (0, 0), (-1, 0), colors.darkblue),
-        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
-        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
-        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
-        ('GRID', (0, 0), (-1, -1), 1, colors.black),
-        ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.lightgrey])
-    ]))
-    elements.append(summary_table)
-    elements.append(PageBreak())
+    
+    summary_table = create_pdf_table(
+        summary_data,
+        ['Material Type', 'Total (kg)', 'Share (%)', 'Daily Avg (kg)'],
+        [2*inch, 1.5*inch, 1*inch, 1.5*inch],
+        colors.darkblue
+    )
+    elements.extend([summary_table, PageBreak()])
+    
+    # Charts Section
     elements.append(Paragraph("Production Analysis Charts", subtitle_style))
-    try:
-        charts = create_pdf_charts(df, stats)
-    except:
-        charts = {}
+    
+    charts = create_pdf_charts(df, stats)
     charts_added = False
     chart_insights = {
         'pie': "Material distribution shows production allocation across different materials. Balanced distribution indicates diversified production capabilities.",
@@ -577,6 +667,7 @@ def create_enhanced_pdf_report(df, stats, outliers, model=None):
         'bar': "Material comparison highlights performance differences and production capacities. Top performers indicate optimization opportunities.",
         'shift': "Shift analysis reveals operational efficiency differences between day and night operations. Balance indicates effective resource utilization."
     }
+    
     for chart_type, chart_title in [
         ('pie', "Production Distribution"),
         ('trend', "Production Trend"), 
@@ -586,67 +677,79 @@ def create_enhanced_pdf_report(df, stats, outliers, model=None):
         chart_path = charts.get(chart_type)
         if chart_path and os.path.exists(chart_path):
             try:
-                elements.append(Paragraph(chart_title, styles['Heading3']))
-                elements.append(Image(chart_path, width=6*inch, height=3*inch))
-                insight_text = f"<i>Analysis: {chart_insights.get(chart_type, 'Chart analysis not available.')}</i>"
-                elements.append(Paragraph(insight_text, ai_style))
-                elements.append(Spacer(1, 20))
+                elements.extend([
+                    Paragraph(chart_title, styles['Heading3']),
+                    Image(chart_path, width=Config.PDF_CHART_SIZE[0], height=Config.PDF_CHART_SIZE[1]),
+                    Paragraph(f"<i>Analysis: {chart_insights.get(chart_type, 'Chart analysis not available.')}</i>", ai_style),
+                    Spacer(1, 20)
+                ])
                 charts_added = True
             except Exception as e:
                 pass
+    
     if not charts_added:
-        elements.append(Paragraph("Charts Generation Failed", styles['Heading3']))
-        elements.append(Paragraph("Production Data Summary:", styles['Normal']))
+        elements.extend([
+            Paragraph("Charts Generation Failed", styles['Heading3']),
+            Paragraph("Production Data Summary:", styles['Normal'])
+        ])
         for material, info in stats.items():
             if material != '_total_':
-                summary_text = f"• {material.replace('_', ' ').title()}: {info['total']:,.0f} kg ({info['percentage']:.1f}%)"
+                summary_text = f"• {format_material_name(material)}: {format_weight(info['total'])} ({format_percentage(info['percentage'])})"
                 elements.append(Paragraph(summary_text, styles['Normal']))
         elements.append(Spacer(1, 20))
+    
     elements.append(PageBreak())
+    
+    # Quality Control Analysis
     elements.append(Paragraph("Quality Control Analysis", subtitle_style))
-    quality_data = [['Material', 'Outliers', 'Normal Range (kg)', 'Status']]
+    
+    quality_data = []
     for material, info in outliers.items():
-        if info['count'] == 0:
-            status = "GOOD"
-        elif info['count'] <= 3:
-            status = "MONITOR"
-        else:
-            status = "ATTENTION"
+        status = "GOOD" if info['count'] == 0 else "MONITOR" if info['count'] <= 3 else "ATTENTION"
         quality_data.append([
-            material.replace('_', ' ').title(),
+            format_material_name(material),
             str(info['count']),
             info['range'],
             status
         ])
-    quality_table = Table(quality_data, colWidths=[2*inch, 1*inch, 2*inch, 1.5*inch])
-    quality_table.setStyle(TableStyle([
-        ('BACKGROUND', (0, 0), (-1, 0), colors.darkred),
-        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
-        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
-        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
-        ('GRID', (0, 0), (-1, -1), 1, colors.black),
-        ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.lightgrey])
-    ]))
+    
+    quality_table = create_pdf_table(
+        quality_data,
+        ['Material', 'Outliers', 'Normal Range (kg)', 'Status'],
+        [2*inch, 1*inch, 2*inch, 1.5*inch],
+        colors.darkred
+    )
     elements.append(quality_table)
+    
+    # AI Analysis Section
     if model:
-        elements.append(PageBreak())
-        elements.append(Paragraph("AI Intelligent Analysis", subtitle_style))
+        elements.extend([
+            PageBreak(),
+            Paragraph("AI Intelligent Analysis", subtitle_style)
+        ])
         try:
             ai_analysis = generate_ai_summary(model, df, stats, outliers)
         except:
             ai_analysis = "AI analysis temporarily unavailable."
+        
         ai_paragraphs = ai_analysis.split('\n\n')
         for paragraph in ai_paragraphs:
             if paragraph.strip():
                 formatted_text = paragraph.replace('**', '<b>', 1).replace('**', '</b>', 1) \
                                             .replace('•', '  •') \
                                             .replace('\n', '<br/>')
-                elements.append(Paragraph(formatted_text, styles['Normal']))
-                elements.append(Spacer(1, 8))
+                elements.extend([
+                    Paragraph(formatted_text, styles['Normal']),
+                    Spacer(1, 8)
+                ])
     else:
-        elements.append(PageBreak())
-        elements.append(Paragraph("AI Analysis", subtitle_style))
-        elements.append(Paragraph("AI analysis unavailable - API key not configured. Please configure Google AI API key to enable intelligent insights.", styles['Normal']))
+        elements.extend([
+            PageBreak(),
+            Paragraph("AI Analysis", subtitle_style),
+            Paragraph("AI analysis unavailable - API key not configured. Please configure Google AI API key to enable intelligent insights.", styles['Normal'])
+        ])
+    
+    # Footer
     elements.append(Spacer(1, 30))
     footer_text = f"""
     <para alignment="center">
@@ -656,6 +759,7 @@ def create_enhanced_pdf_report(df, stats, outliers, model=None):
     </para>
     """
     elements.append(Paragraph(footer_text, styles['Normal']))
+    
     doc.build(elements)
     buffer.seek(0)
     return buffer
@@ -663,7 +767,7 @@ def create_enhanced_pdf_report(df, stats, outliers, model=None):
 def create_csv_export(df, stats):
     summary_df = pd.DataFrame([
         {
-            'Material': material.replace('_', ' ').title(),
+            'Material': format_material_name(material),
             'Total_kg': info['total'],
             'Percentage': info['percentage'],
             'Daily_Average_kg': info['daily_avg'],
@@ -674,25 +778,165 @@ def create_csv_export(df, stats):
     ])
     return summary_df
 
-def add_export_section(df, stats, outliers, model):
+# UI Components
+def render_header():
+    st.markdown("""
+    <div class="main-header">
+        <div class="main-title">🏭 Production Monitor with AI Insights</div>
+        <div class="main-subtitle">Nilsen Service & Consulting AS | Real-time Production Analytics & Recommendations</div>
+    </div>
+    """, unsafe_allow_html=True)
+
+def render_sidebar(model):
+    with st.sidebar:
+        st.markdown("### 📊 Data Source")
+        uploaded_file = st.file_uploader("Upload Production Data", type=['csv'])
+        st.markdown("---")
+        st.markdown("### 📊 Quick Load")
+        
+        col1, col2 = st.columns(2)
+        load_2024 = col1.button("📊 2024 Data", type="primary", key="load_2024")
+        load_2025 = col2.button("📊 2025 Data", type="primary", key="load_2025")
+        
+        st.markdown("---")
+        st.markdown("""
+        **Expected TSV format:**
+        - `date`: MM/DD/YYYY
+        - `weight_kg`: Production weight
+        - `material_type`: Material category
+        - `shift`: day/night (optional)
+        """)
+        
+        if model:
+            st.success("🤖 AI Assistant Ready")
+        else:
+            st.warning("⚠️ AI Assistant Unavailable")
+    
+    return uploaded_file, load_2024, load_2025
+
+def render_metric_cards(stats):
+    st.markdown('<div class="section-header">📋 Material Overview</div>', unsafe_allow_html=True)
+    materials = [k for k in stats.keys() if k != '_total_']
+    cols = st.columns(4)
+    
+    for i, material in enumerate(materials[:3]):
+        info = stats[material]
+        with cols[i]:
+            st.metric(
+                label=format_material_name(material),
+                value=format_weight(info['total']),
+                delta=f"{format_percentage(info['percentage'])} of total"
+            )
+            st.caption(f"Daily avg: {format_weight(info['daily_avg'])}")
+    
+    if len(materials) >= 3:
+        total_info = stats['_total_']
+        with cols[3]:
+            st.metric(
+                label="Total Production",
+                value=format_weight(total_info['total']),
+                delta="100% of total"
+            )
+            st.caption(f"Daily avg: {format_weight(total_info['daily_avg'])}")
+
+def render_charts_section(df, stats):
+    st.markdown('<div class="section-header">📊 Production Trends</div>', unsafe_allow_html=True)
+    col1, col2 = st.columns([3, 1])
+    
+    with col2:
+        time_view = st.selectbox("Time Period", ["daily", "weekly", "monthly"], key="time_view_select")
+    
+    with col1:
+        with st.container():
+            st.markdown('<div class="chart-container">', unsafe_allow_html=True)
+            total_chart = create_total_production_chart(df, time_view)
+            st.plotly_chart(total_chart, use_container_width=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Materials Analysis
+    st.markdown('<div class="section-header">🏷️ Materials Analysis</div>', unsafe_allow_html=True)
+    col1, col2 = st.columns([3, 1])
+    
+    materials = [k for k in stats.keys() if k != '_total_']
+    with col2:
+        selected_materials = st.multiselect(
+            "Select Materials", 
+            options=materials, 
+            default=materials,
+            key="materials_select"
+        )
+    
+    with col1:
+        if selected_materials:
+            with st.container():
+                st.markdown('<div class="chart-container">', unsafe_allow_html=True)
+                materials_chart = create_materials_trend_chart(df, time_view, selected_materials)
+                st.plotly_chart(materials_chart, use_container_width=True)
+                st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Shift Analysis
+    if 'shift' in df.columns:
+        st.markdown('<div class="section-header">🌓 Shift Analysis</div>', unsafe_allow_html=True)
+        with st.container():
+            st.markdown('<div class="chart-container">', unsafe_allow_html=True)
+            shift_chart = create_shift_trend_chart(df, time_view)
+            st.plotly_chart(shift_chart, use_container_width=True)
+            st.markdown('</div>', unsafe_allow_html=True)
+
+def render_quality_check(df):
+    st.markdown('<div class="section-header">⚠️ Quality Check</div>', unsafe_allow_html=True)
+    outliers = detect_outliers(df)
+    cols = st.columns(len(outliers))
+    
+    for i, (material, info) in enumerate(outliers.items()):
+        with cols[i]:
+            if info['count'] > 0:
+                dates_str = ", ".join(info['dates'][:3])
+                if len(info['dates']) > 3:
+                    dates_str += f", +{len(info['dates'])-3} more"
+                
+                alert_html = f"""
+                <div class="alert alert-warning">
+                    <strong>{format_material_name(material)}</strong><br>
+                    {info["count"]} outliers detected<br>
+                    Normal range: {info["range"]}<br>
+                    <small>Dates: {dates_str}</small>
+                </div>
+                """
+            else:
+                alert_html = f"""
+                <div class="alert alert-success">
+                    <strong>{format_material_name(material)}</strong><br>
+                    All values normal
+                </div>
+                """
+            st.markdown(alert_html, unsafe_allow_html=True)
+    
+    return outliers
+
+def render_export_section(df, stats, outliers, model):
     st.markdown('<div class="section-header">📄 Export Reports</div>', unsafe_allow_html=True)
-    if 'export_ready' not in st.session_state:
-        st.session_state.export_ready = False
-    if 'pdf_buffer' not in st.session_state:
-        st.session_state.pdf_buffer = None
-    if 'csv_data' not in st.session_state:
-        st.session_state.csv_data = None
+    
+    # Initialize session state
+    for key in ['export_ready', 'pdf_buffer', 'csv_data']:
+        if key not in st.session_state:
+            st.session_state[key] = None if key != 'export_ready' else False
+    
     col1, col2, col3 = st.columns(3)
+    
     with col1:
         if st.button("📊 Generate PDF Report with AI", key="generate_pdf_btn", type="primary"):
-            try:
-                with st.spinner("Generating PDF with AI analysis..."):
-                    st.session_state.pdf_buffer = create_enhanced_pdf_report(df, stats, outliers, model)
-                    st.session_state.export_ready = True
+            result = safe_execute(
+                "PDF generation",
+                lambda: create_enhanced_pdf_report(df, stats, outliers, model)
+            )
+            if result:
+                st.session_state.pdf_buffer = result
+                st.session_state.export_ready = True
                 st.success("✅ PDF report with AI analysis generated successfully!")
-            except Exception as e:
-                st.error(f"❌ PDF generation failed: {str(e)}")
+            else:
                 st.session_state.export_ready = False
+        
         if st.session_state.export_ready and st.session_state.pdf_buffer:
             st.download_button(
                 label="💾 Download PDF Report",
@@ -701,13 +945,14 @@ def add_export_section(df, stats, outliers, model):
                 mime="application/pdf",
                 key="download_pdf_btn"
             )
+    
     with col2:
         if st.button("📈 Generate CSV Summary", key="generate_csv_btn"):
-            try:
-                st.session_state.csv_data = create_csv_export(df, stats)
+            result = safe_execute("CSV generation", lambda: create_csv_export(df, stats))
+            if result is not None:
+                st.session_state.csv_data = result
                 st.success("✅ CSV summary generated successfully!")
-            except Exception as e:
-                st.error(f"❌ CSV generation failed: {str(e)}")
+        
         if st.session_state.csv_data is not None:
             csv_string = st.session_state.csv_data.to_csv(index=False)
             st.download_button(
@@ -717,6 +962,7 @@ def add_export_section(df, stats, outliers, model):
                 mime="text/csv",
                 key="download_csv_btn"
             )
+    
     with col3:
         csv_string = df.to_csv(index=False)
         st.download_button(
@@ -727,185 +973,126 @@ def add_export_section(df, stats, outliers, model):
             key="download_raw_btn"
         )
 
-def main():
-    load_css()
-    st.markdown("""
-    <div class="main-header">
-        <div class="main-title">🏭 Production Monitor with AI Insights</div>
-        <div class="main-subtitle">Nilsen Service & Consulting AS | Real-time Production Analytics & Recommendations</div>
-    </div>
-    """, unsafe_allow_html=True)
-    model = init_ai()
-    if 'current_df' not in st.session_state:
-        st.session_state.current_df = None
-    if 'current_stats' not in st.session_state:
-        st.session_state.current_stats = None
-    with st.sidebar:
-        st.markdown("### 📊 Data Source")
-        uploaded_file = st.file_uploader("Upload Production Data", type=['csv'])
-        st.markdown("---")
-        st.markdown("### 📊 Quick Load")
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("📊 2024 Data", type="primary", key="load_2024"):
-                st.session_state.load_preset = "2024"
-        with col2:
-            if st.button("📊 2025 Data", type="primary", key="load_2025"):
-                st.session_state.load_preset = "2025"
-        st.markdown("---")
+def render_ai_section(df, stats, model):
+    if not model:
+        return
+    
+    st.markdown('<div class="section-header">🤖 AI Insights</div>', unsafe_allow_html=True)
+    
+    quick_questions = [
+        "How does production distribution on weekdays compare to weekends?",
+        "Which material exhibits the most volatility in our dataset?",
+        "To improve stability, which material or shift needs immediate attention?"
+    ]
+    
+    cols = st.columns(len(quick_questions))
+    for i, question in enumerate(quick_questions):
+        with cols[i]:
+            if st.button(question, key=f"ai_q_{i}"):
+                with st.spinner("Analyzing..."):
+                    answer = query_ai(model, stats, question, df)
+                    st.info(answer)
+    
+    custom_question = st.text_input(
+        "Ask about your production data:", 
+        placeholder="e.g., 'Compare steel vs aluminum last month'",
+        key="custom_ai_question"
+    )
+    
+    if custom_question and st.button("Ask AI", key="ask_ai_btn"):
+        with st.spinner("Analyzing..."):
+            answer = query_ai(model, stats, custom_question, df)
+            st.success(f"**Q:** {custom_question}")
+            st.write(f"**A:** {answer}")
+
+def render_welcome_page():
+    st.markdown('<div class="section-header">📖 How to Use This Platform</div>', unsafe_allow_html=True)
+    col1, col2 = st.columns(2)
+    
+    with col1:
         st.markdown("""
-        **Expected TSV format:**
-        - `date`: MM/DD/YYYY
-        - `weight_kg`: Production weight
-        - `material_type`: Material category
-        - `shift`: day/night (optional)
+        ### 🚀 Quick Start
+        1. Upload your TSV data in the sidebar
+        2. Or click Quick Load buttons for preset data
+        3. View production by material type
+        4. Analyze trends (daily/weekly/monthly)
+        5. Check anomalies in Quality Check
+        6. Export reports (PDF with AI, CSV)
+        7. Ask the AI assistant for insights
         """)
-        if model:
-            st.success("🤖 AI Assistant Ready")
-        else:
-            st.warning("⚠️ AI Assistant Unavailable")
-    df = st.session_state.current_df
-    stats = st.session_state.current_stats
+    
+    with col2:
+        st.markdown("""
+        ### 📊 Key Features
+        - Real-time interactive charts
+        - One-click preset data loading
+        - Time-period comparisons
+        - Shift performance analysis
+        - Outlier detection with dates
+        - AI-powered PDF reports
+        - Intelligent recommendations
+        """)
+    
+    st.info("📁 Ready to start? Upload your production data or use Quick Load buttons to begin analysis!")
+
+def handle_data_input():
+    """Handle all data input scenarios"""
+    uploaded_file, load_2024, load_2025 = render_sidebar(init_ai())
+    
+    # Handle uploaded file
     if uploaded_file:
-        try:
-            df = load_data(uploaded_file)
-            stats = get_material_stats(df)
-            st.session_state.current_df = df
+        result = safe_execute("Data loading", load_data, uploaded_file)
+        if result is not None:
+            stats = get_material_stats(result)
+            st.session_state.current_df = result
             st.session_state.current_stats = stats
             st.success("✅ Data uploaded successfully!")
-        except Exception as e:
-            st.error(f"❌ Error loading uploaded file: {str(e)}")
-    elif 'load_preset' in st.session_state:
-        year = st.session_state.load_preset
-        try:
+            return result, stats
+    
+    # Handle preset data loading
+    for year, button_pressed in [("2024", load_2024), ("2025", load_2025)]:
+        if button_pressed:
             with st.spinner(f"Loading {year} data..."):
-                df = load_preset_data(year)
-            if df is not None:
-                stats = get_material_stats(df)
-                st.session_state.current_df = df
+                result = safe_execute("Preset data loading", load_preset_data, year)
+            if result is not None:
+                stats = get_material_stats(result)
+                st.session_state.current_df = result
                 st.session_state.current_stats = stats
                 st.success(f"✅ {year} data loaded successfully!")
-        except Exception as e:
-            st.error(f"❌ Error loading {year} data: {str(e)}")
-        finally:
-            del st.session_state.load_preset
+                return result, stats
+    
+    # Return session state data if available
+    if hasattr(st.session_state, 'current_df') and st.session_state.current_df is not None:
+        return st.session_state.current_df, st.session_state.current_stats
+    
+    return None, None
+
+def render_dashboard(df, stats, model):
+    """Render the complete dashboard"""
+    render_metric_cards(stats)
+    render_charts_section(df, stats)
+    outliers = render_quality_check(df)
+    render_export_section(df, stats, outliers, model)
+    render_ai_section(df, stats, model)
+
+# Main Application
+def main():
+    load_css()
+    render_header()
+    
+    model = init_ai()
+    
+    # Initialize session state
+    for key in ['current_df', 'current_stats']:
+        if key not in st.session_state:
+            st.session_state[key] = None
+    
+    df, stats = handle_data_input()
+    
     if df is not None and stats is not None:
-        st.markdown('<div class="section-header">📋 Material Overview</div>', unsafe_allow_html=True)
-        materials = [k for k in stats.keys() if k != '_total_']
-        cols = st.columns(4)
-        for i, material in enumerate(materials[:3]):
-            info = stats[material]
-            with cols[i]:
-                st.metric(
-                    label=material.replace('_', ' ').title(),
-                    value=f"{info['total']:,.0f} kg",
-                    delta=f"{info['percentage']:.1f}% of total"
-                )
-                st.caption(f"Daily avg: {info['daily_avg']:,.0f} kg")
-        if len(materials) >= 3:
-            total_info = stats['_total_']
-            with cols[3]:
-                st.metric(
-                    label="Total Production",
-                    value=f"{total_info['total']:,.0f} kg",
-                    delta="100% of total"
-                )
-                st.caption(f"Daily avg: {total_info['daily_avg']:,.0f} kg")
-        st.markdown('<div class="section-header">📊 Production Trends</div>', unsafe_allow_html=True)
-        col1, col2 = st.columns([3, 1])
-        with col2:
-            time_view = st.selectbox("Time Period", ["daily", "weekly", "monthly"], key="time_view_select")
-        with col1:
-            with st.container():
-                st.markdown('<div class="chart-container">', unsafe_allow_html=True)
-                total_chart = create_total_production_chart(df, time_view)
-                st.plotly_chart(total_chart, use_container_width=True)
-                st.markdown('</div>', unsafe_allow_html=True)
-        st.markdown('<div class="section-header">🏷️ Materials Analysis</div>', unsafe_allow_html=True)
-        col1, col2 = st.columns([3, 1])
-        with col2:
-            selected_materials = st.multiselect(
-                "Select Materials", 
-                options=materials, 
-                default=materials,
-                key="materials_select"
-            )
-        with col1:
-            if selected_materials:
-                with st.container():
-                    st.markdown('<div class="chart-container">', unsafe_allow_html=True)
-                    materials_chart = create_materials_trend_chart(df, time_view, selected_materials)
-                    st.plotly_chart(materials_chart, use_container_width=True)
-                    st.markdown('</div>', unsafe_allow_html=True)
-        if 'shift' in df.columns:
-            st.markdown('<div class="section-header">🌓 Shift Analysis</div>', unsafe_allow_html=True)
-            with st.container():
-                st.markdown('<div class="chart-container">', unsafe_allow_html=True)
-                shift_chart = create_shift_trend_chart(df, time_view)
-                st.plotly_chart(shift_chart, use_container_width=True)
-                st.markdown('</div>', unsafe_allow_html=True)
-        st.markdown('<div class="section-header">⚠️ Quality Check</div>', unsafe_allow_html=True)
-        outliers = detect_outliers(df)
-        cols = st.columns(len(outliers))
-        for i, (material, info) in enumerate(outliers.items()):
-            with cols[i]:
-                if info['count'] > 0:
-                    if len(info['dates']) <= 5:
-                        dates_str = ", ".join(info['dates'])
-                    else:
-                        dates_str = f"{', '.join(info['dates'][:3])}, +{len(info['dates'])-3} more"
-                    st.markdown(f'<div class="alert-warning"><strong>{material.title()}</strong><br>{info["count"]} outliers detected<br>Normal range: {info["range"]}<br><small>Dates: {dates_str}</small></div>', unsafe_allow_html=True)
-                else:
-                    st.markdown(f'<div class="alert-success"><strong>{material.title()}</strong><br>All values normal</div>', unsafe_allow_html=True)
-        add_export_section(df, stats, outliers, model)
-        if model:
-            st.markdown('<div class="section-header">🤖 AI Insights</div>', unsafe_allow_html=True)
-            quick_questions = [
-                "How does production distribution on weekdays compare to weekends?",
-                "Which material exhibits the most volatility in our dataset?",
-                "To improve stability, which material or shift needs immediate attention?"
-            ]
-            cols = st.columns(len(quick_questions))
-            for i, q in enumerate(quick_questions):
-                with cols[i]:
-                    if st.button(q, key=f"ai_q_{i}"):
-                        with st.spinner("Analyzing..."):
-                            answer = query_ai(model, stats, q, df)
-                            st.info(answer)
-            custom_question = st.text_input("Ask about your production data:", 
-                                            placeholder="e.g., 'Compare steel vs aluminum last month'",
-                                            key="custom_ai_question")
-            if custom_question and st.button("Ask AI", key="ask_ai_btn"):
-                with st.spinner("Analyzing..."):
-                    answer = query_ai(model, stats, custom_question, df)
-                    st.success(f"**Q:** {custom_question}")
-                    st.write(f"**A:** {answer}")
+        render_dashboard(df, stats, model)
     else:
-        st.markdown('<div class="section-header">📖 How to Use This Platform</div>', unsafe_allow_html=True)
-        col1, col2 = st.columns(2)
-        with col1:
-            st.markdown("""
-            ### 🚀 Quick Start
-            1. Upload your TSV data in the sidebar
-            2. Or click Quick Load buttons for preset data
-            3. View production by material type
-            4. Analyze trends (daily/weekly/monthly)
-            5. Check anomalies in Quality Check
-            6. Export reports (PDF with AI, CSV)
-            7. Ask the AI assistant for insights
-            """)
-        with col2:
-            st.markdown("""
-            ### 📊 Key Features
-            - Real-time interactive charts
-            - One-click preset data loading
-            - Time-period comparisons
-            - Shift performance analysis
-            - Outlier detection with dates
-            - AI-powered PDF reports
-            - Intelligent recommendations
-            """)
-        st.info("📁 Ready to start? Upload your production data or use Quick Load buttons to begin analysis!")
+        render_welcome_page()
 
 if __name__ == "__main__":
     main()