app.py

"""
DataQuest 2026 — Interactive Credit Risk EDA Platform
======================================================
Run with:  streamlit run app.py

Tabs:
  1. 🏠 Home & Data Quality
  2. 📊 Univariate Explorer  (distribution + WoE/IV)
  3. 🔗 Bivariate Explorer   (scatter + heatmaps)
  4. 🧠 Research Reference   (theory + metrics)
  5. 🤖 Model Performance    (plug in Task 2 results)
  6. 💼 Business Dashboard   (Bonus Task 3)
"""

import sys
import os

# Make utils importable regardless of working directory
sys.path.insert(0, os.path.dirname(__file__))

import streamlit as st
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
import matplotlib.patches as mpatches
import seaborn as sns
from io import BytesIO
import warnings
warnings.filterwarnings("ignore")

from utils.data_cleaning import clean_loan_book, data_quality_report
from utils.woe_iv import compute_woe_iv, iv_all_features, compute_iv

# ══════════════════════════════════════════════════════════════════════════════
# CONFIG & STYLING
# ══════════════════════════════════════════════════════════════════════════════

st.set_page_config(
    page_title="DataQuest 2026 | Credit Risk Intelligence Platform",
    page_icon="📊",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Colour palette — dark navy + electric teal accent
PALETTE = {
    "bg":        "#0D1117",
    "card":      "#161B22",
    "border":    "#30363D",
    "accent":    "#00D4AA",    # teal
    "accent2":   "#F78166",    # coral / bad risk
    "accent3":   "#79C0FF",    # sky blue / good
    "text":      "#E6EDF3",
    "muted":     "#8B949E",
    "good":      "#3FB950",
    "bad":       "#F85149",
}

st.markdown(f"""
<style>
  @import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;600&family=IBM+Plex+Sans:wght@300;400;600;700&display=swap');

  html, body, [class*="css"] {{
    font-family: 'IBM Plex Sans', sans-serif;
    background-color: {PALETTE['bg']};
    color: {PALETTE['text']};
  }}
  .stApp {{ background-color: {PALETTE['bg']}; }}

  /* Sidebar */
  [data-testid="stSidebar"] {{
    background-color: {PALETTE['card']};
    border-right: 1px solid {PALETTE['border']};
  }}

  /* Metric cards */
  [data-testid="metric-container"] {{
    background: {PALETTE['card']};
    border: 1px solid {PALETTE['border']};
    border-radius: 8px;
    padding: 16px;
  }}

  /* Dataframes */
  [data-testid="stDataFrame"] {{ border-radius: 8px; }}

  /* Tabs */
  .stTabs [data-baseweb="tab-list"] {{
    gap: 8px;
    background-color: {PALETTE['card']};
    border-radius: 8px;
    padding: 4px;
  }}
  .stTabs [data-baseweb="tab"] {{
    border-radius: 6px;
    color: {PALETTE['muted']};
    font-weight: 600;
    font-family: 'IBM Plex Mono', monospace;
    font-size: 13px;
  }}
  .stTabs [aria-selected="true"] {{
    background-color: {PALETTE['accent']} !important;
    color: {PALETTE['bg']} !important;
  }}

  /* Header banner */
  .dq-header {{
    background: linear-gradient(135deg, #0D1117 0%, #161B22 60%, #0f2027 100%);
    border: 1px solid {PALETTE['border']};
    border-left: 4px solid {PALETTE['accent']};
    border-radius: 10px;
    padding: 28px 36px;
    margin-bottom: 24px;
  }}
  .dq-header h1 {{
    font-size: 2rem;
    font-weight: 700;
    color: {PALETTE['accent']};
    margin: 0 0 6px 0;
    letter-spacing: -0.5px;
    font-family: 'IBM Plex Mono', monospace;
  }}
  .dq-header p {{
    color: {PALETTE['muted']};
    margin: 0;
    font-size: 0.95rem;
  }}

  /* Section headers */
  .section-title {{
    font-family: 'IBM Plex Mono', monospace;
    font-size: 0.75rem;
    font-weight: 600;
    color: {PALETTE['accent']};
    letter-spacing: 2px;
    text-transform: uppercase;
    margin-bottom: 12px;
    padding-bottom: 8px;
    border-bottom: 1px solid {PALETTE['border']};
  }}

  /* Insight cards */
  .insight-card {{
    background: {PALETTE['card']};
    border: 1px solid {PALETTE['border']};
    border-left: 3px solid {PALETTE['accent']};
    border-radius: 8px;
    padding: 16px 20px;
    margin: 12px 0;
    font-size: 0.9rem;
  }}
  .insight-card.warning {{
    border-left-color: {PALETTE['accent2']};
  }}
  .insight-card.good {{
    border-left-color: {PALETTE['good']};
  }}

  /* IV badge colours */
  .iv-useless   {{ color: {PALETTE['muted']}; }}
  .iv-weak      {{ color: #FFDF5D; }}
  .iv-medium    {{ color: {PALETTE['accent3']}; }}
  .iv-strong    {{ color: {PALETTE['accent']}; }}
  .iv-suspicious{{ color: {PALETTE['bad']}; }}

  /* Hide streamlit branding */
  #MainMenu {{visibility:hidden;}}
  footer {{visibility:hidden;}}
  header {{visibility:hidden;}}
</style>
""", unsafe_allow_html=True)

# Matplotlib theme
plt.rcParams.update({
    "figure.facecolor":  PALETTE["bg"],
    "axes.facecolor":    PALETTE["card"],
    "axes.edgecolor":    PALETTE["border"],
    "axes.labelcolor":   PALETTE["muted"],
    "axes.titlecolor":   PALETTE["text"],
    "xtick.color":       PALETTE["muted"],
    "ytick.color":       PALETTE["muted"],
    "text.color":        PALETTE["text"],
    "grid.color":        PALETTE["border"],
    "grid.alpha":        0.5,
    "font.family":       "monospace",
    "figure.dpi":        120,
})

# ══════════════════════════════════════════════════════════════════════════════
# DATA LOADING — cached so the app stays fast
# ══════════════════════════════════════════════════════════════════════════════

@st.cache_data(show_spinner="Loading & cleaning data…")
def load_data(path: str = "data/loan_book.csv"):
    raw = pd.read_csv(path)
    clean = clean_loan_book(raw)
    train = clean_loan_book(raw, split="train")
    return raw, clean, train

@st.cache_data(show_spinner="Computing Information Values…")
def cached_iv_all(train_df_hash, features):
    # We pass a hash to force cache invalidation if data changes
    return iv_all_features(st.session_state["train"], features)

# ── Data path selection ───────────────────────────────────────────────────────
with st.sidebar:
    st.markdown("## 📊 Credit Risk Intelligence")
    st.caption("DataQuest 2026 Submission")

    st.success("✅ Regulatory-Safe Logistic Regression Model")
    st.markdown("---")
    st.markdown(f"""
    <div style="text-align:center; padding:12px 0 20px 0;">
      <span style="font-family:'IBM Plex Mono';font-size:1.2rem;
                   font-weight:700;color:{PALETTE['accent']};">
        📈 DataQuest 2026
      </span><br>
      <span style="color:{PALETTE['muted']};font-size:0.75rem;">
        Credit Risk Intelligence Platform
      </span>
    </div>
    """, unsafe_allow_html=True)

    data_path = st.text_input("CSV path", value="data/loan_book.csv",
                              help="Relative or absolute path to loan_book.csv")
    load_btn = st.button("⟳  Load / Reload Data", use_container_width=True)

if "data_loaded" not in st.session_state or load_btn:
    try:
        raw, clean, train = load_data(data_path)
        st.session_state["raw"]   = raw
        st.session_state["clean"] = clean
        st.session_state["train"] = train
        st.session_state["data_loaded"] = True
        st.session_state["load_error"] = None
    except Exception as e:
        st.session_state["load_error"] = str(e)
        st.session_state["data_loaded"] = False

if not st.session_state.get("data_loaded"):
    err = st.session_state.get("load_error", "Unknown error")
    st.error(f"❌ Could not load data: {err}")
    st.info("Please update the CSV path in the sidebar and click **Load / Reload Data**.")
    st.stop()

raw   = st.session_state["raw"]
clean = st.session_state["clean"]
train = st.session_state["train"]

# Feature lists
NUMERIC_FEATURES = [
    "age", "annual_income", "employment_length_years", "num_open_accounts",
    "total_revolving_balance", "credit_utilisation_pct",
    "months_since_oldest_account", "num_hard_inquiries_6mo",
    "loan_amount", "interest_rate", "dti_ratio",
    "months_since_last_delinquency", "pct_accounts_current",
    "months_at_current_address", "num_delinquencies_2yr",
]
CATEGORICAL_FEATURES = [
    "home_ownership", "loan_purpose", "region",
    "email_domain_type", "application_dow",
]
ALL_FEATURES = NUMERIC_FEATURES + CATEGORICAL_FEATURES

# ══════════════════════════════════════════════════════════════════════════════
# SIDEBAR — global controls
# ══════════════════════════════════════════════════════════════════════════════

with st.sidebar:
    st.markdown("---")
    st.markdown(f"<div class='section-title'>Dataset Info</div>", unsafe_allow_html=True)
    st.metric("Total records", f"{len(raw):,}")
    st.metric("Training set",  f"{len(train):,}")
    st.metric("Test set",      f"{len(raw[raw['set']=='test']):,}")
    st.metric("Default rate",  f"{train['default_flag'].mean():.1%}")

    st.markdown("---")
    st.markdown(f"<div class='section-title'>Analysis Split</div>", unsafe_allow_html=True)
    analysis_split = st.radio("Use data split:", ["Train only", "All data"],
                              index=0,
                              help="Best practice: do EDA on training data only to prevent leakage.")
    df_analysis = train if analysis_split == "Train only" else clean

# ══════════════════════════════════════════════════════════════════════════════
# TABS
# ══════════════════════════════════════════════════════════════════════════════

# ══════════════════════════════════════════════════════════════════════════════
# EXECUTIVE KPI CARDS
# ══════════════════════════════════════════════════════════════════════════════

st.markdown("## 📌 Executive Model Summary")

kpi1, kpi2, kpi3, kpi4 = st.columns(4)

with kpi1:
    st.metric(
        label="Final Model AUC",
        value="0.7822",
        delta="+0.1022 vs baseline"
    )

with kpi2:
    st.metric(
        label="Model Gini",
        value="0.5644"
    )

with kpi3:
    st.metric(
        label="Default Rate",
        value=f"{train['default_flag'].mean():.1%}"
    )

with kpi4:
    st.metric(
        label="Model Status",
        value="5-fold cv"
    )

st.markdown("---")

tabs = st.tabs([
    "🏠 Home & Data Quality",
    "📊 Univariate Explorer",
    "🔗 Bivariate Explorer",
    "🧠 Research Reference",
    "🤖 Model Performance",
    "💼 Business Dashboard",
])

# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# TAB 1 — HOME & DATA QUALITY
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
with tabs[0]:
    st.markdown("""
    ## 🏠 Credit Risk Intelligence Platform

    This platform was developed for the **DataQuest 2026 Credit Risk Challenge** and demonstrates an interpretable, regulator-aware credit-risk modelling framework using logistic regression and Weight of Evidence (WoE) methodologies.

    ### Key Capabilities
    - Interactive exploratory data analysis (EDA)
    - WoE & Information Value (IV) analysis
    - Logistic regression scorecard modelling
    - Regulatory-safe feature engineering
    - Threshold optimisation & business strategy simulation
    - Portfolio risk monitoring insights

    ### Final Model Performance
    - **AUC:** 0.7822
    - **Gini:** 0.5644
    - **Validation:** 5-Fold Stratified Cross-Validation
    - **Approach:** Interpretable L2-Regularised Logistic Regression

    The final framework balances predictive performance, interpretability, and regulatory defensibility for realistic lending decision support.
    """)
    st.markdown(f"""
    <div class='dq-header'>
      <h1>Credit Risk Intelligence Platform</h1>
      <p>DataQuest 2026 · Loan Default Prediction · Interactive EDA & Decision Support</p>
    </div>
    """, unsafe_allow_html=True)

    # ── KPI row ──────────────────────────────────────────────────────────────
    k1, k2, k3, k4, k5 = st.columns(5)
    k1.metric("Records",         f"{len(raw):,}")
    k2.metric("Features",        f"{raw.shape[1]}")
    k3.metric("Default Rate",    f"{raw['default_flag'].mean():.1%}")
    k4.metric("Training rows",   f"{len(train):,}")
    k5.metric("Missing Cells",   f"{raw.isna().sum().sum():,}")

    st.markdown("---")

    # ── Data quality report ───────────────────────────────────────────────────
    st.markdown("<div class='section-title'>Data Quality Report</div>", unsafe_allow_html=True)

    dq = data_quality_report(raw)

    # Highlight rows with issues
    def style_dq(row):
        if row["Issue"]:
            return ["background-color: rgba(247,129,102,0.1)"] * len(row)
        return [""] * len(row)

    styled_dq = dq.style.apply(style_dq, axis=1).format({"Missing %": "{:.2f}%"})
    st.dataframe(styled_dq, use_container_width=True, height=500)

    # ── Key issues callout boxes ──────────────────────────────────────────────
    st.markdown("---")
    st.markdown("<div class='section-title'>Critical Data Issues Found</div>", unsafe_allow_html=True)

    col_a, col_b = st.columns(2)
    with col_a:
        st.markdown("""
        <div class='insight-card warning'>
          <strong>⚠️ Inconsistent Categorical Encoding</strong><br><br>
          <code>home_ownership</code>: 14 raw variants for 4 categories
          (MORTGAGE, RENT, OWN, OTHER). Examples: "mortgage", "Mortgage", "MORTGAGE"
          all mean the same thing.<br><br>
          <code>loan_purpose</code>: 21 raw variants for 7 categories.
          "debt_consolidation", "Debt Consolidation", "DEBT_CONSOLIDATION" are identical.<br><br>
          <em>→ Standardised in cleaning pipeline.</em>
        </div>
        <div class='insight-card warning'>
          <strong>⚠️ Mixed Date Formats</strong><br><br>
          <code>application_date</code> arrives in 3 different formats:
          YYYY-MM-DD (~70%), MM/DD/YYYY (~20%), DD-Mon-YYYY (~10%).
          Standard parsers fail silently on the minority formats.<br><br>
          <em>→ Custom multi-format parser applied.</em>
        </div>
        """, unsafe_allow_html=True)

    with col_b:
        st.markdown("""
        <div class='insight-card warning'>
          <strong>⚠️ 50% Missing — months_since_last_delinquency</strong><br><br>
          This column is missing for ~60,380 records. However, this is
          <em>informative missingness</em>: applicants with no prior
          delinquency have no value to record. Naive imputation would
          destroy this signal.<br><br>
          <em>→ Created binary flag <code>has_prior_delinquency</code>
          and filled with sentinel 999.</em>
        </div>
        <div class='insight-card warning'>
          <strong>⚠️ Extreme Outliers in annual_income</strong><br><br>
          Max income = $2,000,000 vs median = $52,490.
          The top 1% distorts means and damages model calibration.<br><br>
          <em>→ Winsorised at 1st–99th percentile.</em>
        </div>
        """, unsafe_allow_html=True)

    # ── Target distribution ───────────────────────────────────────────────────
    st.markdown("---")
    st.markdown("<div class='section-title'>Target Variable: Default Distribution</div>", unsafe_allow_html=True)

    c1, c2 = st.columns([1, 2])
    with c1:
        n_def = int(raw["default_flag"].sum())
        n_non = int(len(raw) - n_def)
        st.metric("Non-Defaulters (0)", f"{n_non:,}", delta=f"{n_non/len(raw):.1%}")
        st.metric("Defaulters (1)",     f"{n_def:,}",  delta=f"-{n_def/len(raw):.1%}", delta_color="inverse")
        st.markdown("""
        <div class='insight-card'>
          <strong>Class Imbalance</strong><br>
          85.6% non-default vs 15.4% default. Models trained
          without addressing this will be biased toward predicting
          no default. Use class weights or resampling in Task 2.
        </div>
        """, unsafe_allow_html=True)

    with c2:
        fig, axes = plt.subplots(1, 2, figsize=(9, 3.5))
        # Bar chart
        vals = [n_non, n_def]
        colors = [PALETTE["good"], PALETTE["bad"]]
        bars = axes[0].bar(["Non-Default\n(0)", "Default\n(1)"], vals, color=colors,
                           width=0.5, edgecolor=PALETTE["border"])
        for b in bars:
            h = b.get_height()
            axes[0].text(b.get_x() + b.get_width()/2, h + 500,
                        f"{h:,.0f}\n({h/len(raw):.1%})",
                        ha="center", va="bottom", fontsize=9, color=PALETTE["text"])
        axes[0].set_ylabel("Count")
        axes[0].set_title("Class Counts", fontweight="bold")
        axes[0].yaxis.set_major_formatter(mticker.FuncFormatter(lambda x, _: f"{x/1000:.0f}K"))

        # Default rate by year
        clean_plot = clean.copy()
        yr_rate = clean_plot.groupby("app_year")["default_flag"].mean().reset_index()
        axes[1].plot(yr_rate["app_year"], yr_rate["default_flag"],
                    color=PALETTE["accent"], marker="o", linewidth=2.5, markersize=7)
        axes[1].fill_between(yr_rate["app_year"], yr_rate["default_flag"],
                            alpha=0.15, color=PALETTE["accent"])
        axes[1].set_ylabel("Default Rate")
        axes[1].set_title("Default Rate by Year", fontweight="bold")
        axes[1].yaxis.set_major_formatter(mticker.PercentFormatter(xmax=1))
        axes[1].set_xticks(yr_rate["app_year"])
        for spine in axes[1].spines.values():
            spine.set_color(PALETTE["border"])

        plt.tight_layout(pad=2.0)
        st.pyplot(fig)
        plt.close()


# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# TAB 2 — UNIVARIATE EXPLORER
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
with tabs[1]:
    st.markdown("<div class='section-title'>Univariate Feature Explorer</div>", unsafe_allow_html=True)

    # ── Feature selector ─────────────────────────────────────────────────────
    col_sel, col_bins = st.columns([3, 1])
    with col_sel:
        selected_feature = st.selectbox(
            "Select a feature to explore:",
            ALL_FEATURES,
            index=ALL_FEATURES.index("interest_rate"),
        )
    with col_bins:
        n_bins_uni = st.slider("Bins / Groups", 5, 20, 10,
                               help="Number of bins for numeric features; groups for categorical.")

    is_numeric_feat = selected_feature in NUMERIC_FEATURES

    # ── Compute WoE / IV ─────────────────────────────────────────────────────
    try:
        woe_table = compute_woe_iv(df_analysis, selected_feature,
                                   bins=n_bins_uni)
        iv_val = float(woe_table["IV_contribution"].sum())
    except Exception as e:
        woe_table = None
        iv_val = np.nan
        st.warning(f"WoE calculation issue: {e}")

    # ── IV label ─────────────────────────────────────────────────────────────
    def iv_label(iv):
        if np.isnan(iv):  return "N/A", "iv-useless"
        if iv < 0.02:     return "Useless",    "iv-useless"
        if iv < 0.10:     return "Weak",       "iv-weak"
        if iv < 0.30:     return "Medium",     "iv-medium"
        if iv < 0.50:     return "Strong",     "iv-strong"
        return "Suspicious",  "iv-suspicious"

    label_txt, label_cls = iv_label(iv_val)

    # KPIs
    kp1, kp2, kp3, kp4 = st.columns(4)
    kp1.metric("Feature", selected_feature)
    kp2.metric("Type", "Numeric" if is_numeric_feat else "Categorical")
    iv_display = f"{iv_val:.4f}" if not np.isnan(iv_val) else "N/A"
    kp3.metric("Information Value (IV)", iv_display)
    kp4.metric("Predictive Power", label_txt)

    st.markdown("---")

    # ── Plots ─────────────────────────────────────────────────────────────────
    plot_col, table_col = st.columns([3, 2])

    with plot_col:
        fig, axes = plt.subplots(2, 2, figsize=(11, 8))
        fig.suptitle(f"Univariate Analysis: {selected_feature}",
                     fontsize=13, fontweight="bold", color=PALETTE["text"], y=1.01)

        non_def = df_analysis[df_analysis["default_flag"] == 0][selected_feature].dropna()
        defaults = df_analysis[df_analysis["default_flag"] == 1][selected_feature].dropna()
        all_vals = df_analysis[selected_feature].dropna()

        # ── Plot 1: Overall distribution ─────────────────────────────────────
        ax = axes[0, 0]
        if is_numeric_feat:
            ax.hist(all_vals, bins=40, color=PALETTE["accent3"], alpha=0.8, edgecolor=PALETTE["bg"])
            ax.axvline(all_vals.median(), color=PALETTE["accent"], linewidth=2,
                      linestyle="--", label=f"Median: {all_vals.median():.2f}")
            ax.legend(fontsize=8)
        else:
            vc = all_vals.value_counts().head(15)
            ax.barh(range(len(vc)), vc.values, color=PALETTE["accent3"])
            ax.set_yticks(range(len(vc)))
            ax.set_yticklabels(vc.index, fontsize=8)
            ax.invert_yaxis()
        ax.set_title("Overall Distribution", fontweight="bold", fontsize=10)
        ax.set_xlabel(selected_feature)

        # ── Plot 2: Distribution by default status ───────────────────────────
        ax = axes[0, 1]
        if is_numeric_feat:
            ax.hist(non_def, bins=40, color=PALETTE["good"], alpha=0.6,
                   label="Non-Default", density=True)
            ax.hist(defaults, bins=40, color=PALETTE["bad"], alpha=0.6,
                   label="Default", density=True)
            ax.legend(fontsize=8)
        else:
            dr = (df_analysis.groupby(selected_feature)["default_flag"]
                  .agg(["mean", "count"])
                  .rename(columns={"mean": "default_rate", "count": "n"})
                  .sort_values("default_rate", ascending=False)
                  .head(15))
            colors_bar = [PALETTE["bad"] if r > df_analysis["default_flag"].mean()
                         else PALETTE["good"] for r in dr["default_rate"]]
            ax.barh(range(len(dr)), dr["default_rate"], color=colors_bar)
            ax.axvline(df_analysis["default_flag"].mean(),
                      color=PALETTE["accent"], linestyle="--", linewidth=1.5, label="Avg")
            ax.set_yticks(range(len(dr)))
            ax.set_yticklabels(dr.index, fontsize=8)
            ax.invert_yaxis()
            ax.xaxis.set_major_formatter(mticker.PercentFormatter(xmax=1))
            ax.legend(fontsize=8)
        ax.set_title("Distribution by Default Status", fontweight="bold", fontsize=10)
        ax.set_xlabel("Density" if is_numeric_feat else "Default Rate")

        # ── Plot 3: WoE bar chart ─────────────────────────────────────────────
        ax = axes[1, 0]
        if woe_table is not None:
            woe_colors = [PALETTE["bad"] if w > 0 else PALETTE["good"]
                         for w in woe_table["WoE"]]
            bins_str = [str(b)[:25] for b in woe_table["Bin"]]
            y_pos = range(len(woe_table))
            ax.barh(y_pos, woe_table["WoE"], color=woe_colors, alpha=0.85)
            ax.axvline(0, color=PALETTE["text"], linewidth=1)
            ax.set_yticks(y_pos)
            ax.set_yticklabels(bins_str, fontsize=7)
            ax.invert_yaxis()
            ax.set_xlabel("Weight of Evidence (WoE)")
            bad_patch = mpatches.Patch(color=PALETTE["bad"], label="Higher risk (WoE > 0)")
            good_patch = mpatches.Patch(color=PALETTE["good"], label="Lower risk (WoE < 0)")
            ax.legend(handles=[bad_patch, good_patch], fontsize=7)
        ax.set_title("Weight of Evidence by Bin", fontweight="bold", fontsize=10)

        # ── Plot 4: Bad rate by bin ───────────────────────────────────────────
        ax = axes[1, 1]
        if woe_table is not None:
            bins_str = [str(b)[:25] for b in woe_table["Bin"]]
            y_pos = range(len(woe_table))
            bar_colors = [PALETTE["bad"] if r > df_analysis["default_flag"].mean()
                         else PALETTE["good"] for r in woe_table["Bad_Rate"]]
            ax.barh(y_pos, woe_table["Bad_Rate"], color=bar_colors, alpha=0.85)
            ax.axvline(df_analysis["default_flag"].mean(),
                      color=PALETTE["accent"], linestyle="--", linewidth=1.5,
                      label=f"Average: {df_analysis['default_flag'].mean():.1%}")
            ax.set_yticks(y_pos)
            ax.set_yticklabels(bins_str, fontsize=7)
            ax.invert_yaxis()
            ax.xaxis.set_major_formatter(mticker.PercentFormatter(xmax=1))
            ax.set_xlabel("Default Rate within Bin")
            ax.legend(fontsize=8)
        ax.set_title("Default Rate by Bin", fontweight="bold", fontsize=10)

        plt.tight_layout(pad=2.0)
        st.pyplot(fig)
        plt.close()

    with table_col:
        st.markdown(f"<div class='section-title'>WoE / IV Table</div>", unsafe_allow_html=True)
        if woe_table is not None:
            display_woe = woe_table.copy()
            display_woe["Bin"] = display_woe["Bin"].astype(str).str[:30]
            display_woe = display_woe.rename(columns={
                "Count": "N", "Bad_Rate": "Bad Rate",
                "Dist_Bads": "Dist Bads", "Dist_Goods": "Dist Goods",
                "IV_contribution": "IV Contrib"
            })
            display_woe["Bad Rate"] = display_woe["Bad Rate"].map("{:.1%}".format)
            display_woe["WoE"] = display_woe["WoE"].map("{:.4f}".format)
            display_woe["IV Contrib"] = display_woe["IV Contrib"].map("{:.4f}".format)
            display_woe = display_woe[["Bin", "N", "Bads", "Goods", "Bad Rate", "WoE", "IV Contrib"]]
            st.dataframe(display_woe, use_container_width=True, hide_index=True)

        iv_label_html = f"IV = {iv_display} — {label_txt}"
        st.markdown(f"""
        <div class='insight-card' style='margin-top:16px;'>
          <strong>{iv_label_html}</strong><br><br>
          {"WoE > 0 means that bin has a <em>higher proportion of defaulters</em> than the population average. "
           "WoE < 0 means relatively more non-defaulters — a 'safer' segment." if woe_table is not None else ""}
        </div>
        """, unsafe_allow_html=True)

    # ── Feature IV ranking ────────────────────────────────────────────────────
    st.markdown("---")
    st.markdown("<div class='section-title'>All Features — Information Value Ranking</div>",
                unsafe_allow_html=True)

    with st.spinner("Computing IVs for all features…"):
        iv_df = iv_all_features(df_analysis, ALL_FEATURES)

    # Plot IV bar chart
    fig_iv, ax_iv = plt.subplots(figsize=(12, 5))
    iv_colors = []
    for iv in iv_df["IV"]:
        if np.isnan(iv) or iv < 0.02: iv_colors.append(PALETTE["muted"])
        elif iv < 0.10:               iv_colors.append("#FFDF5D")
        elif iv < 0.30:               iv_colors.append(PALETTE["accent3"])
        elif iv < 0.50:               iv_colors.append(PALETTE["accent"])
        else:                         iv_colors.append(PALETTE["bad"])

    bars_iv = ax_iv.bar(range(len(iv_df)), iv_df["IV"].fillna(0), color=iv_colors, width=0.7)
    ax_iv.set_xticks(range(len(iv_df)))
    ax_iv.set_xticklabels(iv_df["Feature"], rotation=45, ha="right", fontsize=8)
    ax_iv.set_ylabel("Information Value (IV)")
    ax_iv.set_title("Feature Predictive Power — Information Value", fontweight="bold")

    # Threshold lines
    for thresh, lbl, col in [(0.02, "Useless <0.02", PALETTE["muted"]),
                              (0.10, "Weak <0.1", "#FFDF5D"),
                              (0.30, "Medium <0.3", PALETTE["accent3"])]:
        ax_iv.axhline(thresh, color=col, linestyle="--", linewidth=1, alpha=0.7)
        ax_iv.text(len(iv_df) - 0.5, thresh + 0.002, lbl, fontsize=7,
                  color=col, ha="right", va="bottom")

    # Highlight selected feature
    if selected_feature in iv_df["Feature"].values:
        idx = iv_df[iv_df["Feature"] == selected_feature].index[0]
        bars_iv[idx].set_edgecolor(PALETTE["text"])
        bars_iv[idx].set_linewidth(2.5)

    plt.tight_layout()
    st.pyplot(fig_iv)
    plt.close()

    # Table
    st.dataframe(iv_df, use_container_width=True, hide_index=True)


# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# TAB 3 — BIVARIATE EXPLORER
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
with tabs[2]:
    st.markdown("<div class='section-title'>Bivariate Relationship Explorer</div>", unsafe_allow_html=True)

    biv_type = st.radio("Exploration type:",
                       ["Numeric vs Numeric", "Numeric vs Target", "Correlation Heatmap",
                        "Categorical Breakdown"],
                       horizontal=True)

    if biv_type == "Numeric vs Numeric":
        col1, col2, col3 = st.columns(3)
        with col1:
            x_feat = st.selectbox("X axis", NUMERIC_FEATURES, index=9)  # interest_rate
        with col2:
            y_feat = st.selectbox("Y axis", NUMERIC_FEATURES, index=3)  # dti_ratio
        with col3:
            sample_n = st.slider("Sample size (for speed)", 500, 10000, 3000, 500)

        plot_df = df_analysis.dropna(subset=[x_feat, y_feat]).sample(
            min(sample_n, len(df_analysis)), random_state=42)

        fig, ax = plt.subplots(figsize=(9, 6))
        scatter = ax.scatter(
            plot_df[x_feat], plot_df[y_feat],
            c=plot_df["default_flag"].map({0: PALETTE["good"], 1: PALETTE["bad"]}),
            alpha=0.4, s=12, edgecolors="none"
        )
        ax.set_xlabel(x_feat)
        ax.set_ylabel(y_feat)
        ax.set_title(f"{x_feat} vs {y_feat} (coloured by default)", fontweight="bold")
        good_p = mpatches.Patch(color=PALETTE["good"], label="Non-Default")
        bad_p  = mpatches.Patch(color=PALETTE["bad"],  label="Default")
        ax.legend(handles=[good_p, bad_p], fontsize=9)

        # Correlation annotation
        corr = plot_df[[x_feat, y_feat]].corr().iloc[0, 1]
        ax.text(0.02, 0.97, f"Pearson r = {corr:.3f}",
               transform=ax.transAxes, fontsize=10, va="top",
               color=PALETTE["accent"], fontfamily="monospace")
        plt.tight_layout()
        st.pyplot(fig)
        plt.close()

    elif biv_type == "Numeric vs Target":
        feat_biv = st.selectbox("Select numeric feature:", NUMERIC_FEATURES,
                                index=NUMERIC_FEATURES.index("interest_rate"))
        n_bins_biv = st.slider("Number of bins", 5, 20, 10)

        bin_col = f"_bin_{feat_biv}"
        plot_df = df_analysis.dropna(subset=[feat_biv]).copy()
        plot_df[bin_col] = pd.qcut(plot_df[feat_biv], q=n_bins_biv, duplicates="drop")

        grp = plot_df.groupby(bin_col, observed=True)["default_flag"].agg(["mean","count"]).reset_index()
        grp.columns = ["Bin", "Default Rate", "Count"]
        grp["Bin_mid"] = grp["Bin"].apply(lambda x: x.mid).astype(float)

        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 7), sharex=True)

        # Default rate by bin
        bar_colors = [PALETTE["bad"] if r > plot_df["default_flag"].mean() else PALETTE["good"]
                     for r in grp["Default Rate"]]
        ax1.bar(range(len(grp)), grp["Default Rate"], color=bar_colors, alpha=0.85, width=0.7)
        ax1.axhline(plot_df["default_flag"].mean(), color=PALETTE["accent"],
                   linestyle="--", linewidth=2, label=f"Overall avg: {plot_df['default_flag'].mean():.1%}")
        ax1.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=1))
        ax1.set_ylabel("Default Rate")
        ax1.set_title(f"Default Rate by {feat_biv} Bin", fontweight="bold")
        ax1.legend()

        # Count per bin
        ax2.bar(range(len(grp)), grp["Count"], color=PALETTE["accent3"], alpha=0.7, width=0.7)
        ax2.set_ylabel("Count")
        ax2.set_xlabel("Bin")
        ax2.set_xticks(range(len(grp)))
        ax2.set_xticklabels([str(b)[:20] for b in grp["Bin"]], rotation=45, ha="right", fontsize=7)
        ax2.set_title("Record Count per Bin", fontweight="bold")

        plt.tight_layout()
        st.pyplot(fig)
        plt.close()

        # Table
        grp["Default Rate"] = grp["Default Rate"].map("{:.1%}".format)
        grp["Count"] = grp["Count"].map("{:,.0f}".format)
        st.dataframe(grp[["Bin", "Count", "Default Rate"]], use_container_width=True, hide_index=True)

    elif biv_type == "Correlation Heatmap":
        # Select numeric features for heatmap
        corr_features = st.multiselect(
            "Features to include:",
            NUMERIC_FEATURES,
            default=["interest_rate", "dti_ratio", "age", "annual_income",
                     "num_delinquencies_2yr", "credit_utilisation_pct",
                     "employment_length_years", "months_since_oldest_account",
                     "pct_accounts_current", "default_flag"]
        )
        if len(corr_features) >= 2:
            corr_method = st.radio("Correlation method:", ["pearson", "spearman"], horizontal=True)
            corr_matrix = df_analysis[corr_features].corr(method=corr_method)

            fig, ax = plt.subplots(figsize=(max(8, len(corr_features)), max(6, len(corr_features) - 1)))
            mask = np.zeros_like(corr_matrix, dtype=bool)
            mask[np.triu_indices_from(mask, k=1)] = True

            sns.heatmap(
                corr_matrix, ax=ax, mask=mask,
                cmap="RdYlGn", center=0, vmin=-1, vmax=1,
                annot=True, fmt=".2f", annot_kws={"size": 8},
                linewidths=0.5, linecolor=PALETTE["border"],
                cbar_kws={"shrink": 0.8},
            )
            ax.set_title(f"Feature Correlation ({corr_method.title()})", fontweight="bold")
            plt.tight_layout()
            st.pyplot(fig)
            plt.close()

            # Highlight strong correlations with target
            if "default_flag" in corr_features:
                st.markdown("<div class='section-title'>Correlations with default_flag</div>",
                           unsafe_allow_html=True)
                target_corr = (corr_matrix["default_flag"]
                               .drop("default_flag")
                               .sort_values(key=abs, ascending=False)
                               .reset_index())
                target_corr.columns = ["Feature", f"{corr_method.title()} r"]
                target_corr[f"{corr_method.title()} r"] = target_corr[f"{corr_method.title()} r"].round(4)
                st.dataframe(target_corr, use_container_width=True, hide_index=True)
        else:
            st.info("Select at least 2 features.")

    else:  # Categorical Breakdown
        cat_feat = st.selectbox("Select categorical feature:", CATEGORICAL_FEATURES)

        grp = df_analysis.groupby(cat_feat)["default_flag"].agg(["mean","count"]).reset_index()
        grp.columns = [cat_feat, "Default Rate", "Count"]
        grp = grp.sort_values("Default Rate", ascending=False)

        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
        avg_rate = df_analysis["default_flag"].mean()
        bar_cols = [PALETTE["bad"] if r > avg_rate else PALETTE["good"] for r in grp["Default Rate"]]

        ax1.barh(range(len(grp)), grp["Default Rate"], color=bar_cols, alpha=0.85)
        ax1.axvline(avg_rate, color=PALETTE["accent"], linestyle="--", linewidth=2,
                   label=f"Avg: {avg_rate:.1%}")
        ax1.set_yticks(range(len(grp)))
        ax1.set_yticklabels(grp[cat_feat], fontsize=9)
        ax1.invert_yaxis()
        ax1.xaxis.set_major_formatter(mticker.PercentFormatter(xmax=1))
        ax1.set_title(f"Default Rate by {cat_feat}", fontweight="bold")
        ax1.legend()

        ax2.barh(range(len(grp)), grp["Count"], color=PALETTE["accent3"], alpha=0.7)
        ax2.set_yticks(range(len(grp)))
        ax2.set_yticklabels(grp[cat_feat], fontsize=9)
        ax2.invert_yaxis()
        ax2.xaxis.set_major_formatter(mticker.FuncFormatter(lambda x, _: f"{x/1000:.0f}K"))
        ax2.set_title(f"Record Count by {cat_feat}", fontweight="bold")

        plt.tight_layout()
        st.pyplot(fig)
        plt.close()

        grp["Default Rate"] = grp["Default Rate"].map("{:.1%}".format)
        grp["Count"] = grp["Count"].map("{:,.0f}".format)
        st.dataframe(grp, use_container_width=True, hide_index=True)


# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# TAB 4 — RESEARCH REFERENCE
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
with tabs[3]:
    st.markdown("<div class='section-title'>Research Reference</div>", unsafe_allow_html=True)

    res_sec = st.selectbox("Jump to section:", [
        "1. GLM vs Non-Linear Models",
        "2. Interpretability vs Complexity",
        "3. Weight of Evidence & Information Value",
        "4. Model Evaluation Metrics",
        "5. Regulatory Considerations",
    ])

    if "1." in res_sec:
        st.markdown("""
        ## Generalised Linear Models vs Non-Linear Models

        ### Logistic Regression (GLM for Binary Classification)

        Logistic regression models the **log-odds** of the positive class (default) as a linear
        function of features:

        $$\\eta = \\beta_0 + \\beta_1 x_1 + \\beta_2 x_2 + \\cdots + \\beta_p x_p$$

        The probability of default is recovered via the **sigmoid (logistic) function**:

        $$P(Y=1 \\mid X) = \\sigma(\\eta) = \\frac{1}{1 + e^{-\\eta}}$$

        **Key properties:**
        - Each coefficient $\\beta_j$ has a direct interpretation: a unit increase in $x_j$
          changes the log-odds by $\\beta_j$, or equivalently multiplies the *odds* of default
          by $e^{\\beta_j}$.
        - Assumes a **linear relationship** between features and the log-odds.
        - Fast to train, stable, easy to audit. Required in many regulated industries.

        ### Non-Linear Models

        | Model | How it works | Interpretability |
        |---|---|---|
        | **Decision Tree** | Recursive feature splits | High (visual) |
        | **Random Forest** | Ensemble of trees (bagging) | Low (black box) |
        | **Gradient Boosting** (LightGBM, XGBoost) | Additive weak learners | Low–Medium |
        | **Neural Network** | Layered non-linear transformations | Very Low |

        Non-linear models can capture complex interactions and achieve higher AUC on the same data,
        but at the cost of **interpretability** — which is unacceptable in regulated lending.

        In this dataset, LightGBM achieves AUC ≈ 0.82 vs. baseline logistic regression ≈ 0.68.
        Through **careful feature engineering** (WoE encoding, interaction terms, log-transforms),
        we aim to narrow this gap while remaining fully interpretable.
        """)

    elif "2." in res_sec:
        st.markdown("""
        ## The Interpretability–Complexity Trade-off

        ```
        High ──────────────────────────── Low
        Interpretability    ◄──────────► Complexity / Performance

        Logistic Regression   Decision Tree   Random Forest   Neural Network
                  ●               ●               ●               ●
        High ─────┼───────────────┼───────────────┼───────────────┼──── Low
        ```

        ### Why Interpretability Matters in Credit

        1. **Regulation**: Credit bureaus and regulators (e.g. Basel, FCRA, GDPR) require that
           lenders explain *why* a loan was declined.
        2. **Fairness auditing**: Regulators must be able to check whether decisions are
           discriminatory by examining model coefficients.
        3. **Operational trust**: Risk managers, loan officers, and board members need to
           understand and challenge the model's logic.

        ### Engineering Interpretability into Logistic Regression

        The gap between logistic regression and black-box models is often **feature engineering**,
        not model capacity. Techniques that close this gap:

        - **WoE encoding**: Transforms features into their log-odds contribution → makes
          non-linear relationships linear.
        - **Binning + indicator variables**: Captures threshold effects (e.g. DTI > 40%).
        - **Interaction terms**: Explicitly models feature combinations.
        - **Scorecard transformation**: Converts coefficients into human-readable score points.
        """)

    elif "3." in res_sec:
        st.markdown("""
        ## Weight of Evidence (WoE) & Information Value (IV)

        Originally developed by credit scorecards practitioners. WoE transforms raw feature
        values into their **log-odds contribution to default prediction**.

        ### WoE Formula

        For bin $i$ of a feature:

        $$WoE_i = \\ln\\left(\\frac{P(\\text{Bads in bin } i)}{P(\\text{Goods in bin } i)}\\right)
                = \\ln\\left(\\frac{\\text{Bad}_i / \\text{Total Bads}}{\\text{Good}_i / \\text{Total Goods}}\\right)$$

        **Interpretation:**
        - $WoE > 0$: This bin has a *higher concentration of defaulters* than average → risky
        - $WoE < 0$: This bin has a *higher concentration of non-defaulters* → safer
        - $WoE = 0$: Bin default rate equals the population average → no signal

        ### Information Value (IV)

        IV measures the *total* predictive power of a feature by aggregating WoE across all bins:

        $$IV = \\sum_{i} \\left(P(\\text{Bads}_i) - P(\\text{Goods}_i)\\right) \\times WoE_i$$

        | IV Range | Predictive Power |
        |---|---|
        | < 0.02 | Useless — exclude from model |
        | 0.02 – 0.10 | Weak — marginal value |
        | 0.10 – 0.30 | Medium — useful predictor |
        | 0.30 – 0.50 | Strong — very useful |
        | > 0.50 | Suspicious — check for data leakage |

        ### Why WoE is Valuable in Credit Modelling

        1. **Handles non-linearity**: By binning and applying WoE, we can capture non-linear
           relationships within a logistic regression framework.
        2. **Handles categoricals naturally**: WoE replaces arbitrary dummy encoding.
        3. **Automatic outlier dampening**: Extreme values fall into edge bins and receive a
           single WoE value, preventing outlier distortion.
        4. **Interpretability**: Each feature's WoE is directly interpretable as a log-odds contribution.
        """)

    elif "4." in res_sec:
        st.markdown("""
        ## Model Evaluation Metrics for Credit Risk

        ### Confusion Matrix Basis

        | | Predicted: No Default | Predicted: Default |
        |---|---|---|
        | **Actual: No Default** | True Negative (TN) | False Positive (FP) → Wrongly declined |
        | **Actual: Default** | False Negative (FN) → Missed bad loan | True Positive (TP) |

        ### Key Metrics

        **Accuracy** — Overall correct predictions:
        $$\\text{Accuracy} = \\frac{TP + TN}{TP + TN + FP + FN}$$
        ⚠️ *Misleading with class imbalance*: a model predicting "never default" achieves 84.6% accuracy.

        **Precision** — Of those predicted to default, how many actually did:
        $$\\text{Precision} = \\frac{TP}{TP + FP}$$
        *Credit context*: low precision = many "good" customers wrongly declined.

        **Recall (Sensitivity)** — Of actual defaulters, how many did we catch:
        $$\\text{Recall} = \\frac{TP}{TP + FN}$$
        *Credit context*: low recall = many bad loans we approved.

        **F1 Score** — Harmonic mean of precision and recall:
        $$F_1 = 2 \\times \\frac{\\text{Precision} \\times \\text{Recall}}{\\text{Precision} + \\text{Recall}}$$

        **AUC-ROC** — Area Under the ROC Curve. Measures the model's ability to *rank*
        defaulters above non-defaulters. AUC = 0.5 is random; AUC = 1.0 is perfect.

        **Gini Coefficient**:
        $$\\text{Gini} = 2 \\times AUC - 1$$
        Industry standard metric in credit: Gini ≥ 0.50 is considered a strong model.

        | Our Benchmarks | AUC | Gini |
        |---|---|---|
        | Baseline logistic regression | 0.68 | 0.36 |
        | LightGBM ceiling | 0.82 | 0.64 |
        | **Our target** | **> 0.74** | **> 0.48** |
        """)

    else:  # Regulatory
        st.markdown("""
        ## Regulatory Considerations

        Credit models in many jurisdictions are subject to anti-discrimination laws
        (e.g. Equal Credit Opportunity Act in the US, Consumer Credit Act in the UK,
        the EU AI Act). Regulators examine whether model features act as **proxies**
        for protected characteristics.

        ### Features in This Dataset That Would Draw Regulatory Scrutiny

        | Feature | Concern | Why |
        |---|---|---|
        | **age** | Direct protected attribute | Age discrimination is illegal in lending in most jurisdictions. Models must not use age as a decision factor. |
        | **email_domain_type** (free vs corporate) | Proxy for socioeconomic status / employment type | May systematically disadvantage lower-income applicants who use free email services. |
        | **application_dow** (day of week) | Potential proxy for employment type | People in formal employment may apply on weekdays; casual/shift workers on weekends. Could proxy for income stability. |
        | **region** | Potential proxy for protected class | Certain geographic regions correlate with race/ethnicity. Redlining concerns. |

        ### What This Means for Your Model

        1. **Exclude `age` from the final model** or use age only in age-banded form if
           permitted, and document the decision.
        2. **Document feature inclusion decisions** for all features above.
        3. **Run disparate impact analysis**: Check whether model scores differ systematically
           across demographic proxies.
        4. **Prefer features with clear causal credit interpretation**: payment history,
           DTI ratio, utilisation, employment stability.

        ### The GDPR / AI Act Angle

        Under the EU AI Act, credit scoring systems are classified as **high-risk AI systems**.
        This means:
        - Full documentation of data, model logic, and performance
        - Explainability for every individual decision
        - Human oversight mechanisms
        - Annual risk assessments

        This is precisely why **interpretable logistic regression** is preferable to black-box
        alternatives — not just business preference, but legal requirement.
        """)


# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# TAB 5 — MODEL PERFORMANCE
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
with tabs[4]:
    st.markdown("<div class='section-title'>Model Performance</div>", unsafe_allow_html=True)
    st.markdown("""
    <div class='insight-card'>
      <strong>Task 2 Integration</strong><br>
      Once you complete Task 2 (feature engineering + logistic regression), paste your
      model's predicted probabilities below to generate the full performance dashboard.
    </div>
    """, unsafe_allow_html=True)

    # Let user upload predictions or enter AUC manually
    upload_mode = st.radio("Input mode:", ["Manual metrics", "Upload predictions CSV"], horizontal=True)

    if upload_mode == "Manual metrics":
        col_m1, col_m2, col_m3 = st.columns(3)
        auc_baseline = col_m1.number_input("Baseline AUC", value=0.68, step=0.01, format="%.4f")
        auc_yours    = col_m2.number_input("Your Model AUC", value=0.76, step=0.01, format="%.4f")
        auc_lgbm     = col_m3.number_input("LightGBM AUC (ceiling)", value=0.82, step=0.01, format="%.4f")

        gini_b = 2 * auc_baseline - 1
        gini_y = 2 * auc_yours - 1
        gini_l = 2 * auc_lgbm - 1
        improvement = (auc_yours - auc_baseline) / (auc_lgbm - auc_baseline) * 100

        c1, c2, c3, c4 = st.columns(4)
        c1.metric("Baseline Gini",     f"{gini_b:.3f}")
        c2.metric("Your Gini",         f"{gini_y:.3f}", delta=f"+{gini_y-gini_b:.3f}")
        c3.metric("LightGBM Gini",     f"{gini_l:.3f}")
        c4.metric("Gap Closed",        f"{improvement:.1f}%")

        fig_perf, ax_p = plt.subplots(figsize=(8, 4))
        models = ["Baseline\nLogReg", "Your\nModel", "LightGBM\n(ceiling)"]
        aucs   = [auc_baseline, auc_yours, auc_lgbm]
        cols   = [PALETTE["muted"], PALETTE["accent"], PALETTE["accent3"]]
        bars_p = ax_p.bar(models, aucs, color=cols, width=0.45, edgecolor=PALETTE["border"])
        ax_p.axhline(0.5, color=PALETTE["muted"], linestyle=":", linewidth=1, label="Random (0.5)")
        for bar, auc in zip(bars_p, aucs):
            ax_p.text(bar.get_x() + bar.get_width()/2, auc + 0.003,
                     f"AUC = {auc:.3f}", ha="center", fontsize=10, color=PALETTE["text"])
        ax_p.set_ylim(0.45, 0.90)
        ax_p.set_ylabel("AUC-ROC")
        ax_p.set_title("Model Performance Comparison", fontweight="bold")
        plt.tight_layout()
        st.pyplot(fig_perf)
        plt.close()

    else:
        st.info("Upload a CSV with columns: `applicant_id_hash`, `predicted_proba`, `actual` (0/1).")
        pred_file = st.file_uploader("Upload predictions", type="csv")

        if pred_file is not None:
            pred_df = pd.read_csv(pred_file)
            if {"predicted_proba", "actual"}.issubset(pred_df.columns):
                from sklearn.metrics import roc_auc_score, roc_curve, precision_recall_curve

                auc_val = roc_auc_score(pred_df["actual"], pred_df["predicted_proba"])
                gini_val = 2 * auc_val - 1

                fpr, tpr, _ = roc_curve(pred_df["actual"], pred_df["predicted_proba"])
                prec, rec, _ = precision_recall_curve(pred_df["actual"], pred_df["predicted_proba"])

                c1, c2, c3 = st.columns(3)
                c1.metric("AUC-ROC", f"{auc_val:.4f}")
                c2.metric("Gini",    f"{gini_val:.4f}")
                c3.metric("vs Baseline", f"{auc_val - 0.68:+.4f}")

                fig2, (ax_roc, ax_pr) = plt.subplots(1, 2, figsize=(11, 5))

                ax_roc.plot(fpr, tpr, color=PALETTE["accent"], linewidth=2.5,
                           label=f"ROC (AUC={auc_val:.3f})")
                ax_roc.plot([0,1],[0,1], color=PALETTE["muted"], linestyle="--", linewidth=1)
                ax_roc.fill_between(fpr, tpr, alpha=0.1, color=PALETTE["accent"])
                ax_roc.set_xlabel("False Positive Rate")
                ax_roc.set_ylabel("True Positive Rate")
                ax_roc.set_title("ROC Curve", fontweight="bold")
                ax_roc.legend()

                ax_pr.plot(rec, prec, color=PALETTE["accent2"], linewidth=2.5, label="Precision-Recall")
                avg_prec = pred_df["actual"].mean()
                ax_pr.axhline(avg_prec, color=PALETTE["muted"], linestyle="--",
                             label=f"Baseline (no skill): {avg_prec:.1%}")
                ax_pr.set_xlabel("Recall")
                ax_pr.set_ylabel("Precision")
                ax_pr.set_title("Precision-Recall Curve", fontweight="bold")
                ax_pr.legend()

                plt.tight_layout()
                st.pyplot(fig2)
                plt.close()
            else:
                st.error("CSV must contain 'predicted_proba' and 'actual' columns.")


# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
# TAB 6 — BUSINESS DASHBOARD (BONUS TASK 3)
# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
with tabs[5]:
    st.markdown("<div class='section-title'>Business Decision Dashboard — Task 3</div>",
                unsafe_allow_html=True)
    st.markdown("""
    <div class='insight-card'>
      <strong>What this dashboard does:</strong> Shows a lending team how changing the
      approval threshold affects volume, risk, and profitability — translating model scores
      into business decisions.
    </div>
    """, unsafe_allow_html=True)

    # ── Simulated scores using available features ──────────────────────────────
    st.markdown("#### Policy Simulator")
    st.markdown("_Adjust the approval score threshold to see the business impact._")

    # Build a simple proxy score from interest_rate and dti_ratio (representative)
    # In the real run, this uses the Task 2 model probabilities
    sim_df = df_analysis[["interest_rate", "dti_ratio", "age",
                          "num_delinquencies_2yr", "default_flag"]].dropna().copy()

    # Proxy score: normalised risk index (higher = riskier) using known correlations
    # (students will replace with actual model probabilities)
    sim_df["proxy_score"] = (
        0.35 * (sim_df["interest_rate"] - sim_df["interest_rate"].min()) /
                (sim_df["interest_rate"].max() - sim_df["interest_rate"].min()) +
        0.30 * (sim_df["dti_ratio"] - sim_df["dti_ratio"].min()) /
                (sim_df["dti_ratio"].max() - sim_df["dti_ratio"].min()) +
        0.20 * sim_df["num_delinquencies_2yr"] /
                sim_df["num_delinquencies_2yr"].max() +
        0.15 * (1 - (sim_df["age"] - sim_df["age"].min()) /
                     (sim_df["age"].max() - sim_df["age"].min()))
    )

    col_thresh, col_costs = st.columns([1, 2])
    with col_thresh:
        threshold = st.slider(
            "Approval threshold (decline if score > threshold):",
            min_value=0.10, max_value=0.90, value=0.50, step=0.01,
            help="Lower = more conservative (fewer approvals, fewer defaults). "
                 "Higher = more lenient (more approvals, more defaults)."
        )

    with col_costs:
        st.markdown("**Loss assumptions (£):**")
        c_tp, c_fp, c_fn = st.columns(3)
        loan_profit    = c_tp.number_input("Avg. profit — good loan", value=800, step=100)
        loan_loss      = c_fp.number_input("Avg. loss — bad loan approved", value=3500, step=100)
        missed_profit  = c_fn.number_input("Profit missed — good loan declined", value=400, step=50)

    # Decisions
    approved = sim_df[sim_df["proxy_score"] <= threshold]
    declined = sim_df[sim_df["proxy_score"] >  threshold]

    n_approved = len(approved)
    n_declined = len(declined)
    n_total    = len(sim_df)

    # Among approved
    tp = int((approved["default_flag"] == 0).sum())  # Good loans approved
    fp = int((approved["default_flag"] == 1).sum())  # Bad loans approved (missed)
    fn = int((declined["default_flag"] == 0).sum())  # Good loans declined (missed opportunity)
    tn = int((declined["default_flag"] == 1).sum())  # Bad loans declined (caught)

    approval_rate  = n_approved / n_total
    portfolio_dr   = fp / n_approved if n_approved > 0 else 0
    precision_val  = tp / n_approved if n_approved > 0 else 0
    recall_val     = tp / (tp + fn) if (tp + fn) > 0 else 0

    net_value = tp * loan_profit - fp * loan_loss - fn * missed_profit

    # ── KPI metrics ───────────────────────────────────────────────────────────
    m1, m2, m3, m4, m5 = st.columns(5)
    m1.metric("Approval Rate",    f"{approval_rate:.1%}")
    m2.metric("Portfolio Default Rate", f"{portfolio_dr:.1%}",
             delta=f"{portfolio_dr - sim_df['default_flag'].mean():.1%}",
             delta_color="inverse")
    m3.metric("Precision",        f"{precision_val:.1%}")
    m4.metric("Recall",           f"{recall_val:.1%}")
    m5.metric("Estimated Net Value", f"£{net_value:,.0f}",
             delta="positive" if net_value > 0 else "negative")

    st.markdown("---")

    # ── Volume-Risk chart ─────────────────────────────────────────────────────
    thresholds = np.arange(0.10, 0.91, 0.02)
    vr_results = []
    for t in thresholds:
        app = sim_df[sim_df["proxy_score"] <= t]
        if len(app) == 0:
            continue
        vr_results.append({
            "Threshold": t,
            "Approval Rate": len(app) / n_total,
            "Portfolio DR": app["default_flag"].mean(),
            "Net Value": (
                (app["default_flag"] == 0).sum() * loan_profit -
                (app["default_flag"] == 1).sum() * loan_loss -
                (sim_df[sim_df["proxy_score"] > t]["default_flag"] == 0).sum() * missed_profit
            )
        })
    vr_df = pd.DataFrame(vr_results)

    fig_biz, axes_biz = plt.subplots(1, 3, figsize=(14, 4))

    # Volume vs Risk
    ax = axes_biz[0]
    ax.plot(vr_df["Approval Rate"], vr_df["Portfolio DR"],
           color=PALETTE["accent"], linewidth=2.5)
    ax.axvline(approval_rate, color=PALETTE["accent2"], linestyle="--",
              linewidth=2, alpha=0.8, label=f"Current ({threshold:.2f})")
    ax.axhline(portfolio_dr, color=PALETTE["accent2"], linestyle="--",
              linewidth=2, alpha=0.8)
    ax.scatter([approval_rate], [portfolio_dr],
              color=PALETTE["accent2"], s=120, zorder=5)
    ax.xaxis.set_major_formatter(mticker.PercentFormatter(xmax=1))
    ax.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=1))
    ax.set_xlabel("Approval Rate")
    ax.set_ylabel("Portfolio Default Rate")
    ax.set_title("Volume vs Risk Trade-off", fontweight="bold")
    ax.legend(fontsize=8)

    # Net value curve
    ax2 = axes_biz[1]
    ax2.plot(vr_df["Threshold"], vr_df["Net Value"],
            color=PALETTE["good"], linewidth=2.5)
    best_t = vr_df.loc[vr_df["Net Value"].idxmax(), "Threshold"]
    best_v = vr_df["Net Value"].max()
    ax2.axvline(best_t, color=PALETTE["accent"], linestyle="--", linewidth=1.5,
               label=f"Optimal threshold: {best_t:.2f}")
    ax2.axvline(threshold, color=PALETTE["accent2"], linestyle="--", linewidth=1.5,
               label=f"Current: {threshold:.2f}")
    ax2.scatter([best_t], [best_v], color=PALETTE["accent"], s=120, zorder=5)
    ax2.yaxis.set_major_formatter(mticker.FuncFormatter(lambda x, _: f"£{x/1000:.0f}K"))
    ax2.set_xlabel("Score Threshold")
    ax2.set_ylabel("Estimated Net Value")
    ax2.set_title("Value by Threshold", fontweight="bold")
    ax2.legend(fontsize=8)

    # Confusion matrix style breakdown
    ax3 = axes_biz[2]
    confusion_vals = [tp, fp, fn, tn]
    confusion_lbls = [f"Good\nApproved\n{tp:,}", f"Bad\nApproved\n{fp:,}",
                      f"Good\nDeclined\n{fn:,}", f"Bad\nDeclined\n{tn:,}"]
    confusion_cols = [PALETTE["good"], PALETTE["bad"], PALETTE["accent2"], PALETTE["muted"]]
    bars_cm = ax3.bar(confusion_lbls, confusion_vals, color=confusion_cols, alpha=0.85, width=0.6)
    ax3.set_title("Decision Breakdown", fontweight="bold")
    ax3.set_ylabel("Count")
    ax3.yaxis.set_major_formatter(mticker.FuncFormatter(lambda x, _: f"{x/1000:.0f}K"))

    plt.tight_layout(pad=2.5)
    st.pyplot(fig_biz)
    plt.close()

    # ── Business interpretation callouts ─────────────────────────────────────
    st.markdown("---")
    c_int1, c_int2 = st.columns(2)
    with c_int1:
        st.markdown(f"""
        <div class='insight-card {"good" if portfolio_dr < 0.15 else "warning"}'>
          <strong>Precision = {precision_val:.1%}</strong><br>
          Of all loans we approved, {precision_val:.1%} were non-defaulters.
          {"✅ Above 85% — strong portfolio quality." if precision_val > 0.85
           else "⚠️ Below 85% — consider tightening the threshold."}
        </div>
        <div class='insight-card'>
          <strong>Optimal Threshold = {best_t:.2f}</strong><br>
          Based on your cost assumptions (profit £{loan_profit:,}, loss £{loan_loss:,}),
          the threshold that <em>maximises net value</em> is <strong>{best_t:.2f}</strong>.
          {"You're currently above optimal — you could approve more loans profitably." if threshold > best_t
           else "You're at or below optimal — further relaxation would cost more than it earns."}
        </div>
        """, unsafe_allow_html=True)

    with c_int2:
        st.markdown(f"""
        <div class='insight-card {"warning" if recall_val < 0.7 else "good"}'>
          <strong>Recall = {recall_val:.1%}</strong><br>
          We capture {recall_val:.1%} of all creditworthy customers.
          {"⚠️ Low recall — many good customers are being declined. Revenue opportunity lost." if recall_val < 0.7
           else "✅ Strong recall — we're approving most creditworthy applicants."}
        </div>
        <div class='insight-card'>
          <strong>What this means for the business:</strong><br>
          At threshold {threshold:.2f}, we approve <strong>{n_approved:,}</strong> loans
          ({approval_rate:.1%} of applicants). Our portfolio contains approximately
          <strong>{fp:,}</strong> expected defaults. Each threshold point is a
          <em>policy decision</em> — not just a model decision.
        </div>
        """, unsafe_allow_html=True)

    st.markdown("---")
    st.markdown("""
    <div class='insight-card'>
      <strong>📝 Note for Task 2 Integration</strong><br>
      Replace the <code>proxy_score</code> in this tab with your actual logistic regression
      predicted probabilities from Task 2. The simulator logic is already built — just pass
      in <code>df["predicted_proba"]</code> from your model.
    </div>
    """, unsafe_allow_html=True)

    st.markdown("---")

st.caption(
    "DataQuest 2026 • Credit Risk Intelligence Platform • "
    "Built with Streamlit, Logistic Regression, WoE Encoding & Business Analytics"
)