Update app.py

app.py

@@ -66,21 +66,13 @@ def load_css():
         opacity: 0.9;
         margin-top: 0.5rem;
     }}
-    .nilsen-badge {{
-        background: linear-gradient(135deg, #10B981, #059669);
-        color: white;
-        padding: 0.5rem 1rem;
-        border-radius: 20px;
-        font-size: 0.9rem;
-        font-weight: 600;
-        margin: 0.5rem 0;
-    }}
-    .tech-highlight {{
-        background: linear-gradient(135deg, #1E40AF15, #1E40AF25);
-        border-left: 4px solid #1E40AF;
-        padding: 1rem;
-        margin: 1rem 0;
-        border-radius: 0 8px 8px 0;
+    .metric-card {{
+        background: white;
+        border: 1px solid {DESIGN_SYSTEM['colors']['border']};
+        border-radius: 12px;
+        padding: 1.5rem;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+        transition: transform 0.2s ease;
     }}
     .section-header {{
         {DESIGN_SYSTEM['fonts']['subtitle']}
@@ -120,6 +112,15 @@ def load_css():
         font-weight: 500;
         transition: all 0.2s ease;
     }}
+    .stDownloadButton > button {{
+        background: {DESIGN_SYSTEM['colors']['primary']} !important;
+        color: white !important;
+        border: none !important;
+        border-radius: 8px !important;
+        padding: 0.5rem 1rem !important;
+        font-weight: 500 !important;
+        transition: all 0.2s ease !important;
+    }}
     </style>
     """, unsafe_allow_html=True)
 
@@ -163,7 +164,12 @@ def generate_sample_data(year):
     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 = {
+                    'steel': 1500,
+                    'aluminum': 800,
+                    'plastic': 600,
+                    'copper': 400
+                }[material]
                 weight = base_weight + np.random.normal(0, base_weight * 0.2)
                 weight = max(weight, base_weight * 0.3)
                 data.append({
@@ -208,168 +214,6 @@ def get_material_stats(df):
     }
     return stats
 
-def calculate_advanced_metrics(df, stats):
-    """Calculate advanced metrics to showcase Nilsen's technical capabilities"""
-    metrics = {}
-    daily_production = df.groupby('date')['weight_kg'].sum()
-    
-    # Nilsen Production Efficiency Index (proprietary algorithm)
-    efficiency_index = (daily_production.mean() / daily_production.std()) * 10
-    metrics['efficiency_index'] = min(100, efficiency_index)
-    
-    # Material Balance Optimization Score
-    material_values = [stats[k]['total'] for k in stats.keys() if k != '_total_']
-    balance_score = (1 - (np.std(material_values) / np.mean(material_values))) * 100
-    metrics['balance_score'] = max(0, min(100, balance_score))
-    
-    # Production Stability Rating (0-10)
-    cv = daily_production.std() / daily_production.mean()
-    stability_score = max(0, min(10, 10 * (1 - cv)))
-    metrics['stability_score'] = stability_score
-    
-    # Trend Strength Indicator
-    x = np.arange(len(daily_production))
-    correlation = np.corrcoef(x, daily_production.values)[0,1]
-    trend_strength = abs(correlation) * 100
-    metrics['trend_strength'] = trend_strength
-    
-    return metrics
-
-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
-
-def generate_nilsen_ai_summary(model, df, stats, outliers):
-    """Generate AI summary showcasing Nilsen's analytical capabilities"""
-    if not model:
-        return "🤖 **Nilsen AI Analysis Engine** - Offline\n\nAdvanced analytics temporarily unavailable. Our proprietary algorithms include machine learning anomaly detection, predictive modeling, and production optimization insights."
-    
-    try:
-        metrics = calculate_advanced_metrics(df, stats)
-        materials = [k for k in stats.keys() if k != '_total_']
-        
-        # Calculate positive indicators
-        total_records = len(df)
-        total_outliers = sum(info['count'] for info in outliers.values())
-        quality_stability_rate = ((total_records - total_outliers) / total_records) * 100
-        
-        # Find top performing material
-        best_material = max(materials, key=lambda x: stats[x]['total'])
-        best_material_share = stats[best_material]['percentage']
-        
-        # Production capacity utilization
-        daily_production = df.groupby('date')['weight_kg'].sum()
-        capacity_utilization = (daily_production.mean() / daily_production.max()) * 100
-        
-        context = f"""
-=== NILSEN ADVANCED ANALYTICS SHOWCASE ===
-
-TECHNICAL PERFORMANCE INDICATORS:
-• Nilsen Efficiency Index: {metrics['efficiency_index']:.1f}/100 (proprietary algorithm)
-• Production Stability Score: {metrics['stability_score']:.1f}/10 (machine learning assessment)
-• Material Balance Optimization: {metrics['balance_score']:.1f}% (advanced distribution analysis)
-• Trend Prediction Confidence: {metrics['trend_strength']:.1f}% (time-series modeling)
-• Quality Stability Rate: {quality_stability_rate:.1f}% (statistical process control)
-
-PRODUCTION EXCELLENCE INDICATORS:
-• Top Performer: {best_material.title()} ({best_material_share:.1f}% production share)
-• Capacity Utilization: {capacity_utilization:.1f}% (operational efficiency)
-• Data Processing Scale: {len(df):,} records across {stats['_total_']['work_days']} production days
-• Multi-dimensional Analysis: {len(materials)} material types, shift patterns, trend analysis
-
-NILSEN VALUE PROPOSITION:
-As Nilsen Service & Consulting's senior AI analyst, showcase our competitive advantages and technical depth.
-        """
-        
-        prompt = f"""
-{context}
-
-You are Nilsen Service & Consulting's AI Analytics Expert. Your mission is to showcase our advanced data science capabilities and highlight production excellence, NOT problems.
-
-Format your response as:
-
-**🏢 NILSEN AI TECHNICAL INSIGHTS**
-Highlight 3 sophisticated analytical discoveries that demonstrate our advanced algorithms and data science expertise.
-
-**🎯 PRODUCTION EXCELLENCE IDENTIFIED**
-Focus on competitive advantages, operational strengths, and performance highlights discovered through our proprietary analysis methods.
-
-**💡 NILSEN VALUE-ADD RECOMMENDATIONS**
-Provide strategic enhancement suggestions that showcase our industry expertise and consulting value.
-
-**🔬 METHODOLOGY NOTE**
-Brief mention of the advanced techniques used (machine learning, predictive modeling, statistical analysis).
-
-Requirements:
-- Professional consulting tone
-- Emphasize Nilsen's technical sophistication
-- Focus on strengths and opportunities, not problems
-- Maximum 300 words
-- Include specific metrics from the data
-"""
-        
-        response = model.generate_content(prompt)
-        return response.text
-        
-    except Exception as e:
-        return f"**🏢 Nilsen AI Analysis Engine**\n\nTemporary processing delay. Our advanced analytics platform combines machine learning, predictive modeling, and statistical analysis to deliver production insights. Error: {str(e)}"
-
-def query_nilsen_ai(model, stats, question, df=None):
-    """Enhanced AI query with Nilsen branding and technical focus"""
-    if not model:
-        return "**Nilsen AI Assistant** - Currently offline. Our intelligent analysis system provides advanced production insights through proprietary algorithms."
-    
-    try:
-        metrics = calculate_advanced_metrics(df, stats) if df is not None else {}
-        
-        context = f"""
-=== NILSEN SERVICE & CONSULTING AI SYSTEM ===
-
-TECHNICAL CAPABILITIES:
-✓ Advanced Data Science Algorithms
-✓ Predictive Analytics Engine  
-✓ Real-time Production Monitoring
-✓ Machine Learning Anomaly Detection
-
-CURRENT ANALYSIS SCOPE:
-- Production Volume: {stats['_total_']['total']:,.0f} kg
-- Analysis Period: {stats['_total_']['work_days']} working days
-- Materials Portfolio: {len([k for k in stats.keys() if k != '_total_'])} types
-- Data Processing: {stats['_total_']['records']:,} records
-
-NILSEN PROPRIETARY METRICS:
-- Efficiency Index: {metrics.get('efficiency_index', 'N/A'):.1f}/100
-- Stability Score: {metrics.get('stability_score', 'N/A'):.1f}/10
-- Balance Optimization: {metrics.get('balance_score', 'N/A'):.1f}%
-
-As Nilsen's AI expert, answer with focus on:
-1. Technical analysis depth
-2. Production advantages and strengths  
-3. Industry expertise demonstration
-4. Value-added insights
-
-Question: {question}
-        """
-        
-        response = model.generate_content(context)
-        return f"**🤖 Nilsen AI Analysis:**\n\n{response.text}\n\n*Analysis powered by Nilsen's proprietary data science platform*"
-        
-    except Exception as e:
-        return f"**Nilsen AI Processing**: {str(e)}"
-
 def get_chart_theme():
     return {
         'layout': {
@@ -386,7 +230,7 @@ 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='Production Performance Trend - Nilsen Analytics',
+                     title='Total Production Trend',
                      labels={'weight_kg': 'Weight (kg)', 'date': 'Date'})
     elif time_period == 'weekly':
         df_copy = df.copy()
@@ -395,7 +239,7 @@ def create_total_production_chart(df, time_period='daily'):
         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='Weekly Production Analysis - Nilsen Intelligence',
+                    title='Total Production Trend (Weekly)',
                     labels={'weight_kg': 'Weight (kg)', 'week_label': 'Week'})
     else:
         df_copy = df.copy()
@@ -403,7 +247,7 @@ def create_total_production_chart(df, time_period='daily'):
         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='Monthly Production Excellence - Nilsen Insights',
+                    title='Total Production Trend (Monthly)',
                     labels={'weight_kg': 'Weight (kg)', 'month': 'Month'})
     fig.update_layout(**get_chart_theme()['layout'], height=400, showlegend=False)
     return fig
@@ -415,7 +259,7 @@ def create_materials_trend_chart(df, time_period='daily', selected_materials=Non
     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='Material Portfolio Performance - Nilsen Analytics',
+                     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
@@ -423,14 +267,14 @@ def create_materials_trend_chart(df, time_period='daily', selected_materials=Non
         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='Weekly Material Excellence - Nilsen Intelligence',
+                    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='Monthly Material Strategy - Nilsen Insights',
+                    title='Materials Production Trends (Monthly)',
                     labels={'weight_kg': 'Weight (kg)', 'month': 'Month', 'material_type': 'Material'})
     fig.update_layout(**get_chart_theme()['layout'], height=400)
     return fig
@@ -442,88 +286,275 @@ def create_shift_trend_chart(df, time_period='daily'):
         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 Performance',
+                x=pivot_data.index, y=pivot_data['day'], name='Day Shift',
                 marker_color=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 Performance',
+                x=pivot_data.index, y=pivot_data['night'], name='Night Shift',
                 marker_color=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='Shift Optimization Analysis - Nilsen Operations Intelligence',
+            title='Daily Shift Production Trends (Stacked)',
             xaxis_title='Date', yaxis_title='Weight (kg)',
             barmode='stack', height=400, 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 Excellence Analysis',
+                    title=f'{time_period.title()} Shift Production Trends',
                     barmode='stack')
         fig.update_layout(**get_chart_theme()['layout'], height=400)
     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
+
+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 = [
+            "# Production Data Analysis Context",
+            f"## Overview",
+            f"- Total Production: {stats['_total_']['total']:,.0f} kg",
+            f"- Production Period: {stats['_total_']['work_days']} working days", 
+            f"- Daily Average: {stats['_total_']['daily_avg']:,.0f} kg",
+            f"- Materials Tracked: {len(materials)}",
+            "",
+            "## 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")
+        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"
+        ])
+        total_outliers = sum(info['count'] for info in outliers.values())
+        context_parts.extend([
+            "",
+            "## Quality Control:",
+            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"
+            ])
+        context_text = "\n".join(context_parts)
+        prompt = f"""
+{context_text}
+
+As an expert AI analyst embedded within the "Production Monitor with AI Insights" platform, provide a comprehensive analysis based on the data provided. Your tone should be professional and data-driven. Your primary goal is to highlight how the platform's features reveal critical insights.
+
+Structure your response in the following format:
+
+**PRODUCTION ASSESSMENT**
+Evaluate the overall production status (Excellent/Good/Needs Attention). Briefly justify your assessment using key metrics from the data summary.
+
+**KEY FINDINGS**
+Identify 3-4 of the most important insights. For each finding, explicitly mention the platform feature that made the discovery possible. Use formats like "(revealed by the 'Quality Check' module)" or "(visualized in the 'Production Trend' chart)".
+
+Example Finding format:
+• Finding X: [Your insight, e.g., "Liquid-Ctu production shows high volatility..."] (as identified by the 'Materials Analysis' view).
+
+**RECOMMENDATIONS**
+Provide 2-3 actionable recommendations. Frame these as steps the management can take, encouraging them to use the platform for further investigation.
+
+Example Recommendation format:
+• Recommendation Y: [Your recommendation, e.g., "Investigate the root causes of the 11 outliers..."] We recommend using the platform's interactive charts to drill down into the specific dates identified by the 'Quality Check' module.
+
+Keep the entire analysis concise and under 300 words.
+"""
+        response = model.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        return f"AI analysis error: {str(e)}"
+
+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}%)" 
+          for mat, info in stats.items() if mat != '_total_'],
+        f"\nTotal Production: {stats['_total_']['total']:,.0f}kg 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"
+
+def save_plotly_as_image(fig, filename):
+    try:
+        temp_dir = tempfile.gettempdir()
+        filepath = os.path.join(temp_dir, filename)
+        theme = get_chart_theme()['layout'].copy()
+        theme.update({
+            'font': dict(size=12, family="Arial"),
+            'plot_bgcolor': 'white',
+            'paper_bgcolor': 'white',
+            '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):
+                return filepath
+        except:
+            pass
+        return None
+    except Exception as e:
+        return None
+
+def create_pdf_charts(df, stats):
+    charts = {}
+    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]
+        if len(materials) > 0 and len(values) > 0:
+            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:
+            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']])
+                charts['bar'] = save_plotly_as_image(fig_bar, "materials.png")
+            except:
+                pass
+        if 'shift' in df.columns and len(df) > 0:
+            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_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()
-    
-    title_style = ParagraphStyle('CustomTitle', parent=styles['Heading1'], fontSize=24, spaceAfter=30, alignment=1, textColor=colors.darkblue)
-    subtitle_style = ParagraphStyle('CustomSubtitle', parent=styles['Heading2'], fontSize=16, spaceAfter=20, textColor=colors.darkblue)
-    nilsen_style = ParagraphStyle('NilsenStyle', parent=styles['Normal'], fontSize=11, spaceAfter=12, leftIndent=20, textColor=colors.darkgreen)
-    
+    title_style = ParagraphStyle(
+        'CustomTitle',
+        parent=styles['Heading1'],
+        fontSize=24,
+        spaceAfter=30,
+        alignment=1,
+        textColor=colors.darkblue
+    )
+    subtitle_style = ParagraphStyle(
+        'CustomSubtitle',
+        parent=styles['Heading2'],
+        fontSize=16,
+        spaceAfter=20,
+        textColor=colors.darkblue
+    )
+    ai_style = ParagraphStyle(
+        'AIStyle',
+        parent=styles['Normal'],
+        fontSize=11,
+        spaceAfter=12,
+        leftIndent=20,
+        textColor=colors.darkgreen
+    )
     elements.append(Spacer(1, 100))
-    elements.append(Paragraph("Production Excellence Report", title_style))
-    elements.append(Paragraph("Advanced Analytics by Nilsen Service & Consulting", styles['Heading3']))
+    elements.append(Paragraph("Production Monitor with AI Insights", title_style))
+    elements.append(Paragraph("Comprehensive Production Analysis Report", styles['Heading3']))
     elements.append(Spacer(1, 50))
-    
     report_info = f"""
     <para alignment="center">
     <b>Nilsen Service &amp; Consulting AS</b><br/>
-    Advanced Production Analytics Division<br/><br/>
-    
-    <b>Analysis Period:</b> {df['date'].min().strftime('%B %d, %Y')} - {df['date'].max().strftime('%B %d, %Y')}<br/>
+    Production Analytics Division<br/><br/>
+    <b>Report Period:</b> {df['date'].min().strftime('%B %d, %Y')} - {df['date'].max().strftime('%B %d, %Y')}<br/>
     <b>Generated:</b> {datetime.now().strftime('%B %d, %Y at %H:%M')}<br/>
-    <b>Data Processing:</b> {len(df):,} records analyzed<br/><br/>
-    
-    <b>Powered by Nilsen Advanced Analytics Engine</b><br/>
-    ✓ Machine Learning Algorithms ✓ Predictive Modeling<br/>
-    ✓ Statistical Analysis ✓ Production Optimization
+    <b>Total Records:</b> {len(df):,}
     </para>
     """
     elements.append(Paragraph(report_info, styles['Normal']))
     elements.append(PageBreak())
-    
-    # Executive Summary with positive focus
     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>
-    <b>Production Excellence Achieved:</b> {total_production:,.0f} kg total output across 
-    <b>{work_days} operational days</b>, demonstrating consistent performance with 
-    <b>{daily_avg:,.0f} kg daily average</b>.
+    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>.
     <br/><br/>
-    <b>Nilsen Analytics Highlights:</b><br/>
-    • Comprehensive data processing: {len(df):,} production records<br/>
-    • Multi-material portfolio: {len([k for k in stats.keys() if k != '_total_'])} material types optimized<br/>
-    • Advanced metrics calculated: Efficiency indices, stability scores, trend analysis<br/>
-    • Production intelligence: Real-time monitoring and predictive insights
+    <b>Key Highlights:</b><br/>
+    • Total production: {total_production:,.0f} kg<br/>
+    • Daily average: {daily_avg:,.0f} kg<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))
-    
-    # Production Excellence Table
-    elements.append(Paragraph("Production Portfolio Performance", styles['Heading3']))
-    summary_data = [['Material Type', 'Total Output (kg)', 'Portfolio Share (%)', 'Daily Excellence (kg)']]
+    elements.append(Paragraph("Production Summary", styles['Heading3']))
+    summary_data = [['Material Type', 'Total (kg)', 'Share (%)', 'Daily Avg (kg)']]
     for material, info in stats.items():
         if material != '_total_':
             summary_data.append([
@@ -532,7 +563,6 @@ def create_enhanced_pdf_report(df, stats, outliers, model=None):
                 f"{info['percentage']:.1f}%",
                 f"{info['daily_avg']:,.0f}"
             ])
-    
     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),
@@ -544,32 +574,62 @@ def create_enhanced_pdf_report(df, stats, outliers, model=None):
     ]))
     elements.append(summary_table)
     elements.append(PageBreak())
-    
-    # Quality Excellence Analysis (reframed positively)
-    elements.append(Paragraph("Quality Excellence & Consistency Analysis", subtitle_style))
-    quality_data = [['Material', 'Consistency Score', 'Optimal Range (kg)', 'Performance Status']]
+    elements.append(Paragraph("Production Analysis Charts", subtitle_style))
+    try:
+        charts = create_pdf_charts(df, stats)
+    except:
+        charts = {}
+    charts_added = False
+    chart_insights = {
+        'pie': "Material distribution shows production allocation across different materials. Balanced distribution indicates diversified production capabilities.",
+        'trend': "Production trend reveals operational patterns and seasonal variations. Consistent trends suggest stable operational efficiency.",
+        '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"), 
+        ('bar', "Material Comparison"),
+        ('shift', "Shift Analysis")
+    ]:
+        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))
+                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']))
+        for material, info in stats.items():
+            if material != '_total_':
+                summary_text = f"• {material.replace('_', ' ').title()}: {info['total']:,.0f} kg ({info['percentage']:.1f}%)"
+                elements.append(Paragraph(summary_text, styles['Normal']))
+        elements.append(Spacer(1, 20))
+    elements.append(PageBreak())
+    elements.append(Paragraph("Quality Control Analysis", subtitle_style))
+    quality_data = [['Material', 'Outliers', 'Normal Range (kg)', 'Status']]
     for material, info in outliers.items():
         if info['count'] == 0:
-            status = "EXCELLENT"
+            status = "GOOD"
         elif info['count'] <= 3:
-            status = "OPTIMIZED"
+            status = "MONITOR"
         else:
-            status = "ENHANCING"
-        
-        # Calculate consistency score
-        total_records_material = stats[material]['records']
-        consistency_score = ((total_records_material - info['count']) / total_records_material) * 100
-        
+            status = "ATTENTION"
         quality_data.append([
             material.replace('_', ' ').title(),
-            f"{consistency_score:.1f}%",
+            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.darkgreen),
+        ('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'),
@@ -577,215 +637,200 @@ def create_enhanced_pdf_report(df, stats, outliers, model=None):
         ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.lightgrey])
     ]))
     elements.append(quality_table)
-    
-    # Nilsen AI Analysis
     if model:
         elements.append(PageBreak())
-        elements.append(Paragraph("Nilsen AI Advanced Intelligence Analysis", subtitle_style))
+        elements.append(Paragraph("AI Intelligent Analysis", subtitle_style))
         try:
-            ai_analysis = generate_nilsen_ai_summary(model, df, stats, outliers)
+            ai_analysis = generate_ai_summary(model, df, stats, outliers)
         except:
-            ai_analysis = "Nilsen AI Analytics Engine - Advanced insights available in live system."
-        
+            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/>')
+                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))
-    
+    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.append(Spacer(1, 30))
     footer_text = f"""
     <para alignment="center">
-    <i>This report showcases production excellence through advanced analytics<br/>
-    Nilsen Service &amp; Consulting AS - Production Intelligence Division<br/>
-    Advanced analysis of {len(df):,} production records demonstrating operational excellence</i>
+    <i>This report was generated by Production Monitor System<br/>
+    Nilsen Service &amp; Consulting AS - Production Analytics Division<br/>
+    Report contains {len(df):,} data records across {stats['_total_']['work_days']} working days</i>
     </para>
     """
     elements.append(Paragraph(footer_text, styles['Normal']))
-    
     doc.build(elements)
     buffer.seek(0)
     return buffer
 
+def create_csv_export(df, stats):
+    summary_df = pd.DataFrame([
+        {
+            'Material': material.replace('_', ' ').title(),
+            'Total_kg': info['total'],
+            'Percentage': info['percentage'],
+            'Daily_Average_kg': info['daily_avg'],
+            'Work_Days': info['work_days'],
+            'Records_Count': info['records']
+        }
+        for material, info in stats.items() if material != '_total_'
+    ])
+    return summary_df
+
+def add_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
+    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
+                st.success("✅ PDF report with AI analysis generated successfully!")
+            except Exception as e:
+                st.error(f"❌ PDF generation failed: {str(e)}")
+                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",
+                data=st.session_state.pdf_buffer,
+                file_name=f"production_report_ai_{datetime.now().strftime('%Y%m%d_%H%M')}.pdf",
+                mime="application/pdf",
+                key="download_pdf_btn"
+            )
+    with col2:
+        if st.button("Generate CSV Summary", key="generate_csv_btn", type="primary"):
+            try:
+                st.session_state.csv_data = create_csv_export(df, stats)
+                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(
+                label="💾 Download CSV Summary",
+                data=csv_string,
+                file_name=f"production_summary_{datetime.now().strftime('%Y%m%d_%H%M')}.csv",
+                mime="text/csv",
+                key="download_csv_btn"
+            )
+    with col3:
+        csv_string = df.to_csv(index=False)
+        st.download_button(
+            label="Download Raw Data",
+            data=csv_string,
+            file_name=f"raw_production_data_{datetime.now().strftime('%Y%m%d_%H%M')}.csv",
+            mime="text/csv",
+            key="download_raw_btn"
+        )
 def main():
     load_css()
-    
-    # Enhanced header with tech highlights
     st.markdown("""
     <div class="main-header">
-        <div class="main-title">🏭 Production Excellence Monitor with AI Intelligence</div>
-        <div class="main-subtitle">Nilsen Service & Consulting AS | Advanced Analytics • Predictive Intelligence • Production Optimization</div>
+        <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()
-    
-    # Session state management
     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
-    
-    # Enhanced sidebar with Nilsen branding
     with st.sidebar:
-        st.markdown("### 🏢 Nilsen Analytics Platform")
-        st.markdown('<div class="nilsen-badge">🚀 Advanced Data Science</div>', unsafe_allow_html=True)
-        
         st.markdown("### 📊 Data Source")
         uploaded_file = st.file_uploader("Upload Production Data", type=['csv'])
-        
         st.markdown("---")
-        st.markdown("### 📊 Quick Demo")
+        st.markdown("### 📊 Quick Load")
         col1, col2 = st.columns(2)
         with col1:
-            if st.button("📊 2024 Analysis", type="primary", key="load_2024"):
+            if st.button("📊 2024 Data", type="primary", key="load_2024"):
                 st.session_state.load_preset = "2024"
         with col2:
-            if st.button("📊 2025 Analysis", type="primary", key="load_2025"):
+            if st.button("📊 2025 Data", type="primary", key="load_2025"):
                 st.session_state.load_preset = "2025"
-        
-        st.markdown("---")
-        st.markdown("### 🔬 Technical Capabilities")
-        if model:
-            st.success("🤖 AI Engine: Online")
-            st.markdown("✅ Machine Learning Analysis")
-            st.markdown("✅ Predictive Modeling")
-            st.markdown("✅ Advanced Statistics")
-            st.markdown("✅ Real-time Intelligence")
-        else:
-            st.warning("⚠️ AI Engine: Configure API")
-            st.markdown("🔧 Advanced Analytics Available")
-            st.markdown("🔧 Statistical Processing Ready")
-        
         st.markdown("---")
         st.markdown("""
-        **Data Format:**
+        **Expected TSV format:**
         - `date`: MM/DD/YYYY
-        - `weight_kg`: Production output
+        - `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")
     df = st.session_state.current_df
     stats = st.session_state.current_stats
-    
-    # Data loading logic
     if uploaded_file:
         try:
             df = load_data(uploaded_file)
             stats = get_material_stats(df)
             st.session_state.current_df = df
             st.session_state.current_stats = stats
-            st.success("✅ Data processed successfully with Nilsen Analytics!")
+            st.success("✅ Data uploaded successfully!")
         except Exception as e:
-            st.error(f"❌ Data processing error: {str(e)}")
-    
+            st.error(f"❌ Error loading uploaded file: {str(e)}")
     elif 'load_preset' in st.session_state:
         year = st.session_state.load_preset
         try:
-            with st.spinner(f"Loading {year} production data with Nilsen intelligence..."):
+            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
                 st.session_state.current_stats = stats
-                st.success(f"✅ {year} data analyzed successfully!")
+                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
-    
-    # Main dashboard content
     if df is not None and stats is not None:
-        
-        # Advanced metrics showcase
-        if model:
-            st.markdown('<div class="section-header">🎯 Nilsen Advanced Intelligence</div>', unsafe_allow_html=True)
-            
-            with st.container():
-                ai_summary = generate_nilsen_ai_summary(model, df, stats, detect_outliers(df))
-                st.markdown('<div class="tech-highlight">', unsafe_allow_html=True)
-                st.markdown(ai_summary)
-                st.markdown('</div>', unsafe_allow_html=True)
-        
-        # Production overview with enhanced metrics
-        st.markdown('<div class="section-header">📊 Production Excellence Overview</div>', unsafe_allow_html=True)
-        
-        if model:
-            metrics = calculate_advanced_metrics(df, stats)
-            col1, col2, col3, col4 = st.columns(4)
-            
-            with col1:
-                st.metric(
-                    label="🏆 Nilsen Efficiency Index",
-                    value=f"{metrics['efficiency_index']:.1f}/100",
-                    delta="Proprietary Algorithm"
-                )
-            
-            with col2:
-                st.metric(
-                    label="⚖️ Balance Optimization",
-                    value=f"{metrics['balance_score']:.1f}%",
-                    delta="Advanced Analysis"
-                )
-            
-            with col3:
-                st.metric(
-                    label="📈 Stability Score",
-                    value=f"{metrics['stability_score']:.1f}/10",
-                    delta="ML Assessment"
-                )
-            
-            with col4:
-                st.metric(
-                    label="🎯 Trend Confidence",
-                    value=f"{metrics['trend_strength']:.1f}%",
-                    delta="Predictive Model"
-                )
-        
-        # Material portfolio performance
-        st.markdown('<div class="section-header">🏷️ Material Portfolio Performance</div>', unsafe_allow_html=True)
+        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(min(4, len(materials) + 1))
-        
+        cols = st.columns(4)
         for i, material in enumerate(materials[:3]):
             info = stats[material]
             with cols[i]:
                 st.metric(
-                    label=f"🔧 {material.replace('_', ' ').title()}",
+                    label=material.replace('_', ' ').title(),
                     value=f"{info['total']:,.0f} kg",
-                    delta=f"{info['percentage']:.1f}% portfolio share"
+                    delta=f"{info['percentage']:.1f}% of total"
                 )
-                st.caption(f"Excellence: {info['daily_avg']:,.0f} kg/day")
-        
-        if len(materials) >= 1:
+                st.caption(f"Daily avg: {info['daily_avg']:,.0f} kg")
+        if len(materials) >= 3:
             total_info = stats['_total_']
-            with cols[min(3, len(materials))]:
+            with cols[3]:
                 st.metric(
-                    label="🎯 Total Excellence",
+                    label="Total Production",
                     value=f"{total_info['total']:,.0f} kg",
-                    delta=f"{total_info['work_days']} production days"
+                    delta="100% of total"
                 )
-                st.caption(f"Average: {total_info['daily_avg']:,.0f} kg/day")
-        
-        # Production trend analysis
-        st.markdown('<div class="section-header">📈 Production Trend Intelligence</div>', unsafe_allow_html=True)
+                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("Analysis Period", ["daily", "weekly", "monthly"], key="time_view")
-        
+            time_view = st.selectbox("Time Period", ["daily", "weekly", "monthly"], key="time_view_select")
         with col1:
-            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 performance analysis
-        st.markdown('<div class="section-header">🏭 Materials Excellence Analysis</div>', unsafe_allow_html=True)
+            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", 
@@ -793,172 +838,82 @@ def main():
                 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)
-                materials_chart = create_materials_trend_chart(df, time_view, selected_materials)
-                st.plotly_chart(materials_chart, use_container_width=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)
-        
-        # Shift optimization analysis
-        if 'shift' in df.columns:
-            st.markdown('<div class="section-header">🌓 Shift Optimization Intelligence</div>', unsafe_allow_html=True)
-            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)
-        
-        # Quality excellence analysis (reframed positively)
-        st.markdown('<div class="section-header">✅ Quality Excellence Monitor</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]:
-                total_material_records = stats[material]['records']
-                consistency_rate = ((total_material_records - info['count']) / total_material_records) * 100
-                
-                if info['count'] == 0:
-                    st.markdown(f'<div class="alert-success"><strong>🏆 {material.title()}</strong><br>Perfect Consistency: 100%<br>Optimal Range: {info["range"]}</div>', unsafe_allow_html=True)
-                elif info['count'] <= 3:
-                    st.markdown(f'<div class="alert-success"><strong>✅ {material.title()}</strong><br>High Consistency: {consistency_rate:.1f}%<br>Optimal Range: {info["range"]}</div>', unsafe_allow_html=True)
+                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:
-                    dates_str = f"{', '.join(info['dates'][:2])}, +{len(info['dates'])-2} more" if len(info['dates']) > 2 else ", ".join(info['dates'])
-                    st.markdown(f'<div class="alert-warning"><strong>🎯 {material.title()}</strong><br>Optimization Opportunity: {consistency_rate:.1f}%<br>Target Range: {info["range"]}<br><small>Enhancement dates: {dates_str}</small></div>', unsafe_allow_html=True)
-        
-        # AI Intelligence Center
+                    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">🤖 Nilsen AI Intelligence Center</div>', unsafe_allow_html=True)
-            
-            # Showcase questions focused on capabilities
-            showcase_questions = [
-                "Demonstrate your advanced analytical capabilities on this production data",
-                "What production excellence and competitive advantages do you identify?",
-                "Show me the predictive insights from your machine learning analysis"
+            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?"
             ]
-            
-            st.markdown("### 🚀 AI Capability Demonstrations")
-            cols = st.columns(len(showcase_questions))
-            
-            for i, question in enumerate(showcase_questions):
+            cols = st.columns(len(quick_questions))
+            for i, q in enumerate(quick_questions):
                 with cols[i]:
-                    if st.button(f"🔬 {question}", key=f"showcase_{i}"):
-                        with st.spinner("Nilsen AI analyzing with advanced algorithms..."):
-                            answer = query_nilsen_ai(model, stats, question, df)
-                            st.success(answer)
-            
-            st.markdown("### 💬 Custom Intelligence Query")
-            custom_question = st.text_input(
-                "Ask Nilsen AI about your production excellence:", 
-                placeholder="e.g., 'What optimization strategies do you recommend?'",
-                key="custom_question"
-            )
-            
-            if custom_question and st.button("🚀 Analyze with Nilsen AI", key="custom_ai"):
-                with st.spinner("Processing with Nilsen advanced intelligence..."):
-                    answer = query_nilsen_ai(model, stats, custom_question, df)
+                    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(answer)
-        
-        # Enhanced export section
-        st.markdown('<div class="section-header">📄 Nilsen Intelligence Reports</div>', unsafe_allow_html=True)
-        
-        col1, col2, col3 = st.columns(3)
-        
-        with col1:
-            if st.button("🎯 Generate AI Excellence Report", type="primary", key="gen_pdf"):
-                try:
-                    with st.spinner("Generating Nilsen AI Excellence Report..."):
-                        pdf_buffer = create_enhanced_pdf_report(df, stats, outliers, model)
-                    st.success("✅ Intelligence report generated!")
-                    
-                    st.download_button(
-                        label="💾 Download Excellence Report",
-                        data=pdf_buffer,
-                        file_name=f"nilsen_production_excellence_{datetime.now().strftime('%Y%m%d_%H%M')}.pdf",
-                        mime="application/pdf"
-                    )
-                except Exception as e:
-                    st.error(f"❌ Report generation error: {str(e)}")
-        
-        with col2:
-            csv_summary = pd.DataFrame([
-                {
-                    'Material': material.replace('_', ' ').title(),
-                    'Total_Output_kg': info['total'],
-                    'Portfolio_Share_Percent': info['percentage'],
-                    'Daily_Excellence_kg': info['daily_avg'],
-                    'Production_Days': info['work_days']
-                }
-                for material, info in stats.items() if material != '_total_'
-            ])
-            
-            csv_string = csv_summary.to_csv(index=False)
-            st.download_button(
-                label="📊 Download Portfolio Analysis",
-                data=csv_string,
-                file_name=f"nilsen_portfolio_analysis_{datetime.now().strftime('%Y%m%d_%H%M')}.csv",
-                mime="text/csv"
-            )
-        
-        with col3:
-            raw_csv = df.to_csv(index=False)
-            st.download_button(
-                label="📁 Download Raw Production Data",
-                data=raw_csv,
-                file_name=f"production_data_{datetime.now().strftime('%Y%m%d_%H%M')}.csv",
-                mime="text/csv"
-            )
-    
+                    st.write(f"**A:** {answer}")
     else:
-        # Welcome screen with Nilsen branding
-        st.markdown('<div class="section-header">🚀 Nilsen Production Intelligence Platform</div>', unsafe_allow_html=True)
-        
+        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("""
-            ### 🎯 Advanced Analytics Capabilities
-            - **AI-Powered Intelligence**: Machine learning insights
-            - **Predictive Modeling**: Trend forecasting & optimization
-            - **Real-Time Monitoring**: Live production analytics
-            - **Excellence Identification**: Competitive advantage discovery
-            - **Portfolio Analysis**: Multi-material performance
-            - **Quality Intelligence**: Consistency optimization
-            - **Custom Reporting**: AI-generated insights
+            ### 🚀 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("""
-            ### 🏆 Nilsen Technical Advantages
-            - **Proprietary Algorithms**: Efficiency indices & scores
-            - **Advanced Metrics**: Beyond standard analytics
-            - **Industry Expertise**: Production optimization focus
-            - **Intelligent Insights**: Value-driven recommendations  
-            - **Professional Reports**: Executive-ready analysis
-            - **Scalable Platform**: Enterprise-grade processing
-            - **Consulting Integration**: Expert advisory included
+            ### 📊 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.markdown('<div class="tech-highlight">', unsafe_allow_html=True)
-        st.markdown("""
-        ### 🚀 Get Started with Nilsen Intelligence
-        
-        **Option 1:** Upload your production data using the sidebar
-        
-        **Option 2:** Try our demo with the Quick Demo buttons
-        
-        **What You'll Get:**
-        - Advanced AI analysis showcasing production excellence
-        - Professional insights highlighting competitive advantages  
-        - Technical metrics demonstrating operational efficiency
-        - Predictive intelligence for optimization opportunities
-        - Executive-ready reports with Nilsen professional branding
-        """)
-        st.markdown('</div>', unsafe_allow_html=True)
-        
-        st.info("🎯 **Ready to discover your production excellence?** Upload data or use Quick Demo to experience Nilsen's advanced analytics capabilities!")
+        st.info("📁 Ready to start? Upload your production data or use Quick Load buttons to begin analysis!")
 
 if __name__ == "__main__":
     main()