# Extract debt from balance sheet with multiple methods
def get_debt_from_balance_sheet(balance_sheet, info, method="STplusHalfLT", fallback=1e6):
    """
    Fetches debt based on the selected method.

    Methods:
      "TOTAL"       -> Uses the 'Total Debt' value from the balance sheet.
      "STplusHalfLT" -> Short-term debt + 0.5 * long-term debt (default).
      "STplusLT"    -> Short-term debt + long-term debt.

    If debt data is unavailable, falls back to info["totalDebt"] or a predefined fallback value.

    Inputs:
      balance_sheet = DataFrame containing balance sheet data.
      info          = Dictionary with company metadata.
      method        = Debt extraction method.
      fallback      = Default debt value if no valid data is found.

    Returns:
      debt_val = Computed debt amount.
    """

    debt_val = None
    short_debt = 0.0
    long_debt = 0.0
    total_debt = 0.0

    # Extract short-term debt
    try:
        short_debt = balance_sheet.loc["Short Term Debt"][0]
        if not np.isfinite(short_debt) or short_debt < 0:
            short_debt = 0.0
    except:
        pass

    # Extract long-term debt
    try:
        long_debt = balance_sheet.loc["Long Term Debt"][0]
        if not np.isfinite(long_debt) or long_debt < 0:
            long_debt = 0.0
    except:
        pass

    # Extract total debt
    try:
        total_debt = balance_sheet.loc["Total Debt"][0]
        if not np.isfinite(total_debt) or total_debt < 0:
            total_debt = 0.0
    except:
        pass

    # If all values are missing, fallback to info["totalDebt"]
    if short_debt == 0.0 and long_debt == 0.0 and total_debt == 0.0:
        fallback_debt = info.get("totalDebt", 0)
        if fallback_debt is not None and fallback_debt > 0:
            total_debt = fallback_debt

    # Compute debt based on the selected method
    if method.upper() == "TOTAL":
        debt_val = total_debt
    elif method.upper() == "STPLUSLT":
        debt_val = short_debt + long_debt
    else:  # Default or "STplusHalfLT"
        debt_val = short_debt + 0.5 * long_debt

    # Final check to ensure a valid debt value
    if debt_val is None or debt_val <= 0:
        debt_val = fallback

    return debt_val

ticker_symbol = "AAPL"  # Change this to analyze a different stock

# Model Parameters
T = 1.0           # Time horizon in years
r = 0.04          # Risk-free interest rate (annual)
debt_method = "STplusHalfLT"  # Options: "TOTAL", "STplusHalfLT", "STplusLT"
debt_factor = 1.0  # Scaling factor applied to debt. Higher factor = lower DTD (higher default risk)

# Volatility Calculation
historical_period = "1y"  # Period used to compute equity volatility (e.g. "1y", "2y", "6mo")
annualization_factor = 252  # Annualization factor for daily stock returns

# Fetch market data for the selected stock
ticker = yf.Ticker(ticker_symbol)
info = ticker.info

# Get stock price
share_price = info.get("regularMarketPrice", None)
if share_price is None:
    raise ValueError("Market price not available.")

# Get total shares outstanding
shares_out = info.get("sharesOutstanding", 0)
if shares_out <= 0:
    raise ValueError("Shares outstanding missing or invalid.")

# Compute total equity market value
E = share_price * shares_out  # Market capitalization

# Fetch historical stock prices
hist = ticker.history(period=historical_period).dropna(subset=["Close"])
close_prices = hist["Close"].values

# Compute log returns and annualized equity volatility
log_returns = np.log(close_prices[1:] / close_prices[:-1])
sigma_E = np.std(log_returns) * np.sqrt(annualization_factor)

# Fetch debt from balance sheet
balance_sheet = ticker.balance_sheet
raw_debt = get_debt_from_balance_sheet(
    balance_sheet=balance_sheet,
    info=info,
    method=debt_method,
    fallback=1e6  # Default value if no valid debt data is found
)
D = raw_debt * debt_factor

# Solve for Asset Value (A) and Asset Volatility (sigma_A) using Merton Model
def solve_merton(E, sigma_E, D, T, r):
    """
    Solve for (A, sigma_A) using the Merton Model.

    Inputs:
      E        = Market value of equity (USD)
      sigma_E  = Equity volatility
      D        = Debt level (Default point)
      T        = Time horizon in years
      r        = Risk-free interest rate (annual)

    Returns:
      (A, sigma_A) = Estimated asset value and asset volatility
    """

    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)

        # Equation 1: Equity as a call option on firm assets
        eq1 = A_ * norm.cdf(d1_) - D * np.exp(-r*T) * norm.cdf(d2_) - E

        # Equation 2: Relationship between equity and asset volatility
        eq2 = sigma_E - (A_/E) * norm.cdf(d1_) * sigmaA_

        return (eq1, eq2)

    # Initial guesses for A and sigma_A
    A_guess = E + D  # Initial estimate of asset value
    sigmaA_guess = sigma_E * (E / (E + D))  # Approximate initial asset volatility

    # Solve the nonlinear system of equations
    A_star, sigmaA_star = fsolve(equations, x0=[A_guess, sigmaA_guess], maxfev=2000)

    return A_star, sigmaA_star

# Solve Merton Model equations to estimate Asset Value (A) and Asset Volatility (σ_A)
A_star, sigmaA_star = solve_merton(E=E, sigma_E=sigma_E, D=D, T=T, r=r)

# Compute Distance to Default
def distance_to_default(A, D, T, r, sigmaA):
    """
    Compute the Distance to Default.

    Formula:
      d2 = [ln(A/D) + (r - 0.5 * sigmaA^2) * T] / [sigmaA * sqrt(T)]

    Inputs:
      A      = Estimated asset value
      D      = Default point (debt level)
      T      = Time horizon in years
      r      = Risk-free interest rate (annual)
      sigmaA = Estimated asset volatility

    Returns:
      d2 (Distance to Default)
    """
    return (np.log(A / D) + (r - 0.5 * sigmaA**2) * T) / (sigmaA * np.sqrt(T))

# Compute Distance to Default
dtd_value = distance_to_default(A_star, D, T, r, sigmaA_star)

# Display results
print("============================================================")
print(f" Ticker: {ticker_symbol}")
print(f" Horizon (T): {T} years")
print(f" Risk-free rate (r): {r:.2%}")
print(f" Debt method: {debt_method}, factor={debt_factor}")
print(f" Historical period for volatility: {historical_period}")
print(f" Annualization factor: {annualization_factor}")
print("------------------------------------------------------------")
print(f" Share Price: ${share_price:,.2f}")
print(f" Shares Outstanding: {shares_out:,.0f}")
print(f" Total Equity Market Value (E): ${E:,.2f}")
print(f" Equity Volatility (σ_E): {sigma_E:.4f}")
print(f" Debt (D): ${D:,.2f}")
print("------------------------------------------------------------")
print("SOLVED MERTON MODEL RESULTS:")
print(f"  Asset Value (A): ${A_star:,.2f}")
print(f"  Asset Volatility (σ_A): {sigmaA_star:.4f}")
print(f"  Distance-to-Default (d2): {dtd_value:.4f}")
print("============================================================")

============================================================
 Ticker: AAPL
 Horizon (T): 1.0 years
 Risk-free rate (r): 4.00%
 Debt method: STplusHalfLT, factor=1.0
 Historical period for volatility: 1y
 Annualization factor: 252
------------------------------------------------------------
 Share Price: $239.07
 Shares Outstanding: 15,022,100,480
 Total Equity Market Value (E): $3,591,333,561,753.60
 Equity Volatility (σ_E): 0.2377
 Debt (D): $42,875,000,000.00
------------------------------------------------------------
SOLVED MERTON MODEL RESULTS:
  Asset Value (A): $3,632,527,408,957.26
  Asset Volatility (σ_A): 0.2350
  Distance-to-Default (d2): 18.9404
============================================================

import matplotlib.pyplot as plt
import seaborn as sns

plt.style.use("dark_background")

# Number of simulations
num_simulations = 10000

# Simulate asset values assuming a normal distribution
A_simulated = np.random.normal(A_star, sigmaA_star * A_star, num_simulations)

# Ensure asset values remain positive to avoid invalid log(A/D)
A_simulated = np.where(A_simulated > 0, A_simulated, np.nan)

# Compute simulated DTD values, ensuring no NaNs
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)]  # Remove NaNs

# Plot histogram of simulated DTD values
plt.figure(figsize=(25, 6))
sns.histplot(DTD_simulated, bins=50, kde=True, color="cyan", alpha=0.7)

# Add vertical line for actual computed DTD
plt.axvline(x=dtd_value, color="red", linestyle="dashed", linewidth=2, label=f"Actual DTD = {dtd_value:.2f}")

# Labels and title
plt.title("Distribution of Simulated Distance-to-Default", fontsize=14)
plt.xlabel("Distance-to-Default", fontsize=12)
plt.ylabel("Frequency", fontsize=12)
plt.legend()

# Show plot
plt.show()

import matplotlib.pyplot as plt

# Generate a range of asset values
asset_range = np.linspace(D, 1.1 * A_star, 200)

# Compute DTD for each asset value in the range
dtd_asset = (np.log(asset_range / D) + (r - 0.5 * sigmaA_star**2) * T) / (sigmaA_star * np.sqrt(T))

# Create a wider figure
plt.figure(figsize=(25, 6))  # Wider figure for better visualization

# Plot DTD vs. Asset Value
plt.plot(asset_range, dtd_asset, linestyle="-", color="cyan", linewidth=2, label="DTD vs. Asset Value")

# Mark the estimated asset value
plt.axvline(x=A_star, color="red", linestyle="dashed", linewidth=2, label=f"Estimated A = {A_star:,.2f}")

# Labels and title
plt.title("Sensitivity of Distance to Default to Asset Value", fontsize=14)
plt.xlabel("Asset Value (A)", fontsize=12)
plt.ylabel("Distance-to-Default", fontsize=12)
plt.xscale("log")  # Log scale for better visualization
plt.legend()

# Show grid for clarity
plt.grid(color="gray", linestyle="dotted", linewidth=0.5)

# Show plot
plt.show()

import matplotlib.pyplot as plt

# Generate a range of debt values
debt_range = np.linspace(0.1 * D, 1.2 * A_star, 300)

# Compute DTD for each debt value in the range
dtd_debt = (np.log(A_star / debt_range) + (r - 0.5 * sigmaA_star**2) * T) / (sigmaA_star * np.sqrt(T))

# Create a wider figure
plt.figure(figsize=(25, 6))  # Wider figure for better visualization

# Plot DTD vs. Debt Level
plt.plot(debt_range, dtd_debt, linestyle="-", color="lime", linewidth=2, label="DTD vs. Debt")

# Mark the estimated debt level
plt.axvline(x=D, color="red", linestyle="dashed", linewidth=2, label=f"Estimated D = {D:,.2f}")

# Labels and title
plt.title("Sensitivity of Distance to Default to Debt Level", fontsize=14)
plt.xlabel("Debt (D)", fontsize=12)
plt.ylabel("Distance-to-Default", fontsize=12)
plt.xscale("log")  # Log scale for better visualization
plt.legend()

# Show grid for clarity
plt.grid(color="gray", linestyle="dotted", linewidth=0.5)

# Show plot
plt.show()

# Define values for the bar chart
categories = ["Asset Value (A)", "Debt (D)"]
values = [A_star, D]
colors = ["cyan", "orange"]  # Custom colors for better contrast

# Create a wider figure
plt.figure(figsize=(25, 6))

# Plot bar chart
plt.bar(categories, values, color=colors, alpha=0.8)

# Labels and title
plt.title("Asset Value vs. Default Point (Debt)", fontsize=14)
plt.ylabel("Value (USD)", fontsize=12)

# Display values on bars
for i, v in enumerate(values):
    plt.text(i, v * 1.02, f"${v:,.2f}", color="white", fontsize=12, ha="center")

# Show grid for better readability
plt.grid(axis="y", color="gray", linestyle="dotted", linewidth=0.5)

# Show plot
plt.show()