Update app.py

app.py

@@ -1,354 +1,424 @@
-# Odyssey - The AI Data Science Workspace
-# A state-of-the-art, AI-native analytic environment.
-# This script is a complete, self-contained Gradio application.
-
 import gradio as gr
 import pandas as pd
 import numpy as np
 import plotly.express as px
 import plotly.graph_objects as go
-import io, os, json, pickle, logging, warnings, uuid
+from plotly.subplots import make_subplots
+import io
+import json
+import warnings
+import google.generativeai as genai
+import os
 from contextlib import redirect_stdout
-from datetime import datetime
-
-# ML & Preprocessing Imports
-from sklearn.model_selection import cross_val_score, train_test_split
-from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
-from sklearn.linear_model import LogisticRegression, LinearRegression
-from sklearn.metrics import roc_curve, auc, confusion_matrix, r2_score, mean_squared_error
-from sklearn.preprocessing import LabelEncoder
-from sklearn.impute import KNNImputer
-
-# Optional: For AI features
-try:
-    import google.generativeai as genai
-except ImportError:
-    print("Warning: 'google-generativeai' not found. AI features will be disabled.")
-    genai = None
 
 # --- Configuration ---
 warnings.filterwarnings('ignore')
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-
-# --- UI Theme & Icons ---
-THEME = gr.themes.Monochrome(primary_hue="indigo", secondary_hue="blue", neutral_hue="slate").set(
-    body_background_fill="radial-gradient(circle, rgba(10,20,50,1) 0%, rgba(0,0,10,1) 100%);",
-    block_label_background_fill="rgba(255,255,255,0.05)",
-    block_background_fill="rgba(255,255,255,0.05)",
-    button_primary_background_fill="linear-gradient(90deg, #6A11CB 0%, #2575FC 100%)",
-    button_secondary_background_fill="linear-gradient(90deg, #556270 0%, #4ECDC4 100%)",
-    color_accent_soft="rgba(255,255,255,0.2)"
-)
-ICONS = {"overview": "🔭", "medic": "🧪", "launchpad": "🚀", "copilot": "💡", "export": "📄"}
+CSS = """
+/* --- Phoenix UI Custom CSS --- */
+/* Stat Card Styling */
+.stat-card {
+    border-radius: 12px !important;
+    padding: 20px !important;
+    background: #f7fafc; /* light gray background */
+    border: 1px solid #e2e8f0;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+    text-align: center;
+}
+.stat-card-title { font-size: 16px; font-weight: 500; color: #4a5568; margin-bottom: 8px; }
+.stat-card-value { font-size: 32px; font-weight: 700; color: #2d3748; }
+
+/* General Layout & Feel */
+.gradio-container { font-family: 'Inter', sans-serif; }
+.gr-button { box-shadow: 0 1px 2px 0 rgba(0,0,0,0.05); }
+
+/* Sidebar Styling */
+.sidebar {
+    background-color: #f9fafb;
+    padding: 15px;
+    border-right: 1px solid #e5e7eb;
+    min-height: 100vh;
+}
+.sidebar .gr-button {
+    width: 100%;
+    text-align: left !important;
+    background: none !important;
+    border: none !important;
+    box-shadow: none !important;
+    color: #374151 !important;
+    font-size: 16px !important;
+    padding: 12px 10px !important;
+    margin-bottom: 8px !important;
+    border-radius: 8px !important;
+}
+.sidebar .gr-button:hover { background-color: #e5e7eb !important; }
+.sidebar .gr-button.selected { background-color: #d1d5db !important; font-weight: 600 !important; }
+
+/* AI Co-pilot Styling */
+.code-block { border: 1px solid #e5e7eb; border-radius: 8px; }
+.explanation-block { background-color: #f0f9ff; border-left: 4px solid #3b82f6; padding: 12px; }
+"""
 
 # --- Helper Functions ---
-def safe_exec(code_string: str, local_vars: dict) -> tuple:
+def safe_exec(code_string: str, local_vars: dict):
     """Safely execute a string of Python code and capture its output."""
     output_buffer = io.StringIO()
     try:
         with redirect_stdout(output_buffer):
             exec(code_string, globals(), local_vars)
+        
         stdout = output_buffer.getvalue()
         fig = local_vars.get('fig')
-        df_out = local_vars.get('df_result')
-        return stdout, fig, df_out, None
+        result_df = local_vars.get('result_df')
+        return stdout, fig, result_df, None
     except Exception as e:
         return None, None, None, f"Execution Error: {str(e)}"
 
-# --- Core State & Project Management ---
-def init_state():
-    """Initializes a blank global state dictionary."""
-    return {
-        "project_name": None, "df_original": None, "df_modified": None,
-        "metadata": None, "insights": None, "chat_history": []
-    }
-
-def save_project(state):
-    """Saves the entire application state to a .odyssey file."""
-    if not state or not state.get("project_name"):
-        return gr.update(value="Project needs a name to save.", interactive=True)
-    
-    filename = f"{state['project_name']}.odyssey"
-    with open(filename, "wb") as f:
-        pickle.dump(state, f)
-    return gr.update(value=f"✅ Project saved to {filename}", interactive=True)
-
-def load_project(file_obj):
-    """Loads a .odyssey file into the application state."""
-    if not file_obj: return init_state()
-    with open(file_obj.name, "rb") as f:
-        return pickle.load(f)
-
-def prime_data(file_obj, project_name):
-    """Main function to load a new CSV, analyze it, and set the initial state."""
-    if not file_obj: return init_state()
-    df = pd.read_csv(file_obj.name)
-    
-    for col in df.select_dtypes(include=['object']).columns:
-        try:
-            df[col] = pd.to_datetime(df[col], errors='raise')
-        except (ValueError, TypeError):
-            if 0.5 > df[col].nunique() / len(df) > 0.0:
-                df[col] = df[col].astype('category')
-    
-    metadata = extract_metadata(df)
-    insights = run_helios_engine(df, metadata)
-    
-    return {
-        "project_name": project_name or f"Project_{datetime.now().strftime('%Y%m%d_%H%M')}",
-        "df_original": df, "df_modified": df.copy(), "metadata": metadata,
-        "insights": insights, "chat_history": []
-    }
+# --- Core Data Processing & State Management ---
+def load_and_process_file(file_obj, state_dict):
+    """Loads a CSV, processes it, and updates the entire UI state."""
+    if file_obj is None:
+        return state_dict, "Please upload a file.", *[gr.update(visible=False)] * 3
+    try:
+        df = pd.read_csv(file_obj.name, low_memory=False)
+        for col in df.select_dtypes(include=['object']).columns:
+            try:
+                df[col] = pd.to_datetime(df[col], errors='raise')
+            except (ValueError, TypeError):
+                continue
+        
+        metadata = extract_dataset_metadata(df)
+        state_dict = {
+            'df': df,
+            'metadata': metadata,
+            'filename': os.path.basename(file_obj.name),
+            'dashboard_plots': []
+        }
+        
+        status_msg = f"✅ **{state_dict['filename']}** loaded successfully."
+        
+        # Update UI elements with new data context
+        cockpit_update = gr.update(visible=True)
+        deep_dive_update = gr.update(visible=False)
+        copilot_update = gr.update(visible=False)
+        welcome_update = gr.update(visible=False)
+        
+        # Stat cards
+        rows, cols = metadata['shape']
+        quality = metadata['data_quality']
+        
+        return (state_dict, status_msg, welcome_update, cockpit_update, deep_dive_update, copilot_update,
+                gr.update(value=f"{rows:,}"), gr.update(value=cols), gr.update(value=f"{quality}%"), 
+                gr.update(value=f"{len(metadata['datetime_cols'])}"),
+                gr.update(choices=metadata['columns']), gr.update(choices=metadata['columns']), gr.update(choices=metadata['columns']))
+    except Exception as e:
+        return state_dict, f"❌ **Error:** {e}", *[gr.update()] * 10
 
-def extract_metadata(df):
-    """Utility to get schema and column types."""
+def extract_dataset_metadata(df: pd.DataFrame):
+    rows, cols = df.shape
+    numeric_cols = df.select_dtypes(include=np.number).columns.tolist()
+    categorical_cols = df.select_dtypes(include=['object', 'category']).columns.tolist()
+    datetime_cols = df.select_dtypes(include=['datetime64', 'datetime64[ns]']).columns.tolist()
+    data_quality = round((df.notna().sum().sum() / (rows * cols)) * 100, 1) if rows * cols > 0 else 0
     return {
-        'shape': df.shape, 'columns': df.columns.tolist(),
-        'numeric': df.select_dtypes(include=np.number).columns.tolist(),
-        'categorical': df.select_dtypes(include=['object', 'category']).columns.tolist(),
-        'datetime': df.select_dtypes(include='datetime').columns.tolist(),
-        'dtypes': df.dtypes.apply(lambda x: x.name).to_dict()
+        'shape': (rows, cols), 'columns': df.columns.tolist(),
+        'numeric_cols': numeric_cols, 'categorical_cols': categorical_cols,
+        'datetime_cols': datetime_cols, 'dtypes': df.dtypes.to_string(),
+        'head': df.head().to_string(), 'data_quality': data_quality
     }
 
-# --- Module-Specific Handlers ---
+# --- Page Navigation ---
+def switch_page(page_name):
+    """Controls visibility of main content pages."""
+    if page_name == "cockpit":
+        return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
+    elif page_name == "deep_dive":
+        return gr.update(visible=False), gr.update(visible=True), gr.update(visible=False)
+    elif page_name == "co-pilot":
+        return gr.update(visible=False), gr.update(visible=False), gr.update(visible=True)
+    return gr.update(visible=True), gr.update(visible=False), gr.update(visible=False)
 
-def run_helios_engine(df, metadata):
-    """The proactive analysis engine for the Helios Overview."""
-    insights = {}
-    missing = df.isnull().sum()
-    insights['missing_data'] = missing[missing > 0].sort_values(ascending=False)
-    insights['high_cardinality'] = {c: df[c].nunique() for c in metadata['categorical'] if df[c].nunique() > 50}
-    
-    outliers = {}
-    for col in metadata['numeric']:
-        Q1, Q3 = df[col].quantile(0.25), df[col].quantile(0.75)
-        IQR = Q3 - Q1
-        count = ((df[col] < (Q1 - 1.5 * IQR)) | (df[col] > (Q3 + 1.5 * IQR))).sum()
-        if count > 0: outliers[col] = count
-    insights['outliers'] = outliers
+# --- Page 1: Data Cockpit ---
+def get_ai_suggestions(state_dict, api_key):
+    """Generates proactive analytical suggestions from the AI."""
+    if not api_key: return "Enter your Gemini API key to get suggestions.", gr.update(visible=False)
+    if not state_dict: return "Upload data first.", gr.update(visible=False)
     
-    suggestions = []
-    for col in metadata['categorical']:
-        if df[col].nunique() == 2: suggestions.append(f"{col} (Classification)")
-    for col in metadata['numeric']:
-        if df[col].nunique() > 20: suggestions.append(f"{col} (Regression)")
-    insights['ml_suggestions'] = suggestions
-    return insights
-
-def prometheus_run_model(state, target, features, model_name):
-    """Trains and evaluates a model in the Prometheus Launchpad."""
-    if not target or not features: return None, None, "Select target and features."
-    df = state['df_modified'].copy()
-    df.dropna(subset=[target] + features, inplace=True)
+    metadata = state_dict['metadata']
+    prompt = f"""
+    Based on the following dataset metadata, generate 3 to 5 specific, actionable, and interesting analytical questions a user might want to ask. Frame them as questions.
+    - **Columns:** {', '.join(metadata['columns'])}
+    - **Numeric:** {', '.join(metadata['numeric_cols'])}
+    - **Categorical:** {', '.join(metadata['categorical_cols'])}
+    - **Datetime:** {', '.join(metadata['datetime_cols'])}
     
-    for col in [target] + features:
-        if df[col].dtype.name in ['category', 'object']:
-            df[col] = LabelEncoder().fit_transform(df[col])
-            
-    X, y = df[features], df[target]
-    problem_type = "Classification" if y.nunique() <= 10 else "Regression"
+    Return ONLY a JSON list of strings. Example: ["What is the trend of sales over time?", "Which category has the highest average price?"]
+    """
+    try:
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-1.5-flash')
+        response = model.generate_content(prompt)
+        suggestions = json.loads(response.text)
+        
+        # Create a button for each suggestion
+        buttons = [gr.Button(s, variant="secondary") for s in suggestions]
+        return gr.update(visible=False), gr.Accordion(label="✨ AI Smart Suggestions", open=True, children=buttons)
     
-    MODELS = {"Classification": {"Random Forest": RandomForestClassifier, "Logistic Regression": LogisticRegression},
-              "Regression": {"Random Forest": RandomForestRegressor, "Linear Regression": LinearRegression}}
-    if model_name not in MODELS[problem_type]: return None, None, "Invalid model for this problem type."
+    except Exception as e:
+        return f"Could not generate suggestions: {e}", gr.update(visible=False)
+
+# --- Page 2: Deep Dive Dashboard ---
+def add_plot_to_dashboard(state_dict, x_col, y_col, plot_type):
+    """Generates a plot and adds it to the state-managed dashboard."""
+    if not x_col: return state_dict, gr.update()
     
-    model = MODELS[problem_type][model_name](random_state=42)
+    df = state_dict['df']
+    title = f"{plot_type.capitalize()}: {y_col} by {x_col}" if y_col else f"Distribution of {x_col}"
+    fig = None
     
-    if problem_type == "Classification":
-        scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')
-        report = f"**Cross-Validated Accuracy:** {np.mean(scores):.3f} ± {np.std(scores):.3f}"
-        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
-        model.fit(X_train, y_train)
-        y_prob = model.predict_proba(X_test)[:, 1]
-        fpr, tpr, _ = roc_curve(y_test, y_prob)
-        fig1 = go.Figure(data=go.Scatter(x=fpr, y=tpr, mode='lines', name=f'ROC (AUC = {auc(fpr, tpr):.2f})'))
-        fig1.add_scatter(x=[0, 1], y=[0, 1], mode='lines', line=dict(dash='dash'), name='Random')
-        fig1.update_layout(title="ROC Curve")
-    else: # Regression
-        scores = cross_val_score(model, X, y, cv=5, scoring='r2')
-        report = f"**Cross-Validated R² Score:** {np.mean(scores):.3f} ± {np.std(scores):.3f}"
-        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
-        model.fit(X_train, y_train)
-        preds = model.predict(X_test)
-        residuals = y_test - preds
-        fig1 = px.scatter(x=preds, y=residuals, title="Residuals vs. Predicted", labels={'x': 'Predicted', 'y': 'Residuals'})
-        fig1.add_hline(y=0, line_dash="dash")
+    try:
+        if plot_type == 'histogram': fig = px.histogram(df, x=x_col, title=title)
+        elif plot_type == 'box': fig = px.box(df, x=x_col, y=y_col, title=title)
+        elif plot_type == 'scatter': fig = px.scatter(df, x=x_col, y=y_col, title=title, trendline="ols")
+        elif plot_type == 'bar': 
+            counts = df[x_col].value_counts().nlargest(20)
+            fig = px.bar(counts, x=counts.index, y=counts.values, title=f"Top 20 Categories for {x_col}")
+            fig.update_xaxes(title=x_col)
         
-    if hasattr(model, 'feature_importances_'):
-        fi = pd.Series(model.feature_importances_, index=features).sort_values(ascending=False)
-        fig2 = px.bar(fi, title="Feature Importance")
-    else:
-        fig2 = go.Figure().update_layout(title="Feature Importance (Not available)")
+        if fig:
+            state_dict['dashboard_plots'].append(fig)
         
-    return fig1, fig2, report
+        # Rebuild the accordion with all plots
+        accordion_children = [gr.Plot(fig, visible=True) for fig in state_dict['dashboard_plots']]
+        return state_dict, gr.Accordion(label="Your Dashboard Plots", children=accordion_children, open=True)
+    except Exception as e:
+        gr.Warning(f"Plotting Error: {e}")
+        return state_dict, gr.update()
+
+def clear_dashboard(state_dict):
+    """Clears all plots from the dashboard."""
+    state_dict['dashboard_plots'] = []
+    return state_dict, gr.Accordion(label="Your Dashboard Plots", children=[])
 
-def athena_respond(user_message, history, state, api_key):
-    """Handles the chat interaction with the AI Co-pilot."""
-    if not genai:
-        history.append((user_message, "Google AI library not installed. Cannot use Athena."))
-        return history, None, None, state
+# --- Page 3: AI Co-pilot ---
+def respond_to_chat(user_message, history, state_dict, api_key):
+    """Handles the advanced chat interaction with the AI Co-pilot."""
     if not api_key:
-        history.append((user_message, "Please enter your Gemini API key to use Athena."))
-        return history, None, None, state
+        history.append((user_message, "I need a Gemini API key to function. Please provide it in the sidebar."))
+        return history, *[gr.update(visible=False)] * 4
+    if not state_dict:
+        history.append((user_message, "Please upload a dataset first."))
+        return history, *[gr.update(visible=False)] * 4
 
     history.append((user_message, None))
-    
-    # Configure the API
-    genai.configure(api_key=api_key)
-    model = genai.GenerativeModel('gemini-1.5-flash')
 
+    metadata = state_dict['metadata']
     prompt = f"""
-    You are 'Athena', an AI data scientist. Your goal is to help a user by writing and executing Python code on a pandas DataFrame named `df`.
-    
-    **DataFrame Info:**
-    {state['df_modified'].info(verbose=False)}
+    You are 'Phoenix Co-pilot', an expert AI data analyst. Your goal is to help a user analyze a pandas DataFrame named `df`.
     
     **Instructions:**
-    1.  Analyze the user's request: '{user_message}'.
-    2.  Formulate a plan (thought).
-    3.  Write Python code to execute the plan. You can use `pandas as pd`, `numpy as np`, and `plotly.express as px`.
-    4.  To show a plot, assign it to a variable `fig`.
-    5.  To show a dataframe, assign it to a variable `df_result`.
-    6.  Use `print()` for text output.
-    7.  **NEVER** modify `df` in place.
-    8.  Respond **ONLY** with a single, valid JSON object with keys "thought" and "code".
-    
+    1.  Carefully understand the user's question.
+    2.  Formulate a plan (thought process).
+    3.  Write Python code to execute that plan.
+    4.  The code can use pandas (pd), numpy (np), and plotly.express (px).
+    5.  **For plots, assign the figure to a variable `fig` (e.g., `fig = px.histogram(...)`).**
+    6.  **For table-like results, assign the final DataFrame to a variable `result_df` (e.g., `result_df = df.describe()`).**
+    7.  Do not modify the original `df`. Use `df.copy()` if needed.
+    8.  Provide a brief, user-friendly explanation of the result.
+    9.  Respond **ONLY** with a single, raw JSON object with keys: "thought", "code", "explanation".
+
+    **DataFrame Metadata:**
+    - Columns and dtypes: {metadata['dtypes']}
+    - First 5 rows: {metadata['head']}
+
+    **User Question:** "{user_message}"
+
     **Your JSON Response:**
     """
+    
     try:
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-1.5-flash')
         response = model.generate_content(prompt)
-        response_json = json.loads(response.text.strip().replace("```json", "").replace("```", ""))
+        
+        response_text = response.text.strip().replace("```json", "").replace("```", "")
+        response_json = json.loads(response_text)
+        
         thought = response_json.get("thought", "Thinking...")
-        code_to_run = response_json.get("code", "print('No code generated.')")
+        code_to_run = response_json.get("code", "")
+        explanation = response_json.get("explanation", "Here is the result.")
         
-        bot_thinking = f"🧠 **Thinking:** *{thought}*"
-        history[-1] = (user_message, bot_thinking)
-        yield history, None, None, state
+        stdout, fig_result, df_result, error = safe_exec(code_to_run, {'df': state_dict['df'], 'px': px, 'pd': pd, 'np': np})
+
+        bot_message = f"🤔 **Thought:** *{thought}*"
+        history[-1] = (user_message, bot_message)
         
-        local_vars = {'df': state['df_modified'], 'px': px, 'pd': pd, 'np': np}
-        stdout, fig_result, df_result, error = safe_exec(code_to_run, local_vars)
-
-        bot_response = bot_thinking + "\n\n---\n\n"
-        if error: bot_response += f"💥 **Error:**\n```\n{error}\n```"
-        if stdout: bot_response += f"📋 **Output:**\n```\n{stdout}\n```"
-        if not error and not stdout and not fig_result and not isinstance(df_result, pd.DataFrame):
-            bot_response += "✅ Code executed, but produced no direct output."
-
-        history[-1] = (user_message, bot_response)
-        state['chat_history'] = history # Persist chat history
-        yield history, fig_result, df_result, state
+        # Prepare outputs, making them visible only if they contain content
+        output_updates = [gr.update(visible=False, value=None)] * 4 # [explanation, code, plot, table]
         
+        if explanation: output_updates[0] = gr.update(visible=True, value=f"**Phoenix Co-pilot:** {explanation}")
+        if code_to_run: output_updates[1] = gr.update(visible=True, value=code_to_run)
+        if fig_result: output_updates[2] = gr.update(visible=True, value=fig_result)
+        if df_result is not None: output_updates[3] = gr.update(visible=True, value=df_result)
+        if stdout:
+            # Append stdout to explanation if it exists
+            new_explanation = (output_updates[0]['value'] if output_updates[0]['value'] else "") + f"\n\n**Console Output:**\n```\n{stdout}\n```"
+            output_updates[0] = gr.update(visible=True, value=new_explanation)
+        if error:
+            error_explanation = f"**Phoenix Co-pilot:** I encountered an error. Here's the details:\n\n`{error}`"
+            output_updates[0] = gr.update(visible=True, value=error_explanation)
+
+        return history, *output_updates
+
     except Exception as e:
-        error_msg = f"A critical error occurred with the AI model: {e}"
+        error_msg = f"A critical error occurred: {e}. The AI may have returned an invalid response. Please try rephrasing your question."
         history[-1] = (user_message, error_msg)
-        yield history, None, None, state
+        return history, *[gr.update(visible=False)] * 4
 
-# --- UI Builder ---
-def build_ui():
-    """Constructs the entire Gradio application interface."""
-    with gr.Blocks(theme=THEME, title="Odyssey AI Data Workspace") as demo:
-        state = gr.State(init_state())
+# --- Gradio UI Definition ---
+def create_gradio_interface():
+    with gr.Blocks(theme=gr.themes.Monochrome(primary_hue="indigo", secondary_hue="blue"), css=CSS, title="Phoenix AI Data Explorer") as demo:
+        global_state = gr.State({})
 
         with gr.Row():
-            # Left Sidebar - Command Center
-            with gr.Column(scale=1):
-                gr.Markdown("# 🦉 Odyssey")
-                with gr.Accordion("📂 Project", open=True):
-                    project_name_input = gr.Textbox(label="Project Name", value="New_Project")
-                    file_input = gr.File(label="Upload CSV", file_types=[".csv"])
-                    api_key_input = gr.Textbox(label="🔑 Gemini API Key", type="password", placeholder="Enter key...")
-                    with gr.Row():
-                        save_btn = gr.Button("Save")
-                        load_btn = gr.UploadButton("Load .odyssey")
-                    project_status = gr.Markdown()
+            # --- Sidebar ---
+            with gr.Column(scale=1, elem_classes="sidebar"):
+                gr.Markdown("# 🚀 Phoenix UI")
+                gr.Markdown("AI Data Explorer")
                 
                 # Navigation buttons
-                overview_btn = gr.Button(f"{ICONS['overview']} Helios Overview")
-                launchpad_btn = gr.Button(f"{ICONS['launchpad']} Prometheus Launchpad")
-                copilot_btn = gr.Button(f"{ICONS['copilot']} Athena Co-pilot")
-                export_btn = gr.Button(f"{ICONS['export']} Export Report", visible=False)
+                cockpit_btn = gr.Button("📊 Data Cockpit", elem_classes="selected")
+                deep_dive_btn = gr.Button("🔍 Deep Dive Builder")
+                copilot_btn = gr.Button("🤖 AI Co-pilot")
+                
+                gr.Markdown("---")
+                file_input = gr.File(label="📁 Upload New CSV", file_types=[".csv"])
+                status_output = gr.Markdown("Status: Awaiting data...")
+                gr.Markdown("---")
+                api_key_input = gr.Textbox(label="🔑 Gemini API Key", type="password", placeholder="Enter key here...")
+                suggestion_btn = gr.Button("Get Smart Suggestions", variant="secondary")
 
-            # Right Panel - Main Workspace
+            # --- Main Content Area ---
             with gr.Column(scale=4):
-                # --- Helios Overview Panel ---
-                with gr.Column(visible=True) as overview_panel:
-                    gr.Markdown(f"# {ICONS['overview']} Helios Overview")
-                    helios_report_md = gr.Markdown("Upload a CSV and provide a project name to begin your Odyssey.")
                 
-                # --- Prometheus Launchpad Panel ---
-                with gr.Column(visible=False) as launchpad_panel:
-                    gr.Markdown(f"# {ICONS['launchpad']} Prometheus Launchpad")
+                # Welcome Page (Visible initially)
+                with gr.Column(visible=True) as welcome_page:
+                    gr.Markdown("# Welcome to the AI Data Explorer (Phoenix UI)", elem_id="welcome-header")
+                    gr.Markdown("Please **upload a CSV file** and **enter your Gemini API key** in the sidebar to begin.")
+                    gr.Image(value="https://i.imgur.com/gY5wSjV.png", label="Workflow", show_label=False, show_download_button=False, container=False) # Placeholder image
+
+                # Page 1: Data Cockpit (Hidden initially)
+                with gr.Column(visible=False) as cockpit_page:
+                    gr.Markdown("## 📊 Data Cockpit")
                     with gr.Row():
-                        lp_target = gr.Dropdown(label="🎯 Target")
-                        # CORRECTED LINE: Use gr.Dropdown with multiselect=True
-                        lp_features = gr.Dropdown(label="✨ Features", multiselect=True)
-                        lp_model = gr.Dropdown(choices=["Random Forest", "Logistic Regression", "Linear Regression"], label="🧠 Model")
-                    lp_run_btn = gr.Button("🚀 Launch Model Training (with CV)")
-                    lp_report_md = gr.Markdown()
+                        with gr.Column(elem_classes="stat-card"):
+                            gr.Markdown("<div class='stat-card-title'>Rows</div>", elem_classes="stat-card-content")
+                            rows_stat = gr.Textbox("0", show_label=False, elem_classes="stat-card-value")
+                        with gr.Column(elem_classes="stat-card"):
+                            gr.Markdown("<div class='stat-card-title'>Columns</div>", elem_classes="stat-card-content")
+                            cols_stat = gr.Textbox("0", show_label=False, elem_classes="stat-card-value")
+                        with gr.Column(elem_classes="stat-card"):
+                            gr.Markdown("<div class='stat-card-title'>Data Quality</div>", elem_classes="stat-card-content")
+                            quality_stat = gr.Textbox("0%", show_label=False, elem_classes="stat-card-value")
+                        with gr.Column(elem_classes="stat-card"):
+                            gr.Markdown("<div class='stat-card-title'>Date/Time Cols</div>", elem_classes="stat-card-content")
+                            time_cols_stat = gr.Textbox("0", show_label=False, elem_classes="stat-card-value")
+
+                    suggestion_status = gr.Markdown(visible=True)
+                    suggestion_accordion = gr.Accordion(label="✨ AI Smart Suggestions", open=False, visible=False)
+
+                # Page 2: Deep Dive Dashboard Builder (Hidden initially)
+                with gr.Column(visible=False) as deep_dive_page:
+                    gr.Markdown("## 🔍 Deep Dive Dashboard Builder")
+                    gr.Markdown("Create a custom dashboard by adding multiple plots to investigate your data.")
                     with gr.Row():
-                        lp_fig1 = gr.Plot()
-                        lp_fig2 = gr.Plot()
-                
-                # --- Athena Co-pilot Panel ---
-                with gr.Column(visible=False) as copilot_panel:
-                    gr.Markdown(f"# {ICONS['copilot']} Athena Co-pilot")
-                    chatbot = gr.Chatbot(height=500, label="Chat History")
-                    with gr.Accordion("AI Generated Results", open=True):
-                        copilot_fig_output = gr.Plot()
-                        copilot_df_output = gr.DataFrame(interactive=False)
-                    chat_input = gr.Textbox(label="Your Request", placeholder="e.g., 'What's the correlation between all numeric columns?'")
-                    chat_submit = gr.Button("Send", variant="primary")
-        
-        # --- Event Handling ---
-        panels = [overview_panel, launchpad_panel, copilot_panel]
-        def switch_panel(btn_idx):
-            return [gr.update(visible=i == btn_idx) for i in range(len(panels))]
+                        plot_type_dd = gr.Dropdown(['histogram', 'bar', 'scatter', 'box'], label="Plot Type", value='histogram')
+                        x_col_dd = gr.Dropdown([], label="X-Axis / Column")
+                        y_col_dd = gr.Dropdown([], label="Y-Axis (for Scatter/Box)")
+                    with gr.Row():
+                        add_plot_btn = gr.Button("Add to Dashboard", variant="primary")
+                        clear_plots_btn = gr.Button("Clear Dashboard")
+                    dashboard_accordion = gr.Accordion(label="Your Dashboard Plots", open=True)
+
+                # Page 3: AI Co-pilot (Hidden initially)
+                with gr.Column(visible=False) as copilot_page:
+                    gr.Markdown("## 🤖 AI Co-pilot")
+                    gr.Markdown("Ask complex questions in natural language. The Co-pilot will write and execute code to find the answer.")
+                    chatbot = gr.Chatbot(height=400, label="Conversation with Co-pilot")
+                    
+                    # AI's multi-modal response area
+                    with gr.Accordion("Co-pilot's Response Details", open=True):
+                        copilot_explanation = gr.Markdown(visible=False, elem_classes="explanation-block")
+                        copilot_code = gr.Code(language="python", visible=False, label="Executed Python Code", elem_classes="code-block")
+                        copilot_plot = gr.Plot(visible=False, label="Generated Visualization")
+                        copilot_table = gr.Dataframe(visible=False, label="Generated Table", wrap=True)
+
+                    with gr.Row():
+                        chat_input = gr.Textbox(label="Your Question", placeholder="e.g., 'What is the correlation between age and salary?'", scale=4)
+                        chat_submit_btn = gr.Button("Submit", variant="primary")
+
+        # --- Event Handlers ---
+        # Page Navigation
+        pages = [cockpit_page, deep_dive_page, copilot_page]
+        nav_buttons = [cockpit_btn, deep_dive_btn, copilot_btn]
         
-        overview_btn.click(lambda: switch_panel(0), None, panels)
-        launchpad_btn.click(lambda: switch_panel(1), None, panels)
-        copilot_btn.click(lambda: switch_panel(2), None, panels)
-
-        def on_upload_or_load(state_data):
-            """Unified function to update UI after data is loaded or a project is loaded."""
-            helios_md = "No data loaded."
-            if state_data and state_data.get('insights'):
-                insights = state_data['insights']
-                md = f"## 🔭 Proactive Insights for `{state_data.get('project_name')}`\n"
-                md += f"Dataset has **{state_data['metadata']['shape'][0]} rows** and **{state_data['metadata']['shape'][1]} columns**.\n\n"
-                if suggestions := insights.get('ml_suggestions'):
-                    md += "### 🔮 Potential ML Targets\n" + "\n".join(f"- `{s}`" for s in suggestions) + "\n"
-                if not insights.get('missing_data', pd.Series()).empty:
-                    md += "\n### 💧 Missing Data\nFound missing values in these columns:\n" + insights['missing_data'].to_frame('Missing Count').to_markdown() + "\n"
-                helios_md = md
-            
-            all_cols = state_data.get('metadata', {}).get('columns', [])
-            return {
-                state: state_data,
-                helios_report_md: helios_md,
-                lp_target: gr.update(choices=all_cols),
-                lp_features: gr.update(choices=all_cols),
-                chatbot: state_data.get('chat_history', [])
-            }
-
-        file_input.upload(prime_data, [file_input, project_name_input], state).then(
-            on_upload_or_load, state, [state, helios_report_md, lp_target, lp_features, chatbot]
-        )
-        load_btn.upload(load_project, load_btn, state).then(
-            on_upload_or_load, state, [state, helios_report_md, lp_target, lp_features, chatbot]
+        for i, btn in enumerate(nav_buttons):
+            btn.click(lambda i=i: (gr.update(visible=i==0), gr.update(visible=i==1), gr.update(visible=i==2)),
+                      outputs=pages).then(
+                      lambda: [gr.update(elem_classes="selected" if j==i else "") for j in range(len(nav_buttons))],
+                      outputs=nav_buttons)
+
+        # File Upload
+        file_input.upload(
+            fn=load_and_process_file,
+            inputs=[file_input, global_state],
+            outputs=[global_state, status_output, welcome_page, cockpit_page, deep_dive_page, copilot_page,
+                     rows_stat, cols_stat, quality_stat, time_cols_stat,
+                     x_col_dd, y_col_dd, copilot_input_col_ref_for_dynamic_update] # This last one is a dummy to trigger updates
+        ).then(
+            fn=lambda: (gr.update(elem_classes="selected"), gr.update(elem_classes=""), gr.update(elem_classes="")),
+            outputs=nav_buttons
         )
-        save_btn.click(save_project, state, project_status)
         
-        lp_run_btn.click(prometheus_run_model, [state, lp_target, lp_features, lp_model], [lp_fig1, lp_fig2, lp_report_md])
-        
-        chat_submit.click(
-            athena_respond,
-            [chat_input, chatbot, state, api_key_input],
-            [chatbot, copilot_fig_output, copilot_df_output, state]
-        ).then(lambda: "", outputs=chat_input)
+        # Suggestions Button
+        suggestion_btn.click(
+            get_ai_suggestions,
+            [global_state, api_key_input],
+            [suggestion_status, suggestion_accordion]
+        ).then(
+            fn=lambda: [gr.Button.update(visible=True) for _ in range(5)], # Assumes max 5 suggestions for demo
+            outputs=[b for b in suggestion_accordion.children] if isinstance(suggestion_accordion, gr.Accordion) and suggestion_accordion.children else []
+        )
+        # Handle suggestion button clicks to populate chat
+        if isinstance(suggestion_accordion, gr.Accordion):
+            for button in suggestion_accordion.children:
+                button.click(
+                    fn=lambda q=button.value: (gr.update(visible=False), gr.update(visible=False), gr.update(visible=True), q),
+                    outputs=[cockpit_page, deep_dive_page, copilot_page, chat_input]
+                ).then(
+                    fn=lambda: (gr.update(elem_classes=""), gr.update(elem_classes=""), gr.update(elem_classes="selected")),
+                    outputs=nav_buttons
+                )
+
+
+        # Dashboard Builder
+        add_plot_btn.click(add_plot_to_dashboard, [global_state, x_col_dd, y_col_dd, plot_type_dd], [global_state, dashboard_accordion])
+        clear_plots_btn.click(clear_dashboard, [global_state], [global_state, dashboard_accordion])
+
+        # AI Co-pilot Chat
+        copilot_input_col_ref_for_dynamic_update = x_col_dd # Dummy placeholder for dynamic updates
+        chat_submit_btn.click(
+            respond_to_chat, 
+            [chat_input, chatbot, global_state, api_key_input], 
+            [chatbot, copilot_explanation, copilot_code, copilot_plot, copilot_table]
+        ).then(lambda: "", outputs=[chat_input])
+        chat_input.submit(
+            respond_to_chat, 
+            [chat_input, chatbot, global_state, api_key_input], 
+            [chatbot, copilot_explanation, copilot_code, copilot_plot, copilot_table]
+        ).then(lambda: "", outputs=[chat_input])
 
-        return demo
+    return demo
 
-# --- Main Execution ---
 if __name__ == "__main__":
-    app = build_ui()
+    app = create_gradio_interface()
     app.launch(debug=True)