"""
Technical Indicator Calculator
Calculates trend, momentum, volatility, and volume indicators for the TVTA Vision Dataset.
"""

import numpy as np
import pandas as pd
from typing import Dict, Any, Optional


def calc_ema(series: pd.Series, period: int) -> pd.Series:
    return series.ewm(span=period, adjust=False).mean()


def calc_sma(series: pd.Series, period: int) -> pd.Series:
    return series.rolling(window=period).mean()


def calc_rsi(series: pd.Series, period: int = 14) -> pd.Series:
    delta = series.diff()
    gain = delta.where(delta > 0, 0.0)
    loss = -delta.where(delta < 0, 0.0)
    avg_gain = gain.ewm(alpha=1.0 / period, adjust=False).mean()
    avg_loss = loss.ewm(alpha=1.0 / period, adjust=False).mean()
    rs = avg_gain / avg_loss
    return 100.0 - (100.0 / (1.0 + rs))


def calc_macd(
    series: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9
) -> tuple[pd.Series, pd.Series, pd.Series]:
    ema_fast = calc_ema(series, fast)
    ema_slow = calc_ema(series, slow)
    macd_line = ema_fast - ema_slow
    signal_line = calc_ema(macd_line, signal)
    histogram = macd_line - signal_line
    return macd_line, signal_line, histogram


def calc_bollinger_bands(
    series: pd.Series, period: int = 20, std_dev: float = 2.0
) -> tuple[pd.Series, pd.Series, pd.Series]:
    sma = calc_sma(series, period)
    std = series.rolling(window=period).std()
    upper = sma + std_dev * std
    lower = sma - std_dev * std
    return upper, sma, lower


def calc_atr(
    df: pd.DataFrame, period: int = 14
) -> pd.Series:
    high = df["high"]
    low = df["low"]
    close = df["close"]
    prev_close = close.shift(1)
    tr = pd.concat(
        [
            (high - low),
            (high - prev_close).abs(),
            (low - prev_close).abs(),
        ],
        axis=1,
    ).max(axis=1)
    return tr.ewm(alpha=1.0 / period, adjust=False).mean()


def calc_stochastic(
    df: pd.DataFrame, k_period: int = 14, d_period: int = 3
) -> tuple[pd.Series, pd.Series]:
    low_min = df["low"].rolling(window=k_period).min()
    high_max = df["high"].rolling(window=k_period).max()
    k = 100.0 * (df["close"] - low_min) / (high_max - low_min)
    d = k.rolling(window=d_period).mean()
    return k, d


def calc_cci(df: pd.DataFrame, period: int = 20) -> pd.Series:
    typical_price = (df["high"] + df["low"] + df["close"]) / 3.0
    sma_tp = calc_sma(typical_price, period)
    mad = typical_price.rolling(window=period).apply(
        lambda x: np.abs(x - x.mean()).mean(), raw=True
    )
    return (typical_price - sma_tp) / (0.015 * mad)


def calc_williams_r(df: pd.DataFrame, period: int = 14) -> pd.Series:
    high_max = df["high"].rolling(window=period).max()
    low_min = df["low"].rolling(window=period).min()
    return -100.0 * (high_max - df["close"]) / (high_max - low_min)


def calc_obv(df: pd.DataFrame) -> pd.Series:
    direction = np.sign(df["close"].diff())
    direction.iloc[0] = 0
    return (direction * df["volume"]).cumsum()


def calc_adx(df: pd.DataFrame, period: int = 14) -> pd.Series:
    """Average Directional Index."""
    high = df["high"]
    low = df["low"]
    close = df["close"]

    up_move = high.diff()
    down_move = -low.diff()

    plus_dm = pd.Series(np.where((up_move > down_move) & (up_move > 0), up_move, 0.0), index=df.index)
    minus_dm = pd.Series(np.where((down_move > up_move) & (down_move > 0), down_move, 0.0), index=df.index)

    atr = calc_atr(df, period)
    plus_di = 100.0 * (calc_ema(plus_dm, period) / atr)
    minus_di = 100.0 * (calc_ema(minus_dm, period) / atr)

    dx = 100.0 * np.abs(plus_di - minus_di) / (plus_di + minus_di)
    dx = dx.fillna(0)
    adx = calc_ema(dx, period)
    return adx


def calc_vwap(df: pd.DataFrame) -> pd.Series:
    """Volume Weighted Price (intraday, resets daily)."""
    typical_price = (df["high"] + df["low"] + df["close"]) / 3.0
    return (typical_price * df["volume"]).cumsum() / df["volume"].cumsum()


def calc_ichimoku(df: pd.DataFrame) -> dict:
    """Ichimoku Cloud components."""
    high = df["high"]
    low = df["low"]
    close = df["close"]

    tenkan = (high.rolling(9).max() + low.rolling(9).min()) / 2.0
    kijun = (high.rolling(26).max() + low.rolling(26).min()) / 2.0
    senkou_a = ((tenkan + kijun) / 2.0).shift(26)
    senkou_b = ((high.rolling(52).max() + low.rolling(52).min()) / 2.0).shift(26)
    chikou = close.shift(-26)
    return {
        "tenkan_sen": tenkan,
        "kijun_sen": kijun,
        "senkou_span_a": senkou_a,
        "senkou_span_b": senkou_b,
        "chikou_span": chikou,
    }


def calc_stoch_rsi(
    series: pd.Series, rsi_period: int = 14, stoch_period: int = 14, k_smooth: int = 3, d_smooth: int = 3
) -> tuple[pd.Series, pd.Series]:
    rsi = calc_rsi(series, rsi_period)
    rsi_min = rsi.rolling(stoch_period).min()
    rsi_max = rsi.rolling(stoch_period).max()
    stoch = 100.0 * (rsi - rsi_min) / (rsi_max - rsi_min)
    k = stoch.rolling(k_smooth).mean()
    d = k.rolling(d_smooth).mean()
    return k, d


def calc_historical_volatility(
    series: pd.Series, period: int = 20
) -> pd.Series:
    """Annualized historical volatility from log returns."""
    log_ret = np.log(series / series.shift(1))
    return log_ret.rolling(period).std() * np.sqrt(252)


def calc_keltner_channels(
    df: pd.DataFrame, ema_period: int = 20, atr_period: int = 10, multiplier: float = 1.5
) -> tuple[pd.Series, pd.Series, pd.Series]:
    ema = calc_ema(df["close"], ema_period)
    atr = calc_atr(df, atr_period)
    upper = ema + multiplier * atr
    lower = ema - multiplier * atr
    return upper, ema, lower


def compute_all_indicators(df: pd.DataFrame) -> pd.DataFrame:
    """Compute all indicators and return enriched DataFrame."""
    out = df.copy()

    # Trend
    for p in [9, 20, 50, 100, 200]:
        out[f"ema_{p}"] = calc_ema(out["close"], p)
    for p in [20, 50, 100, 200]:
        out[f"sma_{p}"] = calc_sma(out["close"], p)
    out["vwap"] = calc_vwap(out)
    out["adx"] = calc_adx(out)

    # Momentum
    out["rsi_14"] = calc_rsi(out["close"], 14)
    macd, signal, hist = calc_macd(out["close"])
    out["macd"] = macd
    out["macd_signal"] = signal
    out["macd_histogram"] = hist
    out["cci_20"] = calc_cci(out, 20)
    out["williams_r_14"] = calc_williams_r(out, 14)
    stoch_k, stoch_d = calc_stochastic(out, 14, 3)
    out["stoch_k"] = stoch_k
    out["stoch_d"] = stoch_d
    stoch_rsi_k, stoch_rsi_d = calc_stoch_rsi(out["close"])
    out["stoch_rsi_k"] = stoch_rsi_k
    out["stoch_rsi_d"] = stoch_rsi_d

    # Volatility
    out["atr_14"] = calc_atr(out, 14)
    bb_upper, bb_mid, bb_lower = calc_bollinger_bands(out["close"])
    out["bb_upper"] = bb_upper
    out["bb_middle"] = bb_mid
    out["bb_lower"] = bb_lower
    kc_upper, kc_mid, kc_lower = calc_keltner_channels(out)
    out["kc_upper"] = kc_upper
    out["kc_middle"] = kc_mid
    out["kc_lower"] = kc_lower
    out["hist_vol_20"] = calc_historical_volatility(out["close"], 20)

    # Volume
    out["obv"] = calc_obv(out)
    out["volume_sma_20"] = calc_sma(out["volume"], 20)

    # Ichimoku
    ichi = calc_ichimoku(out)
    for k, v in ichi.items():
        out[f"ichi_{k}"] = v

    return out


def get_indicator_state(df: pd.DataFrame, idx: int = -1) -> Dict[str, Any]:
    """Extract indicator state at a given index for labeling."""
    if idx < 0:
        idx = len(df) + idx
    if idx < 0 or idx >= len(df):
        idx = len(df) - 1

    row = df.iloc[idx]
    prev = df.iloc[idx - 1] if idx > 0 else row

    # RSI state
    rsi_val = row.get("rsi_14", 50)
    if rsi_val > 70:
        rsi_zone = "overbought"
        rsi_state = "bearish_warning"
    elif rsi_val > 60:
        rsi_zone = "neutral_bullish"
        rsi_state = "bullish_momentum"
    elif rsi_val > 40:
        rsi_zone = "neutral"
        rsi_state = "neutral_momentum"
    elif rsi_val > 30:
        rsi_zone = "neutral_bearish"
        rsi_state = "bearish_momentum"
    else:
        rsi_zone = "oversold"
        rsi_state = "bullish_warning"

    # MACD state
    macd_val = row.get("macd", 0)
    macd_sig = row.get("macd_signal", 0)
    macd_hist = row.get("macd_histogram", 0)
    prev_hist = prev.get("macd_histogram", 0) if idx > 0 else 0
    if macd_val > macd_sig and macd_hist > prev_hist:
        macd_state = "bullish_strengthening"
    elif macd_val > macd_sig:
        macd_state = "bullish"
    elif macd_val < macd_sig and macd_hist < prev_hist:
        macd_state = "bearish_strengthening"
    else:
        macd_state = "bearish"

    # EMA alignment
    ema20 = row.get("ema_20", 0)
    ema50 = row.get("ema_50", 0)
    ema100 = row.get("ema_100", 0)
    ema200 = row.get("ema_200", 0)
    close = row.get("close", 0)

    ema_alignment = "neutral"
    if ema20 > ema50 > ema100 > ema200:
        ema_alignment = "bullish"
    elif ema20 < ema50 < ema100 < ema200:
        ema_alignment = "bearish"

    price_above_ema200 = close > ema200 if ema200 > 0 else False

    # Bollinger position
    bb_upper = row.get("bb_upper", 0)
    bb_lower = row.get("bb_lower", 0)
    bb_width = (bb_upper - bb_lower) / row.get("bb_middle", 1) if row.get("bb_middle", 0) > 0 else 0
    if close > bb_upper * 0.99:
        bb_position = "above_upper"
    elif close > row.get("bb_middle", 0):
        bb_position = "upper_half"
    elif close > bb_lower * 1.01:
        bb_position = "lower_half"
    else:
        bb_position = "below_lower"

    # ADX trend strength
    adx_val = row.get("adx", 20)
    if adx_val > 40:
        trend_strength = "very_strong"
    elif adx_val > 25:
        trend_strength = "strong"
    elif adx_val > 20:
        trend_strength = "moderate"
    else:
        trend_strength = "weak"

    # Volume analysis
    vol = row.get("volume", 0)
    vol_sma = row.get("volume_sma_20", 1)
    vol_ratio = vol / vol_sma if vol_sma > 0 else 1.0
    if vol_ratio > 2.0:
        vol_class = "very_high_volume"
    elif vol_ratio > 1.5:
        vol_class = "high_volume"
    elif vol_ratio > 0.75:
        vol_class = "normal_volume"
    elif vol_ratio > 0.5:
        vol_class = "low_volume"
    else:
        vol_class = "very_low_volume"

    return {
        "rsi": {"value": round(float(rsi_val), 2), "state": rsi_state, "zone": rsi_zone},
        "macd": {
            "value": round(float(macd_val), 4),
            "signal": round(float(macd_sig), 4),
            "histogram": round(float(macd_hist), 4),
            "state": macd_state,
        },
        "ema_structure": {
            "ema20_above_ema50": bool(ema20 > ema50),
            "ema50_above_ema200": bool(ema50 > ema200),
            "price_above_ema200": bool(price_above_ema200),
            "alignment": ema_alignment,
        },
        "bollinger_position": bb_position,
        "bollinger_width": round(float(bb_width), 4),
        "adx": {"value": round(float(adx_val), 2), "trend_strength": trend_strength},
        "volume_analysis": {
            "current_volume_vs_average": round(float(vol_ratio), 2),
            "classification": vol_class,
        },
        "stochastic": {
            "k": round(float(row.get("stoch_k", 50)), 2),
            "d": round(float(row.get("stoch_d", 50)), 2),
        },
        "cci": round(float(row.get("cci_20", 0)), 2),
        "williams_r": round(float(row.get("williams_r_14", -50)), 2),
        "atr": round(float(row.get("atr_14", 0)), 4),
    }