app.py

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

from data_processor import process_csv
from agent import categorize_transactions, generate_financial_insight
from database import (
    insert_expenses,
    get_total_spent,
    get_category_summary,
    get_monthly_summary,
    fetch_expenses_by_category
)

st.set_page_config(page_title="AI Expense Tracking Agent", layout="wide")

st.title("AI Expense Tracking Agent")

menu = st.sidebar.selectbox(
    "Select Page",
    ["Upload Data", "Dashboard"]
)

# PAGE 1 — Upload Data

if menu == "Upload Data":

    uploaded_file = st.file_uploader("Upload your expense CSV", type=["csv"])

    if uploaded_file:
        try:
            try:
                df = pd.read_csv(uploaded_file)
            except:
                df = pd.read_csv(uploaded_file, sep=";")

            cleaned_df = process_csv(df)

            with st.spinner("AI is categorizing transactions..."):
                categorized_df = categorize_transactions(cleaned_df)

            categorized_df = categorized_df.rename(columns={
                "spent_on": "description",
                "predicted_category": "category"
            })

            categorized_df["date"] = pd.to_datetime(
                categorized_df["date"], errors="coerce"
            ).dt.date

            categorized_df = categorized_df[
                ["date", "description", "amount", "category"]
            ]

            st.dataframe(categorized_df.reset_index(drop=True))

            inserted, skipped = insert_expenses(categorized_df)

            st.success(f"{inserted} new records inserted.")
            if skipped > 0:
                st.info(f"{skipped} duplicate records skipped.")

        except Exception as e:
            st.error(f"Error: {e}")

# PAGE 2 — Dashboard

if menu == "Dashboard":

    st.header("Financial Dashboard")

    category_df_all = get_category_summary()
    category_list = ["All"] + category_df_all["category"].tolist()

    selected_category = st.selectbox("Filter by Category", category_list)

    records_df = fetch_expenses_by_category(selected_category)
    total_spent = get_total_spent(selected_category)
    category_df = get_category_summary(selected_category)
    monthly_df = get_monthly_summary(selected_category)

    # TOTAL BUDGET
    
    st.subheader("Monthly Budget Planning")

    total_budget = st.number_input(
        "Set Your Total Monthly Budget (PKR)",
        min_value=0.0,
        step=1000.0
    )

    col1, col2, col3 = st.columns(3)

    col1.metric("Total Spending", f"PKR {total_spent:,.0f}")
    col2.metric("Transactions", len(records_df))

    if total_budget > 0:
        remaining_total = total_budget - total_spent
        col3.metric("Remaining Budget", f"PKR {remaining_total:,.0f}")

        st.progress(min(total_spent / total_budget, 1.0))

    st.divider()

    # CHARTS
    
    col4, col5 = st.columns(2)

    with col4:
        st.subheader("Monthly Spending Trend")

        if not monthly_df.empty:
            fig, ax = plt.subplots(figsize=(6, 4))

            ax.plot(
                monthly_df["month"],
                monthly_df["total"],
                marker="o",
                linewidth=2
            )

            ax.set_title("Monthly Expense Trend")
            ax.set_xlabel("Month")
            ax.set_ylabel("Amount (PKR)")
            ax.grid(True, linestyle="--", alpha=0.6)

            plt.xticks(rotation=45)
            plt.tight_layout()

            st.pyplot(fig)
        else:
            st.info("No data available.")

    with col5:
        st.subheader("Spending by Category")

        if not category_df.empty:
            fig2, ax2 = plt.subplots(figsize=(6, 4))

            ax2.bar(
                category_df["category"],
                category_df["total"]
            )

            ax2.set_title("Category Distribution")
            ax2.set_xlabel("Category")
            ax2.set_ylabel("Amount (PKR)")
            ax2.grid(axis="y", linestyle="--", alpha=0.6)

            plt.xticks(rotation=45)
            plt.tight_layout()

            st.pyplot(fig2)
        else:
            st.info("No data available.")

    st.divider()

    
    # AI Budget Distribution
    
    if total_budget > 0 and not category_df_all.empty:

        st.subheader("AI Suggested Budget Allocation")

        total_historical_spent = category_df_all["total"].sum()

        allocation_data = []

        for _, row in category_df_all.iterrows():

            category_name = row["category"]
            category_spent = row["total"]

            historical_ratio = (
                category_spent / total_historical_spent
                if total_historical_spent > 0 else 0
            )

            suggested_budget = historical_ratio * total_budget
            remaining = suggested_budget - category_spent
            usage_percent = (
                (category_spent / suggested_budget) * 100
                if suggested_budget > 0 else 0
            )

            allocation_data.append([
                category_name,
                round(suggested_budget, 0),
                round(category_spent, 0),
                round(remaining, 0),
                round(usage_percent, 1)
            ])

        allocation_df = pd.DataFrame(
            allocation_data,
            columns=[
                "Category",
                "AI Suggested Budget",
                "Current Spending",
                "Remaining",
                "Usage %"
            ]
        )

        st.dataframe(
            allocation_df,
            use_container_width=True
        )

    st.divider()

    # AI Insight

    st.subheader("AI Financial Insight")

    if "ai_insight" not in st.session_state:
        st.session_state.ai_insight = None

    if st.button("Generate AI Insight"):

        if not records_df.empty:
            with st.spinner("Analyzing your financial data..."):
                st.session_state.ai_insight = generate_financial_insight(
                    total_spent,
                    category_df,
                    monthly_df
                )
        else:
            st.session_state.ai_insight = "No data available for analysis."

    if st.session_state.ai_insight:
        st.success(st.session_state.ai_insight)