# Common functions for Financial Risk Forecasting Notebook
# Functions are added as chapters are converted

import os
import pandas as pd
import numpy as np

EODH_TOKEN = os.environ.get("EODH_TOKEN", "demo")

def get_prices(symbol, exchange, token=None):
    from eodhd import APIClient
    if token is None:
        token = EODH_TOKEN
    api = APIClient(token)
    data = api.get_eod_historical_stock_market_data(
        symbol=f"{symbol}.{exchange}",
        period="d"
    )
    return pd.DataFrame(data)


def ProcessRawData():
    """Load and process S&P 500 and stock data.

    Returns a dictionary containing:
        - sp500: DataFrame with S&P 500 prices and log returns
        - sp500tr: DataFrame with S&P 500 total returns
        - Price: DataFrame with stock prices (wide format)
        - UnAdjustedPrice: DataFrame with unadjusted stock prices
        - Return: DataFrame with stock log returns
        - Ticker: List of ticker symbols
    """
    # Process S&P 500
    sp500 = pd.read_csv('data/sp500.csv')
    sp500 = sp500.rename(columns={'Close': 'price'})
    sp500['y'] = np.log(sp500['price']).diff()
    sp500 = sp500.dropna().reset_index(drop=True)

    # Process S&P 500 Total Return
    sp500tr = pd.read_csv('data/sp500tr.csv')
    sp500tr = sp500tr.rename(columns={'Close': 'price'})
    sp500tr['y'] = np.log(sp500tr['price']).diff()
    sp500tr = sp500tr.dropna().reset_index(drop=True)

    # Process stocks
    stocks = pd.read_csv('data/stocks.csv')
    stocks = stocks.rename(columns={'Close': 'UnAdjustedPrice', 'Adjusted_close': 'price'})
    stocks['date'] = pd.to_datetime(stocks['date'], format='%Y%m%d')

    # Reshape to wide format
    Price = stocks.pivot(index='date', columns='ticker', values='price').reset_index()
    UnAdjustedPrice = stocks.pivot(index='date', columns='ticker', values='UnAdjustedPrice').reset_index()

    # Calculate returns
    Return = Price.copy()
    for col in Return.columns[1:]:
        Return[col] = np.log(Price[col]).diff()

    # Remove NA rows
    mask = Return.iloc[:, 1:].notna().all(axis=1)
    Price = Price[mask].reset_index(drop=True)
    UnAdjustedPrice = UnAdjustedPrice[mask].reset_index(drop=True)
    Return = Return[mask].reset_index(drop=True)

    # Get unique tickers
    Ticker = stocks['ticker'].unique().tolist()

    return {
        'sp500': sp500,
        'sp500tr': sp500tr,
        'Price': Price,
        'UnAdjustedPrice': UnAdjustedPrice,
        'Return': Return,
        'Ticker': Ticker
    }


# Risk functions for backtesting
from scipy import stats
from arch import arch_model

def NormalVaR(p, sd=1):
    """Value at Risk under normal distribution"""
    return -stats.norm.ppf(p) * sd

def NormalES(p, sd=1):
    """Expected Shortfall under normal distribution"""
    return sd * stats.norm.pdf(stats.norm.ppf(p)) / p

def tVaR(p, df, sd=1, Standardized=True):
    """Value at Risk under Student-t distribution.

    The variance normalisation divides by sqrt(df/(df-2)), which needs df > 2.
    Without the check, df = 2 makes the scale infinite and returns a VaR of
    zero: an undefined variance reported as an absence of risk.
    """
    if Standardized and df <= 2:
        raise ValueError("Standardized Student-t needs df > 2: the variance is undefined at or below 2")
    scale = np.sqrt(df / (df - 2)) if Standardized else 1
    return -sd * stats.t.ppf(p, df) / scale

def tES(p, df, sd=1, Standardized=True):
    """Expected Shortfall under Student-t distribution.

    ES carries a second restriction. The tail mean of a raw t is finite only
    for df > 1, so the unstandardised branch needs that even though it skips
    the variance normalisation.
    """
    if Standardized and df <= 2:
        raise ValueError("Standardized Student-t needs df > 2: the variance is undefined at or below 2")
    if df <= 1:
        raise ValueError("Student-t ES needs df > 1: the tail mean is infinite at or below 1")
    scale = np.sqrt(df / (df - 2)) if Standardized else 1
    q = stats.t.ppf(p, df)
    return (sd * stats.t.pdf(q, df) * ((df + q**2) / (df - 1)) / p) / scale

from risk import EmpiricalES  # noqa: E402

def Risk_HS(y, par):
    """Historical Simulation VaR and ES"""
    ys = np.sort(y[-par['WE']:])
    k = int(np.ceil(par['probability'] * par['WE']))
    if k < 1 or k > par['WE']:
        raise ValueError("probability * WE must give a rank between 1 and WE")
    VaR = -ys[k-1] * par['value']
    ES = -EmpiricalES(ys, par['probability']) * par['value']
    return {'VaR': VaR, 'ES': ES}

def Risk_EWMA(y, par):
    """EWMA VaR and ES"""
    y_window = y[-par['WE']:]
    sigma2 = np.var(y_window, ddof=1)
    for i in range(1, len(y_window)):
        sigma2 = par['lambda'] * sigma2 + (1 - par['lambda']) * y_window[i-1]**2
    sigma2 = par['lambda'] * sigma2 + (1 - par['lambda']) * y_window[-1]**2
    sigma = np.sqrt(sigma2)
    VaR = NormalVaR(par['probability'], sigma) * par['value']
    ES = NormalES(par['probability'], sigma) * par['value']
    return {'VaR': VaR, 'ES': ES}

def Risk_nGARCH(y, par):
    """GARCH(1,1) VaR and ES with normal distribution"""
    y_window = y[-par['WE']:]
    y_dm = y_window - np.mean(y_window)
    scale = np.std(y_dm, ddof=1)
    y_scaled = y_dm / scale

    try:
        model = arch_model(y_scaled, vol='Garch', p=1, q=1, mean='Zero', dist='normal')
        res = model.fit(disp='off', show_warning=False)
        omega, alpha, beta = res.params['omega'], res.params['alpha[1]'], res.params['beta[1]']
        last_var = res.conditional_volatility[-1]**2
        sigma2_forecast = omega + alpha * y_scaled[-1]**2 + beta * last_var
        sigma = np.sqrt(sigma2_forecast) * scale
    except Exception as exc:
        raise RuntimeError(
            "Risk_nGARCH: the GARCH(1,1) fit failed and no volatility is substituted"
        ) from exc

    VaR = NormalVaR(par['probability'], sigma) * par['value']
    ES = NormalES(par['probability'], sigma) * par['value']
    return {'VaR': VaR, 'ES': ES}

def Risk_tGARCH(y, par):
    """GARCH(1,1) VaR and ES with Student-t distribution"""
    y_window = y[-par['WE']:]
    y_dm = y_window - np.mean(y_window)
    scale = np.std(y_dm, ddof=1)
    y_scaled = y_dm / scale

    try:
        model = arch_model(y_scaled, vol='Garch', p=1, q=1, mean='Zero', dist='t')
        res = model.fit(disp='off', show_warning=False)
        omega, alpha, beta = res.params['omega'], res.params['alpha[1]'], res.params['beta[1]']
        nu = res.params['nu']
        last_var = res.conditional_volatility[-1]**2
        sigma2_forecast = omega + alpha * y_scaled[-1]**2 + beta * last_var
        sigma = np.sqrt(sigma2_forecast) * scale
    except Exception as exc:
        raise RuntimeError(
            "Risk_tGARCH: the GARCH(1,1) fit failed and no volatility or "
            "degrees of freedom are substituted"
        ) from exc

    VaR = tVaR(par['probability'], nu, sigma) * par['value']
    ES = tES(par['probability'], nu, sigma) * par['value']
    return {'VaR': VaR, 'ES': ES}

def RunOneDay(t, y, par, Methods=['HS', 'EWMA', 'nGARCH', 'tGARCH']):
    """Run all risk models for a single day"""
    y_window = y[t-par['WE']:t]

    risk_funcs = {
        'HS': Risk_HS,
        'EWMA': Risk_EWMA,
        'nGARCH': Risk_nGARCH,
        'tGARCH': Risk_tGARCH
    }

    results = {'index': t, 'y': y[t]}
    for method in Methods:
        res = risk_funcs[method](y_window, par)
        results[f'VaR.{method}'] = res['VaR']
        results[f'ES.{method}'] = res['ES']

    return results
