ProposalWriter.py

"""

Disha Wealth – Mutual Fund Investment Proposal Generator

=========================================================

Run:  streamlit run app.py

Deps: pip install streamlit pandas numpy requests reportlab openpyxl plotly



Logo: Place your logo as  Dishaprintlogo.png  in the SAME folder as app.py

"""

import streamlit as st
import pandas as pd
import numpy as np
import requests
import warnings
import io
import os
import re
from datetime import datetime

from reportlab.lib.pagesizes import A4, landscape
from reportlab.platypus import (SimpleDocTemplate, Table, TableStyle,
                                 Paragraph, Spacer, Image as RLImage,
                                 HRFlowable, PageBreak, KeepTogether)
from reportlab.lib import colors
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.lib.units import cm, mm
from reportlab.lib.enums import TA_CENTER, TA_RIGHT, TA_LEFT, TA_JUSTIFY

warnings.filterwarnings("ignore")

# ─────────────────────────────────────────────────────────────
# CONFIGURATION
# ─────────────────────────────────────────────────────────────
st.set_page_config(page_title="Disha Wealth – MF Proposal", page_icon="🧭", layout="wide")

ADVISOR_NAME   = "Divya Shah"
ADVISOR_ARN    = "ARN-339305"
ADVISOR_EMAIL  = "DIVYA.CE@GMAIL.COM"
ADVISOR_MOBILE = "7738724256"
RISK_FREE      = 0.065
LOGO_PATH      = os.path.join(os.path.dirname(__file__), "Dishaprintlogo.png")

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
    )
}

NAVY  = colors.HexColor("#1B4F72")
LIGHT = colors.HexColor("#D6EAF8")
WHITE = colors.white
GOLD  = colors.HexColor("#F0A500")
RUST  = colors.HexColor("#C0392B")
GREEN = colors.HexColor("#1E8449")
LGREY = colors.HexColor("#F2F3F4")
DGREY = colors.HexColor("#555555")

# ─────────────────────────────────────────────────────────────
# OFFLINE FALLBACK
# ─────────────────────────────────────────────────────────────
OFFLINE_SAMPLE_FUNDS = {
    "HDFC Balanced Advantage Fund - Growth Plan":                               "100026",
    "ICICI Prudential Balanced Advantage Fund - Growth":                    "120505",
    "ICICI Prudential Equity & Debt Fund - Growth":                         "120586",
    "ICICI Prudential Multi-Asset Fund - Growth":                           "120600",
    "Edelweiss Gold and Silver ETF FOF - Regular Plan - Growth":            "145740",
    "Nippon India Multi Asset Allocation Fund - Regular Growth":            "148919",
    "HDFC Flexi Cap Fund - Growth Plan":                                    "100033",
    "Franklin U.S. Opportunities Equity Active Fund of Fund - Regular Growth": "147622",
    "Bandhan Small Cap Fund - Regular Plan - Growth":                       "147946",
    "Axis Greater China Equity Fund of Fund - Regular Growth":              "145169",
    "Nippon India Multi Cap Fund - Growth Plan - Growth Option":            "118701",
    "Nippon India Growth Fund - Regular Plan - Growth":                     "118989",
    "Nippon India Small Cap Fund - Regular Plan - Growth":                  "118778",
    "Nippon India Growth Mid Cap Fund - Growth Plan":                       "118989",
    "Mirae Asset Large Cap Fund - Regular Growth":                          "118834",
    "ICICI Prudential Gilt Fund - Regular Growth":                          "120604",
    "Nippon India Gold Savings Fund - Regular Growth":                      "118748",
}

DEFAULT_FUND_KEYWORDS = [
    "HDFC Balanced Advantage Fund",
    "ICICI Prudential Balanced Advantage Fund",
    "ICICI Prudential Equity & Debt Fund",
    "ICICI Prudential Multi-Asset Fund",
    "Edelweiss Gold and Silver ETF FOF",
    "Nippon India Multi Asset Allocation Fund",
    "HDFC Flexi Cap Fund",
    "Franklin U.S. Opportunities",
    "BANDHAN SMALL CAP FUND",
    "Bandhan Small Cap Fund",
    "Axis Greater China Equity Fund",
    "Nippon India Multi Cap Fund",
    "Nippon India Growth Fund",
    "Nippon India Small Cap Fund",
]


# ═══════════════════════════════════════════════════════════════
# MODULE 1 – AMFI FUND LIST
# ═══════════════════════════════════════════════════════════════
@st.cache_data(ttl=86_400, show_spinner=False)
def fetch_amfi_fund_list() -> dict:
    """Returns {schemeName: schemeCode}"""
    try:
        r = requests.get("https://api.mfapi.in/mf", headers=HEADERS, timeout=45)
        r.raise_for_status()
        data = r.json()
        return {d["schemeName"]: str(d["schemeCode"]) for d in data}
    except Exception as e:
        st.warning(f"Could not fetch AMFI list ({e}). Using offline sample.")
        return OFFLINE_SAMPLE_FUNDS


@st.cache_data(ttl=86_400, show_spinner=False)
def fetch_amfi_fund_list_full() -> list:
    """Returns full list of dicts [{schemeCode, schemeName}] for AMC extraction."""
    try:
        r = requests.get("https://api.mfapi.in/mf", headers=HEADERS, timeout=30)
        r.raise_for_status()
        return r.json()
    except Exception:
        return [{"schemeCode": v, "schemeName": k} for k, v in OFFLINE_SAMPLE_FUNDS.items()]


def extract_amc_from_name(scheme_name: str) -> str:
    """

    Extract AMC/fund-house name from scheme name.

    Returns a normalised string like 'HDFC', 'ICICI Prudential', etc.

    """
    AMC_PREFIXES = [
        "Aditya Birla Sun Life", "Axis", "Bandhan", "Baroda BNP Paribas",
        "Canara Robeco", "DSP", "Edelweiss", "Franklin", "HDFC", "HSBC",
        "ICICI Prudential", "IDFC", "Invesco", "ITI", "JM Financial",
        "Kotak", "L&T", "LIC", "Mahindra Manulife", "Mirae Asset",
        "Motilal Oswal", "Navi", "Nippon India", "NJ", "PGIM India",
        "PPFAS", "Quant", "Quantum", "SBI", "Shriram", "Sundaram",
        "Tata", "Taurus", "Union", "UTI", "WhiteOak Capital", "Zerodha",
    ]
    sl = scheme_name.lower()
    for prefix in sorted(AMC_PREFIXES, key=len, reverse=True):
        if sl.startswith(prefix.lower()):
            return prefix
    # fallback: first word(s) up to common separators
    parts = scheme_name.split()
    return parts[0] if parts else "Other"


# ═══════════════════════════════════════════════════════════════
# MODULE 2 – NAV + STATISTICS
# ═══════════════════════════════════════════════════════════════
@st.cache_data(ttl=3_600, show_spinner=False)
def fetch_nav_stats(scheme_code: str) -> dict:
    empty = {
        "3Y CAGR": "-", "5Y CAGR": "-", "10Y CAGR": "-",
        "15Y CAGR": "-", "20Y CAGR": "-",
        "1Y Return": "-",
        "Std Dev": "-", "Sharpe": "-", "Sortino": "-",
        "Max DD (3Y)": "-", "Max DD (5Y)": "-",
        "Inception Date": "-", "Latest NAV": "-", "NAV Date": "-",
        "_ret_list": None, "_ret_index": None,
    }
    if not scheme_code or scheme_code == "N/A":
        return empty

    try:
        r = requests.get(
            f"https://api.mfapi.in/mf/{scheme_code}",
            headers=HEADERS, timeout=25
        )
        r.raise_for_status()
        payload = r.json()

        df = pd.DataFrame(payload["data"])
        df["date"] = pd.to_datetime(df["date"], format="%d-%m-%Y")
        df["nav"]  = pd.to_numeric(df["nav"], errors="coerce")
        df = df.dropna(subset=["nav"]).sort_values("date").set_index("date")

        if len(df) < 30:
            return empty

        df["ret"] = df["nav"].pct_change()
        df = df.dropna(subset=["ret"])

        latest_date = df.index[-1]
        latest_nav  = df["nav"].iloc[-1]

        result = dict(empty)
        result["Inception Date"] = df.index[0].strftime("%d-%b-%Y")
        result["Latest NAV"]     = f"{latest_nav:.4f}"
        result["NAV Date"]       = latest_date.strftime("%d-%b-%Y")

        for y, label in [(1,"1Y Return"),(3,"3Y CAGR"),(5,"5Y CAGR"),
                         (10,"10Y CAGR"),(15,"15Y CAGR"),(20,"20Y CAGR")]:
            target = latest_date - pd.DateOffset(years=y)
            if df.index[0] <= target:
                idx      = df.index.get_indexer([target], method="nearest")[0]
                past_nav = df["nav"].iloc[idx]
                if past_nav > 0:
                    cagr = ((latest_nav / past_nav) ** (1.0 / y) - 1) * 100
                    result[label] = f"{cagr:.1f}%"

        ann_std = df["ret"].std() * np.sqrt(252)
        result["Std Dev"] = f"{ann_std * 100:.1f}%"
        ann_ret = (1 + df["ret"].mean()) ** 252 - 1

        if_std = ann_std if ann_std > 0 else 1
        sharpe = (ann_ret - RISK_FREE) / if_std
        result["Sharpe"] = f"{sharpe:.2f}" if ann_std > 0 else "-"

        neg_rets = df["ret"][df["ret"] < 0]
        if len(neg_rets) > 5:
            down_std = neg_rets.std() * np.sqrt(252)
            if down_std > 0:
                sortino = (ann_ret - RISK_FREE) / down_std
                result["Sortino"] = f"{sortino:.2f}"

        cutoff_3y = latest_date - pd.DateOffset(years=3)
        df_3y = df[df.index >= cutoff_3y]
        if len(df_3y) >= 30:
            roll_max  = df_3y["nav"].cummax()
            result["Max DD (3Y)"] = f"{((df_3y['nav'] / roll_max) - 1).min() * 100:.1f}%"
        else:
            roll_max  = df["nav"].cummax()
            result["Max DD (3Y)"] = f"{((df['nav'] / roll_max) - 1).min() * 100:.1f}%*"

        cutoff_5y = latest_date - pd.DateOffset(years=5)
        df_5y = df[df.index >= cutoff_5y]
        if len(df_5y) >= 30:
            roll_max5 = df_5y["nav"].cummax()
            result["Max DD (5Y)"] = f"{((df_5y['nav'] / roll_max5) - 1).min() * 100:.1f}%"

        result["_ret_list"]  = df["ret"].tolist()
        result["_ret_index"] = df.index.tolist()
        result["_nav_series"] = df["nav"].tolist()
        result["_nav_index"]  = df.index.tolist()

        return result

    except Exception:
        return empty


@st.cache_data(ttl=3_600, show_spinner=False)
def fetch_nav_history(scheme_code: str) -> pd.DataFrame:
    """Return full NAV history as DataFrame with columns [date, nav]."""
    try:
        r = requests.get(f"https://api.mfapi.in/mf/{scheme_code}", headers=HEADERS, timeout=25)
        r.raise_for_status()
        payload = r.json()
        df = pd.DataFrame(payload["data"])
        df["date"] = pd.to_datetime(df["date"], format="%d-%m-%Y")
        df["nav"]  = pd.to_numeric(df["nav"], errors="coerce")
        df = df.dropna().sort_values("date").reset_index(drop=True)
        return df
    except Exception:
        return pd.DataFrame(columns=["date", "nav"])


def compute_beta_from_stats(fund_stats: dict, mkt_stats: dict) -> str:
    try:
        f_list = fund_stats.get("_ret_list")
        m_list = mkt_stats.get("_ret_list")
        f_idx  = fund_stats.get("_ret_index")
        m_idx  = mkt_stats.get("_ret_index")
        if not f_list or not m_list:
            return "-"
        f_series = pd.Series(f_list, index=f_idx)
        m_series = pd.Series(m_list, index=m_idx)
        aligned  = pd.concat([f_series, m_series], axis=1).dropna()
        if len(aligned) < 30:
            return "-"
        aligned.columns = ["f", "m"]
        cov  = np.cov(aligned["f"], aligned["m"])
        beta = cov[0][1] / cov[1][1]
        return f"{beta:.2f}"
    except Exception:
        return "-"


def compute_negative_obs(fund_stats: dict) -> dict:
    result = {"neg_1y": "N/A", "neg_3y": "N/A", "neg_5y": "N/A"}
    try:
        ret_list = fund_stats.get("_ret_list")
        ret_idx  = fund_stats.get("_ret_index")
        if not ret_list:
            return result
        s = pd.Series(ret_list, index=ret_idx)
        for days, key in [(252, "neg_1y"), (756, "neg_3y"), (1260, "neg_5y")]:
            if len(s) < days:
                continue
            roll = (s + 1).rolling(days).apply(lambda x: x.prod() - 1, raw=True).dropna()
            if len(roll) == 0:
                continue
            result[key] = f"{(roll < 0).sum() / len(roll) * 100:.2f}%"
    except Exception:
        pass
    return result


def show_nav_history_page():
    st.title("📈 Mutual Fund Comparison & NAV History")
    st.markdown("Compare funds within a specific category across all AMCs based on historical performance and key risk metrics.")

    # Fetch the full list of funds {schemeName: schemeCode}
    amfi_dict = fetch_amfi_fund_list()
    all_fund_names = list(amfi_dict.keys())

    # 1. First Box: Highly Specific Granular Category Selection
    fund_categories = [
        "Equity Large", 
        "Equity Large and Mid", 
        "Equity Multicap", 
        "Equity Small", 
        "Equity Flexicap", 
        "Hybrid Conservative", 
        "Hybrid Balanced", 
        "Hybrid Aggressive", 
        "Debt"
    ]
    selected_category = st.selectbox("Step 1: Select Specific Fund Category", options=fund_categories)

    # Filtering logic parsed in a structural ordered manner to isolate precise sub-categories
    def filter_funds_by_exact_category(fund_name, category):
        name_lower = fund_name.lower()
        
        if category == "Equity Large":
            return ("large cap" in name_lower or "nifty 50" in name_lower or "sensex" in name_lower) and "mid" not in name_lower
            
        elif category == "Equity Large and Mid":
            return "large & mid" in name_lower or "large and mid" in name_lower or "nifty next 50" in name_lower
            
        elif category == "Equity Multicap":
            return "multi cap" in name_lower or "multicap" in name_lower
            
        elif category == "Equity Small":
            return "small cap" in name_lower or "smallcap" in name_lower or "micro cap" in name_lower
            
        elif category == "Equity Flexicap":
            return "flexi cap" in name_lower or "flexicap" in name_lower
            
        elif category == "Hybrid Conservative":
            return "conservative hybrid" in name_lower
            
        elif category == "Hybrid Balanced":
            return "balanced advantage" in name_lower or "dynamic asset allocation" in name_lower or "balanced hybrid" in name_lower
            
        elif category == "Hybrid Aggressive":
            return "aggressive hybrid" in name_lower or "equity & debt" in name_lower or "equity and debt" in name_lower
            
        elif category == "Debt":
            return any(k in name_lower for k in ["debt", "liquid", "bond", "gilt", "corporate", "duration", "money market", "overnight", "credit risk"])
            
        return True

    # Filter the asset registry database arrays matching the precise flag metrics
    filtered_funds = [f for f in all_fund_names if filter_funds_by_exact_category(f, selected_category)]
    
    if len(filtered_funds) < 3: 
        st.warning(f"Very few matching funds found online for context '{selected_category}'. Displaying wider cluster profile fallback.")
        filtered_funds = all_fund_names

    # ── ADVANCED ADDITION: BULK EXCEL EXPORT ROUTINE ──
    st.markdown("### 💾 Category Offline Review")
    exp_btn = st.button(f"📊 Generate Offline Comparison Sheet ({selected_category})", use_container_width=True)
    
    if exp_btn:
        bulk_rows = []
        sample_pool = filtered_funds[:50] # Limit evaluation size to 25 records to protect API pipeline from timing out
        st.info(f"Processing evaluation sheets across top {len(sample_pool)} {selected_category} schemes...")
        
        progress_bar = st.progress(0)
        for index, fund_nm in enumerate(sample_pool):
            scode = amfi_dict.get(fund_nm)
            if scode:
                bstats = fetch_nav_stats(scode)
                bulk_rows.append({
                    "Scheme Name": fund_nm,
                    "AMFI Code": scode,
                    "Latest NAV": bstats.get("Latest NAV", "-"),
                    "NAV Date": bstats.get("NAV Date", "-"),
                    "1Y Return": bstats.get("1Y Return", "-"),
                    "3Y CAGR": bstats.get("3Y CAGR", "-"),
                    "5Y CAGR": bstats.get("5Y CAGR", "-"),
                    "Volatility (Std Dev)": bstats.get("Std Dev", "-"),
                    "Sharpe Ratio": bstats.get("Sharpe", "-"),
                    "Sortino Ratio": bstats.get("Sortino", "-"),
                    "Max Drawdown (3Y)": bstats.get("Max DD (3Y)", "-")
                })
            progress_bar.progress((index + 1) / len(sample_pool))
            
        if bulk_rows:
            bulk_df = pd.DataFrame(bulk_rows)
            xls_io = io.BytesIO()
            
            # FIXED: Sanitizing sheet title by removing '/' or spaces to prevent openpyxl exceptions
            safe_sheet_title = f"{selected_category.replace(' ', '_')}_Overview"[:31]
            
            with pd.ExcelWriter(xls_io, engine="openpyxl") as wr:
                bulk_df.to_excel(wr, sheet_name=safe_sheet_title, index=False)
            
            st.success("Comparison registry created!")
            
            safe_filename = selected_category.replace(' ', '_')
            st.download_button(
                label=f"📥 Download {selected_category} Offline Summary (Excel)",
                data=xls_io.getvalue(),
                file_name=f"Disha_Wealth_{safe_filename}_Comparison_{datetime.today().strftime('%Y%m%d')}.xlsx",
                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
                use_container_width=True
            )

    # 2. Second Box: Multi-Select Funds within that Type
    st.divider()
    selected_funds = st.multiselect(
        f"Step 2: Select specific {selected_category} Funds to Compare & extract daily timelines:", 
        options=filtered_funds,
        placeholder="Type or select funds here..."
    )

    # 3. Fetch Statistics and Display Data Table
    if selected_funds:
        st.write("### 📊 Fund Comparison Table")
        
        data_rows = []
        with st.spinner("Fetching NAV history and computing risk ratios..."):
            for fund in selected_funds:
                code = amfi_dict.get(fund)
                stats = fetch_nav_stats(code)
                
                if stats:
                    data_rows.append({
                        "Fund Name": fund,
                        "Latest NAV": stats.get("Latest NAV", "-"),
                        "NAV Date": stats.get("NAV Date", "-"),
                        "1Y Return": stats.get("1Y Return", "-"),
                        "3Y CAGR": stats.get("3Y CAGR", "-"),
                        "5Y CAGR": stats.get("5Y CAGR", "-"),
                        "Std Deviation": stats.get("Std Dev", "-"),
                        "Sharpe Ratio": stats.get("Sharpe", "-"),
                        "Sortino Ratio": stats.get("Sortino", "-"),
                        "Max Drawdown (3Y)": stats.get("Max DD (3Y)", "-")
                    })

        if data_rows:
            df_comparison = pd.DataFrame(data_rows)
            df_comparison.index = df_comparison.index + 1 
            st.dataframe(df_comparison, use_container_width=True)
        else:
            st.warning("Could not fetch data for the selected funds.")

        # ── ADVANCED ADDITION: DAILY CALENDAR TRAILING HISTORIES ──
        st.write("### 📅 Trailing 3-Month Daily NAV Breakdown (Complete Months)")
        st.caption("Displays tracking lines per calendar date spanning the previous 3 completed months.")
        
        current_date = datetime.today()
        first_of_current_month = current_date.replace(day=1)
        
        end_m1 = first_of_current_month - pd.Timedelta(days=1)
        start_m3 = (first_of_current_month - pd.DateOffset(months=3)).replace(day=1)
        
        st.info(f"Isolating operational records from: **{start_m3.strftime('%d-%b-%Y')}** to **{end_m1.strftime('%d-%b-%Y')}**")
        
        combined_history_df = None
        
        with st.spinner("Extracting historical daily sequences..."):
            for fund in selected_funds:
                fcode = amfi_dict.get(fund)
                if fcode:
                    f_history = fetch_nav_history(fcode)
                    if not f_history.empty:
                        sliced = f_history[(f_history["date"] >= start_m3) & (f_history["date"] <= end_m1)].copy()
                        if not sliced.empty:
                            sliced["date"] = sliced["date"].dt.strftime("%Y-%m-%d")
                            sliced = sliced.rename(columns={"nav": fund})
                            
                            if combined_history_df is None:
                                combined_history_df = sliced
                            else:
                                combined_history_df = pd.merge(combined_history_df, sliced, on="date", how="outer")
        
        if combined_history_df is not None and not combined_history_df.empty:
            combined_history_df = combined_history_df.sort_values("date", ascending=False).reset_index(drop=True)
            combined_history_df = combined_history_df.rename(columns={"date": "Trading Date"})
            
            st.dataframe(combined_history_df, use_container_width=True, hide_index=True)
            
            hist_xls = io.BytesIO()
            with pd.ExcelWriter(hist_xls, engine="openpyxl") as hwr:
                combined_history_df.to_excel(hwr, sheet_name="Daily_3M_NAV", index=False)
            
            st.download_button(
                label="📥 Download Daily Timeline Records (Excel)",
                data=hist_xls.getvalue(),
                file_name=f"Daily_NAV_3M_Trailing_{datetime.today().strftime('%Y%m%d')}.xlsx",
                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
            )
        else:
            st.warning("No tracking points found matching the requested tracking window.")


# ═══════════════════════════════════════════════════════════════
# MODULE 3 – SEBI CATEGORY MAP + ALLOCATION INFERENCE
# ═══════════════════════════════════════════════════════════════
FUND_CATEGORY_MAP = {
    "large cap":           ("Equity",             "Large Cap",          80, 10, 10),
    "index fund nifty":    ("Equity",             "Large Cap Index",    95,  3,  2),
    "index fund sensex":   ("Equity",             "Large Cap Index",    95,  3,  2),
    "nifty 50":            ("Equity",             "Large Cap Index",    95,  3,  2),
    "nifty next 50":       ("Equity",             "Large & Mid Cap",    60, 30, 10),
    "large & mid cap":     ("Equity",             "Large & Mid Cap",    50, 40, 10),
    "large and mid cap":   ("Equity",             "Large & Mid Cap",    50, 40, 10),
    "mid cap":             ("Equity",             "Mid Cap",            25, 65, 10),
    "small cap":           ("Equity",             "Small Cap",          15, 15, 70),
    "micro cap":           ("Equity",             "Small/Micro Cap",    10, 10, 80),
    "flexi cap":           ("Equity",             "Flexi Cap",          50, 30, 20),
    "multi cap":           ("Equity",             "Multi Cap",          35, 35, 30),
    "focused fund":        ("Equity",             "Focused",            55, 25, 20),
    "contra":              ("Equity",             "Contra/Value",       50, 30, 20),
    "value fund":          ("Equity",             "Value",              50, 30, 20),
    "dividend yield":      ("Equity",             "Dividend Yield",     60, 25, 15),
    "tax saver":           ("Equity/ELSS",        "ELSS",               50, 30, 20),
    "elss":                ("Equity/ELSS",        "ELSS",               50, 30, 20),
    "balanced advantage":  ("Hybrid",             "BAF",                55, 15, 10),
    "dynamic asset":       ("Hybrid",             "BAF",                55, 15, 10),
    "aggressive hybrid":   ("Hybrid",             "Aggressive Hybrid",  55, 25, 10),
    "equity & debt":       ("Hybrid",             "Aggressive Hybrid",  55, 25, 10),
    "equity and debt":     ("Hybrid",             "Aggressive Hybrid",  55, 25, 10),
    "conservative hybrid": ("Hybrid",             "Conservative Hybrid",15,  5,  5),
    "equity savings":      ("Hybrid",             "Equity Savings",     35, 10,  5),
    "multi asset":         ("Multi Asset",        "Multi Asset",        40, 15, 10),
    "asset allocation":    ("Multi Asset",        "Multi Asset",        40, 15, 10),
    "banking":             ("Sectoral",           "Banking",            90,  5,  5),
    "bank ":               ("Sectoral",           "Banking",            90,  5,  5),
    "financial services":  ("Sectoral",           "Financials",         85, 10,  5),
    "pharma":              ("Sectoral",           "Pharma",             75, 15, 10),
    "healthcare":          ("Sectoral",           "Healthcare",         70, 20, 10),
    "infra":               ("Sectoral",           "Infrastructure",     55, 25, 20),
    "infrastructure":      ("Sectoral",           "Infrastructure",     55, 25, 20),
    "technology":          ("Sectoral",           "Technology",         80, 12,  8),
    "it fund":             ("Sectoral",           "Technology",         80, 12,  8),
    "fmcg":                ("Sectoral",           "FMCG",               80, 12,  8),
    "consumption":         ("Sectoral",           "Consumption",        65, 20, 15),
    "manufacturing":       ("Sectoral",           "Manufacturing",      50, 28, 22),
    "psu equity":          ("Sectoral",           "PSU",                70, 20, 10),
    "energy":              ("Sectoral",           "Energy",             75, 15, 10),
    "defence":             ("Sectoral",           "Defence",            55, 28, 17),
    "real estate":         ("Sectoral",           "Real Estate",        75, 15, 10),
    "gilt":                ("Debt",               "Gilt",                0,  0,  0),
    "liquid":              ("Debt",               "Liquid",              0,  0,  0),
    "overnight":           ("Debt",               "Overnight",           0,  0,  0),
    "short duration":      ("Debt",               "Short Duration",      0,  0,  0),
    "medium duration":     ("Debt",               "Medium Duration",     0,  0,  0),
    "long duration":       ("Debt",               "Long Duration",       0,  0,  0),
    "corporate bond":      ("Debt",               "Corporate Bond",      0,  0,  0),
    "credit risk":         ("Debt",               "Credit Risk",         0,  0,  0),
    "money market":        ("Debt",               "Money Market",        0,  0,  0),
    "banking and psu":     ("Debt",               "Banking & PSU Debt",  0,  0,  0),
    "gold etf":            ("Gold/Commodity",     "Gold ETF",            0,  0,  0),
    "gold savings":        ("Gold/Commodity",     "Gold Fund",           0,  0,  0),
    "gold and silver":     ("Gold/Commodity",     "Gold & Silver",       0,  0,  0),
    "silver etf":          ("Gold/Commodity",     "Silver ETF",          0,  0,  0),
    "commodity":           ("Gold/Commodity",     "Commodity",           0,  0,  0),
    "nasdaq":              ("International",      "US Equity",           0,  0,  0),
    "s&p 500":             ("International",      "US Equity",           0,  0,  0),
    "us equity":           ("International",      "US Equity",           0,  0,  0),
    "u.s. opportunities":  ("International",      "US Equity",           0,  0,  0),
    "international":       ("International",      "International",       0,  0,  0),
    "global":              ("International",      "International",       0,  0,  0),
    "china":               ("International",      "China Equity",        0,  0,  0),
    "greater china":       ("International",      "China Equity",        0,  0,  0),
    "opportunities fund":  ("International/FOF",  "FOF",                 0,  0,  0),
    "fund of fund":        ("International/FOF",  "FOF",                 0,  0,  0),
}

_ASSET_EQUITY_PCT = {
    "Equity": 97, "Equity/ELSS": 97, "Sectoral": 97,
    "Hybrid": 70, "Multi Asset": 55,
    "Debt": 2,    "Gold/Commodity": 5, "International": 0, "International/FOF": 0,
}
_ASSET_DEBT_PCT = {
    "Equity": 0,  "Equity/ELSS": 0,  "Sectoral": 0,
    "Hybrid": 20, "Multi Asset": 25,
    "Debt": 95,   "Gold/Commodity": 0, "International": 0, "International/FOF": 0,
}
_ASSET_GOLD_PCT = {
    "Equity": 0,  "Equity/ELSS": 0,  "Sectoral": 0,
    "Hybrid": 0,  "Multi Asset": 15,
    "Debt": 0,    "Gold/Commodity": 92, "International": 0, "International/FOF": 0,
}
_ASSET_INTL_PCT = {
    "Equity": 0,  "Equity/ELSS": 0,  "Sectoral": 0,
    "Hybrid": 0,  "Multi Asset": 0,
    "Debt": 0,    "Gold/Commodity": 0, "International": 93, "International/FOF": 90,
}


def infer_allocation_from_name(scheme_name: str) -> dict:
    name_lower = scheme_name.lower()
    matched_key = None
    for kw in FUND_CATEGORY_MAP:
        if kw in name_lower:
            matched_key = kw
            break
    if matched_key:
        asset_class, category, lc, mc, sc = FUND_CATEGORY_MAP[matched_key]
    else:
        asset_class, category, lc, mc, sc = "Equity", "Unknown", 50, 30, 20

    eq   = _ASSET_EQUITY_PCT.get(asset_class, 95)
    debt = _ASSET_DEBT_PCT.get(asset_class, 0)
    gold = _ASSET_GOLD_PCT.get(asset_class, 0)
    intl = _ASSET_INTL_PCT.get(asset_class, 0)
    cash = max(0, 100 - eq - debt - gold - intl)

    if "balanced advantage" in name_lower or "dynamic asset" in name_lower:
        eq, debt, cash = 65, 25, 10

    return dict(asset_class=asset_class, category=category,
                large_cap=lc, mid_cap=mc, small_cap=sc,
                equity=eq, debt=debt, gold=gold, intl=intl, cash=cash)


@st.cache_data(ttl=3_600, show_spinner=False)
def fetch_portfolio_allocation_amfi(scheme_code: str, scheme_name: str) -> dict:
    try:
        url = (f"https://www.amfiindia.com/modules/PorfolioDisclousure"
               f"?loadPage=true&rn=1&sc={scheme_code}")
        r = requests.get(url, headers=HEADERS, timeout=10)
        if r.status_code == 200 and len(r.text) > 500:
            alloc = _parse_amfi_portfolio_html(r.text, scheme_name)
            if alloc:
                return alloc
    except Exception:
        pass

    try:
        r = requests.get(f"https://api.mfapi.in/mf/{scheme_code}", headers=HEADERS, timeout=10)
        if r.status_code == 200:
            meta     = r.json().get("meta", {})
            combined = f"{scheme_name} {meta.get('scheme_category','')} {meta.get('scheme_type','')}".lower()
            base     = infer_allocation_from_name(scheme_name)
            if "large cap" in combined and "mid" not in combined:
                base.update(large_cap=80, mid_cap=10, small_cap=10)
            elif "mid cap" in combined:
                base.update(large_cap=25, mid_cap=65, small_cap=10)
            elif "small cap" in combined:
                base.update(large_cap=15, mid_cap=15, small_cap=70)
            base["source"] = "mfapi-meta"
            return base
    except Exception:
        pass

    base = infer_allocation_from_name(scheme_name)
    base["source"] = "Inferred (SEBI rules)"
    return base


def _parse_amfi_portfolio_html(html: str, scheme_name: str):
    try:
        eq_m   = re.search(r'Equity[^\d]*(\d+\.?\d*)\s*%', html, re.IGNORECASE)
        debt_m = re.search(r'Debt[^\d]*(\d+\.?\d*)\s*%',   html, re.IGNORECASE)
        gold_m = re.search(r'Gold[^\d]*(\d+\.?\d*)\s*%',   html, re.IGNORECASE)
        if eq_m or debt_m:
            eq   = float(eq_m.group(1))   if eq_m   else 0
            debt = float(debt_m.group(1)) if debt_m else 0
            gold = float(gold_m.group(1)) if gold_m else 0
            cash = max(0, 100 - eq - debt - gold)
            base = infer_allocation_from_name(scheme_name)
            ef   = eq / 100
            base.update(
                equity=round(eq,1), debt=round(debt,1),
                gold=round(gold,1), cash=round(cash,1),
                large_cap=round(base["large_cap"] * ef, 1),
                mid_cap  =round(base["mid_cap"]   * ef, 1),
                small_cap=round(base["small_cap"] * ef, 1),
                source="AMFI"
            )
            return base
    except Exception:
        pass
    return None


# ═══════════════════════════════════════════════════════════════
# MODULE 4 – PROJECTIONS
# ═══════════════════════════════════════════════════════════════
def sip_fv(monthly: float, rate_pa: float, years: int) -> float:
    r = rate_pa / 12
    n = years * 12
    if r == 0:
        return monthly * n
    return monthly * (((1 + r) ** n - 1) / r) * (1 + r)


def build_projection_table(monthly_sip, annual_topup, ret_pct, horizons=(3,5,8,10,15,20)):
    rows = []
    for y in horizons:
        fv = sip_fv(monthly_sip, ret_pct / 100, y)
        if annual_topup > 0:
            fv += sum(sip_fv(annual_topup / 12, ret_pct / 100, y - yi) for yi in range(y))
        invested = monthly_sip * y * 12 + annual_topup * y
        rows.append({
            "Year": y,
            "Total Invested (Rs.)": f"{invested:,.0f}",
            "Probable Value (Rs.)": f"{int(fv):,}",
            "Wealth Multiple":      f"{fv/invested:.1f}x" if invested else "-",
        })
    return pd.DataFrame(rows)


def probability_of_negative_returns(equity_pct: float) -> dict:
    return {
        "1Y":  round(21.14 * (equity_pct / 70), 1),
        "3Y":  round(8.87  * (equity_pct / 70), 1),
        "15Y": 0.00,
    }


# ═══════════════════════════════════════════════════════════════
# MODULE 5 – WEIGHTED PORTFOLIO SUMMARY
# ═══════════════════════════════════════════════════════════════
def compute_weighted_allocation(fund_names, alloc_pcts):
    wt = dict(equity=0, debt=0, gold=0, intl=0, cash=0,
              large_cap=0, mid_cap=0, small_cap=0)
    for name, pct in zip(fund_names, alloc_pcts):
        w = pct / 100
        a = infer_allocation_from_name(name)
        for k in ["equity","debt","gold","intl","cash"]:
            wt[k] += a.get(k, 0) * w
        eq_w = a.get("equity", 0) / 100 * w
        wt["large_cap"] += a.get("large_cap", 0) * eq_w
        wt["mid_cap"]   += a.get("mid_cap",   0) * eq_w
        wt["small_cap"] += a.get("small_cap", 0) * eq_w
    return {k: round(v, 1) for k, v in wt.items()}


# ═══════════════════════════════════════════════════════════════
# MODULE 6 – PDF STYLES & HELPERS
# ═══════════════════════════════════════════════════════════════
PAGE_W, PAGE_H = landscape(A4)
MARGIN    = 18 * mm
CONTENT_W = PAGE_W - 2 * MARGIN


def _styles():
    base = getSampleStyleSheet()
    return {
        "title":      ParagraphStyle("T",   parent=base["Title"],   fontSize=20,
                                     textColor=NAVY, spaceAfter=6,  alignment=TA_CENTER),
        "cover_sub":  ParagraphStyle("CS",  parent=base["Normal"],  fontSize=12,
                                     textColor=DGREY, spaceAfter=4, alignment=TA_CENTER),
        "h1":         ParagraphStyle("H1",  parent=base["Heading1"],fontSize=13,
                                     textColor=NAVY, spaceBefore=6, spaceAfter=4),
        "h2":         ParagraphStyle("H2",  parent=base["Heading2"],fontSize=9,
                                     textColor=NAVY, spaceBefore=10, spaceAfter=3),
        "h2_rust":    ParagraphStyle("H2R", parent=base["Heading2"],fontSize=9,
                                     textColor=RUST, spaceBefore=8, spaceAfter=3),
        "normal":     base["Normal"],
        "body":       ParagraphStyle("BD",  parent=base["Normal"],  fontSize=8.5,
                                     leading=13, textColor=colors.HexColor("#222222")),
        "body_j":     ParagraphStyle("BDJ", parent=base["Normal"],  fontSize=8.5,
                                     leading=13, alignment=TA_JUSTIFY),
        "small":      ParagraphStyle("SM",  parent=base["Normal"],  fontSize=6.5,
                                     textColor=colors.grey),
        "small_b":    ParagraphStyle("SMB", parent=base["Normal"],  fontSize=6.5,
                                     textColor=colors.grey, fontName="Helvetica-Bold"),
        "cell":       ParagraphStyle("C",   parent=base["Normal"],  fontSize=6.5,
                                     wordWrap="CJK"),
        "cell_hdr":   ParagraphStyle("CH",  parent=base["Normal"],  fontSize=6.5,
                                     textColor=WHITE, fontName="Helvetica-Bold",
                                     wordWrap="CJK"),
        "meta":       ParagraphStyle("M",   parent=base["Normal"],  fontSize=7.5,
                                     textColor=colors.HexColor("#333333")),
        "note":       ParagraphStyle("NT",  parent=base["Normal"],  fontSize=7,
                                     textColor=DGREY, leading=10),
        "howto":      ParagraphStyle("HT",  parent=base["Normal"],  fontSize=7.5,
                                     textColor=colors.HexColor("#1A5276"),
                                     fontName="Helvetica-Bold", spaceAfter=2),
        "howto_body": ParagraphStyle("HTB", parent=base["Normal"],  fontSize=7,
                                     textColor=DGREY, leading=10),
        "sig":        ParagraphStyle("SG",  parent=base["Normal"],  fontSize=9,
                                     textColor=NAVY, spaceBefore=6),
    }


def _make_table(data_rows, headers, col_widths, styles_dict, font_size=6.5):
    ncols = len(headers)
    if ncols >= 11:
        font_size = min(font_size, 5.8)
    elif ncols >= 8:
        font_size = min(font_size, 6.2)

    base = getSampleStyleSheet()
    cs  = ParagraphStyle("_c",   parent=base["Normal"], fontSize=font_size,
                         wordWrap="CJK", leading=font_size + 1.5)
    chs = ParagraphStyle("_ch", parent=base["Normal"], fontSize=font_size,
                         textColor=WHITE, fontName="Helvetica-Bold",
                         wordWrap="CJK", leading=font_size + 1.5)

    hdr  = [Paragraph(str(h), chs) for h in headers]
    rows = [hdr]
    for row in data_rows:
        rows.append([Paragraph(str(v), cs) for v in row])

    pad = 2 if ncols >= 8 else 3
    t = Table(rows, colWidths=col_widths, repeatRows=1)
    t.setStyle(TableStyle([
        ("BACKGROUND",    (0,0), (-1,0),  NAVY),
        ("TEXTCOLOR",     (0,0), (-1,0),  WHITE),
        ("FONTNAME",      (0,0), (-1,0),  "Helvetica-Bold"),
        ("ALIGN",         (0,0), (-1,-1), "CENTER"),
        ("VALIGN",        (0,0), (-1,-1), "MIDDLE"),
        ("ROWBACKGROUNDS",(0,1), (-1,-1), [WHITE, LIGHT]),
        ("GRID",          (0,0), (-1,-1), 0.3, colors.HexColor("#AAAAAA")),
        ("TOPPADDING",    (0,0), (-1,-1), pad),
        ("BOTTOMPADDING", (0,0), (-1,-1), pad),
        ("LEFTPADDING",   (0,0), (-1,-1), 2),
        ("RIGHTPADDING",  (0,0), (-1,-1), 2),
    ]))
    return t


def _howto_box(title_text, body_text, S):
    data = [[
        Paragraph(f"<b>{title_text}</b>", S["howto"]),
        Paragraph(body_text, S["howto_body"]),
    ]]
    t = Table(data, colWidths=[CONTENT_W * 0.18, CONTENT_W * 0.82])
    t.setStyle(TableStyle([
        ("BACKGROUND",   (0,0),(-1,-1), colors.HexColor("#EBF5FB")),
        ("BOX",          (0,0),(-1,-1), 0.5, NAVY),
        ("VALIGN",       (0,0),(-1,-1), "TOP"),
        ("TOPPADDING",   (0,0),(-1,-1), 4),
        ("BOTTOMPADDING",(0,0),(-1,-1), 4),
        ("LEFTPADDING",  (0,0),(-1,-1), 5),
        ("RIGHTPADDING", (0,0),(-1,-1), 5),
    ]))
    return t


def _note_box(text, S):
    t = Table([[Paragraph(text, S["note"])]], colWidths=[CONTENT_W])
    t.setStyle(TableStyle([
        ("BACKGROUND",   (0,0),(-1,-1), LGREY),
        ("BOX",          (0,0),(-1,-1), 0.3, colors.grey),
        ("TOPPADDING",   (0,0),(-1,-1), 3),
        ("BOTTOMPADDING",(0,0),(-1,-1), 3),
        ("LEFTPADDING",  (0,0),(-1,-1), 5),
    ]))
    return t


def _section_header(text, S):
    t = Table([[Paragraph(f"<b>{text}</b>",
                ParagraphStyle("SH", parent=S["normal"], fontSize=9,
                               textColor=WHITE, fontName="Helvetica-Bold"))]],
              colWidths=[CONTENT_W])
    t.setStyle(TableStyle([
        ("BACKGROUND",   (0,0),(-1,-1), NAVY),
        ("TOPPADDING",   (0,0),(-1,-1), 4),
        ("BOTTOMPADDING",(0,0),(-1,-1), 4),
        ("LEFTPADDING",  (0,0),(-1,-1), 8),
    ]))
    return t


# ═══════════════════════════════════════════════════════════════
# MODULE 7 – PDF GENERATION
# ═══════════════════════════════════════════════════════════════
def generate_pdf(client_name, investment_objective, horizon_yrs,

                 proj_df, comp_df, perf_df, alloc_df,

                 monthly_sip, annual_topup, risk_profile, wtd,

                 expected_ret, all_stats):

    buf  = io.BytesIO()
    doc  = SimpleDocTemplate(buf, pagesize=landscape(A4),
                              rightMargin=MARGIN, leftMargin=MARGIN,
                              topMargin=14*mm, bottomMargin=14*mm)
    S      = _styles()
    story  = []
    today_str = datetime.today().strftime("%d %b %Y")

    def _page_hf(canvas, doc):
        canvas.saveState()
        canvas.setStrokeColor(NAVY)
        canvas.setLineWidth(0.5)
        canvas.line(MARGIN, PAGE_H - 12*mm, PAGE_W - MARGIN, PAGE_H - 12*mm)
        canvas.setFont("Helvetica", 7)
        canvas.setFillColor(DGREY)
        canvas.drawString(MARGIN, PAGE_H - 10*mm, "Mutual Fund Investment Proposal")
        canvas.drawRightString(PAGE_W - MARGIN, PAGE_H - 10*mm, today_str)
        canvas.line(MARGIN, 11*mm, PAGE_W - MARGIN, 11*mm)
        canvas.drawString(MARGIN, 7*mm, client_name)
        canvas.drawRightString(PAGE_W - MARGIN, 7*mm, f"Page {doc.page}")
        canvas.restoreState()

    # ── COVER ──────────────────────────────────────────────────
    logo_el = (RLImage(LOGO_PATH, width=4.5*cm, height=1.5*cm)
               if os.path.exists(LOGO_PATH) else
               Paragraph("<b>Disha Wealth</b>",
                         ParagraphStyle("DW", fontSize=14, textColor=NAVY,
                                        fontName="Helvetica-Bold")))

    cover_banner = Table([[Paragraph(
        "<font color='white'><b>MUTUAL FUND INVESTMENT PROPOSAL</b></font>",
        ParagraphStyle("CB", fontSize=18, alignment=TA_CENTER,
                       textColor=WHITE, fontName="Helvetica-Bold"))]],
        colWidths=[CONTENT_W])
    cover_banner.setStyle(TableStyle([
        ("BACKGROUND",    (0,0),(-1,-1), NAVY),
        ("TOPPADDING",    (0,0),(-1,-1), 18),
        ("BOTTOMPADDING", (0,0),(-1,-1), 18),
    ]))

    story += [Spacer(1, 15*mm), logo_el, Spacer(1, 10*mm), cover_banner,
              Spacer(1, 8*mm),
              Paragraph(today_str, S["cover_sub"]),
              Spacer(1, 12*mm)]

    info_data = [
        [Paragraph("<b>Prepared For:</b>", S["body"]),
         Paragraph(f"<b><font color='#1B4F72'>{client_name}</font></b>",
                   ParagraphStyle("CN", fontSize=14, textColor=NAVY, fontName="Helvetica-Bold")),
         Paragraph("<b>Prepared By:</b>", S["body"]),
         Paragraph(f"<b><font color='#1B4F72'>{ADVISOR_NAME}</font></b>",
                   ParagraphStyle("AN", fontSize=12, textColor=NAVY, fontName="Helvetica-Bold"))],
        [Paragraph("Investment Horizon:", S["body"]), Paragraph(f"{horizon_yrs} Years", S["body"]),
         Paragraph("ARN:", S["body"]),     Paragraph(ADVISOR_ARN, S["body"])],
        [Paragraph("Risk Profile:", S["body"]),  Paragraph(risk_profile, S["body"]),
         Paragraph("Email:", S["body"]),   Paragraph(ADVISOR_EMAIL, S["body"])],
        [Paragraph("Monthly SIP:", S["body"]),   Paragraph(f"Rs. {monthly_sip:,.0f}", S["body"]),
         Paragraph("Mobile:", S["body"]),  Paragraph(ADVISOR_MOBILE, S["body"])],
    ]
    info_t = Table(info_data, colWidths=[CONTENT_W*0.15, CONTENT_W*0.35,
                                         CONTENT_W*0.15, CONTENT_W*0.35])
    info_t.setStyle(TableStyle([
        ("BOX",          (0,0),(-1,-1), 0.5, NAVY),
        ("INNERGRID",    (0,0),(-1,-1), 0.3, colors.HexColor("#CCCCCC")),
        ("BACKGROUND",   (0,0),(0,-1),  LGREY),
        ("BACKGROUND",   (2,0),(2,-1),  LGREY),
        ("VALIGN",       (0,0),(-1,-1), "MIDDLE"),
        ("TOPPADDING",   (0,0),(-1,-1), 5),
        ("BOTTOMPADDING",(0,0),(-1,-1), 5),
        ("LEFTPADDING",  (0,0),(-1,-1), 8),
    ]))
    story += [info_t, PageBreak()]

    # ── INTRODUCTION ───────────────────────────────────────────
    story.append(_section_header("Introduction", S))
    story.append(Spacer(1, 6))
    story.append(Paragraph("<b>Mutual Fund Investment Proposal</b>",
                            ParagraphStyle("IP", fontSize=11, textColor=NAVY,
                                           fontName="Helvetica-Bold", spaceBefore=4, spaceAfter=4)))
    story.append(Paragraph(f"Dear {client_name},", S["body"]))
    story.append(Spacer(1, 4))
    story.append(Paragraph("Greetings!", S["body"]))
    story.append(Spacer(1, 4))
    story.append(Paragraph(
        "Thank you for giving us the opportunity to assist you in your investment requirement. "
        "We are pleased to present this customised Mutual Fund Investment Proposal for your consideration.",
        S["body_j"]))
    story.append(Spacer(1, 6))
    story.append(Paragraph(
        "This investment proposal follows a step-by-step process of investment decision making:",
        S["body_j"]))
    story.append(Spacer(1, 4))

    step_hdr_style = ParagraphStyle("StepH", parent=S["normal"], fontSize=8, textColor=NAVY, fontName="Helvetica-Bold", spaceAfter=2)
    step_body_style = ParagraphStyle("StepB", parent=S["normal"], fontSize=6.5, textColor=DGREY, leading=9)

    step_data = [
        [
            Paragraph("<b>1. Define Investment Objective</b>", step_hdr_style),
            Paragraph("<b>2. Select Asset Allocation</b>", step_hdr_style),
            Paragraph("<b>3. Select MF Portfolio</b>", step_hdr_style)
        ],
        [
            Paragraph("Choose your objective, investment horizon and planned investments.", step_body_style),
            Paragraph("Review and choose a suitable risk-return trade-off for different asset allocations.", step_body_style),
            Paragraph("Build a diversified portfolio of well-researched mutual fund schemes.", step_body_style)
        ]
    ]
    
    step_t = Table(step_data, colWidths=[CONTENT_W / 3.0] * 3)
    step_t.setStyle(TableStyle([
        ("BOX",          (0,0),(-1,-1), 0.5, NAVY),
        ("INNERGRID",    (0,0),(-1,-1), 0.3, LIGHT),
        ("BACKGROUND",   (0,0),(-1,-1), LIGHT),
        ("TOPPADDING",   (0,0),(-1,-1), 4),
        ("BOTTOMPADDING",(0,0),(-1,-1), 5),
        ("LEFTPADDING",  (0,0),(-1,-1), 8),
        ("RIGHTPADDING", (0,0),(-1,-1), 8),
        ("VALIGN",       (0,0),(-1,-1), "TOP"),
    ]))
    story.append(step_t)
    story.append(Spacer(1, 6))
    story.append(Paragraph(
        "We believe each step is important and thus thoughtfully considered. The Asset Allocation and "
        "Portfolio suggested is after considering your investment objective, risk appetite, risk-return "
        "expectations for this particular investment and suitability of the underlying schemes.",
        S["body_j"]))
    story.append(Spacer(1, 4))
    story.append(Paragraph(
        "We look forward to explaining the proposal to you and supporting you through your investment "
        "journey. Please feel free to get in touch for any clarifications or further guidance.",
        S["body_j"]))
    story.append(Spacer(1, 10))
    story.append(Paragraph("Warm regards,", S["sig"]))
    story.append(Paragraph(f"<b>{ADVISOR_NAME}</b>", S["sig"]))
    story.append(Paragraph(ADVISOR_ARN, S["sig"]))
    story.append(PageBreak())

    # ── PROPOSAL DETAILS ───────────────────────────────────────
    story.append(_section_header("Proposal Details", S))
    story.append(Spacer(1, 5))
    story.append(Paragraph(
        "These are the basic requirements shared and/or considered for the generation of the proposal.",
        S["body"]))
    story.append(Spacer(1, 6))

    prop_meta = [
        [Paragraph("<b>Partner Name</b>",  S["small_b"]), Paragraph(ADVISOR_NAME, S["note"]),
         Paragraph("<b>Email</b>",          S["small_b"]), Paragraph(ADVISOR_EMAIL, S["note"])],
        [Paragraph("<b>ARN</b>",            S["small_b"]), Paragraph(ADVISOR_ARN, S["note"]),
         Paragraph("<b>Mobile</b>",         S["small_b"]), Paragraph(ADVISOR_MOBILE, S["note"])],
        [Paragraph("<b>Proposal Date</b>",  S["small_b"]), Paragraph(today_str, S["note"]),
         Paragraph("", S["note"]),                         Paragraph("", S["note"])],
    ]
    pm_t = Table(prop_meta, colWidths=[CONTENT_W*0.15, CONTENT_W*0.35,
                                        CONTENT_W*0.15, CONTENT_W*0.35])
    pm_t.setStyle(TableStyle([
        ("BOX",         (0,0),(-1,-1), 0.5, colors.grey),
        ("INNERGRID",   (0,0),(-1,-1), 0.3, LGREY),
        ("BACKGROUND",  (0,0),(0,-1),  LGREY),
        ("BACKGROUND",  (2,0),(2,-1),  LGREY),
        ("TOPPADDING",  (0,0),(-1,-1), 4),
        ("BOTTOMPADDING",(0,0),(-1,-1), 4),
        ("LEFTPADDING", (0,0),(-1,-1), 6),
    ]))
    story += [pm_t, Spacer(1, 8)]
    story.append(Paragraph("<b>Proposal Inputs</b>", S["h2"]))

    inv_data = [
        [Paragraph("<b>Lead Name</b>",          S["small_b"]), Paragraph(client_name, S["note"]),
         Paragraph("<b>Objective</b>",           S["small_b"]), Paragraph(investment_objective, S["note"])],
        [Paragraph("<b>Horizon</b>",             S["small_b"]), Paragraph(f"{horizon_yrs} Years", S["note"]),
         Paragraph("<b>Risk Profile</b>",        S["small_b"]), Paragraph(risk_profile, S["note"])],
        [Paragraph("<b>Monthly SIP</b>",         S["small_b"]), Paragraph(f"Rs. {monthly_sip:,.0f}", S["note"]),
         Paragraph("<b>Annual Top-Up</b>",       S["small_b"]),
         Paragraph(f"Rs. {annual_topup:,.0f}" if annual_topup else "Nil", S["note"])],
        [Paragraph("<b>Assumed Return</b>",      S["small_b"]), Paragraph(f"{expected_ret:.1f}% p.a.", S["note"]),
         Paragraph("", S["note"]),                              Paragraph("", S["note"])],
    ]
    inv_t = Table(inv_data, colWidths=[CONTENT_W*0.18, CONTENT_W*0.32,
                                        CONTENT_W*0.18, CONTENT_W*0.32])
    inv_t.setStyle(TableStyle([
        ("BOX",         (0,0),(-1,-1), 0.5, colors.grey),
        ("INNERGRID",   (0,0),(-1,-1), 0.3, LGREY),
        ("BACKGROUND",  (0,0),(0,-1),  LGREY),
        ("BACKGROUND",  (2,0),(2,-1),  LGREY),
        ("TOPPADDING",  (0,0),(-1,-1), 4),
        ("BOTTOMPADDING",(0,0),(-1,-1), 4),
        ("LEFTPADDING", (0,0),(-1,-1), 6),
    ]))
    story += [inv_t, PageBreak()]

    # ── ASSET ALLOCATION & PROJECTION ──────────────────────────
    story.append(_section_header("Asset Allocation & Wealth Projection", S))
    story.append(Spacer(1, 5))
    story.append(Paragraph(
        "Asset allocation is the distribution of investments across different asset classes like "
        "equity, debt, gold and international funds to balance risk and returns. "
        "The allocation below has been determined after considering your investment objective, "
        "risk appetite and investment horizon.",
        S["body_j"]))
    story.append(Spacer(1, 6))

    story.append(Paragraph("<b>Portfolio Weighted Allocation (Estimated)</b>", S["h2"]))
    sum_data = [
        ["Equity %","Debt %","Gold %","Intl %","Cash %","Large Cap","Mid Cap","Small Cap"],
        [f"{wtd['equity']}%", f"{wtd['debt']}%", f"{wtd['gold']}%",
         f"{wtd['intl']}%",  f"{wtd['cash']}%",
         f"{wtd['large_cap']}%", f"{wtd['mid_cap']}%", f"{wtd['small_cap']}%"],
    ]
    cw8 = [CONTENT_W / 8] * 8
    sum_t = Table(sum_data, colWidths=cw8)
    sum_t.setStyle(TableStyle([
        ("BACKGROUND",    (0,0),(-1,0), NAVY),
        ("TEXTCOLOR",     (0,0),(-1,0), WHITE),
        ("BACKGROUND",    (0,1),(-1,1), LIGHT),
        ("ALIGN",         (0,0),(-1,-1),"CENTER"),
        ("FONTSIZE",      (0,0),(-1,-1), 8),
        ("FONTNAME",      (0,0),(-1,0), "Helvetica-Bold"),
        ("FONTNAME",      (0,1),(-1,1), "Helvetica-Bold"),
        ("GRID",          (0,0),(-1,-1), 0.3, colors.grey),
        ("TOPPADDING",    (0,0),(-1,-1), 4),
        ("BOTTOMPADDING", (0,0),(-1,-1), 4),
    ]))
    story += [sum_t, Spacer(1, 8)]

    eq_pct  = wtd.get("equity", 70)
    neg_ret = probability_of_negative_returns(eq_pct)
    story.append(Paragraph(
        f"<b>Estimated Progress &amp; Probable Risk</b> "
        f"<font color='grey' size='7'> — Assumed return: {expected_ret:.1f}% p.a.</font>",
        S["h2"]))
    prob_cw = [CONTENT_W * r for r in [0.12, 0.30, 0.30, 0.28]]
    story.append(_make_table(proj_df.values.tolist(), proj_df.columns.tolist(), prob_cw, S))
    story.append(Spacer(1, 6))

    neg_rows = [
        ["Probability of Negative Returns in 1 Year",  f"{neg_ret['1Y']:.2f}%"],
        ["Probability of Negative Returns in 3 Years", f"{neg_ret['3Y']:.2f}%"],
        ["Probability of Negative Returns in 15 Years","0.00%"],
    ]
    neg_t = Table(neg_rows, colWidths=[CONTENT_W * 0.6, CONTENT_W * 0.4])
    neg_t.setStyle(TableStyle([
        ("BACKGROUND",   (0,0),(-1,-1), LGREY),
        ("BOX",          (0,0),(-1,-1), 0.5, colors.grey),
        ("INNERGRID",    (0,0),(-1,-1), 0.3, colors.HexColor("#CCCCCC")),
        ("ALIGN",        (1,0),(1,-1),  "CENTER"),
        ("FONTSIZE",     (0,0),(-1,-1), 7.5),
        ("FONTNAME",     (1,0),(1,-1),  "Helvetica-Bold"),
        ("TOPPADDING",   (0,0),(-1,-1), 3),
        ("BOTTOMPADDING",(0,0),(-1,-1), 3),
        ("LEFTPADDING",  (0,0),(-1,-1), 6),
    ]))
    story += [neg_t, Spacer(1, 4)]
    story.append(_note_box(
        "Notes: Probability of negative returns estimated from historical rolling return analysis "
        "(Nifty 500 TRI + Crisil 10yr GSec).  "
        "Past performance may or may not be sustained. Projections are illustrative only.", S))
    story.append(PageBreak())

    # ── PORTFOLIO COMPOSITION ──────────────────────────────────
    story.append(_section_header("Suggested Portfolio Composition", S))
    story.append(Spacer(1, 5))
    story.append(Paragraph(
        "With the asset allocation finalised, a suitable portfolio of mutual fund schemes "
        "is proposed below based on your investment objective, risk appetite and suitability.",
        S["body_j"]))
    story.append(Spacer(1, 6))
    _make_scheme = CONTENT_W * 0.36
    _make_rest   = (CONTENT_W - _make_scheme) / max(1, len(comp_df.columns) - 1)
    bc = [_make_scheme] + [_make_rest] * (len(comp_df.columns) - 1)
    story.append(_make_table(comp_df.values.tolist(), comp_df.columns.tolist(), bc, S))
    story.append(Spacer(1, 4))
    story.append(_note_box(
        "The above portfolio is structured based on understanding of your investment needs. "
        "Investment amounts are indicative; actual amounts may vary based on scheme minimums.", S))
    story.append(PageBreak())

    # ── SCHEME PERFORMANCE ─────────────────────────────────────
    story.append(_section_header("Scheme Performance & Risk Metrics", S))
    story.append(Spacer(1, 5))
    _pc_scheme = CONTENT_W * 0.30
    _pc_rest   = (CONTENT_W - _pc_scheme) / max(1, len(perf_df.columns) - 1)
    pc = [_pc_scheme] + [_pc_rest] * (len(perf_df.columns) - 1)
    story.append(_make_table(perf_df.values.tolist(), perf_df.columns.tolist(), pc, S))
    story.append(Spacer(1, 4))
    story.append(_note_box(
        "Source: mfapi.in  |  Sharpe & Sortino: risk-free rate = 6.5% p.a.  |  "
        "Beta: computed vs Nifty 500 proxy  |  Max DD = maximum drawdown over 3 years.", S))
    story.append(Spacer(1, 6))
    story.append(_howto_box("How to Read:",
        "<b>CAGR:</b> Compounded Annual Growth Rate — higher the better.  "
        "<b>Std Dev:</b> Volatility — higher means more risk.  "
        "<b>Sharpe:</b> Risk-adjusted return — above 1 is good.  "
        "<b>Sortino:</b> Penalises only downside risk — higher the better.  "
        "<b>Max DD:</b> Largest peak-to-trough fall in 3 years — lower the better.  "
        "<b>Beta:</b> Market sensitivity — 1 = in line with market; below 1 = less volatile.", S))
    story.append(PageBreak())

    # ── ASSET & MCAP ALLOCATION ────────────────────────────────
    story.append(_section_header("Asset & Market-Cap Allocation (Per Scheme)", S))
    story.append(Spacer(1, 5))
    _dc_scheme   = CONTENT_W * 0.26
    _dc_category = CONTENT_W * 0.10
    _dc_rest     = (CONTENT_W - _dc_scheme - _dc_category) / max(1, len(alloc_df.columns) - 2)
    dc = [_dc_scheme, _dc_category] + [_dc_rest] * (len(alloc_df.columns) - 2)
    story.append(_make_table(alloc_df.values.tolist(), alloc_df.columns.tolist(), dc, S))
    story.append(Spacer(1, 4))
    story.append(_note_box(
        "Source: AMFI Portfolio Disclosure → mfapi metadata → SEBI category rule inference.  "
        "Large/Mid/Small Cap % are estimates based on SEBI category norms.", S))
    story.append(Spacer(1, 6))
    story.append(_howto_box("How to Read:",
        "<b>Equity %:</b> Stocks.  <b>Debt %:</b> Fixed income.  "
        "<b>Gold %:</b> Gold / commodity exposure.  <b>Intl %:</b> Overseas markets.  "
        "<b>Large Cap:</b> Top 100 cos — relatively stable.  "
        "<b>Mid Cap:</b> Cos 101-250 — higher growth, moderate risk.  "
        "<b>Small Cap:</b> Cos 251+ — highest growth potential, highest risk.", S))
    story.append(PageBreak())

    # ── SCHEME INSIGHTS ────────────────────────────────────────
    story.append(_section_header("Scheme Insights", S))
    story.append(Spacer(1, 5))
    story.append(Paragraph("<b>Scheme Details & Historical Observations</b>", S["h2"]))

    insight_hdr  = ["Scheme Name","Category","Alloc %",
                    "Inception","Latest NAV","1Y Ret",
                    "3Y CAGR","5Y CAGR","10Y CAGR",
                    "Neg Obs 1Y","Neg Obs 3Y",
                    "Max DD 3Y","Max DD 5Y","Beta"]
    insight_rows = []
    for _, row in perf_df.iterrows():
        fname = row["Scheme"]
        stats = all_stats.get(fname, {})
        neg   = compute_negative_obs(stats)
        a_row = alloc_df[alloc_df["Scheme"] == fname]
        cat   = a_row["Category"].values[0] if len(a_row) else "-"
        insight_rows.append([
            fname,
            cat,
            row.get("Alloc %", "-"),
            stats.get("Inception Date", "-"),
            stats.get("Latest NAV", "-"),
            stats.get("1Y Return", "-"),
            stats.get("3Y CAGR",  "-"),
            stats.get("5Y CAGR",  "-"),
            stats.get("10Y CAGR", "-"),
            neg["neg_1y"],
            neg["neg_3y"],
            stats.get("Max DD (3Y)", "-"),
            stats.get("Max DD (5Y)", "-"),
            row.get("Beta", "-"),
        ])

    _is_scheme = CONTENT_W * 0.20
    _is_cat    = CONTENT_W * 0.09
    _is_rest   = (CONTENT_W - _is_scheme - _is_cat) / (len(insight_hdr) - 2)
    is_cw = [_is_scheme, _is_cat] + [_is_rest] * (len(insight_hdr) - 2)
    story.append(_make_table(insight_rows, insight_hdr, is_cw, S))
    story.append(Spacer(1, 4))
    story.append(_note_box(
        "* Negative Observations: % of rolling windows (1Y / 3Y) where returns were negative "
        "from daily NAV data — lower is better.  "
        "| Max DD 5Y: Maximum drawdown over last 5 years.  "
        "| All data sourced from mfapi.in.", S))
    story.append(PageBreak())

    # ── EXPECTATIONS & DISCLAIMER ──────────────────────────────
    story.append(_section_header("Expectations, Next Steps & Disclaimer", S))
    story.append(Spacer(1, 6))

    exp_inner = Table([
        [Paragraph("<b>Expectations from You</b>", S["h2"])],
        [Paragraph("• Ensure the investment objectives and planned investments are appropriate for your needs.", S["body"])],
        [Paragraph("• Ensure you have understood the suggested asset allocation and find it suitable.", S["body"])],
        [Paragraph("• Review the portfolio of schemes and the investment allocation.", S["body"])],
        [Paragraph("• Look at the scheme-related information and disclosures provided.", S["body"])],
        [Paragraph("• Read the Disclaimer carefully before proceeding.", S["body"])],
    ], colWidths=[CONTENT_W * 0.48])
    exp_inner.setStyle(TableStyle([("TOPPADDING",(0,0),(-1,-1),2),("BOTTOMPADDING",(0,0),(-1,-1),2),("LEFTPADDING",(0,0),(-1,-1),0)]))

    nxt_inner = Table([
        [Paragraph("<b>Next Steps</b>", S["h2"])],
        [Paragraph("• Review this proposal and come back with any questions or comments.", S["body"])],
        [Paragraph("• Give confirmation / go-ahead for execution of planned investments.", S["body"])],
        [Paragraph("• Authorise any transactions as part of the execution of this proposal.", S["body"])],
        [Paragraph("• Set up KYC and SIP mandates if not already done.", S["body"])],
        [Paragraph("• Stay invested for the planned horizon to maximise compounding benefits.", S["body"])],
    ], colWidths=[CONTENT_W * 0.48])
    nxt_inner.setStyle(TableStyle([("TOPPADDING",(0,0),(-1,-1),2),("BOTTOMPADDING",(0,0),(-1,-1),2),("LEFTPADDING",(0,0),(-1,-1),0)]))

    two_col = Table([[exp_inner, nxt_inner]], colWidths=[CONTENT_W*0.5, CONTENT_W*0.5])
    two_col.setStyle(TableStyle([
        ("BOX",          (0,0),(-1,-1), 0.5, colors.grey),
        ("INNERGRID",    (0,0),(-1,-1), 0.3, LGREY),
        ("VALIGN",       (0,0),(-1,-1), "TOP"),
        ("TOPPADDING",   (0,0),(-1,-1), 8),
        ("BOTTOMPADDING",(0,0),(-1,-1), 8),
        ("LEFTPADDING",  (0,0),(-1,-1), 8),
        ("RIGHTPADDING", (0,0),(-1,-1), 8),
    ]))
    story += [two_col, Spacer(1, 10)]

    story.append(Paragraph("<b>Disclaimer</b>",
                            ParagraphStyle("DR", parent=S["h2"], textColor=RUST)))
    story.append(HRFlowable(width="100%", thickness=0.5, color=RUST, spaceAfter=4))
    story.append(Paragraph(
        f"This investment proposal has been prepared by an AMFI-registered Mutual Fund Distributor "
        f"({ADVISOR_ARN}). It is strictly private and intended solely for the requesting client. "
        "Projections are illustrative and assume constant returns. All performance metrics (CAGR, "
        "Sharpe, Sortino, Max Drawdown, Beta) are computed from historical NAV data (mfapi.in) and "
        "are for reference only. Asset allocation and market-cap figures are estimates using SEBI "
        "category rules and may differ from actual holdings. Mutual fund investments are subject to "
        "market risks. Read all scheme-related documents carefully. Past performance may or may not "
        "be sustained in future and is not a guarantee of any future returns.",
        S["small"]))
    story.append(Spacer(1, 4))
    story.append(Paragraph("—— END OF PROPOSAL ——",
                            ParagraphStyle("EP", fontSize=8, alignment=TA_CENTER,
                                           textColor=NAVY, fontName="Helvetica-Bold")))

    doc.build(story, onFirstPage=_page_hf, onLaterPages=_page_hf)
    return buf.getvalue()


# ═══════════════════════════════════════════════════════════════
# MODULE 8 – CSV EXPORTS
# ═══════════════════════════════════════════════════════════════
def build_all_funds_csv(funds_dict: dict, mkt_stats: dict) -> bytes:
    rows = []
    for name, code in list(funds_dict.items()):
        a = infer_allocation_from_name(name)
        rows.append({"Scheme Name": name, "Scheme Code": code,
                     "Asset Class": a["asset_class"], "Category": a["category"]})
    return pd.DataFrame(rows).to_csv(index=False).encode("utf-8")


def build_selected_funds_csv(perf_df: pd.DataFrame, alloc_df: pd.DataFrame) -> bytes:
    return pd.merge(perf_df, alloc_df, on="Scheme", how="left").to_csv(index=False).encode("utf-8")


# ═══════════════════════════════════════════════════════════════
# STREAMLIT MAIN UI  — Page router
# ═══════════════════════════════════════════════════════════════
def main():
    # ── Sidebar navigation ──────────────────────────────────
    with st.sidebar:
        if os.path.exists(LOGO_PATH):
            st.image(LOGO_PATH, width=160)
        else:
            st.markdown(
                "<div style='font-size:20px;font-weight:bold;color:#1B4F72'>🧭 Disha Wealth</div>",
                unsafe_allow_html=True)
        st.caption(f"{ADVISOR_NAME} | {ADVISOR_ARN}")
        st.divider()
        page = st.radio(
                "Navigation",
                ["🏠 Proposal Generator", "🔍 NAV History & Comparison"], 
                key="nav_page"
            )
        st.divider()
        st.caption("Data source: mfapi.in / AMFI")
        st.caption("Metrics: Risk-free = 6.5% p.a.")
    
    # ── Load AMFI fund universe ────────────────────────
    with st.spinner("Loading AMFI fund universe…"):
        funds_dict = fetch_amfi_fund_list()

    if not funds_dict:
        st.error("Could not load fund list. Please check your internet connection.")
        return

    # ── Route to selected page ──────────────────────────────
    if page == "🏠 Proposal Generator":
        
        st.markdown(
            "<h1 style='text-align:center;color:#1B4F72'>🧭 Disha Wealth</h1>"
            "<h4 style='text-align:center;color:#555'>Your Compass to Financial Freedom</h4>",
            unsafe_allow_html=True)
        st.caption(f"Prepared By: **{ADVISOR_NAME}** | {ADVISOR_ARN}")
        st.divider()

        # ── Step 1: Client Details ──────────────────────────────
        st.subheader("📋 Step 1 – Client & Investment Details")
        c1,c2,c3,c4 = st.columns(4)
        client_name  = c1.text_input("Client Name", placeholder="e.g. Divya")
        monthly_sip  = c2.number_input("Monthly SIP (Rs.)", value=10_000, step=5_000)
        annual_topup = c3.number_input("Annual Top-Up (Rs.)", value=1_000, step=1_000)
        horizon_yrs  = c4.number_input("Investment Horizon (yrs)", value=15, step=1,
                                    min_value=1, max_value=40)
        c5,c6,c7 = st.columns(3)
        expected_ret         = c5.number_input("Assumed Return (% p.a.)", value=12.0, step=0.5)
        risk_profile         = c6.selectbox("Risk Profile",
                                            ["Low","Moderate","Moderately High","High","Very High"])
        investment_objective = c7.selectbox("Investment Objective",
                                            ["Wealth Building","Retirement Planning",
                                             "Child Education","Tax Saving",
                                             "Regular Income","Capital Preservation","Other"])

        # ── Step 2: Fund Selection ──────────────────────────────
        st.divider()
        st.subheader("📦 Step 2 – Select Mutual Funds")

        fund_names_all = sorted(funds_dict.keys())

        default_sel = []
        for kw in DEFAULT_FUND_KEYWORDS:
            for f in fund_names_all:
                if kw.lower() in f.lower():
                    if f not in default_sel:
                        default_sel.append(f)
                    break
        default_sel = default_sel[:13]

        selected_funds = st.multiselect(
            "Search & select funds (defaults = Disha recommended list):",
            fund_names_all, default=default_sel,
            help="Type fund name to search.")
        if not selected_funds:
            st.info("Select at least one fund to continue.")
            return

        # ── Step 3: Allocation ──────────────────────────────────
        st.divider()
        st.subheader("📊 Step 3 – Set SIP Allocation (%)")

        if "alloc_data" not in st.session_state:
            st.session_state.alloc_data = {}
        for f in selected_funds:
            if f not in st.session_state.alloc_data:
                st.session_state.alloc_data[f] = round(100 / len(selected_funds), 1)
        for f in list(st.session_state.alloc_data):
            if f not in selected_funds:
                del st.session_state.alloc_data[f]

        cols = st.columns(min(len(selected_funds), 4))
        for i, fund in enumerate(selected_funds):
            st.session_state.alloc_data[fund] = cols[i % 4].number_input(
                f"{fund[:28]}…" if len(fund) > 90 else fund,
                value=float(st.session_state.alloc_data[fund]),
                min_value=0.0, max_value=100.0, step=0.5, key=f"alloc_{i}")

        alloc_pcts  = st.session_state.alloc_data
        total_alloc = sum(alloc_pcts.values())
        st.metric("Total Allocation", f"{total_alloc:.1f}%",
                delta="✓ OK" if abs(total_alloc-100) < 0.5 else f"{100-total_alloc:+.1f}% remaining")

        # ── Generate ────────────────────────────────────────────
        st.divider()
        go = st.button("🚀 Generate Proposal", type="primary", use_container_width=True)
        if not go:
            return
        if not client_name:
            st.error("Enter client name.")
            return
        if abs(total_alloc - 100) > 0.5:
            st.error("Allocations must sum to exactly 100%.")
            return

        st.markdown("---")
        st.markdown(
            f"## 📄 Investment Proposal — {client_name}\n"
            f"**Date:** {datetime.today().strftime('%d %b %Y')}  |  "
            f"**Advisor:** {ADVISOR_NAME} {ADVISOR_ARN}  |  "
            f"**Risk:** {risk_profile}  |  **Horizon:** {horizon_yrs} yrs  |  "
            f"**Objective:** {investment_objective}")

        # A: Projection
        st.subheader("📈 A. Wealth Compounding Projection")
        proj_df = build_projection_table(monthly_sip, annual_topup, expected_ret)
        st.dataframe(proj_df, use_container_width=True, hide_index=True)
        st.caption(f"Assumed {expected_ret}% p.a. | SIP Rs.{monthly_sip:,}/mo | Top-Up Rs.{annual_topup:,}/yr")

        eq_pct  = 70
        neg_ret = probability_of_negative_returns(eq_pct)
        col_a,col_b,col_c = st.columns(3)
        col_a.metric("Prob. Negative (1Y)",  f"{neg_ret['1Y']:.2f}%")
        col_b.metric("Prob. Negative (3Y)",  f"{neg_ret['3Y']:.2f}%")
        col_c.metric("Prob. Negative (15Y)", "0.00%")

        # B: Composition
        st.subheader("📋 B. Portfolio Composition")
        comp_rows = []
        for fund, pct in alloc_pcts.items():
            a = infer_allocation_from_name(fund)
            comp_rows.append({
                "Scheme Name":  fund,
                "Category":     a["category"],
                "Asset Class":  a["asset_class"],
                "Alloc %":      f"{pct:.1f}%",
                "SIP (Rs.)":    f"Rs.{monthly_sip*pct/100:,.0f}",
                "Top-Up (Rs.)": f"Rs.{annual_topup*pct/100:,.0f}",
            })
        comp_df = pd.DataFrame(comp_rows)
        st.dataframe(comp_df, use_container_width=True, hide_index=True)

        # C: Performance
        st.subheader("📊 C. Scheme Performance & Risk Metrics")
        st.caption("ℹ️ Max Drawdown shown is for last 3 years")
        with st.spinner("Fetching NAV data from mfapi.in…"):
            mkt_code  = funds_dict.get("Nippon India Nifty 500 Index Fund - Regular Growth",
                        funds_dict.get("Nippon India Multi Cap Fund - Regular Growth", "118701"))
            mkt_stats = fetch_nav_stats(mkt_code)
            all_stats = {}
            perf_rows = []
            for fund, pct in alloc_pcts.items():
                code  = funds_dict.get(fund, "")
                stats = fetch_nav_stats(code) if code else {}
                all_stats[fund] = stats
                beta  = compute_beta_from_stats(stats, mkt_stats)
                perf_rows.append({
                    "Scheme":      fund,
                    "Alloc %":     f"{pct:.1f}%",
                    "3Y CAGR":     stats.get("3Y CAGR",  "-"),
                    "5Y CAGR":     stats.get("5Y CAGR",  "-"),
                    "10Y CAGR":    stats.get("10Y CAGR", "-"),
                    "15Y CAGR":    stats.get("15Y CAGR", "-"),
                    "Std Dev":     stats.get("Std Dev",  "-"),
                    "Sharpe":      stats.get("Sharpe",   "-"),
                    "Sortino":     stats.get("Sortino",  "-"),
                    "Max DD (3Y)": stats.get("Max DD (3Y)", "-"),
                    "Beta":        beta,
                })
        perf_df = pd.DataFrame(perf_rows)
        st.dataframe(perf_df, use_container_width=True, hide_index=True)

        # D: Allocation
        st.subheader("🏗️ D. Asset & Market-Cap Allocation")
        with st.spinner("Fetching portfolio allocation data…"):
            alloc_rows = []
            for fund, pct in alloc_pcts.items():
                code = funds_dict.get(fund, "")
                a    = fetch_portfolio_allocation_amfi(code, fund)
                alloc_rows.append({
                    "Scheme":      fund,
                    "Category":    a["category"],
                    "Alloc %":     f"{pct:.1f}%",
                    "Equity %":    f"{a.get('equity','-')}",
                    "Debt %":      f"{a.get('debt','-')}",
                    "Gold %":      f"{a.get('gold','-')}",
                    "Intl %":      f"{a.get('intl','-')}",
                    "Cash %":      f"{a.get('cash','-')}",
                    "Large Cap %": f"{a.get('large_cap','-')}",
                    "Mid Cap %":   f"{a.get('mid_cap','-')}",
                    "Small Cap %": f"{a.get('small_cap','-')}",
                    "Source":      a.get("source", "Inferred"),
                })
        alloc_df = pd.DataFrame(alloc_rows)
        st.dataframe(alloc_df, use_container_width=True, hide_index=True)
        st.caption("Source: AMFI → mfapi meta → SEBI category rule inference")

        funds_list = list(alloc_pcts.keys())
        pcts_list  = list(alloc_pcts.values())
        wtd        = compute_weighted_allocation(funds_list, pcts_list)
        st.markdown("**📌 Portfolio Weighted Average Allocation**")
        col_list = st.columns(8)
        for col, (label, key) in zip(col_list, [
            ("Equity","equity"),("Debt","debt"),("Gold","gold"),("Intl","intl"),("Cash","cash"),
            ("Large Cap","large_cap"),("Mid Cap","mid_cap"),("Small Cap","small_cap")
        ]):
            col.metric(label, f"{wtd[key]}%")

        with st.expander("📜 Disclaimer"):
            st.markdown(
                "This proposal is prepared by an AMFI-registered Mutual Fund Distributor. "
                "Mutual fund investments are subject to market risks. Read all scheme-related "
                "documents carefully. Past performance is not a guarantee of future returns. "
                "Projections are illustrative only.")

        # ── EXPORTS ────────────────────────────────────────────
        st.divider()
        st.subheader("💾 Export")
        ec1,ec2 = st.columns(2)

        all_csv = build_all_funds_csv(funds_dict, mkt_stats)
        ec1.download_button("📥 All AMFI Funds (CSV)", data=all_csv,
            file_name=f"AMFI_All_Funds_{datetime.today().strftime('%Y%m%d')}.csv",
            mime="text/csv", use_container_width=True)

        selected_csv = build_selected_funds_csv(perf_df, alloc_df)
        ec2.download_button("📥 Selected Funds Metrics (CSV)", data=selected_csv,
            file_name=f"Selected_Funds_{client_name.replace(' ','_')}_{datetime.today().strftime('%Y%m%d')}.csv",
            mime="text/csv", use_container_width=True)

        xls_buf = io.BytesIO()
        with pd.ExcelWriter(xls_buf, engine="openpyxl") as w:
            proj_df.to_excel(w,  sheet_name="Projection",  index=False)
            comp_df.to_excel(w,  sheet_name="Portfolio",   index=False)
            perf_df.to_excel(w,  sheet_name="Performance", index=False)
            alloc_df.to_excel(w, sheet_name="Allocation",  index=False)

        with st.spinner("Generating PDF…"):
            pdf_bytes = generate_pdf(
                client_name, investment_objective, horizon_yrs,
                proj_df, comp_df, perf_df, alloc_df,
                monthly_sip, annual_topup, risk_profile, wtd,
                expected_ret, all_stats)

        col_xls,col_pdf = st.columns(2)
        col_xls.download_button("📊 Download Excel", data=xls_buf.getvalue(),
            file_name=f"MF_Proposal_{client_name.replace(' ','_')}_{datetime.today().strftime('%Y%m%d')}.xlsx",
            mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            use_container_width=True)
        col_pdf.download_button("📄 Download PDF (Landscape)", data=pdf_bytes,
            file_name=f"MF_Proposal_{client_name.replace(' ','_')}_{datetime.today().strftime('%Y%m%d')}.pdf",
            mime="application/pdf", use_container_width=True)
         
    elif page == "🔍 NAV History & Comparison":
        show_nav_history_page()
if __name__ == "__main__":
    main()