Ta Lib

#!/usr/bin/env python3
"""Compute common TA-Lib technical indicators on synthetic OHLCV data.

Demonstrates RSI, MACD, Bollinger Bands, ATR, and ADX using TA-Lib when
available, with manual fallback implementations for environments without
the C library installed. Includes a performance comparison between
TA-Lib and manual computation.

Usage:
    python scripts/compute_indicators.py
    python scripts/compute_indicators.py --demo
    python scripts/compute_indicators.py --bars 5000

Dependencies:
    uv pip install numpy pandas
    Optional: uv pip install TA-Lib  (requires C library)
"""

import argparse
import sys
import time
from typing import Optional, Tuple

import numpy as np
import pandas as pd

# ── TA-Lib Import (optional) ───────────────────────────────────────
TALIB_AVAILABLE = False
try:
    import talib
    TALIB_AVAILABLE = True
except ImportError:
    pass


# ── Synthetic Data Generation ──────────────────────────────────────

def generate_ohlcv(
    bars: int = 500,
    start_price: float = 100.0,
    volatility: float = 0.02,
    seed: int = 42,
) -> pd.DataFrame:
    """Generate synthetic OHLCV data with realistic price dynamics.

    Uses geometric Brownian motion for close prices with random
    high/low/open offsets and volume proportional to price changes.

    Args:
        bars: Number of bars to generate.
        start_price: Starting price.
        volatility: Per-bar return standard deviation.
        seed: Random seed for reproducibility.

    Returns:
        DataFrame with columns: open, high, low, close, volume.
    """
    rng = np.random.default_rng(seed)

    # Geometric Brownian motion for close prices
    returns = rng.normal(0, volatility, bars)
    close = start_price * np.exp(np.cumsum(returns))

    # Generate OHLV around close
    spread = close * volatility
    high = close + np.abs(rng.normal(0, 1, bars)) * spread
    low = close - np.abs(rng.normal(0, 1, bars)) * spread
    open_ = close + rng.normal(0, 0.5, bars) * spread

    # Ensure high >= max(open, close) and low <= min(open, close)
    high = np.maximum(high, np.maximum(open_, close))
    low = np.minimum(low, np.minimum(open_, close))

    # Volume correlated with absolute returns
    base_volume = 100_000
    volume = base_volume * (1 + 5 * np.abs(returns))
    volume = volume.astype(np.float64)

    df = pd.DataFrame({
        "open": open_,
        "high": high,
        "low": low,
        "close": close,
        "volume": volume,
    })
    return df


# ── Manual Indicator Implementations (Fallback) ───────────────────

def manual_sma(data: np.ndarray, period: int) -> np.ndarray:
    """Simple Moving Average using cumulative sum trick.

    Args:
        data: Input price array.
        period: Lookback window.

    Returns:
        Array with SMA values (NaN for first period-1 bars).
    """
    result = np.full_like(data, np.nan)
    if len(data) < period:
        return result
    cumsum = np.cumsum(data)
    cumsum[period:] = cumsum[period:] - cumsum[:-period]
    result[period - 1:] = cumsum[period - 1:] / period
    return result


def manual_ema(data: np.ndarray, period: int) -> np.ndarray:
    """Exponential Moving Average.

    Args:
        data: Input price array.
        period: Lookback period (determines alpha = 2/(period+1)).

    Returns:
        Array with EMA values (NaN for first period-1 bars).
    """
    result = np.full_like(data, np.nan, dtype=np.float64)
    if len(data) < period:
        return result
    alpha = 2.0 / (period + 1)
    # Seed with SMA of first `period` values
    result[period - 1] = np.mean(data[:period])
    for i in range(period, len(data)):
        result[i] = alpha * data[i] + (1 - alpha) * result[i - 1]
    return result


def manual_rsi(close: np.ndarray, period: int = 14) -> np.ndarray:
    """Relative Strength Index using Wilder's smoothing.

    Args:
        close: Close price array.
        period: RSI lookback period.

    Returns:
        Array with RSI values 0-100 (NaN for first period bars).
    """
    result = np.full_like(close, np.nan, dtype=np.float64)
    if len(close) < period + 1:
        return result

    deltas = np.diff(close)
    gains = np.where(deltas > 0, deltas, 0.0)
    losses = np.where(deltas < 0, -deltas, 0.0)

    # Initial average gain/loss
    avg_gain = np.mean(gains[:period])
    avg_loss = np.mean(losses[:period])

    if avg_loss == 0:
        result[period] = 100.0
    else:
        rs = avg_gain / avg_loss
        result[period] = 100.0 - (100.0 / (1.0 + rs))

    # Wilder's smoothing
    for i in range(period, len(deltas)):
        avg_gain = (avg_gain * (period - 1) + gains[i]) / period
        avg_loss = (avg_loss * (period - 1) + losses[i]) / period
        if avg_loss == 0:
            result[i + 1] = 100.0
        else:
            rs = avg_gain / avg_loss
            result[i + 1] = 100.0 - (100.0 / (1.0 + rs))

    return result


def manual_macd(
    close: np.ndarray,
    fast: int = 12,
    slow: int = 26,
    signal_period: int = 9,
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
    """MACD: difference of two EMAs plus signal line.

    Args:
        close: Close price array.
        fast: Fast EMA period.
        slow: Slow EMA period.
        signal_period: Signal line EMA period.

    Returns:
        Tuple of (macd_line, signal_line, histogram).
    """
    ema_fast = manual_ema(close, fast)
    ema_slow = manual_ema(close, slow)
    macd_line = ema_fast - ema_slow

    # Signal line: EMA of MACD line (only where MACD is valid)
    valid_start = slow - 1
    signal_line = np.full_like(close, np.nan, dtype=np.float64)
    macd_valid = macd_line[valid_start:]
    if len(macd_valid) >= signal_period:
        sig = manual_ema(macd_valid, signal_period)
        signal_line[valid_start:] = sig

    histogram = macd_line - signal_line
    return macd_line, signal_line, histogram


def manual_bbands(
    close: np.ndarray,
    period: int = 20,
    nbdev: float = 2.0,
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
    """Bollinger Bands: SMA +/- N standard deviations.

    Args:
        close: Close price array.
        period: Moving average period.
        nbdev: Number of standard deviations.

    Returns:
        Tuple of (upper, middle, lower) band arrays.
    """
    middle = manual_sma(close, period)
    upper = np.full_like(close, np.nan, dtype=np.float64)
    lower = np.full_like(close, np.nan, dtype=np.float64)

    for i in range(period - 1, len(close)):
        std = np.std(close[i - period + 1: i + 1], ddof=0)
        upper[i] = middle[i] + nbdev * std
        lower[i] = middle[i] - nbdev * std

    return upper, middle, lower


def manual_true_range(
    high: np.ndarray, low: np.ndarray, close: np.ndarray
) -> np.ndarray:
    """True Range: max(H-L, |H-prevC|, |L-prevC|).

    Args:
        high: High price array.
        low: Low price array.
        close: Close price array.

    Returns:
        True range array (NaN for first bar).
    """
    tr = np.full_like(close, np.nan, dtype=np.float64)
    tr[0] = high[0] - low[0]
    for i in range(1, len(close)):
        hl = high[i] - low[i]
        hc = abs(high[i] - close[i - 1])
        lc = abs(low[i] - close[i - 1])
        tr[i] = max(hl, hc, lc)
    return tr


def manual_atr(
    high: np.ndarray,
    low: np.ndarray,
    close: np.ndarray,
    period: int = 14,
) -> np.ndarray:
    """Average True Range using Wilder's smoothing.

    Args:
        high: High price array.
        low: Low price array.
        close: Close price array.
        period: ATR lookback period.

    Returns:
        ATR array (NaN for first period bars).
    """
    tr = manual_true_range(high, low, close)
    atr = np.full_like(close, np.nan, dtype=np.float64)
    if len(close) < period + 1:
        return atr

    atr[period] = np.mean(tr[1: period + 1])
    for i in range(period + 1, len(close)):
        atr[i] = (atr[i - 1] * (period - 1) + tr[i]) / period

    return atr


def manual_adx(
    high: np.ndarray,
    low: np.ndarray,
    close: np.ndarray,
    period: int = 14,
) -> np.ndarray:
    """Average Directional Index.

    Computes +DM, -DM, smoothed +DI, -DI, DX, then ADX.

    Args:
        high: High price array.
        low: Low price array.
        close: Close price array.
        period: ADX lookback period.

    Returns:
        ADX array (NaN for initial lookback bars).
    """
    n = len(close)
    adx_out = np.full(n, np.nan, dtype=np.float64)
    if n < 2 * period + 1:
        return adx_out

    # Directional movement
    plus_dm = np.zeros(n, dtype=np.float64)
    minus_dm = np.zeros(n, dtype=np.float64)
    tr = manual_true_range(high, low, close)

    for i in range(1, n):
        up_move = high[i] - high[i - 1]
        down_move = low[i - 1] - low[i]
        plus_dm[i] = up_move if (up_move > down_move and up_move > 0) else 0.0
        minus_dm[i] = down_move if (down_move > up_move and down_move > 0) else 0.0

    # Wilder's smoothing for TR, +DM, -DM
    smooth_tr = np.sum(tr[1: period + 1])
    smooth_plus = np.sum(plus_dm[1: period + 1])
    smooth_minus = np.sum(minus_dm[1: period + 1])

    dx_values = []
    for i in range(period, n):
        if i > period:
            smooth_tr = smooth_tr - smooth_tr / period + tr[i]
            smooth_plus = smooth_plus - smooth_plus / period + plus_dm[i]
            smooth_minus = smooth_minus - smooth_minus / period + minus_dm[i]

        if smooth_tr == 0:
            dx_values.append(0.0)
            continue

        plus_di = 100.0 * smooth_plus / smooth_tr
        minus_di = 100.0 * smooth_minus / smooth_tr
        di_sum = plus_di + minus_di
        if di_sum == 0:
            dx_values.append(0.0)
        else:
            dx = 100.0 * abs(plus_di - minus_di) / di_sum
            dx_values.append(dx)

    # ADX is smoothed DX
    if len(dx_values) >= period:
        adx_val = np.mean(dx_values[:period])
        adx_out[2 * period - 1] = adx_val
        for i in range(period, len(dx_values)):
            adx_val = (adx_val * (period - 1) + dx_values[i]) / period
            adx_out[period + i] = adx_val

    return adx_out


# ── Computation Engine ─────────────────────────────────────────────

def compute_with_talib(df: pd.DataFrame) -> pd.DataFrame:
    """Compute indicators using TA-Lib.

    Args:
        df: OHLCV DataFrame with float64 columns.

    Returns:
        DataFrame with indicator columns added.
    """
    close = df["close"].values.astype(np.float64)
    high = df["high"].values.astype(np.float64)
    low = df["low"].values.astype(np.float64)
    volume = df["volume"].values.astype(np.float64)

    result = df.copy()
    result["RSI_14"] = talib.RSI(close, timeperiod=14)
    macd, signal, hist = talib.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
    result["MACD"] = macd
    result["MACD_signal"] = signal
    result["MACD_hist"] = hist
    upper, middle, lower = talib.BBANDS(close, timeperiod=20, nbdevup=2, nbdevdn=2)
    result["BB_upper"] = upper
    result["BB_middle"] = middle
    result["BB_lower"] = lower
    result["ATR_14"] = talib.ATR(high, low, close, timeperiod=14)
    result["ADX_14"] = talib.ADX(high, low, close, timeperiod=14)
    return result


def compute_manual(df: pd.DataFrame) -> pd.DataFrame:
    """Compute indicators using manual fallback implementations.

    Args:
        df: OHLCV DataFrame.

    Returns:
        DataFrame with indicator columns added.
    """
    close = df["close"].values.astype(np.float64)
    high = df["high"].values.astype(np.float64)
    low = df["low"].values.astype(np.float64)

    result = df.copy()
    result["RSI_14"] = manual_rsi(close, 14)
    macd, signal, hist = manual_macd(close, 12, 26, 9)
    result["MACD"] = macd
    result["MACD_signal"] = signal
    result["MACD_hist"] = hist
    upper, middle, lower = manual_bbands(close, 20, 2.0)
    result["BB_upper"] = upper
    result["BB_middle"] = middle
    result["BB_lower"] = lower
    result["ATR_14"] = manual_atr(high, low, close, 14)
    result["ADX_14"] = manual_adx(high, low, close, 14)
    return result


# ── Performance Benchmark ─────────────────────────────────────────

def benchmark(df: pd.DataFrame, iterations: int = 50) -> None:
    """Compare TA-Lib vs manual computation speed.

    Args:
        df: OHLCV DataFrame for benchmarking.
        iterations: Number of iterations for timing.
    """
    print(f"\n{'='*60}")
    print(f"Performance Benchmark ({len(df)} bars, {iterations} iterations)")
    print(f"{'='*60}")

    # Manual timing
    start = time.perf_counter()
    for _ in range(iterations):
        compute_manual(df)
    manual_time = time.perf_counter() - start
    print(f"Manual fallback: {manual_time:.3f}s total, "
          f"{manual_time/iterations*1000:.1f}ms per call")

    if TALIB_AVAILABLE:
        start = time.perf_counter()
        for _ in range(iterations):
            compute_with_talib(df)
        talib_time = time.perf_counter() - start
        print(f"TA-Lib (C):      {talib_time:.3f}s total, "
              f"{talib_time/iterations*1000:.1f}ms per call")
        speedup = manual_time / talib_time if talib_time > 0 else float("inf")
        print(f"Speedup:         {speedup:.1f}x faster with TA-Lib")
    else:
        print("TA-Lib not installed — skipping C library benchmark.")


# ── Display Functions ──────────────────────────────────────────────

def display_results(df: pd.DataFrame, label: str, tail_n: int = 10) -> None:
    """Print the last N rows of computed indicators.

    Args:
        df: DataFrame with indicator columns.
        label: Label for the output section.
        tail_n: Number of recent bars to display.
    """
    cols = ["close", "RSI_14", "MACD", "MACD_signal", "MACD_hist",
            "BB_upper", "BB_middle", "BB_lower", "ATR_14", "ADX_14"]
    available = [c for c in cols if c in df.columns]

    print(f"\n{'='*60}")
    print(f"Indicator Values — {label} (last {tail_n} bars)")
    print(f"{'='*60}")
    print(df[available].tail(tail_n).to_string(float_format="{:.4f}".format))

    # Summary statistics
    print(f"\n--- Summary ---")
    last = df.iloc[-1]
    if "RSI_14" in df.columns and not np.isnan(last["RSI_14"]):
        rsi_val = last["RSI_14"]
        zone = "OVERSOLD" if rsi_val < 30 else ("OVERBOUGHT" if rsi_val > 70 else "NEUTRAL")
        print(f"RSI(14):  {rsi_val:.2f} [{zone}]")
    if "MACD_hist" in df.columns and not np.isnan(last["MACD_hist"]):
        hist_val = last["MACD_hist"]
        trend = "BULLISH" if hist_val > 0 else "BEARISH"
        print(f"MACD Hist: {hist_val:.4f} [{trend}]")
    if "ATR_14" in df.columns and not np.isnan(last["ATR_14"]):
        atr_pct = last["ATR_14"] / last["close"] * 100
        print(f"ATR(14):  {last['ATR_14']:.4f} ({atr_pct:.2f}% of price)")
    if "ADX_14" in df.columns and not np.isnan(last["ADX_14"]):
        adx_val = last["ADX_14"]
        strength = "STRONG TREND" if adx_val > 25 else "RANGING/WEAK"
        print(f"ADX(14):  {adx_val:.2f} [{strength}]")
    if "BB_upper" in df.columns and not np.isnan(last["BB_upper"]):
        bb_pos = (last["close"] - last["BB_lower"]) / (last["BB_upper"] - last["BB_lower"])
        print(f"BB %B:    {bb_pos:.2f} (0=lower band, 1=upper band)")


def compare_results(talib_df: pd.DataFrame, manual_df: pd.DataFrame) -> None:
    """Compare TA-Lib and manual results to validate accuracy.

    Args:
        talib_df: DataFrame computed with TA-Lib.
        manual_df: DataFrame computed with manual fallback.
    """
    print(f"\n{'='*60}")
    print("Accuracy Comparison: TA-Lib vs Manual")
    print(f"{'='*60}")

    indicators = ["RSI_14", "MACD", "MACD_signal", "ATR_14", "ADX_14",
                   "BB_upper", "BB_middle", "BB_lower"]

    for ind in indicators:
        if ind not in talib_df.columns or ind not in manual_df.columns:
            continue
        t = talib_df[ind].values
        m = manual_df[ind].values
        # Compare only where both are valid
        mask = ~(np.isnan(t) | np.isnan(m))
        if mask.sum() == 0:
            print(f"  {ind:15s}: no overlapping valid values")
            continue
        diff = np.abs(t[mask] - m[mask])
        max_diff = np.max(diff)
        mean_diff = np.mean(diff)
        print(f"  {ind:15s}: max_diff={max_diff:.6f}, mean_diff={mean_diff:.6f}")


# ── Main ───────────────────────────────────────────────────────────

def main() -> None:
    """Entry point: generate data, compute indicators, display results."""
    parser = argparse.ArgumentParser(
        description="Compute TA-Lib indicators on synthetic OHLCV data."
    )
    parser.add_argument(
        "--demo", action="store_true",
        help="Run in demo mode with default settings."
    )
    parser.add_argument(
        "--bars", type=int, default=500,
        help="Number of OHLCV bars to generate (default: 500)."
    )
    parser.add_argument(
        "--benchmark", action="store_true",
        help="Run performance benchmark comparing TA-Lib vs manual."
    )
    args = parser.parse_args()

    bars = args.bars
    print(f"TA-Lib available: {TALIB_AVAILABLE}")
    print(f"Generating {bars} bars of synthetic OHLCV data...")

    df = generate_ohlcv(bars=bars)
    print(f"Price range: {df['close'].min():.2f} - {df['close'].max():.2f}")

    if TALIB_AVAILABLE:
        talib_df = compute_with_talib(df)
        display_results(talib_df, "TA-Lib (C Library)")

        manual_df = compute_manual(df)
        display_results(manual_df, "Manual Fallback")

        compare_results(talib_df, manual_df)
    else:
        print("\nTA-Lib not installed. Using manual fallback implementations.")
        print("Install TA-Lib for C-optimized performance:")
        print("  brew install ta-lib && uv pip install TA-Lib")
        manual_df = compute_manual(df)
        display_results(manual_df, "Manual Fallback")

    if args.benchmark or args.demo:
        benchmark(df)

    print("\nNote: This is synthetic data for demonstration purposes only.")
    print("Not financial advice. Use with real market data for actual analysis.")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Scan OHLCV data for candlestick patterns using TA-Lib.

Detects all 61 TA-Lib candlestick patterns on synthetic or provided data.
Falls back to manual detection of doji, hammer, and engulfing patterns
when TA-Lib is not installed.

Usage:
    python scripts/pattern_scanner.py
    python scripts/pattern_scanner.py --demo
    python scripts/pattern_scanner.py --bars 1000

Dependencies:
    uv pip install numpy pandas
    Optional: uv pip install TA-Lib  (requires C library)
"""

import argparse
import sys
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Tuple

import numpy as np
import pandas as pd

# ── TA-Lib Import (optional) ───────────────────────────────────────
TALIB_AVAILABLE = False
try:
    import talib
    TALIB_AVAILABLE = True
except ImportError:
    pass


# ── Data Classes ───────────────────────────────────────────────────

@dataclass
class PatternDetection:
    """A single pattern detection on a specific bar."""
    bar_index: int
    value: int  # +100 bullish, -100 bearish
    close_price: float


@dataclass
class PatternResult:
    """Results for a single pattern type across all bars."""
    name: str
    display_name: str
    detections: List[PatternDetection] = field(default_factory=list)

    @property
    def count(self) -> int:
        """Total number of detections."""
        return len(self.detections)

    @property
    def bullish_count(self) -> int:
        """Number of bullish detections."""
        return sum(1 for d in self.detections if d.value > 0)

    @property
    def bearish_count(self) -> int:
        """Number of bearish detections."""
        return sum(1 for d in self.detections if d.value < 0)


# ── Synthetic Data with Clear Patterns ─────────────────────────────

def generate_pattern_data(bars: int = 500, seed: int = 42) -> pd.DataFrame:
    """Generate synthetic OHLCV data that contains clear candlestick patterns.

    Embeds specific pattern structures (doji, hammer, engulfing) at known
    positions so the scanner can demonstrate detection.

    Args:
        bars: Number of bars to generate.
        seed: Random seed for reproducibility.

    Returns:
        DataFrame with columns: open, high, low, close, volume.
    """
    rng = np.random.default_rng(seed)

    # Base price movement
    returns = rng.normal(0, 0.015, bars)
    close = 100.0 * np.exp(np.cumsum(returns))

    spread = close * 0.015
    high = close + np.abs(rng.normal(0, 1, bars)) * spread
    low = close - np.abs(rng.normal(0, 1, bars)) * spread
    open_ = close + rng.normal(0, 0.5, bars) * spread

    # Ensure OHLC consistency
    high = np.maximum(high, np.maximum(open_, close))
    low = np.minimum(low, np.minimum(open_, close))

    volume = (100_000 * (1 + 3 * np.abs(returns))).astype(np.float64)

    # ── Embed clear patterns ───────────────────────────────────
    # Doji patterns: open ~= close, with wicks
    doji_bars = [50, 150, 250, 350, 450]
    for i in doji_bars:
        if i < bars:
            mid = close[i]
            open_[i] = mid * 1.0005
            close[i] = mid * 0.9995
            high[i] = mid * 1.015
            low[i] = mid * 0.985

    # Hammer patterns: small body at top, long lower wick
    hammer_bars = [75, 175, 275, 375]
    for i in hammer_bars:
        if i < bars:
            body_top = close[i]
            body_size = body_top * 0.003
            open_[i] = body_top - body_size
            close[i] = body_top
            high[i] = body_top + body_size * 0.5
            low[i] = body_top - body_size * 4  # Long lower wick

    # Bullish engulfing: small bearish bar followed by large bullish bar
    engulfing_bars = [100, 200, 300, 400]
    for i in engulfing_bars:
        if i + 1 < bars:
            mid = close[i]
            # Bar i: small bearish
            open_[i] = mid * 1.002
            close[i] = mid * 0.998
            high[i] = mid * 1.003
            low[i] = mid * 0.997
            # Bar i+1: large bullish engulfing
            open_[i + 1] = mid * 0.996
            close[i + 1] = mid * 1.005
            high[i + 1] = mid * 1.006
            low[i + 1] = mid * 0.995

    # Shooting star: small body at bottom, long upper wick
    shooting_bars = [125, 225, 325]
    for i in shooting_bars:
        if i < bars:
            body_bottom = close[i]
            body_size = body_bottom * 0.003
            open_[i] = body_bottom + body_size
            close[i] = body_bottom
            high[i] = body_bottom + body_size * 4  # Long upper wick
            low[i] = body_bottom - body_size * 0.5

    # Re-enforce OHLC consistency after pattern embedding
    high = np.maximum(high, np.maximum(open_, close))
    low = np.minimum(low, np.minimum(open_, close))

    df = pd.DataFrame({
        "open": open_,
        "high": high,
        "low": low,
        "close": close,
        "volume": volume,
    })
    return df


# ── TA-Lib Pattern Scanner ─────────────────────────────────────────

# Display names for TA-Lib candlestick functions
PATTERN_DISPLAY_NAMES: Dict[str, str] = {
    "CDL2CROWS": "Two Crows",
    "CDL3BLACKCROWS": "Three Black Crows",
    "CDL3INSIDE": "Three Inside Up/Down",
    "CDL3LINESTRIKE": "Three-Line Strike",
    "CDL3OUTSIDE": "Three Outside Up/Down",
    "CDL3STARSINSOUTH": "Three Stars in the South",
    "CDL3WHITESOLDIERS": "Three White Soldiers",
    "CDLABANDONEDBABY": "Abandoned Baby",
    "CDLADVANCEBLOCK": "Advance Block",
    "CDLBELTHOLD": "Belt Hold",
    "CDLBREAKAWAY": "Breakaway",
    "CDLCLOSINGMARUBOZU": "Closing Marubozu",
    "CDLCONCEALBABYSWALL": "Concealing Baby Swallow",
    "CDLCOUNTERATTACK": "Counterattack",
    "CDLDARKCLOUDCOVER": "Dark Cloud Cover",
    "CDLDOJI": "Doji",
    "CDLDOJISTAR": "Doji Star",
    "CDLDRAGONFLYDOJI": "Dragonfly Doji",
    "CDLENGULFING": "Engulfing",
    "CDLEVENINGDOJISTAR": "Evening Doji Star",
    "CDLEVENINGSTAR": "Evening Star",
    "CDLGAPSIDESIDEWHITE": "Gap Side-by-Side White",
    "CDLGRAVESTONEDOJI": "Gravestone Doji",
    "CDLHAMMER": "Hammer",
    "CDLHANGINGMAN": "Hanging Man",
    "CDLHARAMI": "Harami",
    "CDLHARAMICROSS": "Harami Cross",
    "CDLHIGHWAVE": "High Wave",
    "CDLHIKKAKE": "Hikkake",
    "CDLHIKKAKEMOD": "Modified Hikkake",
    "CDLHOMINGPIGEON": "Homing Pigeon",
    "CDLIDENTICAL3CROWS": "Identical Three Crows",
    "CDLINNECK": "In-Neck",
    "CDLINVERTEDHAMMER": "Inverted Hammer",
    "CDLKICKING": "Kicking",
    "CDLKICKINGBYLENGTH": "Kicking by Length",
    "CDLLADDERBOTTOM": "Ladder Bottom",
    "CDLLONGLEGGEDDOJI": "Long-Legged Doji",
    "CDLLONGLINE": "Long Line",
    "CDLMARUBOZU": "Marubozu",
    "CDLMATCHINGLOW": "Matching Low",
    "CDLMATHOLD": "Mat Hold",
    "CDLMORNINGDOJISTAR": "Morning Doji Star",
    "CDLMORNINGSTAR": "Morning Star",
    "CDLONNECK": "On-Neck",
    "CDLPIERCING": "Piercing",
    "CDLRICKSHAWMAN": "Rickshaw Man",
    "CDLRISEFALL3METHODS": "Rising/Falling Three Methods",
    "CDLSEPARATINGLINES": "Separating Lines",
    "CDLSHOOTINGSTAR": "Shooting Star",
    "CDLSHORTLINE": "Short Line",
    "CDLSPINNINGTOP": "Spinning Top",
    "CDLSTALLEDPATTERN": "Stalled Pattern",
    "CDLSTICKSANDWICH": "Stick Sandwich",
    "CDLTAKURI": "Takuri",
    "CDLTASUKIGAP": "Tasuki Gap",
    "CDLTHRUSTING": "Thrusting",
    "CDLTRISTAR": "Tri-Star",
    "CDLUNIQUE3RIVER": "Unique Three River",
    "CDLXSIDEGAP3METHODS": "Side Gap Three Methods",
}


def scan_talib_patterns(
    open_: np.ndarray,
    high: np.ndarray,
    low: np.ndarray,
    close: np.ndarray,
) -> List[PatternResult]:
    """Scan for all 61 TA-Lib candlestick patterns.

    Args:
        open_: Open price array (float64).
        high: High price array (float64).
        low: Low price array (float64).
        close: Close price array (float64).

    Returns:
        List of PatternResult for patterns with at least one detection.
    """
    candle_funcs = talib.get_function_groups()["Pattern Recognition"]
    results: List[PatternResult] = []

    for func_name in candle_funcs:
        func = getattr(talib, func_name)
        output = func(open_, high, low, close)
        hits = np.nonzero(output)[0]

        if len(hits) > 0:
            display = PATTERN_DISPLAY_NAMES.get(func_name, func_name)
            pr = PatternResult(name=func_name, display_name=display)
            for idx in hits:
                pr.detections.append(PatternDetection(
                    bar_index=int(idx),
                    value=int(output[idx]),
                    close_price=float(close[idx]),
                ))
            results.append(pr)

    # Sort by detection count descending
    results.sort(key=lambda r: r.count, reverse=True)
    return results


# ── Manual Pattern Detection (Fallback) ────────────────────────────

def detect_doji(
    open_: np.ndarray,
    high: np.ndarray,
    low: np.ndarray,
    close: np.ndarray,
    body_threshold: float = 0.001,
) -> np.ndarray:
    """Detect doji patterns: open ~= close with visible wicks.

    A doji has a very small body relative to its total range,
    indicating indecision.

    Args:
        open_: Open prices.
        high: High prices.
        low: Low prices.
        close: Close prices.
        body_threshold: Max body/range ratio to qualify as doji.

    Returns:
        Array with +100 where doji detected, 0 otherwise.
    """
    n = len(close)
    result = np.zeros(n, dtype=np.int32)
    for i in range(n):
        total_range = high[i] - low[i]
        if total_range == 0:
            continue
        body = abs(close[i] - open_[i])
        body_ratio = body / total_range
        if body_ratio <= body_threshold and total_range > close[i] * 0.005:
            result[i] = 100
    return result


def detect_hammer(
    open_: np.ndarray,
    high: np.ndarray,
    low: np.ndarray,
    close: np.ndarray,
    lower_wick_ratio: float = 2.0,
) -> np.ndarray:
    """Detect hammer patterns: small body at top, long lower shadow.

    A hammer has a lower wick at least N times the body size, with
    minimal upper wick.

    Args:
        open_: Open prices.
        high: High prices.
        low: Low prices.
        close: Close prices.
        lower_wick_ratio: Min ratio of lower wick to body.

    Returns:
        Array with +100 where bullish hammer detected, 0 otherwise.
    """
    n = len(close)
    result = np.zeros(n, dtype=np.int32)
    for i in range(n):
        body = abs(close[i] - open_[i])
        if body == 0:
            continue
        body_top = max(open_[i], close[i])
        body_bottom = min(open_[i], close[i])
        lower_wick = body_bottom - low[i]
        upper_wick = high[i] - body_top

        # Hammer: long lower wick, short upper wick, small body
        if (lower_wick >= lower_wick_ratio * body
                and upper_wick <= body * 0.5):
            result[i] = 100
    return result


def detect_shooting_star(
    open_: np.ndarray,
    high: np.ndarray,
    low: np.ndarray,
    close: np.ndarray,
    upper_wick_ratio: float = 2.0,
) -> np.ndarray:
    """Detect shooting star patterns: small body at bottom, long upper shadow.

    Args:
        open_: Open prices.
        high: High prices.
        low: Low prices.
        close: Close prices.
        upper_wick_ratio: Min ratio of upper wick to body.

    Returns:
        Array with -100 where shooting star detected, 0 otherwise.
    """
    n = len(close)
    result = np.zeros(n, dtype=np.int32)
    for i in range(n):
        body = abs(close[i] - open_[i])
        if body == 0:
            continue
        body_top = max(open_[i], close[i])
        body_bottom = min(open_[i], close[i])
        upper_wick = high[i] - body_top
        lower_wick = body_bottom - low[i]

        if (upper_wick >= upper_wick_ratio * body
                and lower_wick <= body * 0.5):
            result[i] = -100
    return result


def detect_engulfing(
    open_: np.ndarray,
    high: np.ndarray,
    low: np.ndarray,
    close: np.ndarray,
) -> np.ndarray:
    """Detect bullish and bearish engulfing patterns.

    Bullish engulfing: bearish bar followed by bullish bar whose body
    completely engulfs the prior bar's body.
    Bearish engulfing: bullish bar followed by bearish bar that engulfs.

    Args:
        open_: Open prices.
        high: High prices.
        low: Low prices.
        close: Close prices.

    Returns:
        Array with +100 (bullish) or -100 (bearish) engulfing, 0 otherwise.
    """
    n = len(close)
    result = np.zeros(n, dtype=np.int32)
    for i in range(1, n):
        prev_body_top = max(open_[i - 1], close[i - 1])
        prev_body_bot = min(open_[i - 1], close[i - 1])
        curr_body_top = max(open_[i], close[i])
        curr_body_bot = min(open_[i], close[i])

        prev_bearish = close[i - 1] < open_[i - 1]
        prev_bullish = close[i - 1] > open_[i - 1]
        curr_bearish = close[i] < open_[i]
        curr_bullish = close[i] > open_[i]

        # Bullish engulfing: prev bearish, current bullish, engulfs
        if (prev_bearish and curr_bullish
                and curr_body_bot <= prev_body_bot
                and curr_body_top >= prev_body_top
                and (curr_body_top - curr_body_bot) > (prev_body_top - prev_body_bot)):
            result[i] = 100

        # Bearish engulfing: prev bullish, current bearish, engulfs
        elif (prev_bullish and curr_bearish
              and curr_body_bot <= prev_body_bot
              and curr_body_top >= prev_body_top
              and (curr_body_top - curr_body_bot) > (prev_body_top - prev_body_bot)):
            result[i] = -100

    return result


def scan_manual_patterns(
    open_: np.ndarray,
    high: np.ndarray,
    low: np.ndarray,
    close: np.ndarray,
) -> List[PatternResult]:
    """Scan using manual fallback pattern detection.

    Detects doji, hammer, shooting star, and engulfing patterns
    without TA-Lib.

    Args:
        open_: Open prices.
        high: High prices.
        low: Low prices.
        close: Close prices.

    Returns:
        List of PatternResult for detected patterns.
    """
    manual_scanners = [
        ("CDLDOJI", "Doji (manual)", detect_doji),
        ("CDLHAMMER", "Hammer (manual)", detect_hammer),
        ("CDLSHOOTINGSTAR", "Shooting Star (manual)", detect_shooting_star),
        ("CDLENGULFING", "Engulfing (manual)", detect_engulfing),
    ]

    results: List[PatternResult] = []
    for name, display, func in manual_scanners:
        output = func(open_, high, low, close)
        hits = np.nonzero(output)[0]
        if len(hits) > 0:
            pr = PatternResult(name=name, display_name=display)
            for idx in hits:
                pr.detections.append(PatternDetection(
                    bar_index=int(idx),
                    value=int(output[idx]),
                    close_price=float(close[idx]),
                ))
            results.append(pr)

    results.sort(key=lambda r: r.count, reverse=True)
    return results


# ── Display Functions ──────────────────────────────────────────────

def print_pattern_summary(results: List[PatternResult], bars: int) -> None:
    """Print a summary table of all detected patterns.

    Args:
        results: List of PatternResult objects.
        bars: Total number of bars scanned.
    """
    total_detections = sum(r.count for r in results)
    print(f"\n{'='*70}")
    print(f"Pattern Scan Summary — {bars} bars, "
          f"{len(results)} pattern types, {total_detections} total detections")
    print(f"{'='*70}")

    if not results:
        print("No patterns detected.")
        return

    print(f"{'Pattern':<35} {'Total':>6} {'Bull':>6} {'Bear':>6}")
    print(f"{'-'*35} {'-'*6} {'-'*6} {'-'*6}")

    for r in results:
        print(f"{r.display_name:<35} {r.count:>6} "
              f"{r.bullish_count:>6} {r.bearish_count:>6}")

    print(f"{'-'*35} {'-'*6} {'-'*6} {'-'*6}")
    total_bull = sum(r.bullish_count for r in results)
    total_bear = sum(r.bearish_count for r in results)
    print(f"{'TOTAL':<35} {total_detections:>6} {total_bull:>6} {total_bear:>6}")


def print_recent_detections(
    results: List[PatternResult],
    n_recent: int = 10,
) -> None:
    """Print the N most recent pattern detections across all patterns.

    Args:
        results: List of PatternResult objects.
        n_recent: Number of recent detections to show.
    """
    # Flatten all detections with pattern name
    all_detections: List[Tuple[str, PatternDetection]] = []
    for r in results:
        for d in r.detections:
            all_detections.append((r.display_name, d))

    # Sort by bar index descending
    all_detections.sort(key=lambda x: x[1].bar_index, reverse=True)
    recent = all_detections[:n_recent]

    print(f"\n{'='*70}")
    print(f"Most Recent {min(n_recent, len(recent))} Detections")
    print(f"{'='*70}")

    if not recent:
        print("No detections to display.")
        return

    print(f"{'Bar':>6} {'Pattern':<35} {'Signal':>8} {'Price':>12}")
    print(f"{'-'*6} {'-'*35} {'-'*8} {'-'*12}")

    for name, det in recent:
        signal = "BULL" if det.value > 0 else "BEAR"
        color_signal = f"+{det.value}" if det.value > 0 else str(det.value)
        print(f"{det.bar_index:>6} {name:<35} {color_signal:>8} "
              f"{det.close_price:>12.4f}")


def print_pattern_distribution(results: List[PatternResult], bars: int) -> None:
    """Print where patterns cluster in the data.

    Args:
        results: List of PatternResult objects.
        bars: Total number of bars.
    """
    if not results:
        return

    # Divide into quartiles
    q_size = bars // 4
    quartile_counts = [0, 0, 0, 0]

    for r in results:
        for d in r.detections:
            q = min(d.bar_index // q_size, 3)
            quartile_counts[q] += 1

    total = sum(quartile_counts)
    if total == 0:
        return

    print(f"\n--- Pattern Distribution by Quarter ---")
    labels = ["Q1 (oldest)", "Q2", "Q3", "Q4 (newest)"]
    for i, label in enumerate(labels):
        pct = quartile_counts[i] / total * 100 if total > 0 else 0
        bar = "#" * int(pct / 2)
        print(f"  {label:<15} {quartile_counts[i]:>4} ({pct:>5.1f}%) {bar}")


# ── Main ───────────────────────────────────────────────────────────

def main() -> None:
    """Entry point: generate data, scan patterns, display results."""
    parser = argparse.ArgumentParser(
        description="Scan OHLCV data for candlestick patterns."
    )
    parser.add_argument(
        "--demo", action="store_true",
        help="Run demo with synthetic data containing embedded patterns."
    )
    parser.add_argument(
        "--bars", type=int, default=500,
        help="Number of OHLCV bars to generate (default: 500)."
    )
    parser.add_argument(
        "--recent", type=int, default=15,
        help="Number of recent detections to display (default: 15)."
    )
    args = parser.parse_args()

    bars = args.bars
    print(f"TA-Lib available: {TALIB_AVAILABLE}")
    print(f"Generating {bars} bars of synthetic OHLCV data with embedded patterns...")

    df = generate_pattern_data(bars=bars)
    open_ = df["open"].values.astype(np.float64)
    high = df["high"].values.astype(np.float64)
    low = df["low"].values.astype(np.float64)
    close = df["close"].values.astype(np.float64)

    print(f"Price range: {close.min():.2f} - {close.max():.2f}")

    if TALIB_AVAILABLE:
        print(f"\nScanning all 61 TA-Lib candlestick patterns...")
        results = scan_talib_patterns(open_, high, low, close)
    else:
        print(f"\nTA-Lib not installed. Using manual fallback for 4 patterns.")
        print("Install TA-Lib for all 61 patterns:")
        print("  brew install ta-lib && uv pip install TA-Lib")
        results = scan_manual_patterns(open_, high, low, close)

    print_pattern_summary(results, bars)
    print_recent_detections(results, n_recent=args.recent)
    print_pattern_distribution(results, bars)

    # If both available, compare
    if TALIB_AVAILABLE:
        print(f"\n--- Manual Fallback Comparison ---")
        manual_results = scan_manual_patterns(open_, high, low, close)
        for mr in manual_results:
            # Find corresponding TA-Lib result
            talib_match = next((r for r in results if r.name == mr.name), None)
            talib_count = talib_match.count if talib_match else 0
            print(f"  {mr.display_name:<35} manual={mr.count:>4}, "
                  f"talib={talib_count:>4}")

    print("\nNote: This is synthetic data for demonstration purposes only.")
    print("Not financial advice. Use with real market data for actual analysis.")


if __name__ == "__main__":
    main()