import pandas as pd
import numpy as np

def load_data(file):
    if file.name.endswith('.csv'):
        df = pd.read_csv(file)
    elif file.name.endswith('.xlsx'):
        df = pd.read_excel(file)
    else:
        return None
    return df

def get_data_summary(df):
    summary = {
        'rows': len(df),
        'columns': len(df.columns),
        'column_names': df.columns.tolist(),
        'missing_values': df.isnull().sum().to_dict(),
        'numeric_cols': df.select_dtypes(include=[np.number]).columns.tolist(),
        'categorical_cols': df.select_dtypes(include=['object']).columns.tolist(),
        'sample': df.head(5).to_dict('records')
    }
    return summary

# Sample data generation
def generate_sample_data():
    np.random.seed(42)
    dates = pd.date_range('2023-01-01', periods=100)
    categories = ['Electronics', 'Clothing', 'Books', 'Home', 'Sports']
    regions = ['North', 'South', 'East', 'West']

    data = {
        'date': np.random.choice(dates, 500),
        'category': np.random.choice(categories, 500),
        'region': np.random.choice(regions, 500),
        'sales': np.random.randint(1000, 50000, 500),
        'quantity': np.random.randint(1, 20, 500),
        'customer_id': np.random.randint(1, 100, 500)
    }

    df = pd.DataFrame(data)
    return df

import openai

def generate_ai_insights(df_summary, df):
    prompt = f"""
    Analyze this dataset and provide business insights.

    Data Summary:
    - Rows: {df_summary['rows']}
    - Columns: {', '.join(df_summary['column_names'])}
    - Numeric columns: {', '.join(df_summary['numeric_cols'])}
    - Categorical columns: {', '.join(df_summary['categorical_cols'])}

    Key Statistics:
    {df.describe().to_string()}

    Provide:
    1. Top 3 key insights for business users
    2. Potential correlations to explore
    3. Recommended next steps

    Keep insights practical and actionable.
    """

    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

def generate_correlations(df):
    numeric_df = df.select_dtypes(include=[np.number])
    if numeric_df.shape[1] > 1:
        corr = numeric_df.corr()
        return corr
    return None

def generate_automated_report(df):
    summary = get_data_summary(df)
    insights = generate_ai_insights(summary, df)

    report = {
        'summary': summary,
        'insights': insights,
        'statistics': df.describe().to_dict(),
        'missing_values': df.isnull().sum().to_dict()
    }
    return report

def format_report_html(report):
    html = f"""
    
Data Analysis Report
    
Rows: {report['summary']['rows']}
    
Columns: {', '.join(report['summary']['column_names'])}

    
AI Insights
    
{report['insights'].replace('\n', '
')}
    """
    return html

import plotly.express as px
import matplotlib.pyplot as plt
import seaborn as sns

def create_charts(df):
    charts = []

    # Sales by category
    cat_sales = df.groupby('category')['sales'].sum().reset_index()
    fig1 = px.bar(cat_sales, x='category', y='sales',
                  title='Sales by Category', color='category')
    charts.append(('Sales by Category', fig1))

    # Sales over time
    if 'date' in df.columns:
        df['date'] = pd.to_datetime(df['date'])
        time_sales = df.groupby(df['date'].dt.to_period('M'))['sales'].sum().reset_index()
        time_sales['date'] = time_sales['date'].astype(str)
        fig2 = px.line(time_sales, x='date', y='sales',
                       title='Sales Trend')
        charts.append(('Sales Trend', fig2))

    # Sales by region
    if 'region' in df.columns:
        region_sales = df.groupby('region')['sales'].sum().reset_index()
        fig3 = px.pie(region_sales, values='sales', names='region',
                      title='Sales by Region')
        charts.append(('Sales by Region', fig3))

    return charts

def auto_visualize(df):
    suggestions = []

    # Check for time series
    if 'date' in df.columns:
        suggestions.append('line: date vs sales')

    # Check for categorical data
    cat_cols = df.select_dtypes(include=['object']).columns
    num_cols = df.select_dtypes(include=[np.number]).columns

    for cat in cat_cols:
        if cat != 'date':
            for num in num_cols:
                suggestions.append(f'bar: {cat} vs {num}')

    return suggestions

def create_recommended_charts(df, suggestions):
    charts = []
    for s in suggestions[:3]:  # Limit to 3 charts
        chart_type, cols = s.split(':')
        cols = cols.strip().split(' vs ')
        if len(cols) == 2:
            cat, num = cols[0], cols[1]
            if cat in df.columns and num in df.columns:
                agg = df.groupby(cat)[num].sum().reset_index()
                fig = px.bar(agg, x=cat, y=num,
                             title=f'{num} by {cat}')
                charts.append((f'{num} by {cat}', fig))
    return charts

import streamlit as st

st.title("AI-Powered Business Intelligence Assistant")
st.markdown("Upload your data and get AI insights and visualizations instantly.")

# Upload data
uploaded_file = st.file_uploader("Upload CSV or Excel file", type=['csv', 'xlsx'])

if uploaded_file:
    df = load_data(uploaded_file)

    if df is not None:
        st.subheader("Data Preview")
        st.dataframe(df.head())

        # Generate insights
        if st.button("Generate AI Insights"):
            with st.spinner("Analyzing data with AI..."):
                report = generate_automated_report(df)

            st.subheader("AI Insights")
            st.write(report['insights'])

            st.subheader("Data Summary")
            col1, col2, col3 = st.columns(3)
            col1.metric("Rows", report['summary']['rows'])
            col2.metric("Columns", report['summary']['columns'])
            col3.metric("Missing Values", sum(report['missing_values'].values()))

        # Generate visualizations
        if st.button("Generate Visualizations"):
            with st.spinner("Creating visualizations..."):
                charts = create_charts(df)

            st.subheader("Visualizations")
            for title, fig in charts:
                st.plotly_chart(fig, use_container_width=True)

        # Raw data
        with st.expander("Raw Data"):
            st.dataframe(df)

        # Download report
        if st.button("Download Report"):
            report = generate_automated_report(df)
            st.download_button(
                label="Download Report",
                data=report['insights'],
                file_name="bi_report.txt",
                mime="text/plain"
            )
    else:
        st.error("Unsupported file format. Please upload CSV or Excel.")

# Deploy on Streamlit Cloud
# Requirements:
# streamlit, openai, pandas, plotly, matplotlib, seaborn

# Environment variables:
# OPENAI_API_KEY

# Run:
# streamlit run app.py