app.py

from dash import html, dcc, Input, Output, State, callback, Dash, no_update
import dash_ag_grid as dag
import pandas as pd
import google.generativeai as genai
from datetime import datetime
import json

app=Dash(__name__)
app.title="AI Dash-ag-grid"

def create_enhanced_sample_data():
    """Create an enhanced sample dataset with more features"""
    import numpy as np

    np.random.seed(42)
    dates = pd.date_range(start='2024-01-01', periods=200, freq='D')

    data = {
        'Date': dates,
        'Region': np.random.choice(['North', 'South', 'East', 'West'], 200),
        'Product': np.random.choice(['Electronics', 'Clothing', 'Home & Garden', 'Sports', 'Books'], 200),
        'Sales': np.random.normal(5_000, 1_500, 200).clip(min=100),
        'Units': np.random.randint(5, 50, 200),
        'Customer_Type': np.random.choice(['B2B', 'B2C'], 200, p=[0.6, 0.4]),
        'Satisfaction_Score': np.random.uniform(3.0, 5.0, 200),
        'Marketing_Spend': np.random.uniform(100, 1000, 200)
    }

    df = pd.DataFrame(data)

    # Add seasonal variation
    df['Sales'] = df['Sales'] * (1 + 0.3 * np.sin(2 * np.pi * df.index / 365))

    # Calculate derived metrics
    df['Revenue'] = df['Sales'] * df['Units']
    df['Profit_Margin'] = 0.15 + np.random.uniform(-0.05, 0.10, 200)
    df['Profit'] = df['Revenue'] * df['Profit_Margin']
    df['ROI'] = (df['Profit'] / df['Marketing_Spend']) * 100

    return df

# Load data
df = create_enhanced_sample_data()

# Convert dates to string format for JSON serialization
df['Date_str'] = df['Date'].dt.strftime('%Y-%m-%d')

# Enhanced AG-Grid column definitions
columnDefs = [
    {"field": "Date_str", "headerName": "Date", "filter": "agDateColumnFilter"},
    {"field": "Region", "filter": True},
    {"field": "Product", "filter": True},
    {"field": "Sales", "filter": "agNumberColumnFilter",
     "valueFormatter": {"function": "d3.format('$,.0f')(params.value)"}},
    {"field": "Units", "filter": "agNumberColumnFilter"},
    {"field": "Customer_Type", "headerName": "Customer Type", "filter": True},
    {"field": "Revenue", "filter": "agNumberColumnFilter",
     "valueFormatter": {"function": "d3.format('$,.0f')(params.value)"}},
    {"field": "Profit", "filter": "agNumberColumnFilter",
     "valueFormatter": {"function": "d3.format('$,.0f')(params.value)"}},
    {"field": "Profit_Margin", "headerName": "Profit Margin", "filter": "agNumberColumnFilter",
     "valueFormatter": {"function": "d3.format('.1%')(params.value)"}},
    {"field": "Satisfaction_Score", "headerName": "Satisfaction", "filter": "agNumberColumnFilter",
     "valueFormatter": {"function": "d3.format('.2f')(params.value)"}},
    {"field": "Marketing_Spend", "headerName": "Marketing Spend", "filter": "agNumberColumnFilter",
     "valueFormatter": {"function": "d3.format('$,.0f')(params.value)"}},
    {"field": "ROI", "filter": "agNumberColumnFilter",
     "valueFormatter": {"function": "d3.format('.1f')(params.value) + '%'"}}
]


# App layout
app.layout = html.Div([
    # Header
    html.Div([
        html.H1("📊 Advanced Data Analysis Dashboard",
                style={'margin': '0 0 10px 0', 'color': 'white'}),
        html.P("Interactive data grid with AI-powered insights",
               style={'margin': '0', 'opacity': '0.9', 'color': 'white'})
    ], style={
        'background': 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
        'padding': '30px',
        'borderRadius': '15px',
        'marginBottom': '30px',
        'boxShadow': '0 10px 30px rgba(0,0,0,0.1)'
    }),

    # API Key and Controls
    html.Div([
        html.H3("Configuration & Actions"),
        html.Div([
            html.Div([
                dcc.Input(
                    id='api-key-input',
                    type='password',
                    placeholder='Enter Gemini API Key',
                    style={
                        'width': '300px',
                        'padding': '8px 12px',
                        'border': '1px solid #ddd',
                        'borderRadius': '6px',
                        'marginRight': '10px'
                    }
                ),
                html.Button(
                    '🤖 Generate AI Summary',
                    id='generate-summary-btn',
                    style={
                        'background': 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
                        'color': 'white',
                        'border': 'none',
                        'padding': '12px 24px',
                        'borderRadius': '6px',
                        'fontSize': '16px',
                        'cursor': 'pointer',
                        'marginRight': '10px'
                    }
                ),
                html.Button(
                    '📥 Export to CSV',
                    id='export-btn',
                    style={
                        'background': '#48bb78',
                        'color': 'white',
                        'border': 'none',
                        'padding': '12px 24px',
                        'borderRadius': '6px',
                        'fontSize': '16px',
                        'cursor': 'pointer'
                    }
                ),
                dcc.Download(id="download-dataframe-csv"),
                dcc.Loading(
                    id="loading-summary",
                    type="circle",
                    children=[html.Div(id="loading-output")]
                )
            ], style={'display': 'flex', 'alignItems': 'center'}),
            html.Div(id='api-key-status', style={'marginTop': '10px'})
        ])
    ], style={
        'background': 'white',
        'padding': '20px',
        'borderRadius': '10px',
        'marginBottom': '20px',
        'boxShadow': '0 2px 10px rgba(0,0,0,0.05)'
    }),

    # Data Grid
    html.Div([
        html.H3("Sales Data Table"),
        dag.AgGrid(
            id="data-grid",
            rowData=df.to_dict("records"),
            columnDefs=columnDefs,
            defaultColDef={
                "sortable": True,
                "filter": True,
                "resizable": True,
                "floatingFilter": True
            },
            dashGridOptions={
                "pagination": True,
                "paginationPageSize": 20,
                "domLayout": "normal",
                "rowSelection": "multiple"
            },
            style={"height": "600px"}
        )
    ], style={
        'background': 'white',
        'padding': '20px',
        'borderRadius': '10px',
        'marginBottom': '20px',
        'boxShadow': '0 2px 10px rgba(0,0,0,0.05)'
    }),

    # Summary Display
    html.Div([
        html.Div([
            html.H3("🤖 AI-Generated Summary",
                    style={'margin': '0', 'color': '#333', 'flexGrow': '1'})
        ], style={'display': 'flex', 'alignItems': 'center', 'marginBottom': '15px'}),
        html.Div(
            id='summary-content',
            children=dcc.Markdown("Click 'Generate AI Summary' to analyze the dataset using Google Gemini..."),
            style={
                'color': '#555',
                'lineHeight': '1.8',
                'fontSize': '16px'
            }
        )
    ], style={
        'background': 'white',
        'padding': '25px',
        'borderRadius': '10px',
        'boxShadow': '0 2px 10px rgba(0,0,0,0.05)',
        'marginBottom': '20px'
    }),

    # Hidden div to store the filtered data
    html.Div(id='filtered-data', style={'display': 'none'})
], style={
    'maxWidth': '1600px',
    'margin': '0 auto',
    'padding': '20px',
    'backgroundColor': '#f5f7fa',
    'minHeight': '100vh'
})

# Callback to get filtered data from AG-Grid
@app.callback(
    Output('filtered-data', 'children'),
    Input('data-grid', 'virtualRowData')
)
def store_filtered_data(virtual_row_data):
    if virtual_row_data:
        return json.dumps(virtual_row_data)

    # Convert DataFrame to dict and handle datetime serialization
    df_dict = df.to_dict('records')
    for record in df_dict:
        # Convert any datetime objects to strings
        for key, value in record.items():
            if hasattr(value, 'isoformat'):
                record[key] = value.isoformat()
            elif pd.isna(value):
                record[key] = None

    return json.dumps(df_dict)


# Callback for CSV export
@app.callback(
    Output("download-dataframe-csv", "data"),
    Input("export-btn", "n_clicks"),
    State('filtered-data', 'children'),
    prevent_initial_call=True,
)
def export_csv(n_clicks, filtered_data_json):
    filtered_data = json.loads(filtered_data_json)
    filtered_df = pd.DataFrame(filtered_data)

    # Rename Date_str back to Date for export if it exists
    if 'Date_str' in filtered_df.columns:
        filtered_df = filtered_df.rename(columns={'Date_str': 'Date'})

    return dcc.send_data_frame(filtered_df.to_csv, f"data_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv")


# Enhanced callback to generate summary with more analysis
@app.callback(
    Output('summary-content', 'children'),
    Output('api-key-status', 'children'),
    Input('generate-summary-btn', 'n_clicks'),
    State('api-key-input', 'value'),
    State('filtered-data', 'children')
)
def generate_enhanced_summary(n_clicks, api_key, filtered_data_json):
    if not n_clicks:
        return no_update, ""

    if not api_key:
        return no_update, html.Div("⚠️ Please enter your Gemini API key!",
                                        style={'color': '#e53e3e'})

    try:
        # Configure Gemini
        genai.configure(api_key=api_key)
        model = genai.GenerativeModel('gemini-2.5-flash-preview-05-20')

        # Parse filtered data
        filtered_data = json.loads(filtered_data_json)
        filtered_df = pd.DataFrame(filtered_data)

        # Handle date conversion
        if 'Date_str' in filtered_df.columns:
            filtered_df['Date'] = pd.to_datetime(filtered_df['Date_str'])
        elif 'Date' in filtered_df.columns and filtered_df['Date'].dtype == 'object':
            filtered_df['Date'] = pd.to_datetime(filtered_df['Date'])

        # Calculate additional metrics
        revenue_growth = filtered_df.groupby('Date')['Revenue'].sum().pct_change().mean() * 100
        best_product = filtered_df.groupby('Product')['Revenue'].sum().idxmax()
        best_region = filtered_df.groupby('Region')['Revenue'].sum().idxmax()
        avg_satisfaction = filtered_df['Satisfaction_Score'].mean()

        # Prepare enhanced data summary for Gemini
        data_summary = f"""
        Analyze this comprehensive sales dataset and provide strategic insights:

        DATASET OVERVIEW:
        - Total Records: {len(filtered_df)}
        - Date Range: {filtered_df['Date'].min()} to {filtered_df['Date'].max()}
        - Unique Regions: {filtered_df['Region'].unique().tolist()}
        - Product Categories: {filtered_df['Product'].unique().tolist()}

        KEY PERFORMANCE METRICS:
        - Total Revenue: ${filtered_df['Revenue'].sum():,.2f}
        - Total Profit: ${filtered_df['Profit'].sum():,.2f}
        - Average Profit Margin: {filtered_df['Profit_Margin'].mean():.1%}
        - Total Units Sold: {filtered_df['Units'].sum():,}
        - Average Sale Value: ${filtered_df['Sales'].mean():,.2f}
        - Daily Revenue Growth Rate: {revenue_growth:.2f}%

        CUSTOMER INSIGHTS:
        - Average Satisfaction Score: {avg_satisfaction:.2f}/5.0
        - Customer Type Revenue Split:
        {filtered_df.groupby('Customer_Type')['Revenue'].sum().to_dict()}

        REGIONAL PERFORMANCE:
        {filtered_df.groupby('Region').agg({'Revenue': 'sum', 'Profit': 'sum', 'Units': 'sum'}).to_dict()}

        PRODUCT PERFORMANCE:
        {filtered_df.groupby('Product').agg({'Revenue': 'sum', 'Profit': 'sum', 'Units': 'sum', 'Satisfaction_Score': 'mean'}).to_dict()}

        MARKETING EFFECTIVENESS:
        - Total Marketing Spend: ${filtered_df['Marketing_Spend'].sum():,.2f}
        - Average ROI: {filtered_df['ROI'].mean():.1f}%
        - Best ROI Product: {filtered_df.groupby('Product')['ROI'].mean().idxmax()}

        Please provide:
        1. Executive Summary (3-4 key takeaways)
        2. Performance Analysis with specific numbers and percentages
        3. Customer Satisfaction Insights
        4. Regional Strategy Recommendations
        5. Product Portfolio Optimization suggestions
        6. Marketing Investment Recommendations based on ROI
        7. Risk factors and areas of concern
        8. 3-5 specific, actionable next steps with expected impact

        Format the response using proper Markdown syntax with:
        - Headers using ## for main sections and ### for subsections
        - Bullet points using * or - for lists
        - **Bold** text for emphasis on key metrics
        - Clear section breaks between topics
        """

        # Generate summary
        response = model.generate_content(data_summary)

        # Create a formatted markdown component
        summary_markdown = dcc.Markdown(
            response.text,
            style={
                'backgroundColor': '#f8f9fa',
                'padding': '20px',
                'borderRadius': '8px',
                'border': '1px solid #e9ecef'
            }
        )

        return summary_markdown, html.Div("✅ API key validated - Summary generated successfully!",
                                          style={'color': '#52c41a'})

    except Exception as e:
        error_msg = f"❌ **Error generating summary:** {str(e)}"
        return dcc.Markdown(error_msg), html.Div("❌ API key error - Please check your key",
                                                 style={'color': '#e53e3e'})

# Run the app
if __name__ == '__main__':
    app.run(debug=True, port=1260)