import streamlit as st
import requests 
import pandas as pd
import numpy as np
import yfinance as yf
import plotly.graph_objects as go
import plotly.figure_factory as ff
from datetime import datetime, date
from dateutil.relativedelta import relativedelta
import datetime as dt
import warnings 
warnings.filterwarnings("ignore")
import os
from scipy.optimize import fsolve
from scipy.stats import norm

###############################################################################
# SET WIDE LAYOUT AND PAGE TITLE
###############################################################################
st.set_page_config(page_title="Default Risk Estimation", layout="wide")

###############################################################################
# GLOBALS & SESSION STATE
###############################################################################
FMP_API_KEY = os.getenv("FMP_API_KEY")

if "altman_results" not in st.session_state:
    st.session_state["altman_results"] = None

if "dtd_results" not in st.session_state:
    st.session_state["dtd_results"] = None

###############################################################################
# HELPER FUNCTIONS (Altman Z)
###############################################################################
def get_fmp_json(url):
    """
    Retrieves JSON from the specified URL and returns as a list.
    Omits direct mention of data source in any error messages.
    """
    r = requests.get(url)
    try:
        data = r.json()
        if not isinstance(data, list):
            return []
        return data
    except Exception:
        return []

def fetch_fmp_annual(endpoint):
    """
    Fetches annual data from the endpoint, sorts by date if present.
    """
    data = get_fmp_json(endpoint)
    df = pd.DataFrame(data)
    if not df.empty and 'date' in df.columns:
        df['date'] = pd.to_datetime(df['date'])
        df.sort_values('date', inplace=True)
    return df

###############################################################################
# HELPER FUNCTIONS (Distance-to-Default)
###############################################################################
def solve_merton(E, sigma_E, D, T, r):
    """
    Merton model solver:
      E = A * N(d1) - D * exp(-rT) * N(d2)
      sigma_E = (A / E) * N(d1) * sigma_A
    """
    def equations(vars_):
        A_, sigmaA_ = vars_
        d1_ = (np.log(A_ / D) + (r + 0.5 * sigmaA_**2) * T) / (sigmaA_ * np.sqrt(T))
        d2_ = d1_ - sigmaA_ * np.sqrt(T)
        eq1 = A_ * norm.cdf(d1_) - D * np.exp(-r * T) * norm.cdf(d2_) - E
        eq2 = sigma_E - (A_ / E) * norm.cdf(d1_) * sigmaA_
        return (eq1, eq2)

    A_guess = E + D
    sigmaA_guess = sigma_E * (E / (E + D))
    A_star, sigmaA_star = fsolve(equations, [A_guess, sigmaA_guess], maxfev=3000)
    return A_star, sigmaA_star

def distance_to_default(A, D, T, r, sigmaA):
    """
    Merton distance to default (d2):
      d2 = [ln(A/D) + (r - 0.5*sigmaA^2)*T] / (sigmaA * sqrt(T))
    """
    return (np.log(A / D) + (r - 0.5 * sigmaA**2) * T) / (sigmaA * np.sqrt(T))

###############################################################################
# ALTMAN Z-SCORE EXECUTION (From Provided Code)
###############################################################################
def run_altman_zscore_calculations(ticker, years_back):
    """
    Uses the original user-provided Altman Z code to fetch and compute partials.
    Returns the final DataFrame with partials and total Z-scores.
    """
    # 1) FETCH ANNUAL STATEMENTS
    income_url = f"https://financialmodelingprep.com/api/v3/income-statement/{ticker}?period=annual&limit=100&apikey={FMP_API_KEY}"
    balance_url = f"https://financialmodelingprep.com/api/v3/balance-sheet-statement/{ticker}?period=annual&limit=100&apikey={FMP_API_KEY}"

    income_df = fetch_fmp_annual(income_url)
    balance_df = fetch_fmp_annual(balance_url)

    merged_bi = pd.merge(balance_df, income_df, on='date', how='inner', suffixes=('_bal','_inc'))
    merged_bi.sort_values('date', inplace=True)

    if merged_bi.empty:
        st.warning("No statements to analyze for this ticker/date range.")
        return pd.DataFrame()

    # 2) FILTER TO LAST X YEARS
    end_date = pd.Timestamp.today()
    start_date = end_date - relativedelta(years=years_back)

    merged_bi = merged_bi[(merged_bi['date'] >= start_date) & (merged_bi['date'] <= end_date)]
    merged_bi.sort_values('date', inplace=True)

    if merged_bi.empty:
        st.warning("No financial statements found in the chosen range.")
        return pd.DataFrame()

    # 3) FETCH HISTORICAL MARKET CAP
    mktcap_df = pd.DataFrame()
    iterations = (years_back // 5) + (1 if years_back % 5 != 0 else 0)

    for i in range(iterations):
        period_end_date = end_date - relativedelta(years=i * 5)
        period_start_date = period_end_date - relativedelta(years=5)

        if period_start_date < start_date:
            period_start_date = start_date

        mktcap_url = (
            f"https://financialmodelingprep.com/api/v3/historical-market-capitalization/{ticker}"
            f"?from={period_start_date.date()}&to={period_end_date.date()}&apikey={FMP_API_KEY}"
        )
        mktcap_data = get_fmp_json(mktcap_url)
        mktcap_period_df = pd.DataFrame(mktcap_data)
        
        if not mktcap_period_df.empty and 'date' in mktcap_period_df.columns:
            mktcap_period_df['date'] = pd.to_datetime(mktcap_period_df['date'])
            mktcap_period_df.rename(columns={'marketCap': 'historical_market_cap'}, inplace=True)
            mktcap_df = pd.concat([mktcap_df, mktcap_period_df], ignore_index=True)

    mktcap_df = mktcap_df.sort_values('date').drop_duplicates(subset=['date'])
    if not mktcap_df.empty and 'date' in mktcap_df.columns:
        mktcap_df['date'] = pd.to_datetime(mktcap_df['date'])
        mktcap_df = mktcap_df[(mktcap_df['date'] >= start_date) & (mktcap_df['date'] <= end_date)]
        mktcap_df.sort_values('date', inplace=True)
    else:
        mktcap_df = pd.DataFrame(columns=['date','historical_market_cap'])

    if not merged_bi.empty and not mktcap_df.empty:
        merged_bi = pd.merge_asof(
            merged_bi.sort_values('date'),
            mktcap_df.sort_values('date'),
            on='date',
            direction='nearest'
        )
    else:
        merged_bi['historical_market_cap'] = np.nan

    # 4) COMPUTE PARTIAL CONTRIBUTIONS
    z_rows = []
    for _, row in merged_bi.iterrows():
        ta = row.get('totalAssets', np.nan)
        tl = row.get('totalLiabilities', np.nan)
        if pd.isnull(ta) or pd.isnull(tl) or ta == 0 or tl == 0:
            continue

        rev = row.get('revenue', 0)
        hist_mcap = row.get('historical_market_cap', np.nan)
        if pd.isnull(hist_mcap):
            continue

        tca = row.get('totalCurrentAssets', np.nan)
        tcl = row.get('totalCurrentLiabilities', np.nan)
        if pd.isnull(tca) or pd.isnull(tcl):
            continue

        wc = (tca - tcl)   
        re = row.get('retainedEarnings', 0)
        ebit = row.get('operatingIncome', np.nan)
        if pd.isnull(ebit):
            ebit = row.get('ebitda', 0)

        X1 = wc / ta
        X2 = re / ta
        X3 = ebit / ta
        X4 = hist_mcap / tl
        X5 = rev / ta if ta != 0 else 0

        # Original Z
        o_part1 = 1.2 * X1  
        o_part2 = 1.4 * X2  
        o_part3 = 3.3 * X3  
        o_part4 = 0.6 * X4  
        o_part5 = 1.0 * X5  
        z_original = o_part1 + o_part2 + o_part3 + o_part4 + o_part5

        # Z''
        d_part1 = 6.56 * X1  
        d_part2 = 3.26 * X2  
        d_part3 = 6.72 * X3  
        d_part4 = 1.05 * X4  
        z_double_prime = d_part1 + d_part2 + d_part3 + d_part4

        # Z'''
        t_part1 = 3.25 * X1  
        t_part2 = 2.85 * X2  
        t_part3 = 4.15 * X3  
        t_part4 = 0.95 * X4  
        z_triple_prime_service = t_part1 + t_part2 + t_part3 + t_part4

        z_rows.append({
            'date': row['date'],

            # Original partials
            'o_part1': o_part1,
            'o_part2': o_part2,
            'o_part3': o_part3,
            'o_part4': o_part4,
            'o_part5': o_part5,
            'z_original': z_original,

            # Z'' partials
            'd_part1': d_part1,
            'd_part2': d_part2,
            'd_part3': d_part3,
            'd_part4': d_part4,
            'z_double_prime': z_double_prime,

            # Z''' partials
            't_part1': t_part1,
            't_part2': t_part2,
            't_part3': t_part3,
            't_part4': t_part4,
            'z_triple_prime_service': z_triple_prime_service
        })

    z_df = pd.DataFrame(z_rows)
    z_df.sort_values('date', inplace=True)
    return z_df

###############################################################################
# DTD EXECUTION (From Provided Code)
###############################################################################
def calculate_yearly_distance_to_default(
    symbol="AAPL",
    years_back=10,
    debt_method="TOTAL",
    risk_free_ticker="^TNX",
    apikey="YOUR_FMP_API_KEY",
):
    """
    Fetches up to `years_back` years of annual data, merges market cap, debt, 
    and risk-free yields. Then computes Merton Distance to Default for each year.
    Returns a DataFrame.
    """
    end_date = date.today()
    start_date = end_date - dt.timedelta(days=365 * years_back)

    # Market cap
    df_mcap = pd.DataFrame()
    iterations = (years_back // 5) + (1 if years_back % 5 != 0 else 0)
    for i in range(iterations):
        period_end_date = end_date - dt.timedelta(days=365 * i * 5)
        period_start_date = period_end_date - dt.timedelta(days=365 * 5)
        url_mcap = (
            f"https://financialmodelingprep.com/api/v3/historical-market-capitalization/"
            f"{symbol}?from={period_start_date}&to={period_end_date}&apikey={apikey}"
        )
        resp_mcap = requests.get(url_mcap)
        data_mcap = resp_mcap.json() if resp_mcap.status_code == 200 else []
        df_mcap_period = pd.DataFrame(data_mcap)
        df_mcap = pd.concat([df_mcap, df_mcap_period], ignore_index=True)

    if df_mcap.empty or "date" not in df_mcap.columns:
        raise ValueError("No market cap data returned. Check your inputs.")
    df_mcap["year"] = pd.to_datetime(df_mcap["date"]).dt.year
    df_mcap = (
        df_mcap.groupby("year", as_index=False)
        .agg({"marketCap": "mean"})
        .sort_values("year", ascending=False)
    )

    # Balance Sheet
    url_bs = f"https://financialmodelingprep.com/api/v3/balance-sheet-statement/{symbol}?period=annual&apikey={apikey}"
    resp_bs = requests.get(url_bs)
    data_bs = resp_bs.json() if resp_bs.status_code == 200 else []
    df_bs = pd.DataFrame(data_bs)
    if df_bs.empty or "date" not in df_bs.columns:
        raise ValueError("No balance sheet data returned. Check your inputs.")
    df_bs["year"] = pd.to_datetime(df_bs["date"]).dt.year
    keep_cols = ["year", "shortTermDebt", "longTermDebt", "totalDebt", "date"]
    df_bs = df_bs[keep_cols].sort_values("year", ascending=False)

    # Risk-free from yfinance
    rf_ticker_obj = yf.Ticker(risk_free_ticker)
    rf_data = rf_ticker_obj.history(start=start_date, end=end_date, auto_adjust=False)
    if rf_data.empty or "Close" not in rf_data.columns:
        raise ValueError("No valid risk-free rate data found. Check your inputs.")
    rf_data = rf_data.reset_index()
    rf_data["year"] = rf_data["Date"].dt.year
    rf_data = rf_data[["year", "Close"]]
    rf_yearly = rf_data.groupby("year", as_index=False)["Close"].mean()
    rf_yearly.rename(columns={"Close": "rf_yield"}, inplace=True)
    rf_yearly["rf_yield"] = rf_yearly["rf_yield"] / 100.0  # decimal

    # Merge
    df_all = pd.merge(df_mcap, df_bs, on="year", how="left")
    df_all = pd.merge(df_all, rf_yearly, on="year", how="left")

    # Merton each year
    results = []
    for _, row in df_all.iterrows():
        yr = row["year"]
        E = row["marketCap"]
        if pd.isna(E) or E <= 0:
            continue

        shortD = row.get("shortTermDebt", 0) or 0
        longD = row.get("longTermDebt", 0) or 0
        totalD = row.get("totalDebt", 0) or 0
        if debt_method.upper() == "STPLUSLT":
            D = shortD + longD
        elif debt_method.upper() == "STPLUSHALFLT":
            D = shortD + 0.5 * longD
        else:
            D = totalD
        if not D or D <= 0:
            D = np.nan

        r_val = row.get("rf_yield", 0.03)

        from_dt = f"{yr}-01-01"
        to_dt = f"{yr}-12-31"
        url_hist = (
            f"https://financialmodelingprep.com/api/v3/historical-price-full/{symbol}"
            f"?from={from_dt}&to={to_dt}&apikey={apikey}"
        )
        resp_hist = requests.get(url_hist)
        data_hist = resp_hist.json() if resp_hist.status_code == 200 else {}
        daily_prices = data_hist.get("historical", [])

        if not daily_prices:
            sigma_E = 0.30
        else:
            df_prices = pd.DataFrame(daily_prices)
            df_prices.sort_values("date", inplace=True)
            close_vals = df_prices["close"].values
            log_rets = np.diff(np.log(close_vals))
            daily_vol = np.std(log_rets)
            sigma_E = daily_vol * np.sqrt(252)
            if sigma_E < 1e-4:
                sigma_E = 0.30

        T = 1.0
        if not np.isnan(D):
            try:
                A_star, sigmaA_star = solve_merton(E, sigma_E, D, T, r_val)
                dtd_value = distance_to_default(A_star, D, T, r_val, sigmaA_star)
            except:
                A_star, sigmaA_star, dtd_value = np.nan, np.nan, np.nan
        else:
            A_star, sigmaA_star, dtd_value = np.nan, np.nan, np.nan

        results.append({
            "year": yr,
            "marketCap": E,
            "shortTermDebt": shortD,
            "longTermDebt": longD,
            "totalDebt": totalD,
            "chosenDebt": D,
            "rf": r_val,
            "sigma_E": sigma_E,
            "A_star": A_star,
            "sigmaA_star": sigmaA_star,
            "DTD": dtd_value
        })

    result_df = pd.DataFrame(results).sort_values("year")
    return result_df

###############################################################################
# PLOTTING HELPERS
###############################################################################
def plot_zscore_figure(df, date_col, partial_cols, total_col, partial_names, total_name, title_text, zones, ticker):
    """
    Creates stacked bar for partial contributions plus a line for the total Z.
    Draws shading for distress/gray/safe zones. Full width.
    """
    fig = go.Figure()

    x_min = df[date_col].min()
    x_max = df[date_col].max()
    total_max = df[total_col].max()
    partial_sum_max = df[partial_cols].sum(axis=1).max() if not df[partial_cols].empty else 0
    y_max = max(total_max, partial_sum_max, 0) * 1.2
    y_min = min(df[total_col].min(), 0) * 1.2 if df[total_col].min() < 0 else 0

    # Distress
    fig.add_shape(
        type="rect",
        x0=x_min, x1=x_max,
        y0=y_min, y1=zones['distress'],
        fillcolor="red",
        opacity=0.2,
        layer="below",
        line=dict(width=0)
    )
    # Gray
    fig.add_shape(
        type="rect",
        x0=x_min, x1=x_max,
        y0=zones['gray_lower'], y1=zones['gray_upper'],
        fillcolor="gray",
        opacity=0.2,
        layer="below",
        line=dict(width=0)
    )
    # Safe
    fig.add_shape(
        type="rect",
        x0=x_min, x1=x_max,
        y0=zones['safe'], y1=y_max,
        fillcolor="green",
        opacity=0.2,
        layer="below",
        line=dict(width=0)
    )

    # Stacked bars
    for col, name, color in partial_names:
        fig.add_trace(go.Bar(
            x=df[date_col],
            y=df[col],
            name=name,
            marker_color=color
        ))

    # Line
    fig.add_trace(go.Scatter(
        x=df[date_col],
        y=df[total_col],
        mode='lines+markers+text',
        text=df[total_col].round(2),
        textposition='top center',
        textfont=dict(size=16),
        name=total_name,
        line=dict(color='white', width=2)
    ))

    fig.update_layout(
        title=dict(
            text=f"{title_text} for {ticker}",
            font=dict(size=26, color="white")
        ),
        
        legend=dict(
            font=dict(color="white", size=18)
        ),
        barmode="stack",
        template="plotly_dark",
        paper_bgcolor="#0e1117",
        plot_bgcolor="#0e1117",
        xaxis=dict(
            title="Year",
            tickangle=45,
            tickformat="%Y",
            dtick="M12",
            showgrid=True,
            gridcolor="rgba(255, 255, 255, 0.1)"
        ),
        yaxis=dict(
            title="Z-Score Contribution",
            showgrid=True,
            gridcolor="rgba(255, 255, 255, 0.1)"
        ),
        margin=dict(l=40, r=40, t=80, b=80),
        height=700
    )
    st.plotly_chart(fig, use_container_width=True)

###############################################################################
# STREAMLIT APP
###############################################################################
st.title("Bankruptcy Risk Estimation")

#st.write("## Overview")
st.write("This tool assesses a firm's bankruptcy and default risk using two widely recognized models:")
st.write("1) **Altman Z-Score**: A financial distress predictor based on accounting ratios.")
st.write("2) **Merton Distance-to-Default (DTD)**: A market-based risk measure derived from option pricing theory.")
#st.write("Select a page from the sidebar to explore each model’s estimates and methodology.")

# Sidebar for user inputs
with st.sidebar:
    st.write("## Input Parameters")
    
    # Page selector in an open-by-default expander
    with st.expander("Page Selector", expanded=True):
        page = st.radio("Select Page:", ["Altman Z Score", "Distance-to-Default"])
    
    with st.expander("General Settings", expanded=True):
        ticker = st.text_input("Ticker", value="AAPL", help="Enter a valid stock ticker")
        years_back = st.number_input("Years back", min_value=1, max_value=30, value=10, step=1,
                                     help="How many years of data to retrieve?")
    run_button = st.button("Run Analysis", help="Fetch data and compute metrics")

# If user clicks to run, fetch data
if run_button:
    # Altman Z
    z_data = run_altman_zscore_calculations(ticker, years_back)
    st.session_state["altman_results"] = z_data

    # DTD
    try:
        dtd_df = calculate_yearly_distance_to_default(
            symbol=ticker,
            years_back=years_back,
            debt_method="TOTAL",
            risk_free_ticker="^TNX",
            apikey=FMP_API_KEY
        )
        st.session_state["dtd_results"] = dtd_df
    except ValueError:
        st.warning("No valid data was returned. Check your inputs.")

###############################################################################
# PAGE 1: ALTMAN Z
###############################################################################
if page == "Altman Z Score":
    z_df = st.session_state.get("altman_results", None)
    if z_df is None or z_df.empty:
        st.info("Select Page, input the paramters and click 'Run Analysis' on the sidebar.")
    else:
        # Original
        #st.subheader("Original Altman Z-Score (1968)")
        
        with st.expander("Methodology: Original Altman Z-Score (1968)", expanded=False):
            st.write("The **Altman Z-Score** is a financial distress prediction model developed by Edward Altman in 1968. It combines five financial ratios to assess the likelihood of corporate bankruptcy.")
            
            # Formula
            st.latex(r"Z = 1.2 \times X_1 + 1.4 \times X_2 + 3.3 \times X_3 + 0.6 \times X_4 + 1.0 \times X_5")
            
            # Definitions of variables
            st.latex(r"X_1 = \frac{\text{Working Capital}}{\text{Total Assets}}")
            st.write("**Liquidity (X₁)**: Measures short-term financial health by comparing working capital to total assets. Higher values suggest better liquidity and lower default risk.")

            st.latex(r"X_2 = \frac{\text{Retained Earnings}}{\text{Total Assets}}")
            st.write("**Accumulated Profitability (X₂)**: Indicates the proportion of assets financed through retained earnings. Firms with strong retained earnings are less dependent on external financing.")

            st.latex(r"X_3 = \frac{\text{EBIT}}{\text{Total Assets}}")
            st.write("**Earnings Strength (X₃)**: EBIT (Earnings Before Interest and Taxes) relative to total assets reflects operating profitability and efficiency.")

            st.latex(r"X_4 = \frac{\text{Market Value of Equity}}{\text{Total Liabilities}}")
            st.write("**Leverage (X₄)**: Compares a firm's market capitalization to its total liabilities. A higher ratio suggests lower financial risk, as equity holders have a stronger claim.")

            st.latex(r"X_5 = \frac{\text{Revenue}}{\text{Total Assets}}")
            st.write("**Asset Turnover (X₅)**: Assesses how efficiently a company generates revenue from its assets. High turnover suggests better asset utilization.")

            # Academic Justification
            st.write("##### Academic Justification")
            st.write(
                "The Altman Z-Score was developed using **discriminant analysis** on a dataset of manufacturing firms. "
                "The Altman Z-Score was found to correctly predict bankruptcy **72-80%** of the time in original studies, typically with a **one-year lead time** before actual default."
                "The model’s strength lies in its ability to quantify financial health across multiple dimensions—liquidity, profitability, leverage, and efficiency."
            )

            # Interpretation
            st.write("##### Interpretation")
            st.write(
                "**Z > 2.99**: Company is considered financially healthy (Low risk of bankruptcy).  \n"
                "**1.81 ≤ Z ≤ 2.99**: 'Gray Area' where financial stability is uncertain.  \n"
                "**Z < 1.81**: High financial distress, indicating potential bankruptcy risk."
            )

            # Downsides / Limitations
            st.write("##### Limitations")
            st.write(
                "- Developed using **only manufacturing firms**, which limits its applicability to other industries.\n"
                "- Uses **historical accounting data**, which may not reflect current market conditions.\n"
                "- Market Value of Equity (X₄) makes the score **sensitive to stock price volatility**.\n"
                "- Does not incorporate forward-looking indicators such as market sentiment or macroeconomic risks."
            )
        
        
        orig_partial_names = [
            ('o_part1', "1.2 × (WC/TA)", 'blue'),
            ('o_part2', "1.4 × (RE/TA)", 'orange'),
            ('o_part3', "3.3 × (EBIT/TA)", 'green'),
            ('o_part4', "0.6 × (MktCap/TL)", 'red'),
            ('o_part5', "1.0 × (Rev/TA)", 'purple'),
        ]
        orig_zones = {
            'distress': 1.81,
            'gray_lower': 1.81,
            'gray_upper': 2.99,
            'safe': 2.99
        }
        plot_zscore_figure(
            df=z_df,
            date_col='date',
            partial_cols=['o_part1','o_part2','o_part3','o_part4','o_part5'],
            total_col='z_original',
            partial_names=orig_partial_names,
            total_name="Original Z (Total)",
            title_text="Original Altman Z-Score (1968)",
            zones=orig_zones,
            ticker=ticker
        )
        

        with st.expander("Interpretation", expanded=False):
            # EXACT TEXT from user code (Original Z)
            latest_z = z_df['z_original'].iloc[-1]
            # For time-series logic:
            first_val = z_df['z_original'].iloc[0]
            if latest_z > first_val:
                trend = "increased"
            elif latest_z < first_val:
                trend = "decreased"
            else:
                trend = "remained the same"
            min_val = z_df['z_original'].min()
            max_val = z_df['z_original'].max()
            min_idx = z_df['z_original'].idxmin()
            max_idx = z_df['z_original'].idxmax()
            min_year = z_df.loc[min_idx, 'date'].year
            max_year = z_df.loc[max_idx, 'date'].year

            st.write("**--- Interpretation for Original Z-Score ---")
            st.write(f"Over the entire time series, the Z-Score has {trend}.")
            st.write(f"The lowest value was {min_val:.2f} in {min_year}.")
            st.write(f"The highest value was {max_val:.2f} in {max_year}.")

            if latest_z < orig_zones['distress']:
                st.write("Current reading is in distress zone. This suggests high financial risk.")
            elif latest_z < orig_zones['gray_upper']:
                st.write("Current reading is in the gray area. This signals mixed financial stability.")
            else:
                st.write("Current reading is in the safe zone. This implies a stronger financial condition.")

            latest_data = z_df.iloc[-1]
            orig_partials = {
                'o_part1': latest_data['o_part1'],
                'o_part2': latest_data['o_part2'],
                'o_part3': latest_data['o_part3'],
                'o_part4': latest_data['o_part4'],
                'o_part5': latest_data['o_part5']
            }
            key_driver = max(orig_partials, key=orig_partials.get)
            if key_driver == 'o_part1':
                st.write("The most significant factor is Working Capital. This suggests the company's ability to cover short-term obligations with current assets. ")
                st.write("A high contribution from Working Capital means strong liquidity, but too much could indicate inefficient capital allocation. ")
                st.write("If the company holds excess current assets, it may not be deploying resources efficiently for growth.")
            elif key_driver == 'o_part2':
                st.write("The most significant factor is Retained Earnings. This reflects the company's history of profitability and reinvestment. ")
                st.write("A high retained earnings contribution indicates that past profits have been reinvested rather than paid out as dividends. ")
                st.write("This can be a positive sign of financial stability, but if earnings retention is excessive, investors may question the company’s capital allocation strategy.")
            elif key_driver == 'o_part3':
                st.write("The most significant factor is EBIT (Earnings Before Interest and Taxes). This underscores the company’s ability to generate profits from operations. ")
                st.write("A high EBIT contribution suggests that core business activities are profitable and drive financial health. ")
                st.write("However, if EBIT dominates the Z-Score, it may mean the company is heavily reliant on operational earnings, making it vulnerable to downturns in revenue.")
            elif key_driver == 'o_part4':
                st.write("The most significant factor is Market Cap to Liabilities. This reflects investor confidence in the company’s future performance relative to its debt burden. ")
                st.write("A strong market cap contribution means investors perceive the company as having high equity value compared to liabilities, reducing bankruptcy risk. ")
                st.write("However, if this is the dominant driver, financial stability may be tied to market sentiment, which can be volatile.")
            elif key_driver == 'o_part5':
                st.write("The most significant factor is Revenue. This indicates that top-line growth is a major driver of financial stability. ")
                st.write("A high revenue contribution is positive if it translates to strong margins, but if costs are rising at the same pace, profitability may not improve. ")
                st.write("If revenue dominates the Z-Score, the company must ensure sustainable cost management and profitability to maintain financial strength.")

            st.write("If management seeks to lower this Z-Score, they might reduce liquidity or raise liabilities.")
            st.write("A higher liability base or weaker earnings can press the score downward.")

        # Z'' 
        #st.subheader("Z'' (1993, Non-Manufacturing)")
        
        with st.expander("Methodology: Z'' (1993, Non-Manufacturing)", expanded=False):
            st.write("The **Z''-Score (1993)** is an adaptation of the original Altman Z-Score, developed to assess financial distress in **non-manufacturing firms**, particularly service and retail sectors. It removes the revenue-based efficiency metric (X₅) and adjusts weightings to better fit firms with different asset structures.")

            # Formula
            st.latex(r"Z'' = 6.56 \times X_1 + 3.26 \times X_2 + 6.72 \times X_3 + 1.05 \times X_4")

            # Definitions of variables
            st.latex(r"X_1 = \frac{\text{Working Capital}}{\text{Total Assets}}")
            st.write("**Liquidity (X₁)**: Measures short-term financial flexibility. Firms with higher working capital relative to assets are better positioned to meet short-term obligations.")

            st.latex(r"X_2 = \frac{\text{Retained Earnings}}{\text{Total Assets}}")
            st.write("**Cumulative Profitability (X₂)**: Higher retained earnings relative to total assets suggest long-term profitability and financial resilience.")

            st.latex(r"X_3 = \frac{\text{EBIT}}{\text{Total Assets}}")
            st.write("**Operating Profitability (X₃)**: Measures how efficiently a company generates profit from its assets, reflecting core business strength.")

            st.latex(r"X_4 = \frac{\text{Market Value of Equity}}{\text{Total Liabilities}}")
            st.write("**Leverage (X₄)**: A firm's ability to cover its liabilities with market value equity. A lower ratio suggests greater financial risk.")

            # Academic Justification
            st.write("##### Academic Justification")
            st.write(
                "The original Z-Score was optimized for **manufacturing firms**, making it less effective for firms with fewer tangible assets. "
                "Z'' (1993) improves bankruptcy prediction for **service and retail firms**, as it excludes the revenue turnover component (X₅) "
                "and places greater emphasis on profitability and liquidity. Empirical studies found Z'' to be **better suited for firms with lower capital intensity**."
            )

            # Interpretation
            st.write("##### Interpretation")
            st.write(
                "**Z'' > 2.60**: Firm is financially stable, with low bankruptcy risk.  \n"
                "**1.10 ≤ Z'' ≤ 2.60**: 'Gray Area'—financial condition is uncertain.  \n"
                "**Z'' < 1.10**: Firm is in financial distress, at a higher risk of default."
            )

            # Downsides / Limitations
            st.write("##### Limitations")
            st.write(
                "- Developed for **non-manufacturing firms**, but may not be applicable to banks or financial institutions.\n"
                "- Still **relies on historical accounting data**, which may not fully capture real-time financial conditions.\n"
                "- Market-based variable (X₄) makes the score **sensitive to stock market fluctuations**.\n"
                "- Does not consider external macroeconomic risks or qualitative factors like management decisions."
            )

        
        double_partial_names = [
            ('d_part1', "6.56 × (WC/TA)", 'blue'),
            ('d_part2', "3.26 × (RE/TA)", 'orange'),
            ('d_part3', "6.72 × (EBIT/TA)", 'green'),
            ('d_part4', "1.05 × (MktCap/TL)", 'red'),
        ]
        double_zones = {
            'distress': 1.1,
            'gray_lower': 1.1,
            'gray_upper': 2.6,
            'safe': 2.6
        }
        plot_zscore_figure(
            df=z_df,
            date_col='date',
            partial_cols=['d_part1','d_part2','d_part3','d_part4'],
            total_col='z_double_prime',
            partial_names=double_partial_names,
            total_name="Z'' (Total)",
            title_text="Z'' (1993, Non-Manufacturing)",
            zones=double_zones,
            ticker=ticker
        )

        with st.expander("Interpretation", expanded=False):
            latest_z_double = z_df['z_double_prime'].iloc[-1]
            first_val = z_df['z_double_prime'].iloc[0]
            if latest_z_double > first_val:
                trend_d = "increased"
            elif latest_z_double < first_val:
                trend_d = "decreased"
            else:
                trend_d = "remained the same"

            min_val_d = z_df['z_double_prime'].min()
            max_val_d = z_df['z_double_prime'].max()
            min_idx_d = z_df['z_double_prime'].idxmin()
            max_idx_d = z_df['z_double_prime'].idxmax()
            min_year_d = z_df.loc[min_idx_d, 'date'].year
            max_year_d = z_df.loc[max_idx_d, 'date'].year

            st.write("**--- Interpretation for Z'' (Non-Manufacturing) ---**")
            st.write(f"Over the chosen period, the Z-Score has {trend_d}.")
            st.write(f"Lowest: {min_val_d:.2f} in {min_year_d}.")
            st.write(f"Highest: {max_val_d:.2f} in {max_year_d}.")

            if latest_z_double < double_zones['distress']:
                st.write("Current reading is in distress zone. Financial risk is elevated.")
            elif latest_z_double < double_zones['gray_upper']:
                st.write("Current reading is in the gray zone. Financial signals are not clear.")
            else:
                st.write("Current reading is in the safe zone. Financial picture seems stable.")

            latest_data_double = z_df.iloc[-1]
            double_partials = {
                'd_part1': latest_data_double['d_part1'],
                'd_part2': latest_data_double['d_part2'],
                'd_part3': latest_data_double['d_part3'],
                'd_part4': latest_data_double['d_part4']
            }
            key_driver_double = max(double_partials, key=double_partials.get)

            if key_driver_double == 'd_part1':
                st.write("The key factor is Working Capital. This measures the company’s ability to cover short-term liabilities with current assets.")
                st.write("A strong working capital contribution means the company has a healthy liquidity buffer, reducing short-term financial risk.")
                st.write("However, excessive working capital can signal inefficient capital deployment, where too much cash is tied up in receivables or inventory.")
            elif key_driver_double == 'd_part2':
                st.write("The key factor is Retained Earnings. This represents accumulated profits that have been reinvested rather than distributed as dividends.")
                st.write("A high retained earnings contribution suggests financial discipline and the ability to self-finance operations, reducing reliance on external funding.")
                st.write("However, if retained earnings are excessive, investors may question whether the company is efficiently reinvesting in growth opportunities or hoarding cash.")
            elif key_driver_double == 'd_part3':
                st.write("The key factor is EBIT (Earnings Before Interest and Taxes). This highlights the strength of the company’s core operations in driving profitability.")
                st.write("A high EBIT contribution is a strong indicator of financial health, as it suggests the company generates consistent earnings before financing costs.")
                st.write("However, if EBIT is the dominant driver, the company may be vulnerable to economic downturns or market shifts that impact its ability to sustain margins.")
            elif key_driver_double == 'd_part4':
                st.write("The key factor is Market Cap vs. Liabilities. This shows how the market values the company relative to its total debt obligations.")
                st.write("A strong contribution from this metric suggests investor confidence in the company’s financial future, lowering perceived bankruptcy risk.")
                st.write("However, if market sentiment is the main driver, the company could be vulnerable to stock price fluctuations rather than underlying business fundamentals.")

            st.write("To decrease this score, raising debt or reducing EBIT can cause the drop.")
            st.write("An increase in liabilities often pulls down the ratio.")

        # Z'''
        #st.subheader("Z''' (2023, Service/Tech)")
        
        with st.expander("Methodology: Z''' (2023, Service/Tech)", expanded=False):
            st.write("The **Z'''-Score (2023)** is a further refinement of the Altman Z models, designed to assess financial distress in **modern service and technology firms**. This version accounts for the **intangible asset-heavy nature** of these companies, where traditional balance sheet metrics may not fully capture financial health.")

            # Formula
            st.latex(r"Z''' = 3.25 \times X_1 + 2.85 \times X_2 + 4.15 \times X_3 + 0.95 \times X_4")

            # Definitions of variables
            st.latex(r"X_1 = \frac{\text{Working Capital}}{\text{Total Assets}}")
            st.write("**Liquidity (X₁)**: Measures short-term financial flexibility. A strong working capital position helps firms cover immediate liabilities.")

            st.latex(r"X_2 = \frac{\text{Retained Earnings}}{\text{Total Assets}}")
            st.write("**Accumulated Profitability (X₂)**: Indicates the extent to which a firm’s assets are funded by retained earnings rather than external debt or equity.")

            st.latex(r"X_3 = \frac{\text{EBIT}}{\text{Total Assets}}")
            st.write("**Core Earnings Strength (X₃)**: Measures profitability before interest and taxes, reflecting operational efficiency.")

            st.latex(r"X_4 = \frac{\text{Market Value of Equity}}{\text{Total Liabilities}}")
            st.write("**Market Confidence (X₄)**: Assesses how the market values the firm relative to its total liabilities. Higher values suggest lower financial risk.")

            # Academic Justification
            st.write("##### Academic Justification")
            st.write(
                "Unlike traditional manufacturing firms, **service and tech firms rely heavily on intangible assets** (e.g., software, R&D, brand equity), "
                "which are often not reflected on the balance sheet. **Z''' (2023) adjusts for this** by rebalancing weightings to better account for profitability "
                "and market valuation. It provides a more relevant measure for industries where physical assets play a reduced role in financial stability."
            )

            # Interpretation
            st.write("##### Interpretation")
            st.write(
                "**Z''' > 2.90**: Firm is financially stable, with a low probability of distress.  \n"
                "**1.50 ≤ Z''' ≤ 2.90**: 'Gray Area'—financial condition is uncertain.  \n"
                "**Z''' < 1.50**: Firm is in financial distress, with an elevated bankruptcy risk."
            )

            # Downsides / Limitations
            st.write("##### Limitations")
            st.write(
                "- Developed for **service and tech firms**, but may not generalize well to capital-intensive industries.\n"
                "- **Still based on historical financial data**, which may lag behind real-time market shifts.\n"
                "- Market value component (X₄) **introduces volatility**, making results sensitive to stock price swings.\n"
                "- Does not explicitly factor in **R&D investment or future revenue potential**, which are key in tech sectors."
            )

        
        triple_partial_names = [
            ('t_part1', "3.25 × (WC/TA)", 'blue'),
            ('t_part2', "2.85 × (RE/TA)", 'orange'),
            ('t_part3', "4.15 × (EBIT/TA)", 'green'),
            ('t_part4', "0.95 × (MktCap/TL)", 'red'),
        ]
        triple_zones = {
            'distress': 1.5,
            'gray_lower': 1.5,
            'gray_upper': 2.9,
            'safe': 2.9
        }
        plot_zscore_figure(
            df=z_df,
            date_col='date',
            partial_cols=['t_part1','t_part2','t_part3','t_part4'],
            total_col='z_triple_prime_service',
            partial_names=triple_partial_names,
            total_name="Z''' (Total)",
            title_text="Z''' (2023, Service/Tech)",
            zones=triple_zones,
            ticker=ticker
        )
       
        with st.expander("Interpretation", expanded=False):
            latest_z_triple = z_df['z_triple_prime_service'].iloc[-1]
            first_val_t = z_df['z_triple_prime_service'].iloc[0]
            if latest_z_triple > first_val_t:
                trend_t = "increased"
            elif latest_z_triple < first_val_t:
                trend_t = "decreased"
            else:
                trend_t = "remained the same"

            min_val_t = z_df['z_triple_prime_service'].min()
            max_val_t = z_df['z_triple_prime_service'].max()
            min_idx_t = z_df['z_triple_prime_service'].idxmin()
            max_idx_t = z_df['z_triple_prime_service'].idxmax()
            min_year_t = z_df.loc[min_idx_t, 'date'].year
            max_year_t = z_df.loc[max_idx_t, 'date'].year

            st.write("**--- Interpretation for Z''' (Service/Tech) ---**")
            st.write(f"Across the selected years, this Z-Score has {trend_t}.")
            st.write(f"Minimum was {min_val_t:.2f} in {min_year_t}.")
            st.write(f"Maximum was {max_val_t:.2f} in {max_year_t}.")

            if latest_z_triple < triple_zones['distress']:
                st.write("Current reading is in the distress zone. This indicates possible financial strain.")
            elif latest_z_triple < triple_zones['gray_upper']:
                st.write("Current reading is in the gray range. This means uncertain financial signals.")
            else:
                st.write("Current reading is in the safe zone. Financial health looks positive.")

            latest_data_triple = z_df.iloc[-1]
            triple_partials = {
                't_part1': latest_data_triple['t_part1'],
                't_part2': latest_data_triple['t_part2'],
                't_part3': latest_data_triple['t_part3'],
                't_part4': latest_data_triple['t_part4']
            }
            key_driver_triple = max(triple_partials, key=triple_partials.get)
            if key_driver_triple == 't_part1':
                st.write("Working Capital stands out as the main influence, emphasizing the company's short-term financial flexibility.")
                st.write("A strong working capital contribution indicates a well-managed balance between current assets and liabilities, reducing liquidity risk.")
                st.write("However, if too much capital is tied up in cash or inventory, it may suggest inefficiency in deploying assets for growth.")
            elif key_driver_triple == 't_part2':
                st.write("Retained Earnings plays the biggest role, highlighting the company's ability to reinvest past profits into future growth.")
                st.write("A high retained earnings contribution suggests the company has a history of profitability and financial discipline, reducing reliance on external financing.")
                st.write("However, if retained earnings dominate, it raises questions about whether capital is allocated effectively.")
            elif key_driver_triple == 't_part3':
                st.write("EBIT is the dominant factor, meaning the company’s operational efficiency is the primary driver of financial stability.")
                st.write("A strong EBIT contribution indicates that core business activities are profitable. This supports the firm's financial health.")
                st.write("But if EBIT is the largest driver, the company may be heavily dependent on margins, making it vulnerable to cost pressures.")
            elif key_driver_triple == 't_part4':
                st.write("Market Cap vs. Liabilities leads, suggesting that investor confidence and market valuation are key drivers of financial stability.")
                st.write("A high contribution from this metric means the company’s equity is valued significantly higher than its liabilities.")
                st.write("Reliance on market sentiment can expose the firm to stock price volatility.")

            st.write("If the goal is to reduce this Z-Score, rising debt or shrinking EBIT will push it downward.")
            st.write("Lower liquidity or lower equity value can also move the score lower.")

        # Show raw data
        with st.expander("Raw Altman Z Data", expanded=False):
            st.dataframe(z_df)

###############################################################################
# PAGE 2: DISTANCE TO DEFAULT
###############################################################################
if page == "Distance-to-Default":

    dtd_df = st.session_state.get("dtd_results", None)
    if dtd_df is None or dtd_df.empty:
        st.info("Select Page, input the paramters and click 'Run Analysis' on the sidebar.")
    else:
        valid_df = dtd_df.dropna(subset=["chosenDebt", "A_star", "sigmaA_star", "DTD"])
        if valid_df.empty:
            st.warning("No valid rows for Merton calculations in the chosen range.")
        else:
            with st.expander("Methodology: Merton Distance-to-Default (DTD)", expanded=False):
                st.write(
                    "The **Distance-to-Default (DTD)** is a structural credit risk model based on Merton's (1974) option pricing theory. "
                    "It estimates the likelihood that a firm's asset value will fall below its debt obligations, triggering default."
                )

                # Merton Model Core Equations
                st.latex(r"V_t = S_t + D_t")
                st.write("**Firm Value (Vₜ)**: The total market value of the firm, consisting of equity (Sₜ) and debt (Dₜ).")

                st.latex(r"\sigma_V = \frac{S_t}{V_t} \sigma_S")
                st.write("**Asset Volatility (σ_V)**: Derived from the observed equity volatility (σ_S), using the Merton model.")

                st.latex(r"d_1 = \frac{\ln{\left(\frac{V_t}{D_t}\right)} + \left( r - \frac{1}{2} \sigma_V^2 \right)T}{\sigma_V \sqrt{T}}")
                st.latex(r"d_2 = d_1 - \sigma_V \sqrt{T}")
                st.write("**Merton's d₁ and d₂**: Standardized metrics capturing the firm's asset dynamics relative to debt.")

                st.latex(r"\text{DTD} = d_2 = \frac{\ln{\left(\frac{V_t}{D_t}\right)} + \left( r - \frac{1}{2} \sigma_V^2 \right)T}{\sigma_V \sqrt{T}}")
                st.write("**Distance-to-Default (DTD)**: Measures how many standard deviations the firm's asset value is from the default threshold (Dₜ).")

                # Academic Justification
                st.write("##### Academic Justification")
                st.write(
                    "Merton's model treats a firm's equity as a **call option** on its assets, where default occurs if asset value (Vₜ) "
                    "falls below debt (Dₜ) at time T. **DTD quantifies this probability** by measuring how far the firm is from this threshold, "
                    "adjusting for volatility. Studies show that **lower DTD values correlate with higher default probabilities**, making it "
                    "a key metric for credit risk analysis in corporate finance and banking."
                )

                # Interpretation
                st.write("##### Interpretation")
                st.write(
                    "**DTD > 2.0**: Low probability of default (strong financial health).  \n"
                    "**1.0 ≤ DTD ≤ 2.0**: Moderate risk—firm is financially stable but should be monitored.  \n"
                    "**DTD < 1.0**: High default risk—firm is approaching financial distress.  \n"
                    "**DTD < 0.0**: Extreme risk—firm’s asset value is below its debt obligations."
                )

                # Downsides / Limitations
                st.write("##### Limitations")
                st.write(
                    "- **Assumes market efficiency**, meaning it relies heavily on accurate stock price movements.\n"
                    "- **Volatility estimates impact accuracy**, as market fluctuations can distort results.\n"
                    "- **Ignores liquidity constraints**—a firm may default due to cash flow problems, even if assets exceed liabilities.\n"
                    "- **Not designed for financial institutions**, where leverage and risk dynamics differ significantly.\n"
                    "- **Short-term focused**, making it less predictive for long-term financial health."
                )
            
            #st.subheader("Annual Distance to Default (Merton Model)")

            # Chart 1
            fig_time = go.Figure()
            fig_time.add_trace(
                go.Scatter(
                    x=dtd_df["year"],
                    y=dtd_df["DTD"],
                    mode="lines+markers",
                    name="Distance to Default"
                )
            )
            fig_time.update_layout(
                title=f"{ticker} Annual Distance to Default (Merton Model)",
                title_font=dict(size=26, color="white"),
                xaxis_title="Year",
                yaxis_title="Distance to Default (d2)",
                template="plotly_dark",
                paper_bgcolor="#0e1117",
                plot_bgcolor="#0e1117",
                xaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                ),
                yaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                )
            )
            st.plotly_chart(fig_time, use_container_width=True)

            # --- Dynamic Interpretation for Chart 1 (Exact user code) ---
            with st.expander("Interpretation", expanded=False):
                dtd_series = dtd_df["DTD"].dropna()
                if len(dtd_series) > 1:
                    first_val = dtd_series.iloc[0]
                    last_val = dtd_series.iloc[-1]
                    trend_str = "increased" if last_val > first_val else "decreased" if last_val < first_val else "remained stable"
                    min_val = dtd_series.min()
                    max_val = dtd_series.max()
                    min_yr = dtd_df.loc[dtd_series.idxmin(), "year"]
                    max_yr = dtd_df.loc[dtd_series.idxmax(), "year"]

                    st.write("Dynamic Interpretation for Annual Distance to Default:")
                    st.write(f"**1) The time series shows that DTD has {trend_str} from {first_val:.2f} to {last_val:.2f}.**")
                    st.write(f"**2) The lowest DTD was {min_val:.2f} in {min_yr}, and the highest was {max_val:.2f} in {max_yr}.**")
                    if last_val < 0:
                        st.write("   Current DTD is negative. The firm may be in distress territory, implying higher default risk.")
                    elif last_val < 1:
                        st.write("   Current DTD is below 1. This suggests caution, as default risk is higher than comfortable.")
                    elif last_val < 2:
                        st.write("   Current DTD is between 1 and 2. This is moderate territory. Risk is not extreme but warrants monitoring.")
                    else:
                        st.write("   Current DTD is above 2. This generally indicates safer conditions and lower default probability.")
                else:
                    st.write("DTD time series is insufficient for a dynamic interpretation.")

            # Chart 2: Distribution
            #st.subheader("Distribution of Simulated Distance-to-Default")
            latest_data = valid_df.iloc[-1]
            A_star = latest_data["A_star"]
            sigmaA_star = latest_data["sigmaA_star"]
            D = latest_data["chosenDebt"]
            r = latest_data["rf"]
            T = 1.0
            dtd_value = latest_data["DTD"]

            num_simulations = 10000
            A_simulated = np.random.normal(A_star, sigmaA_star * A_star, num_simulations)
            A_simulated = np.where(A_simulated > 0, A_simulated, np.nan)
            DTD_simulated = (np.log(A_simulated / D) + (r - 0.5 * sigmaA_star**2) * T) / (sigmaA_star * np.sqrt(T))
            DTD_simulated = DTD_simulated[~np.isnan(DTD_simulated)]

            fig_hist = ff.create_distplot(
                [DTD_simulated],
                ["Simulated DTD"],
                show_hist=True,
                show_rug=False,
                curve_type='kde'
            )
            fig_hist.add_vline(
                x=dtd_value,
                line=dict(color="red", dash="dash"),
                annotation_text=f"Actual DTD = {dtd_value:.2f}"
            )
            fig_hist.update_layout(
                title=f"{ticker} Distribution of Simulated Distance-to-Default (DTD)",
                title_font=dict(size=26, color="white"),
                xaxis_title="Distance-to-Default (DTD)",
                yaxis_title="Frequency",
                template="plotly_dark",
                paper_bgcolor="#0e1117",
                plot_bgcolor="#0e1117",
                xaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                ),
                yaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                )
            )
            st.plotly_chart(fig_hist, use_container_width=True)

            # --- Dynamic Interpretation for Chart 2 (Exact user code) ---
            with st.expander("Interpretation", expanded=False):
                mean_sim = np.mean(DTD_simulated)
                median_sim = np.median(DTD_simulated)
                st.write("\n--- Dynamic Interpretation for DTD Distribution ---")
                st.write(f"**1) The mean simulated Distance-to-Default (DTD) is {mean_sim:.2f}, while the median is {median_sim:.2f}.**")
                if mean_sim < 0:
                    st.write("   On average, the simulations suggest the firm is in distress. A negative mean DTD implies that, in many scenarios, asset value falls below debt obligations.")
                    st.write("   This significantly raises default risk, indicating a high probability of financial distress under typical market conditions.")
                elif mean_sim < 1:
                    st.write("   A large portion of simulations yield a DTD below 1, signaling heightened risk. The firm’s financial cushion against default is thin.")
                    st.write("   Companies in this range often face higher borrowing costs and investor skepticism, as they are perceived as more vulnerable to downturns.")
                elif mean_sim < 2:
                    st.write("   The majority of simulations fall between 1 and 2, meaning the firm is not in immediate danger but isn’t fully secure either.")
                    st.write("   This suggests moderate financial health. While not at crisis levels, management should remain cautious about leverage and volatility.")
                else:
                    st.write("   The distribution is mostly above 2, implying that, under most scenarios, the firm maintains a strong buffer against default.")
                    st.write("   Companies in this range generally enjoy greater financial stability, better credit ratings, and lower risk premiums.")

                if dtd_value < mean_sim:
                    st.write(f"**2) The actual DTD ({dtd_value:.2f}) is below the simulation average ({mean_sim:.2f}).**")
                    st.write("   This suggests that the real-world financial position of the company is weaker than the average simulated outcome.")
                    st.write("   It may imply that recent market conditions or company-specific factors have increased risk beyond what the model predicts.")
                    st.write("   Management might need to reinforce liquidity or reassess capital structure to avoid sliding into higher-risk territory.")
                else:
                    st.write(f"2) The actual DTD ({dtd_value:.2f}) is above the simulation average ({mean_sim:.2f}).")
                    st.write("   This is a positive signal, suggesting that real-world financial conditions are better than the typical simulated scenario.")
                    st.write("   The firm may have a stronger-than-expected balance sheet or be benefiting from favorable market conditions.")
                    st.write("   While this is reassuring, it is important to monitor whether this stability is due to structural financial strength or short-term market factors.")

            # Chart 3: Sensitivity of DTD to Asset Value
            #st.subheader("Sensitivity of DTD to Asset Value")
            asset_range = np.linspace(D, 1.1 * A_star, 200)
            dtd_asset = (np.log(asset_range / D) + (r - 0.5 * sigmaA_star**2) * T) / (sigmaA_star * np.sqrt(T))

            fig_asset = go.Figure()
            fig_asset.add_trace(
                go.Scatter(
                    x=asset_range,
                    y=dtd_asset,
                    mode='lines',
                    name="DTD vs. Asset Value",
                    line=dict(color="blue")
                )
            )
            fig_asset.add_vline(
                x=A_star,
                line=dict(color="red", dash="dash"),
                annotation_text=f"Estimated A = {A_star:,.2f}"
            )
            fig_asset.update_layout(
                title=f"{ticker} Sensitivity of DTD to Variation in Asset Value",
                title_font=dict(size=26, color="white"),
                xaxis_title="Asset Value (A)",
                yaxis_title="Distance-to-Default (d2)",
                xaxis_type="log",
                template="plotly_dark",
                paper_bgcolor="#0e1117",
                plot_bgcolor="#0e1117",
                xaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                ),
                yaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                )
            )
            st.plotly_chart(fig_asset, use_container_width=True)

            # --- Dynamic Interpretation for Chart 3 (Exact user code) ---
            with st.expander("Interpretation", expanded=False):
                dtd_lowA = dtd_asset[0]
                dtd_highA = dtd_asset[-1]
                st.write("\nDynamic Interpretation for Asset Value Sensitivity:")
                st.write(f"**1) At the lower bound (A = {asset_range[0]:,.2f}), DTD is {dtd_lowA:.2f}.**")
                st.write(f"**2) At the higher bound (A = {asset_range[-1]:,.2f}), DTD rises to {dtd_highA:.2f}.**")
                if dtd_highA > 2:
                    st.write("   If asset value grows, the firm gains a comfortable buffer against default.")
                else:
                    st.write("   Even at higher asset values, default risk remains moderate. Growth alone may not guarantee safety.")

            # Chart 4: Sensitivity of DTD to Debt Variation
            #st.subheader("Sensitivity of DTD to Debt Variation")
            debt_range = np.linspace(0.1 * D, 1.2 * A_star, 300)
            dtd_debt = (np.log(A_star / debt_range) + (r - 0.5 * sigmaA_star**2) * T) / (sigmaA_star * np.sqrt(T))

            fig_debt = go.Figure()
            fig_debt.add_trace(
                go.Scatter(
                    x=debt_range,
                    y=dtd_debt,
                    mode='lines',
                    name="DTD vs. Debt",
                    line=dict(color="green")
                )
            )
            fig_debt.add_vline(
                x=D,
                line=dict(color="red", dash="dash"),
                annotation_text=f"Estimated D = {D:,.2f}"
            )
            fig_debt.update_layout(
                title=f"{ticker} Sensitivity of DTD to Variation in Debt (Extended Range)",
                title_font=dict(size=26, color="white"),
                xaxis_title="Debt (D)",
                yaxis_title="Distance-to-Default (d2)",
                xaxis_type="log",
                template="plotly_dark",
                paper_bgcolor="#0e1117",
                plot_bgcolor="#0e1117",
                xaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                ),
                yaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                )
            )
            st.plotly_chart(fig_debt, use_container_width=True)

            # --- Dynamic Interpretation for Chart 4 (Exact user code) ---
            with st.expander("Interpretation", expanded=False):
                dtd_lowD = dtd_debt[0]
                dtd_highD = dtd_debt[-1]
                st.write("\n--- Dynamic Interpretation for Debt Variation ---")
                st.write(f"**1) At lower debt levels (D ≈ {debt_range[0]:,.2f}), the estimated Distance-to-Default (DTD) is {dtd_lowD:.2f}.**")
                st.write(f"**2) At higher debt levels (D ≈ {debt_range[-1]:,.2f}), the estimated DTD drops to {dtd_highD:.2f}.**")

                if dtd_lowD > 2:
                    st.write("   With lower debt, the firm has a strong financial cushion. A DTD above 2 typically indicates low default risk.")
                    st.write("   This suggests the company could sustain economic downturns or earnings declines without significantly increasing its probability of distress.")
                    st.write("   In this range, the firm may enjoy better credit ratings, lower borrowing costs, and greater investor confidence.")
                elif 1 < dtd_lowD <= 2:
                    st.write("   Even with reduced debt, the firm remains in a moderate risk zone. While the probability of default is not alarming, it isn't fully secure.")
                    st.write("   This suggests that other financial pressures—such as earnings volatility or low asset returns—might be limiting the risk buffer.")
                    st.write("   Maintaining a balanced capital structure with prudent debt management will be key to ensuring financial stability.")
                else:
                    st.write("   Despite lowering debt, the firm remains in a high-risk category. This indicates that other financial weaknesses, such as low asset returns or high volatility, are still dominant.")
                    st.write("   The company may need a more aggressive strategy to strengthen its financial position, such as improving earnings stability or reducing operational risks.")

                if dtd_highD < 0:
                    st.write("   At significantly higher debt levels, the model suggests a **negative DTD**, which signals extreme financial distress.")
                    st.write("   This implies that, under this scenario, the company's total asset value would likely fall below its debt obligations.")
                    st.write("   If this situation were to materialize, the company would be seen as highly vulnerable, potentially leading to credit downgrades or refinancing difficulties.")
                elif 0 <= dtd_highD < 1:
                    st.write("   With higher debt, DTD drops to below 1, meaning the firm is dangerously close to default.")
                    st.write("   A DTD below 1 indicates that even small negative shocks to asset value could push the firm into financial distress.")
                    st.write("   This could lead to increased borrowing costs, investor concerns, and potential restrictions on raising further capital.")
                elif 1 <= dtd_highD < 2:
                    st.write("   The firm’s risk profile worsens with higher debt, but it remains in the moderate zone. The probability of distress increases but is not immediately alarming.")
                    st.write("   Companies in this range often need to manage debt maturities carefully and ensure steady cash flow generation to avoid further deterioration.")
                else:
                    st.write("   Even at a higher debt level, the firm maintains a strong buffer (DTD > 2).")
                    st.write("   This suggests the company has **enough asset value or earnings strength to comfortably manage the additional leverage**.")
                    st.write("   However, increasing debt too aggressively, even in a safe zone, could reduce financial flexibility in downturns.")

            # Chart 5: Asset Value vs. Debt
            #st.subheader("Asset Value vs. Default Point (Debt)")
            fig_bar = go.Figure()
            fig_bar.add_trace(
                go.Bar(
                    x=["Asset Value (A)", "Debt (D)"],
                    y=[A_star, D],
                    marker=dict(color=["blue", "orange"])
                )
            )
            fig_bar.update_layout(
                title=f"{ticker} Asset Value vs. Default Point",
                title_font=dict(size=26, color="white"),
                yaxis_title="Value (USD)",
                template="plotly_dark",
                paper_bgcolor="#0e1117",
                plot_bgcolor="#0e1117",
                xaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                ),
                yaxis=dict(
                    showgrid=True,
                    gridcolor="rgba(255, 255, 255, 0.1)"
                )
            )
            st.plotly_chart(fig_bar, use_container_width=True)

            # --- Dynamic Interpretation for Chart 5 (Exact user code) ---
            with st.expander("Interpretation", expanded=False):
                st.write("\n--- Dynamic Interpretation for Asset Value vs. Debt ---")
                if A_star > D:
                    st.write(f"**1) The estimated asset value ({A_star:,.2f}) exceeds total debt ({D:,.2f}), providing a financial buffer.**")
                    asset_debt_ratio = A_star / D
                    if asset_debt_ratio > 2:
                        st.write("   The asset-to-debt ratio is above 2, meaning the firm holds **more than double the assets compared to its debt obligations**.")
                        st.write("   This implies a highly secure financial position, with a strong ability to absorb economic downturns or revenue declines.")
                    elif 1.5 <= asset_debt_ratio <= 2:
                        st.write("   The asset-to-debt ratio is between 1.5 and 2, which is considered **moderately strong**.")
                        st.write("   While there is a solid financial cushion, **prudent debt management is still necessary** to maintain stability.")
                    else:
                        st.write("   The asset-to-debt ratio is between 1 and 1.5, meaning the firm has a **narrower but still positive buffer.**")
                        st.write("   This level is acceptable, but **a small decline in asset value could quickly increase financial risk.**")
                else:
                    st.write(f"1) The estimated asset value ({A_star:,.2f}) is **less than or close to total debt** ({D:,.2f}).")
                    st.write("   This signals **a limited financial cushion**, increasing the probability of distress in unfavorable conditions.")
                    if A_star < D:
                        st.write("   **Warning:** The company’s total assets are lower than its total debt.")
                        st.write("   This implies that if the company were to liquidate its assets today, it would still **not be able to fully cover its obligations**.")
                        st.write("   Such a position increases the likelihood of credit downgrades and difficulty in securing additional financing.")
                    elif A_star / D < 1.1:
                        st.write("   The asset buffer is extremely thin. A minor shock in earnings or asset valuation could put the firm in distress.")
                        st.write("   The company should consider **reducing leverage or improving asset utilization** to reinforce financial stability.")

                gap = A_star - D
                if gap > 0.5 * D:
                    st.write("**2) The firm has a **comfortable margin** between assets and debt. Even with some decline in asset value, financial stability is not immediately at risk.**")
                elif 0.2 * D < gap <= 0.5 * D:
                    st.write("2) The firm has **a moderate cushion**, but there is some vulnerability to financial shocks.")
                    st.write("   If debt levels increase or asset values decline, risk could rise quickly.")
                else:
                    st.write("2) The asset buffer is **very narrow**, making the firm susceptible to external risks such as declining revenues, rising interest rates, or asset write-downs.")
                    st.write("   A **small misstep in financial strategy could significantly increase default probability.**")

        with st.expander("Raw Distance-to-Default Data", expanded=False):
            st.dataframe(dtd_df)


# Hide default Streamlit style
st.markdown(
    """
    <style>
    #MainMenu {visibility: hidden;}
    footer {visibility: hidden;}
    </style>
    """,
    unsafe_allow_html=True
)