Update app.py

app.py

@@ -10,11 +10,28 @@ import streamlit.components.v1 as components
 from datetime import datetime, date
 import io
 import base64
+from typing import Dict, List, Any, Optional
 
 # ------------------------------
-# Custom JSON Encoder for Timestamps
+# Configuration & Constants
+# ------------------------------
+APP_TITLE = "Enterprise AI BI Dashboard"
+APP_ICON = "🚀"
+
+# Model Configuration Strategy
+# We define the specific requested models here. 
+# NOTE: Ensure your Google Cloud Project has access to these specific Model IDs.
+AI_CONFIG = {
+    "analyst_model": "gemini-3.0-pro-preview",      # The heavy lifter for reasoning
+    "dashboard_model": "gemini-nano-banana-pro",    # The specialist for HTML/Code generation
+    "fallback_model": "gemini-2.0-flash-exp"        # Fallback if specific previews aren't active
+}
+
+# ------------------------------
+# Service Layer: Utilities
 # ------------------------------
 class CustomJSONEncoder(json.JSONEncoder):
+    """Robust JSON Encoder for Dataframes and NumPy types."""
     def default(self, obj):
         if isinstance(obj, (datetime, date, pd.Timestamp)):
             return obj.isoformat()
@@ -28,634 +45,299 @@ class CustomJSONEncoder(json.JSONEncoder):
             return None
         return super().default(obj)
 
+def clean_ai_response(text: str) -> str:
+    """Cleans Markdown code blocks from AI responses."""
+    text = text.strip()
+    if text.startswith("```"):
+        # Find the first newline to skip the language tag (e.g. ```json)
+        newline_index = text.find("\n")
+        if newline_index != -1:
+            text = text[newline_index+1:]
+        # Remove the closing ```
+        if text.endswith("```"):
+            text = text[:-3]
+    return text.strip()
+
 # ------------------------------
-# Page Configuration
+# Service Layer: AI Handler
 # ------------------------------
-st.set_page_config(
-    page_title="AI Excel BI Dashboard",
-    page_icon="📊",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
+class AIService:
+    def __init__(self, api_key: str):
+        self.client = genai.Client(api_key=api_key)
+
+    def _generate(self, model_id: str, prompt: str) -> str:
+        """Wrapper to handle generation with fallback logic."""
+        try:
+            response = self.client.models.generate_content(
+                model=model_id,
+                contents=[prompt]
+            )
+            return response.text
+        except Exception as e:
+            # If the specific preview model fails (404/Permission), try fallback
+            if "404" in str(e) or "not found" in str(e).lower():
+                st.warning(f"⚠️ Model '{model_id}' not found. Falling back to '{AI_CONFIG['fallback_model']}'.")
+                response = self.client.models.generate_content(
+                    model=AI_CONFIG['fallback_model'],
+                    contents=[prompt]
+                )
+                return response.text
+            raise e
+
+    def analyze_dataset(self, schema: Dict) -> Dict:
+        """Uses Gemini 3.0 Pro to analyze data structure and suggest charts."""
+        prompt = f"""
+        You are a Principal Data Architect. Analyze this dataset schema:
+        {json.dumps(schema, indent=2, cls=CustomJSONEncoder)}
+
+        Task:
+        1. Identify the industry/domain.
+        2. Determine if this is company-specific data.
+        3. Create a visualization plan with 4-6 specific charts.
+        4. Generate 3 C-level executive insights.
 
-# Initialize session state
-if 'api_configured' not in st.session_state:
-    st.session_state['api_configured'] = False
-if 'dark_mode' not in st.session_state:
-    st.session_state['dark_mode'] = True  # Default to dark mode
+        Return ONLY raw JSON:
+        {{
+            "domain": "string",
+            "is_company_data": boolean,
+            "charts": [
+                {{"type": "bar|line|scatter|pie|histogram", "x": "col", "y": "col", "title": "string"}}
+            ],
+            "insights": ["string"]
+        }}
+        """
+        response_text = self._generate(AI_CONFIG['analyst_model'], prompt)
+        return json.loads(clean_ai_response(response_text))
+
+    def generate_dashboard_html(self, context: Dict) -> str:
+        """Uses Gemini Nano Banana Pro to generate high-performance HTML."""
+        prompt = f"""
+        You are an Expert Frontend Engineer specialized in BI Dashboards.
+        
+        CONTEXT:
+        Title: {context['title']}
+        Domain: {context['domain']}
+        Stats: {json.dumps(context['stats'], cls=CustomJSONEncoder)}
+        Sample: {json.dumps(context['sample'], cls=CustomJSONEncoder)}
+
+        REQUIREMENTS:
+        1. Create a single-file, responsive HTML dashboard.
+        2. Use **Chart.js** via CDN.
+        3. Style with a modern, glassmorphism dark theme suitable for {context['domain']}.
+        4. Include a 'Key Metrics' row at the top (Cards).
+        5. Include a grid of interactive charts.
+        6. Handle missing data gracefully in JavaScript.
+        
+        Return ONLY valid HTML code.
+        """
+        return clean_ai_response(self._generate(AI_CONFIG['dashboard_model'], prompt))
+
+    def generate_presentation(self, context: Dict) -> str:
+        """Uses Gemini 3.0 Pro to generate a strategic slide deck."""
+        prompt = f"""
+        Create a Reveal.js (HTML) presentation for this dataset.
+        
+        Title: {context['title']}
+        Insights: {json.dumps(context['insights'])}
+        
+        Create 5 slides: Title, Objectives, Data Analysis, Strategic Insights, Conclusion.
+        Use a professional gradient theme.
+        Return ONLY valid HTML.
+        """
+        return clean_ai_response(self._generate(AI_CONFIG['analyst_model'], prompt))
 
 # ------------------------------
-# Sidebar: API Key Setup
+# UI Configuration
 # ------------------------------
-with st.sidebar:
-    st.header("⚙️ Configuration")
-    st.markdown("---")
-    
-    api_key = st.text_input(
-        "🔑 Gemini API Key",
-        type="password",
-        help="Enter your Google Gemini API key"
-    )
-    
-    if api_key:
-        try:
-            client = genai.Client(api_key=api_key)
-            st.success("✅ API Key Configured")
-            st.session_state['api_configured'] = True
-        except Exception as e:
-            st.error(f"❌ Invalid API Key: {e}")
-            client = None
-            st.session_state['api_configured'] = False
-    else:
-        client = None
-    
-    st.markdown("---")
-    
-    st.subheader("ℹ️ About")
-    st.info("""
-    This AI-powered dashboard:
-    - Analyzes Excel/CSV data
-    - Generates intelligent visualizations
-    - Creates interactive HTML dashboards
-    - Provides business insights
-    - Detects company/brand data
-    """)
-    
-    st.markdown("---")
-    st.caption("Powered by Google Gemini AI")
+st.set_page_config(page_title=APP_TITLE, page_icon=APP_ICON, layout="wide")
 
-# Apply dark mode styling (always on by default)
 st.markdown("""
     <style>
-    .stApp {
-        background-color: #0e1117;
-        color: #fafafa;
-    }
+    .stApp { background-color: #0e1117; color: #fafafa; }
+    .stButton>button { border-radius: 8px; font-weight: bold; }
+    div[data-testid="stMetricValue"] { font-size: 24px; color: #4db8ff; }
     </style>
 """, unsafe_allow_html=True)
 
 # ------------------------------
-# Main Area: Dashboard
+# Main Application Logic
 # ------------------------------
-st.title("📊 AI-Powered Business Intelligence Dashboard")
-st.markdown("Upload your data file and let AI create professional insights!")
-
-# Check if API key is configured
-if not api_key or not client:
-    st.warning("⚠️ Please enter your Gemini API Key in the sidebar to continue.")
-    st.stop()
+def main():
+    # --- Sidebar ---
+    with st.sidebar:
+        st.header(f"{APP_ICON} Configuration")
+        api_key = st.text_input("🔑 Google Gemini API Key", type="password")
+        
+        st.divider()
+        st.caption("Active Models:")
+        st.code(f"Analyst: {AI_CONFIG['analyst_model']}\nDashboard: {AI_CONFIG['dashboard_model']}")
+        
+        st.info("Ensure your API key has access to the Preview models, otherwise fallback will be used.")
 
-# ------------------------------
-# File Upload Section
-# ------------------------------
-st.markdown("---")
-uploaded_file = st.file_uploader(
-    "📂 Upload Your Data File",
-    type=["csv", "xlsx"],
-    help="Supports CSV and Excel files"
-)
+    if not api_key:
+        st.warning("⚠️ Please enter your API Key to initialize the AI Engine.")
+        st.stop()
 
-if uploaded_file:
+    # Initialize Service
     try:
-        # Load dataset
-        with st.spinner("Loading data..."):
-            if uploaded_file.name.endswith(".csv"):
+        ai_service = AIService(api_key)
+    except Exception as e:
+        st.error(f"Failed to initialize AI Client: {e}")
+        st.stop()
+
+    # --- Main Content ---
+    st.title(f"{APP_TITLE}")
+    
+    uploaded_file = st.file_uploader("📂 Upload Data (CSV/Excel)", type=["csv", "xlsx"])
+
+    if uploaded_file:
+        # Load Data
+        try:
+            if uploaded_file.name.endswith('.csv'):
                 df = pd.read_csv(uploaded_file)
             else:
                 df = pd.read_excel(uploaded_file)
-        
-        st.success(f"✅ File '{uploaded_file.name}' uploaded successfully!")
-        
-        # ------------------------------
-        # Enhanced Data Overview Section
-        # ------------------------------
-        st.markdown("---")
-        st.subheader("📋 Comprehensive Data Overview")
-        
-        # Basic Metrics
-        col1, col2, col3, col4, col5 = st.columns(5)
-        with col1:
-            st.metric("Total Rows", f"{df.shape[0]:,}")
-        with col2:
-            st.metric("Total Columns", df.shape[1])
-        with col3:
-            st.metric("Numeric Columns", len(df.select_dtypes(include=['number']).columns))
-        with col4:
-            st.metric("Categorical Columns", len(df.select_dtypes(include=['object']).columns))
-        with col5:
-            missing_pct = (df.isnull().sum().sum() / (df.shape[0] * df.shape[1]) * 100)
-            st.metric("Missing Data", f"{missing_pct:.1f}%")
-        
-        # Detailed Data Analysis
-        with st.expander("🔍 View Detailed Data Analysis", expanded=True):
-            tab1, tab2, tab3 = st.tabs(["📊 Data Preview", "📈 Statistics", "⚠️ Data Quality"])
             
-            with tab1:
-                st.dataframe(df.head(15), use_container_width=True)
+            # Basic cleanup
+            df.columns = [c.strip() for c in df.columns]
             
-            with tab2:
-                # Statistical Summary
-                st.markdown("**Statistical Summary**")
-                numeric_cols = df.select_dtypes(include=['number']).columns
-                if len(numeric_cols) > 0:
-                    stats_df = df[numeric_cols].describe()
-                    st.dataframe(stats_df, use_container_width=True)
+            # --- Data Overview ---
+            st.divider()
+            c1, c2, c3, c4 = st.columns(4)
+            c1.metric("Rows", df.shape[0])
+            c2.metric("Columns", df.shape[1])
+            c3.metric("Numeric Fields", len(df.select_dtypes(include=np.number).columns))
+            c4.metric("Categorical Fields", len(df.select_dtypes(exclude=np.number).columns))
+
+            with st.expander("🔍 View Raw Data & Quality Checks"):
+                st.dataframe(df.head())
+                st.write(df.describe())
+
+            # --- AI Operations ---
+            st.divider()
+            st.subheader("🤖 AI Intelligence Operations")
+            
+            col_ops1, col_ops2, col_ops3 = st.columns(3)
+            
+            # Prepare Schema for AI (Lightweight)
+            sample_data = df.head(3).copy()
+            # Convert timestamps to string for JSON serialization
+            for col in sample_data.columns:
+                if pd.api.types.is_datetime64_any_dtype(sample_data[col]):
+                    sample_data[col] = sample_data[col].astype(str)
+
+            schema = {
+                "columns": {col: str(df[col].dtype) for col in df.columns},
+                "sample": sample_data.to_dict(orient='records'),
+                "numeric_columns": df.select_dtypes(include=np.number).columns.tolist()
+            }
+
+            # 1. ANALYZE DATA
+            if col_ops1.button("📊 Analyze & Visualize", type="primary", use_container_width=True):
+                with st.spinner(f"Reasoning with {AI_CONFIG['analyst_model']}..."):
+                    try:
+                        analysis = ai_service.analyze_dataset(schema)
+                        st.session_state['analysis'] = analysis
+                        st.session_state['df_context'] = df # Store for plotting
+                    except Exception as e:
+                        st.error(f"Analysis failed: {e}")
+
+            # 2. GENERATE DASHBOARD
+            if col_ops2.button("🎨 Create HTML Dashboard", use_container_width=True):
+                if 'analysis' not in st.session_state:
+                    st.warning("Please run 'Analyze' first to determine the domain.")
                 else:
-                    st.info("No numeric columns found for statistical analysis")
-                
-                # Categorical Summary
-                cat_cols = df.select_dtypes(include=['object']).columns
-                if len(cat_cols) > 0:
-                    st.markdown("**Categorical Summary**")
-                    cat_summary = pd.DataFrame({
-                        'Column': cat_cols,
-                        'Unique Values': [df[col].nunique() for col in cat_cols],
-                        'Most Frequent': [df[col].mode()[0] if len(df[col].mode()) > 0 else 'N/A' for col in cat_cols],
-                        'Frequency': [df[col].value_counts().iloc[0] if len(df[col]) > 0 else 0 for col in cat_cols]
-                    })
-                    st.dataframe(cat_summary, use_container_width=True)
+                    with st.spinner(f"Coding with {AI_CONFIG['dashboard_model']}..."):
+                        try:
+                            # Prepare context
+                            stats = df.describe().to_dict()
+                            context = {
+                                "title": uploaded_file.name,
+                                "domain": st.session_state['analysis'].get('domain', 'General'),
+                                "stats": stats,
+                                "sample": df.head(15).to_dict(orient='records') # larger sample for dashboard
+                            }
+                            html_code = ai_service.generate_dashboard_html(context)
+                            st.session_state['html_dashboard'] = html_code
+                        except Exception as e:
+                            st.error(f"Dashboard generation failed: {e}")
+
+            # 3. GENERATE SLIDES
+            if col_ops3.button("🎤 Generate Presentation", use_container_width=True):
+                if 'analysis' not in st.session_state:
+                    st.warning("Please run 'Analyze' first.")
+                else:
+                    with st.spinner("Drafting slides..."):
+                        context = {
+                            "title": uploaded_file.name,
+                            "insights": st.session_state['analysis'].get('insights', [])
+                        }
+                        ppt_html = ai_service.generate_presentation(context)
+                        st.session_state['ppt_html'] = ppt_html
+
+            # --- Display Results ---
             
-            with tab3:
-                # Data Quality Metrics
-                quality_data = []
-                for col in df.columns:
-                    missing = df[col].isnull().sum()
-                    missing_pct = (missing / len(df)) * 100
-                    
-                    # Check for blank spaces in string columns
-                    blank_spaces = 0
-                    if df[col].dtype == 'object':
-                        blank_spaces = df[col].astype(str).str.strip().eq('').sum()
-                    
-                    # Standard deviation for numeric columns
-                    std_dev = df[col].std() if df[col].dtype in ['int64', 'float64'] else None
-                    
-                    quality_data.append({
-                        'Column': col,
-                        'Data Type': str(df[col].dtype),
-                        'Missing Values': missing,
-                        'Missing %': f"{missing_pct:.2f}%",
-                        'Blank Spaces': blank_spaces,
-                        'Std Deviation': f"{std_dev:.2f}" if std_dev is not None else 'N/A',
-                        'Unique Values': df[col].nunique()
-                    })
+            # Result 1: Static Charts (Collage)
+            if 'analysis' in st.session_state and 'df_context' in st.session_state:
+                st.divider()
+                st.subheader(f"📈 Strategic Analysis ({st.session_state['analysis']['domain']})")
                 
-                quality_df = pd.DataFrame(quality_data)
-                st.dataframe(quality_df, use_container_width=True)
+                # Display Insights
+                for i, insight in enumerate(st.session_state['analysis']['insights']):
+                    st.success(f"**Insight {i+1}:** {insight}")
+
+                # Plotting logic
+                charts = st.session_state['analysis']['charts']
+                fig = plt.figure(figsize=(18, 5 * ((len(charts)+2)//3)))
                 
-                # Highlight issues
-                total_missing = df.isnull().sum().sum()
-                if total_missing > 0:
-                    st.warning(f"⚠️ Found {total_missing:,} missing values across the dataset")
-                else:
-                    st.success("✅ No missing values detected")
-        
-        # ------------------------------
-        # AI Analysis Section
-        # ------------------------------
-        st.markdown("---")
-        st.subheader("🤖 AI-Generated Dashboard")
-        
-        col_btn1, col_btn2 = st.columns(2)
-        
-        with col_btn1:
-            generate_charts = st.button("📈 Generate Charts & Insights", type="primary", use_container_width=True)
-        
-        with col_btn2:
-            generate_interactive = st.button("🎨 Generate Interactive HTML Dashboard", type="secondary", use_container_width=True)
-        
-        # Add Presentation Maker Button
-        st.markdown("")
-        generate_presentation = st.button("🎤 Generate AI Presentation (PPT)", use_container_width=True)
-        
-        # ------------------------------
-        # Generate Charts and Insights (Collage View)
-        # ------------------------------
-        if generate_charts:
-            with st.spinner("AI is analyzing your data..."):
-                try:
-                    # Prepare schema with proper serialization
-                    sample_data = df.head(3).copy()
-                    for col in sample_data.columns:
-                        if sample_data[col].dtype == 'datetime64[ns]' or isinstance(sample_data[col].iloc[0], pd.Timestamp):
-                            sample_data[col] = sample_data[col].astype(str)
-                    
-                    schema = {
-                        "columns": {col: str(df[col].dtype) for col in df.columns},
-                        "sample": sample_data.to_dict(),
-                        "shape": {"rows": int(df.shape[0]), "columns": int(df.shape[1])},
-                        "numeric_columns": [col for col in df.select_dtypes(include=['number']).columns.tolist()],
-                        "categorical_columns": [col for col in df.select_dtypes(include=['object']).columns.tolist()]
-                    }
-                    
-                    prompt = f"""
-                    You are a business intelligence and data visualization expert.
-                    
-                    Dataset Information:
-                    {json.dumps(schema, indent=2, cls=CustomJSONEncoder)}
-                    
-                    Analyze this dataset and determine:
-                    1. Is this company/business data? (sales, revenue, employees, products, etc.)
-                    2. What industry or domain does it belong to? (retail, finance, healthcare, entertainment, etc.)
-                    3. What are the key metrics and KPIs?
-                    
-                    Then respond with ONLY a valid JSON object (no markdown, no explanations) with this exact structure:
-                    {{
-                        "domain": "industry name (e.g., retail, finance, entertainment, generic)",
-                        "is_company_data": true/false,
-                        "charts": [
-                            {{"type": "bar", "x": "column_name", "y": "column_name", "title": "Descriptive Chart Title"}},
-                            {{"type": "line", "x": "column_name", "y": "column_name", "title": "Descriptive Chart Title"}},
-                            {{"type": "scatter", "x": "column_name", "y": "column_name", "title": "Descriptive Chart Title"}},
-                            {{"type": "pie", "column": "column_name", "title": "Descriptive Chart Title"}}
-                        ],
-                        "insights": [
-                            "First business insight about the data",
-                            "Second business insight about the data",
-                            "Third business insight about the data"
-                        ]
-                    }}
-                    
-                    Chart types available: bar, line, scatter, histogram, pie
-                    Generate 4-6 charts that would be most insightful for this data domain.
-                    """
-                    
-                    # Call Gemini API
-                    response = client.models.generate_content(
-                        model="gemini-2.0-flash-exp",
-                        contents=[prompt]
-                    )
-                    
-                    # Parse response
-                    response_text = response.text.strip()
-                    if response_text.startswith("```"):
-                        response_text = response_text.split("```")[1]
-                        if response_text.startswith("json"):
-                            response_text = response_text[4:]
-                    
-                    chart_plan = json.loads(response_text)
-                    
-                    # Store in session state
-                    st.session_state['chart_plan'] = chart_plan
-                    st.session_state['df'] = df
-                    
-                except Exception as e:
-                    st.error(f"❌ Error generating dashboard: {e}")
-                    st.exception(e)
-        
-        # ------------------------------
-        # Display Charts in Collage View
-        # ------------------------------
-        if 'chart_plan' in st.session_state:
-            chart_plan = st.session_state['chart_plan']
-            df = st.session_state['df']
-            
-            st.markdown("---")
-            st.markdown("### 📈 Visualizations Collage")
-            st.markdown(f"**Dashboard Title:** {uploaded_file.name.split('.')[0].replace('_', ' ').title()}")
-            st.markdown("**Detailed Charts & Graphs** - Comprehensive visual analysis with proper labels and insights")
-            
-            charts = chart_plan.get("charts", [])
-            
-            # Create matplotlib figure with all charts
-            num_charts = len(charts)
-            cols_per_row = 3
-            rows = (num_charts + cols_per_row - 1) // cols_per_row
-            
-            fig = plt.figure(figsize=(20, 5 * rows))
-            
-            for idx, chart in enumerate(charts, 1):
-                try:
-                    chart_type = chart.get("type")
-                    title = chart.get("title", f"Chart {idx}")
-                    
-                    ax = fig.add_subplot(rows, cols_per_row, idx)
-                    
-                    if chart_type == "bar" and "x" in chart and "y" in chart:
-                        grouped_data = df.groupby(chart["x"])[chart["y"]].sum()
-                        # Limit to top 15 categories for readability
-                        if len(grouped_data) > 15:
-                            grouped_data = grouped_data.nlargest(15)
-                        sns.barplot(x=grouped_data.values, y=grouped_data.index, ax=ax, palette='Blues_d')
-                        ax.set_xlabel(chart["y"], fontsize=10)
-                        ax.set_ylabel(chart["x"], fontsize=10)
-                        
-                    elif chart_type == "line" and "x" in chart and "y" in chart:
-                        # Sample data if too many points
-                        plot_df = df.copy()
-                        if len(plot_df) > 100:
-                            plot_df = plot_df.sample(100).sort_values(by=chart["x"])
-                        sns.lineplot(data=plot_df, x=chart["x"], y=chart["y"], ax=ax, marker='o', color='green', linewidth=2)
-                        ax.set_xlabel(chart["x"], fontsize=10)
-                        ax.set_ylabel(chart["y"], fontsize=10)
-                        plt.setp(ax.xaxis.get_majorticklabels(), rotation=45, ha='right', fontsize=8)
-                        
-                    elif chart_type == "scatter" and "x" in chart and "y" in chart:
-                        sns.scatterplot(data=df, x=chart["x"], y=chart["y"], ax=ax, color='coral', s=50, alpha=0.6)
-                        ax.set_xlabel(chart["x"], fontsize=10)
-                        ax.set_ylabel(chart["y"], fontsize=10)
+                for idx, chart in enumerate(charts, 1):
+                    ax = fig.add_subplot(((len(charts)+2)//3), 3, idx)
+                    try:
+                        c_type = chart['type']
+                        x_col = chart.get('x')
+                        y_col = chart.get('y')
                         
-                    elif chart_type == "histogram" and "x" in chart:
-                        sns.histplot(df[chart["x"]].dropna(), bins=20, kde=True, ax=ax, color='purple', alpha=0.7)
-                        ax.set_xlabel(chart["x"], fontsize=10)
-                        ax.set_ylabel("Frequency", fontsize=10)
+                        if c_type == 'bar' and x_col and y_col:
+                            # Aggregate for bar charts to avoid clutter
+                            data_agg = df.groupby(x_col)[y_col].sum().nlargest(10)
+                            sns.barplot(x=data_agg.values, y=data_agg.index, ax=ax, palette="viridis")
+                            ax.set_title(chart['title'])
+                        elif c_type == 'scatter' and x_col and y_col:
+                            sns.scatterplot(data=df, x=x_col, y=y_col, ax=ax, alpha=0.6)
+                            ax.set_title(chart['title'])
+                        elif c_type == 'line' and x_col and y_col:
+                            # Sort for line charts
+                            temp_df = df.sort_values(x_col)
+                            sns.lineplot(data=temp_df, x=x_col, y=y_col, ax=ax)
+                            ax.set_title(chart['title'])
+                        elif c_type == 'histogram' and x_col:
+                            sns.histplot(df[x_col], kde=True, ax=ax)
+                            ax.set_title(chart['title'])
                         
-                    elif chart_type == "pie" and "column" in chart:
-                        data = df[chart["column"]].value_counts().head(5)
-                        colors = sns.color_palette("pastel")
-                        ax.pie(data.values, labels=data.index, autopct='%1.1f%%', startangle=90, colors=colors)
-                    
-                    ax.set_title(title, fontsize=11, fontweight='bold', pad=10)
-                    
-                except Exception as chart_error:
-                    ax.text(0.5, 0.5, f'Error: {str(chart_error)}', ha='center', va='center')
-                    ax.set_title(title, fontsize=11)
-            
-            plt.tight_layout()
-            st.pyplot(fig)
-            plt.close()
-            
-            # Display Insights
-            st.markdown("---")
-            st.markdown("### 💡 Business Insights")
-            
-            insights = chart_plan.get("insights", [])
-            for idx, insight in enumerate(insights, 1):
-                st.markdown(f"**{idx}.** {insight}")
-        
-        # ------------------------------
-        # Generate Interactive HTML Dashboard (Professional Power BI Style)
-        # ------------------------------
-        if generate_interactive:
-            with st.spinner("Generating professional interactive dashboard..."):
-                try:
-                    # Detect domain and company info
-                    domain = st.session_state.get('chart_plan', {}).get('domain', 'general')
-                    is_company = st.session_state.get('chart_plan', {}).get('is_company_data', False)
-                    
-                    # Get file name for dashboard title
-                    dashboard_title = uploaded_file.name.split('.')[0].replace('_', ' ').title()
-                    
-                    # Prepare data with proper serialization
-                    sample_data = df.head(20).copy()
-                    for col in sample_data.columns:
-                        if sample_data[col].dtype == 'datetime64[ns]' or isinstance(sample_data[col].iloc[0], pd.Timestamp):
-                            sample_data[col] = sample_data[col].astype(str)
-                    
-                    stats_dict = {}
-                    for col in df.select_dtypes(include=['number']).columns:
-                        stats_dict[col] = {
-                            'mean': float(df[col].mean()),
-                            'median': float(df[col].median()),
-                            'std': float(df[col].std()),
-                            'min': float(df[col].min()),
-                            'max': float(df[col].max())
-                        }
-                    
-                    html_prompt = f"""
-                    Create a COMPLETE, self-contained, professional Power BI-style HTML dashboard.
-                    
-                    Dataset Context:
-                    - Dashboard Title: {dashboard_title}
-                    - Domain: {domain}
-                    - Is Company Data: {is_company}
-                    - Columns: {', '.join(df.columns.tolist())}
-                    - Rows: {df.shape[0]}
-                    - Sample Data: {json.dumps(sample_data.to_dict('records')[:10], cls=CustomJSONEncoder)}
-                    - Statistics: {json.dumps(stats_dict, cls=CustomJSONEncoder)}
-                    
-                    CRITICAL Requirements for Handling Large Data:
-                    1. For bar charts with many categories (>15), show only TOP 15 values and add "...and X more" text
-                    2. For time series/date data, aggregate by week or month, never show individual dates
-                    3. Use responsive chart heights (max 300px per chart)
-                    4. Implement proper overflow handling with max-height and scrolling only if necessary
-                    5. For dates on x-axis: rotate labels 45deg, use abbreviated format (MMM-YY), show every Nth label
-                    
-                    Dashboard Design:
-                    1. Use Chart.js from CDN: https://cdn.jsdelivr.net/npm/chart.js
-                    2. Dynamic color scheme based on domain/data characteristics:
-                       - Finance: Blue (#1e3a8a) to Navy gradient with gold accents
-                       - Retail/Sales: Orange (#ea580c) to Green (#16a34a) gradient
-                       - Healthcare: Teal (#0d9488) to Blue (#0284c7) gradient
-                       - Entertainment/Movies: Purple (#7c3aed) to Magenta (#db2777) gradient
-                       - Technology: Cyan (#06b6d4) to Blue (#3b82f6) gradient
-                       - Generic: Professional Blue (#2563eb) to Gray (#64748b) gradient
-                    3. Layout: Responsive grid with 2-3 columns, cards with shadows
-                    4. Include:
-                       - Top banner with "{dashboard_title}" as main title
-                       - 4-6 KPI cards with key metrics (large numbers, trend indicators)
-                       - 6-8 charts in grid layout (bar, line, pie, doughnut, area charts)
-                       - Each chart in a card with title, proper spacing
-                       - All charts must be USEFUL for Business Intelligence and KPI tracking
-                       - Focus on metrics that show: trends, comparisons, distributions, performance
-                    5. If company data, add company logo placeholder at top
-                    6. Footer: "{datetime.now().strftime('%B %d, %Y')} | {dashboard_title} Analytics Dashboard"
-                    7. Make charts interactive: hover tooltips, legend toggle
-                    8. Use actual data values, aggregate large datasets intelligently
-                    9. Add smooth animations (fade-in, scale effects)
-                    10. Ensure dates are always visible, accurate & readable
-                    
-                    Chart Configuration Best Practices:
-                    - Bar charts: Horizontal for many categories.
-                    - Line charts: Aggregate time data, show trends not noise
-                    - Pie/Doughnut: Limit to top 10 categories, group "Others"
-                    - Use appropriate scales and formatting (K, M, B for large numbers)
-                    
-                    Return ONLY complete HTML code starting with <!DOCTYPE html>
-                    NO markdown, NO explanations, just pure HTML that looks like a professional BI tool.
-                    """
-                    
-                    response = client.models.generate_content(
-                        model="gemini-2.0-flash-exp",
-                        contents=[html_prompt]
-                    )
-                    
-                    html_code = response.text.strip()
-                    
-                    if html_code.startswith("```"):
-                        html_code = html_code.split("```")[1]
-                        if html_code.startswith("html"):
-                            html_code = html_code[4:]
-                        html_code = html_code.strip()
-                    
-                    st.session_state['html_dashboard'] = html_code
-                    st.success("✅ Professional dashboard generated!")
-                    
-                except Exception as e:
-                    st.error(f"❌ Error generating HTML dashboard: {e}")
-                    st.exception(e)
-        
-        # ------------------------------
-        # Display Interactive HTML Dashboard
-        # ------------------------------
-        if 'html_dashboard' in st.session_state:
-            st.markdown("---")
-            st.markdown("### 🎨 Professional Interactive Dashboard")
-            
-            html_code = st.session_state['html_dashboard']
-            
-            # Display the interactive HTML
-            components.html(html_code, height=1000, scrolling=True)
-            
-            col1, col2 = st.columns(2)
-            with col1:
-                st.download_button(
-                    label="📥 Download HTML Dashboard",
-                    data=html_code,
-                    file_name=f"dashboard_{uploaded_file.name.split('.')[0]}.html",
-                    mime="text/html",
-                    use_container_width=True
-                )
-            
-            with col2:
-                with st.expander("💻 View HTML Source Code"):
-                    st.code(html_code, language="html")
-        
-        # ------------------------------
-        # Generate AI Presentation (PPT-style HTML)
-        # ------------------------------
-        if generate_presentation:
-            with st.spinner("Creating professional presentation..."):
-                try:
-                    # Get insights and domain info
-                    chart_plan = st.session_state.get('chart_plan', {})
-                    domain = chart_plan.get('domain', 'general')
-                    insights = chart_plan.get('insights', [])
-                    
-                    dashboard_title = uploaded_file.name.split('.')[0].replace('_', ' ').title()
-                    
-                    # Prepare data summary
-                    key_metrics = []
-                    for col in df.select_dtypes(include=['number']).columns[:4]:
-                        key_metrics.append({
-                            'metric': col,
-                            'value': float(df[col].sum()),
-                            'avg': float(df[col].mean()),
-                            'trend': 'up' if df[col].mean() > df[col].median() else 'down'
-                        })
-                    
-                    presentation_prompt = f"""
-                    Create a professional HTML presentation (PowerPoint-style) with slide navigation.
-                    
-                    Presentation Context:
-                    - Title: {dashboard_title} - Business Intelligence Analysis
-                    - Domain: {domain}
-                    - Dataset: {df.shape[0]} rows, {df.shape[1]} columns
-                    - Key Insights: {json.dumps(insights, cls=CustomJSONEncoder)}
-                    - Key Metrics: {json.dumps(key_metrics, cls=CustomJSONEncoder)}
-                    
-                    Create EXACTLY 5 slides with this structure:
-                    
-                    SLIDE 1 - Title & Introduction:
-                    - Large title: "{dashboard_title}"
-                    - Subtitle: "Business Intelligence Dashboard Analysis"
-                    - Brief introduction about the data and purpose
-                    - Beautiful gradient background matching {domain} theme
-                    - Company logo placeholder if applicable
-                    
-                    SLIDE 2 - Key Objectives & Questions:
-                    - Title: "Business Objectives"
-                    - List 3-4 core business questions this analysis answers
-                    - Use bullet points with icons
-                    - Examples: "What drives revenue growth?", "Which segments perform best?", etc.
-                    
-                    SLIDE 3 - Data & Analysis:
-                    - Title: "Key Findings & Visualizations"
-                    - Include 2-3 mini chart visualizations using Chart.js
-                    - Show the most important metrics and trends
-                    - Use actual data from the metrics provided
-                    - Keep charts simple and clear
-                    
-                    SLIDE 4 - Insights & Recommendations:
-                    - Title: "Strategic Insights"
-                    - Present the top 3 insights from the data
-                    - Add actionable recommendations for each insight
-                    - Use cards/boxes for visual separation
-                    - Include trend indicators (↑↓→)
-                    
-                    SLIDE 5 - Conclusion & Next Steps:
-                    - Title: "Conclusion & Action Plan"
-                    - Recap key takeaways (3-4 points)
-                    - Suggest 2-3 concrete next steps
-                    - Add a "Questions?" section
-                    - Thank you message
-                    
-                    Technical Requirements:
-                    1. Full-screen slides (100vh height, 100vw width)
-                    2. Slide navigation: Previous/Next buttons + keyboard arrows
-                    3. Slide counter: "Slide X of 5"
-                    4. Smooth transitions between slides (slide/fade effect)
-                    5. Professional design matching {domain} color scheme:
-                       - Finance: Navy blue with gold accents
-                       - Retail: Orange and green tones
-                       - Healthcare: Teal and blue
-                       - Entertainment: Purple and magenta
-                       - Technology: Cyan and blue
-                       - Generic: Professional blue-gray
-                    6. Use Chart.js for any charts (CDN: https://cdn.jsdelivr.net/npm/chart.js)
-                    7. Responsive typography and spacing
-                    8. Each slide should be self-contained and visually appealing
-                    9. Add subtle animations (fade-in effects for content)
-                    10. Footer on each slide with page number and date
-                    
-                    Return ONLY complete HTML code starting with <!DOCTYPE html>
-                    NO markdown, NO explanations.
-                    The presentation should look like a professional PowerPoint/Keynote presentation.
-                    """
-                    
-                    response = client.models.generate_content(
-                        model="gemini-2.0-flash-exp",
-                        contents=[presentation_prompt]
-                    )
-                    
-                    ppt_html = response.text.strip()
-                    
-                    if ppt_html.startswith("```"):
-                        ppt_html = ppt_html.split("```")[1]
-                        if ppt_html.startswith("html"):
-                            ppt_html = ppt_html[4:]
-                        ppt_html = ppt_html.strip()
-                    
-                    st.session_state['presentation'] = ppt_html
-                    st.success("✅ Presentation generated!")
-                    
-                except Exception as e:
-                    st.error(f"❌ Error generating presentation: {e}")
-                    st.exception(e)
-        
-        # ------------------------------
-        # Display Presentation
-        # ------------------------------
-        if 'presentation' in st.session_state:
-            st.markdown("---")
-            st.markdown("### 🎤 AI-Generated Business Presentation")
-            st.info("Use arrow keys or navigation buttons to move between slides")
-            
-            ppt_html = st.session_state['presentation']
-            
-            # Display the presentation
-            components.html(ppt_html, height=700, scrolling=False)
-            
-            st.download_button(
-                label="📥 Download Presentation (HTML)",
-                data=ppt_html,
-                file_name=f"presentation_{uploaded_file.name.split('.')[0]}.html",
-                mime="text/html",
-                use_container_width=True
-            )
-    
-    except Exception as e:
-        st.error(f"❌ Error loading file: {e}")
-        st.exception(e)
+                        # Cleanup axes
+                        ax.tick_params(axis='x', rotation=45)
+                    except Exception as e:
+                        ax.text(0.5, 0.5, "Could not render chart", ha='center')
+                
+                plt.tight_layout()
+                st.pyplot(fig)
 
-else:
-    st.info("👆 Please upload a CSV or Excel file to get started.")
+            # Result 2: HTML Dashboard
+            if 'html_dashboard' in st.session_state:
+                st.divider()
+                st.subheader("🖥️ Interactive Dashboard (Banana Pro Generated)")
+                components.html(st.session_state['html_dashboard'], height=800, scrolling=True)
+                st.download_button("📥 Download HTML", st.session_state['html_dashboard'], "dashboard.html", "text/html")
 
-# ------------------------------
-# Footer
-# ------------------------------
-st.markdown("---")
-st.markdown(
-    f"<div style='text-align: center; color: gray;'>Built with Streamlit & Google Gemini AI</div>",
-    unsafe_allow_html=True
-)
+            # Result 3: Presentation
+            if 'ppt_html' in st.session_state:
+                st.divider()
+                st.subheader("📽️ Executive Presentation")
+                components.html(st.session_state['ppt_html'], height=600)
+                st.download_button("📥 Download Slides", st.session_state['ppt_html'], "presentation.html", "text/html")
+
+        except Exception as e:
+            st.error(f"Error processing file: {e}")
+
+if __name__ == "__main__":
+    main()