Ftd Detector

#!/usr/bin/env python3
# GENERATED by scripts/generate_fmp_client.py — do not edit.
# Source of truth: scripts/fmp_client/ (core_template.py.tmpl, registry.py, extensions/).
# Regenerate: python3 scripts/generate_fmp_client.py
"""
FMP API Client for FTD Detector

Provides rate-limited access to Financial Modeling Prep API endpoints.

Features:
- Rate limiting (0.3s between requests)
- Automatic retry on 429 errors
- Session caching for duplicate requests
- Batch quote support
"""

import os
import sys
import time
from datetime import date, timedelta
from typing import Optional

try:
    import requests
except ImportError:
    print("ERROR: requests library not found. Install with: pip install requests", file=sys.stderr)
    sys.exit(1)


# --- FMP endpoint fallback: stable (new users) -> v3 (legacy users) ---


def _stable_quote_url(base, symbols_str, params):
    """stable/quote?symbol=^GSPC"""
    params["symbol"] = symbols_str
    return base, params


def _v3_quote_url(base, symbols_str, params):
    """api/v3/quote/^GSPC"""
    return f"{base}/{symbols_str}", params


def _stable_hist_url(base, symbols_str, params):
    """stable/historical-price-eod/full?symbol=^GSPC&from=...&to=..."""
    params["symbol"] = symbols_str
    # New stable EOD endpoint ignores `timeseries`; convert to from/to range
    # to bound the payload. Use 2x calendar days to cover N trading days
    # (trading-day/calendar-day ratio ~252/365 ~0.69, so *2 leaves headroom).
    days = params.pop("timeseries", None)
    if days is not None:
        today = date.today()
        params["from"] = (today - timedelta(days=int(days) * 2)).isoformat()
        params["to"] = today.isoformat()
    return base, params


def _v3_hist_url(base, symbols_str, params):
    """api/v3/historical-price-full/^GSPC?timeseries=80"""
    return f"{base}/{symbols_str}", params


_FMP_ENDPOINTS = {
    "quote": [
        ("https://financialmodelingprep.com/stable/quote", _stable_quote_url),
        ("https://financialmodelingprep.com/api/v3/quote", _v3_quote_url),
    ],
    "historical": [
        ("https://financialmodelingprep.com/stable/historical-price-eod/full", _stable_hist_url),
        ("https://financialmodelingprep.com/api/v3/historical-price-full", _v3_hist_url),
    ],
}


def _normalize_eod_flat_list(data, symbols_str: str, limit: Optional[int] = None):
    """Convert stable/historical-price-eod/full flat list to v3-compatible dict.

    Input  : [{"symbol": "SPY", "date": "...", "open": ..., ...}, ...]
    Output : {"symbol": "SPY", "historical": [{"date": ..., "open": ..., ...}, ...]}

    Returns the input unchanged if not a list (passthrough for v3 dict /
    historicalStockList responses). Returns None when no row matches the
    requested symbol; the caller will record the failure and try the next
    endpoint.

    If `limit` is provided (the original `timeseries=N` request), the
    `historical` list is truncated to the first `limit` entries. The new
    EOD endpoint ignores `timeseries` and returns the full available history,
    so the caller's date-range bounding plus this truncation together preserve
    the legacy "most-recent N rows" contract. Truncation assumes descending
    date order, which the FMP EOD endpoint provides (verified live).

    Note: empty list ``[]`` does not reach this normalizer because the caller's
    ``if not data: continue`` falsy check handles it earlier in
    ``_request_with_fallback``.
    """
    if not isinstance(data, list):
        return data
    if not data:
        return None
    norm_target = symbols_str.replace("-", ".")
    matched_symbol = None
    historical = []
    for row in data:
        if not isinstance(row, dict):
            continue
        # Be permissive: single-symbol endpoint may omit per-row "symbol".
        # Treat missing symbol as belonging to the requested symbols_str.
        row_sym = row.get("symbol") or symbols_str
        if row_sym.replace("-", ".") != norm_target:
            continue
        matched_symbol = matched_symbol or row_sym
        historical.append({k: v for k, v in row.items() if k != "symbol"})
    if not historical:
        return None
    if limit is not None and limit > 0:
        historical = historical[:limit]
    return {"symbol": matched_symbol or symbols_str, "historical": historical}


class FMPClient:
    """Client for Financial Modeling Prep API with rate limiting and caching"""

    BASE_URL = "https://financialmodelingprep.com/api/v3"
    RATE_LIMIT_DELAY = 0.3  # 300ms between requests

    _ENDPOINT_FAILURE_THRESHOLD = 3  # disable endpoint after N consecutive failures

    def __init__(self, api_key: Optional[str] = None):
        self.api_key = api_key or os.getenv("FMP_API_KEY")
        if not self.api_key:
            raise ValueError(
                "FMP API key required. Set FMP_API_KEY environment variable "
                "or pass api_key parameter."
            )
        self.session = requests.Session()
        self.session.headers.update({"apikey": self.api_key})
        self.cache = {}
        self.last_call_time = 0
        self.rate_limit_reached = False
        self.retry_count = 0
        self.max_retries = 1
        self.api_calls_made = 0
        # Circuit breaker: track consecutive failures per endpoint URL prefix
        self._endpoint_failures: dict[str, int] = {}
        self._disabled_endpoints: set[str] = set()
        # Most recent transport-level failure reason; set by _rate_limited_get
        # so _request_with_fallback can surface suppressed errors even when
        # an endpoint was called with quiet=True.
        self._last_error: Optional[str] = None

    def _rate_limited_get(
        self, url: str, params: Optional[dict] = None, quiet: bool = False
    ) -> Optional[dict]:
        self._last_error = None
        if self.rate_limit_reached:
            self._last_error = "daily rate limit already reached"
            return None

        if params is None:
            params = {}

        elapsed = time.time() - self.last_call_time
        if elapsed < self.RATE_LIMIT_DELAY:
            time.sleep(self.RATE_LIMIT_DELAY - elapsed)

        try:
            response = self.session.get(url, params=params, timeout=30)
            self.last_call_time = time.time()
            self.api_calls_made += 1

            if response.status_code == 200:
                self.retry_count = 0
                return response.json()
            elif response.status_code == 429:
                self.retry_count += 1
                if self.retry_count <= self.max_retries:
                    print("WARNING: Rate limit exceeded. Waiting 60 seconds...", file=sys.stderr)
                    time.sleep(60)
                    return self._rate_limited_get(url, params, quiet=quiet)
                else:
                    self._last_error = "HTTP 429 (daily rate limit)"
                    print("ERROR: Daily API rate limit reached.", file=sys.stderr)
                    self.rate_limit_reached = True
                    return None
            else:
                msg = f"HTTP {response.status_code} - {response.text[:200]}"
                self._last_error = msg
                if not quiet:
                    print(
                        f"ERROR: API request failed: {msg}",
                        file=sys.stderr,
                    )
                return None
        except requests.exceptions.RequestException as e:
            self._last_error = f"request exception: {e}"
            print(f"ERROR: Request exception: {e}", file=sys.stderr)
            return None

    def _request_with_fallback(self, endpoint_key, symbols_str, extra_params=None):
        """Try stable endpoint first, fall back to v3 for legacy users.

        Returns parsed JSON in v3-compatible shape, or None if all fail.
        Non-last endpoints are called with quiet=True so the user isn't
        alarmed by an expected stable failure when v3 will catch it — but
        when a non-last endpoint DOES fail, a WARN line is emitted explaining
        why we're falling back. Otherwise users only see the (often misleading)
        last-endpoint error and have no clue what really went wrong.
        """
        params = dict(extra_params) if extra_params else {}
        endpoints = _FMP_ENDPOINTS[endpoint_key]
        is_single = "," not in symbols_str

        for i, (base_url, url_builder) in enumerate(endpoints):
            # Circuit breaker: skip endpoints with too many consecutive failures
            if base_url in self._disabled_endpoints:
                continue

            url, final_params = url_builder(base_url, symbols_str, dict(params))
            is_last = i == len(endpoints) - 1
            data = self._rate_limited_get(url, final_params, quiet=not is_last)
            if not data:  # falsy (None, [], {}) — try next endpoint
                self._record_endpoint_failure(base_url)
                self._warn_fallback(base_url, is_last, self._last_error)
                continue

            # Normalize new stable EOD flat-list shape to v3-compatible dict.
            # No-op for v3 dict / historicalStockList responses.
            # `timeseries` (original request) is passed as `limit` so the
            # EOD endpoint's full-history response is truncated to the
            # legacy "most-recent N rows" contract.
            if endpoint_key == "historical":
                limit = params.get("timeseries") if isinstance(params, dict) else None
                data = _normalize_eod_flat_list(data, symbols_str, limit=limit)
                if not data:
                    self._record_endpoint_failure(base_url)
                    self._warn_fallback(
                        base_url,
                        is_last,
                        f"response had no rows matching '{symbols_str}'",
                    )
                    continue

            # Shape validation: reject truthy-but-wrong-shape responses
            valid = True
            shape_issue: Optional[str] = None
            if endpoint_key == "quote":
                if not isinstance(data, list) or len(data) == 0:
                    valid = False
                    shape_issue = "expected non-empty list"
                elif is_single and not any(
                    q.get("symbol", "").replace("-", ".") == symbols_str.replace("-", ".")
                    for q in data
                ):
                    valid = False
                    shape_issue = f"requested symbol '{symbols_str}' not in response"

            if endpoint_key == "historical":
                if not isinstance(data, dict):
                    valid = False
                    shape_issue = "expected dict"
                elif "historicalStockList" in data:
                    # stable batch format -> v3 single format (exact match only)
                    norm = symbols_str.replace("-", ".")
                    found = None
                    for entry in data["historicalStockList"]:
                        if entry.get("symbol", "").replace("-", ".") == norm:
                            found = {
                                "symbol": entry.get("symbol"),
                                "historical": entry.get("historical", []),
                            }
                            break
                    if found:
                        self._endpoint_failures[base_url] = 0
                        return found
                    valid = False
                    shape_issue = f"'{symbols_str}' not in historicalStockList"
                elif "historical" not in data:
                    valid = False
                    shape_issue = "missing 'historical' key"
                elif is_single and data.get("symbol"):
                    if data["symbol"].replace("-", ".") != symbols_str.replace("-", "."):
                        valid = False
                        shape_issue = (
                            f"response symbol '{data['symbol']}' != requested '{symbols_str}'"
                        )

            if valid:
                self._endpoint_failures[base_url] = 0
                return data
            self._record_endpoint_failure(base_url)
            self._warn_fallback(base_url, is_last, shape_issue or "unexpected response shape")
        return None

    def _warn_fallback(self, base_url: str, is_last: bool, reason: Optional[str]) -> None:
        """Emit a WARN line so users see why a non-last endpoint failed and the
        client is falling back. No-op when the failing endpoint is the last one
        (its error was already printed by _rate_limited_get with quiet=False)."""
        if is_last or not reason:
            return
        print(
            f"WARN: {base_url} failed ({reason}); falling back to next endpoint",
            file=sys.stderr,
        )

    def _record_endpoint_failure(self, base_url: str) -> None:
        """Track consecutive failures and disable endpoint after threshold."""
        failures = self._endpoint_failures.get(base_url, 0) + 1
        self._endpoint_failures[base_url] = failures
        if failures >= self._ENDPOINT_FAILURE_THRESHOLD:
            self._disabled_endpoints.add(base_url)

    def get_quote(self, symbols: str) -> Optional[list[dict]]:
        """Fetch real-time quote data for one or more symbols (comma-separated)"""
        cache_key = f"quote_{symbols}"
        if cache_key in self.cache:
            return self.cache[cache_key]

        data = self._request_with_fallback("quote", symbols)
        if data:
            self.cache[cache_key] = data
        return data

    def get_batch_quotes(self, symbols: list[str]) -> dict[str, dict]:
        """Fetch quotes for a list of symbols, batching up to 5 per request"""
        results = {}
        batch_size = 5
        for i in range(0, len(symbols), batch_size):
            batch = symbols[i : i + batch_size]
            batch_str = ",".join(batch)
            quotes = self.get_quote(batch_str)
            if quotes:
                for q in quotes:
                    results[q["symbol"]] = q
        return results

    def get_batch_historical(self, symbols: list[str], days: int = 50) -> dict[str, list[dict]]:
        """Fetch historical prices for multiple symbols"""
        results = {}
        for symbol in symbols:
            data = self.get_historical_prices(symbol, days=days)
            if data and "historical" in data:
                results[symbol] = data["historical"]
        return results

    def calculate_sma(self, prices: list[float], period: int) -> float:
        """Calculate Simple Moving Average from a list of prices (most recent first)"""
        if len(prices) < period:
            return sum(prices) / len(prices)
        return sum(prices[:period]) / period

    def calculate_ema(self, prices: list[float], period: int) -> float:
        """Calculate Exponential Moving Average from a list of prices (most recent first)"""
        if len(prices) < period:
            return sum(prices) / len(prices)

        prices_reversed = prices[::-1]
        sma = sum(prices_reversed[:period]) / period
        ema = sma
        k = 2 / (period + 1)
        for price in prices_reversed[period:]:
            ema = price * k + ema * (1 - k)
        return ema

    def get_historical_prices(self, symbol: str, days: int = 365) -> Optional[dict]:
        """Fetch historical daily OHLCV data.

        Args:
            symbol: Stock symbol
            days: Number of trading days to fetch

        Returns:
            Dict with 'symbol' and 'historical' keys, where 'historical' is a
            list of price dicts (most-recent-first) with: date, open, high, low,
            close, adjClose, volume
        """
        cache_key = f"prices_{symbol}_{days}"
        if cache_key in self.cache:
            return self.cache[cache_key]

        data = self._request_with_fallback("historical", symbol, {"timeseries": days})
        if data:
            self.cache[cache_key] = data
        return data

    def get_api_stats(self) -> dict:
        """Return API usage statistics."""
        return {
            "cache_entries": len(self.cache),
            "api_calls_made": self.api_calls_made,
            "rate_limit_reached": self.rate_limit_reached,
        }

#!/usr/bin/env python3
"""
FTD Detector - Main Orchestrator

Detects Follow-Through Day (FTD) signals for market bottom confirmation
using William O'Neil's methodology with dual-index tracking.

Usage:
    python3 ftd_detector.py --api-key YOUR_KEY
    python3 ftd_detector.py  # uses FMP_API_KEY env var

Output:
    - JSON: ftd_detector_YYYY-MM-DD_HHMMSS.json
    - Markdown: ftd_detector_YYYY-MM-DD_HHMMSS.md
"""

import argparse
import os
import sys
from datetime import datetime

# Add parent directory to path for imports
sys.path.insert(0, os.path.dirname(__file__))

from fmp_client import FMPClient
from post_ftd_monitor import assess_post_ftd_health
from rally_tracker import get_market_state
from report_generator import generate_json_report, generate_markdown_report


def parse_arguments():
    parser = argparse.ArgumentParser(
        description="FTD Detector - Follow-Through Day Bottom Confirmation"
    )
    parser.add_argument(
        "--api-key", help="FMP API key (defaults to FMP_API_KEY environment variable)"
    )
    parser.add_argument(
        "--output-dir",
        default=".",
        help="Output directory for reports (default: current directory)",
    )
    return parser.parse_args()


def main():
    args = parse_arguments()

    print("=" * 70)
    print("FTD Detector - Follow-Through Day Bottom Confirmation")
    print("O'Neil Rally Attempt + FTD State Machine (Dual Index)")
    print("=" * 70)
    print()

    # Initialize FMP client
    try:
        client = FMPClient(api_key=args.api_key)
        print("FMP API client initialized")
    except ValueError as e:
        print(f"ERROR: {e}", file=sys.stderr)
        sys.exit(1)

    # ========================================================================
    # Step 1: Fetch Market Data (4 API calls)
    # ========================================================================
    print()
    print("Step 1: Fetching Market Data")
    print("-" * 70)

    # S&P 500 history (60 trading days)
    print("  Fetching S&P 500 history...", end=" ", flush=True)
    sp500_history_data = client.get_historical_prices("^GSPC", days=80)
    sp500_history = sp500_history_data.get("historical", []) if sp500_history_data else []
    if sp500_history:
        print(f"OK ({len(sp500_history)} days)")
    else:
        print("FAILED")
        print("ERROR: Cannot proceed without S&P 500 data", file=sys.stderr)
        sys.exit(1)

    # NASDAQ/QQQ history (60 trading days)
    print("  Fetching NASDAQ (QQQ) history...", end=" ", flush=True)
    qqq_history_data = client.get_historical_prices("QQQ", days=80)
    qqq_history = qqq_history_data.get("historical", []) if qqq_history_data else []
    if qqq_history:
        print(f"OK ({len(qqq_history)} days)")
    else:
        print("WARN - NASDAQ data unavailable, using S&P 500 only")

    # S&P 500 quote (for current price)
    print("  Fetching S&P 500 quote...", end=" ", flush=True)
    sp500_quote_list = client.get_quote("^GSPC")
    sp500_quote = sp500_quote_list[0] if sp500_quote_list else None
    if sp500_quote:
        print(f"OK (${sp500_quote.get('price', 0):.2f})")
    else:
        print("WARN - Using historical close as current price")

    # QQQ quote
    print("  Fetching QQQ quote...", end=" ", flush=True)
    qqq_quote_list = client.get_quote("QQQ")
    qqq_quote = qqq_quote_list[0] if qqq_quote_list else None
    if qqq_quote:
        print(f"OK (${qqq_quote.get('price', 0):.2f})")
    else:
        print("WARN - Using historical close as current price")

    print()

    # ========================================================================
    # Step 2: Run State Machine (Rally Tracker)
    # ========================================================================
    print("Step 2: Analyzing Market State")
    print("-" * 70)

    market_state = get_market_state(sp500_history, qqq_history)

    sp500_state = market_state["sp500"]["state"]
    nasdaq_state = market_state["nasdaq"]["state"]
    combined = market_state["combined_state"]

    print(f"  S&P 500 State: {sp500_state}")
    print(f"  NASDAQ State:  {nasdaq_state}")
    print(f"  Combined:      {combined}")

    # Print swing low info if found
    for label, idx_data in [("S&P 500", market_state["sp500"]), ("NASDAQ", market_state["nasdaq"])]:
        swing = idx_data.get("swing_low")
        if swing:
            print(
                f"  {label} Swing Low: {swing['swing_low_date']} "
                f"(${swing['swing_low_price']:.2f}, "
                f"{swing['decline_pct']:.1f}% decline)"
            )
        rally = idx_data.get("rally_attempt")
        if rally and rally.get("day1_date"):
            print(f"  {label} Rally Day 1: {rally['day1_date']} (Day {rally['current_day_count']})")

    print()

    # ========================================================================
    # Step 3: Post-FTD Health Assessment
    # ========================================================================
    print("Step 3: Post-FTD Health Assessment")
    print("-" * 70)

    # Convert to chronological for post-FTD analysis
    sp500_chrono = list(reversed(sp500_history))
    nasdaq_chrono = list(reversed(qqq_history)) if qqq_history else []

    market_state = assess_post_ftd_health(market_state, sp500_chrono, nasdaq_chrono)

    quality = market_state.get("quality_score", {})
    print(f"  Quality Score: {quality.get('total_score', 0)}/100")
    print(f"  Signal: {quality.get('signal', 'N/A')}")
    print(f"  Guidance: {quality.get('guidance', 'N/A')}")
    print(f"  Exposure Range: {quality.get('exposure_range', 'N/A')}")

    # Power trend
    pt = market_state.get("power_trend", {})
    if pt:
        print(
            f"  Power Trend: {'YES' if pt.get('power_trend') else 'No'} "
            f"({pt.get('conditions_met', 0)}/3 conditions)"
        )

    # Post-FTD distribution
    dist = market_state.get("post_ftd_distribution", {})
    if dist:
        print(
            f"  Post-FTD Distribution Days: {dist.get('distribution_count', 0)} "
            f"(monitored {dist.get('days_monitored', 0)} days)"
        )

    # Invalidation
    inv = market_state.get("ftd_invalidation", {})
    if inv and inv.get("invalidated"):
        print(
            f"  FTD INVALIDATED on {inv.get('invalidation_date')} "
            f"({inv.get('days_after_ftd')} days after FTD)"
        )

    print()

    # ========================================================================
    # Step 4: Generate Reports
    # ========================================================================
    print("Step 4: Generating Reports")
    print("-" * 70)

    analysis = {
        "metadata": {
            "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "api_calls": client.get_api_stats(),
            "index_prices": {
                "sp500": sp500_quote.get("price", 0)
                if sp500_quote
                else (sp500_history[0].get("close", 0) if sp500_history else None),
                "qqq": qqq_quote.get("price", 0)
                if qqq_quote
                else (qqq_history[0].get("close", 0) if qqq_history else None),
            },
        },
        "market_state": {
            "combined_state": market_state["combined_state"],
            "dual_confirmation": market_state["dual_confirmation"],
            "ftd_index": market_state.get("ftd_index"),
        },
        "sp500": _serialize_index(market_state["sp500"]),
        "nasdaq": _serialize_index(market_state["nasdaq"]),
        "quality_score": quality,
        "post_ftd_distribution": market_state.get("post_ftd_distribution", {}),
        "ftd_invalidation": market_state.get("ftd_invalidation", {}),
        "power_trend": market_state.get("power_trend", {}),
    }

    timestamp = datetime.now().strftime("%Y-%m-%d_%H%M%S")
    json_file = os.path.join(args.output_dir, f"ftd_detector_{timestamp}.json")
    md_file = os.path.join(args.output_dir, f"ftd_detector_{timestamp}.md")

    generate_json_report(analysis, json_file)
    generate_markdown_report(analysis, md_file)

    print()
    print("=" * 70)
    print("FTD Detection Complete")
    print("=" * 70)
    print(f"  Combined State: {market_state['combined_state']}")
    print(f"  Quality Score: {quality.get('total_score', 0)}/100 ({quality.get('signal', 'N/A')})")
    print(f"  JSON Report: {json_file}")
    print(f"  Markdown Report: {md_file}")
    print()

    stats = client.get_api_stats()
    print("API Usage:")
    print(f"  API calls made: {stats['api_calls_made']}")
    print(f"  Cache entries: {stats['cache_entries']}")
    print()


def _serialize_index(idx_data: dict) -> dict:
    """Serialize index analysis for JSON output, removing large rally_days lists."""
    result = {
        "state": idx_data.get("state"),
        "current_price": idx_data.get("current_price"),
        "lookback_high": idx_data.get("lookback_high"),
        "correction_depth_pct": idx_data.get("correction_depth_pct"),
    }

    swing = idx_data.get("swing_low")
    if swing:
        result["swing_low"] = {
            "date": swing.get("swing_low_date"),
            "price": swing.get("swing_low_price"),
            "decline_pct": swing.get("decline_pct"),
            "down_days": swing.get("down_days"),
            "recent_high_date": swing.get("recent_high_date"),
            "recent_high_price": swing.get("recent_high_price"),
        }

    rally = idx_data.get("rally_attempt")
    if rally:
        result["rally_attempt"] = {
            "day1_date": rally.get("day1_date"),
            "current_day_count": rally.get("current_day_count"),
            "invalidated": rally.get("invalidated"),
            "invalidation_reason": rally.get("invalidation_reason"),
        }

    ftd = idx_data.get("ftd")
    if ftd:
        result["ftd"] = {
            "ftd_detected": ftd.get("ftd_detected"),
            "ftd_date": ftd.get("ftd_date"),
            "ftd_day_number": ftd.get("ftd_day_number"),
            "ftd_low": ftd.get("ftd_low"),
            "gain_pct": ftd.get("gain_pct"),
            "gain_tier": ftd.get("gain_tier"),
            "volume_above_avg": ftd.get("volume_above_avg"),
        }

    return result


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
FTD Detector - Post-FTD Health Monitor

Monitors the health of a confirmed Follow-Through Day by tracking:
1. Distribution days after FTD (early distribution = high failure risk)
2. FTD invalidation (close below FTD day's low)
3. Power Trend confirmation (21EMA > 50SMA, slope positive)
4. Quality score calculation (0-100)
"""


def count_post_ftd_distribution(history: list[dict], ftd_idx: int) -> dict:
    """
    Count distribution days (down days on higher volume) after FTD.

    Distribution within first 1-2 days = very bearish (FTD likely fails)
    Distribution on day 3 = moderately bearish
    Distribution on day 4-5 = mild negative

    Args:
        history: Daily OHLCV in chronological order
        ftd_idx: Index of the FTD day in history

    Returns:
        Dict with distribution count, timing, and details
    """
    if ftd_idx >= len(history) - 1:
        return {
            "distribution_count": 0,
            "days_monitored": 0,
            "earliest_distribution_day": None,
            "details": [],
        }

    n = len(history)
    distributions = []
    days_monitored = 0

    for i in range(ftd_idx + 1, min(ftd_idx + 6, n)):  # Monitor up to 5 days post-FTD
        days_monitored += 1
        curr_close = history[i].get("close", 0)
        prev_close = history[i - 1].get("close", 0)
        curr_volume = history[i].get("volume", 0)
        prev_volume = history[i - 1].get("volume", 0)

        if prev_close <= 0 or prev_volume <= 0:
            continue

        change_pct = (curr_close - prev_close) / prev_close * 100

        # Distribution day: down >= 0.2% on higher volume
        if change_pct <= -0.2 and curr_volume > prev_volume:
            day_num = i - ftd_idx
            distributions.append(
                {
                    "day": day_num,
                    "date": history[i].get("date", "N/A"),
                    "change_pct": round(change_pct, 2),
                    "volume_change_pct": round((curr_volume / prev_volume - 1) * 100, 1),
                }
            )

    earliest = distributions[0]["day"] if distributions else None

    return {
        "distribution_count": len(distributions),
        "days_monitored": days_monitored,
        "earliest_distribution_day": earliest,
        "details": distributions,
    }


def check_ftd_invalidation(history: list[dict], ftd_idx: int) -> dict:
    """
    Check if FTD has been invalidated by a close below FTD day's low.

    Args:
        history: Daily OHLCV in chronological order
        ftd_idx: Index of the FTD day in history

    Returns:
        Dict with invalidated flag and details
    """
    ftd_low = history[ftd_idx].get("low", history[ftd_idx].get("close", 0))
    n = len(history)

    for i in range(ftd_idx + 1, n):
        curr_close = history[i].get("close", 0)
        if curr_close < ftd_low:
            return {
                "invalidated": True,
                "invalidation_date": history[i].get("date", "N/A"),
                "invalidation_close": curr_close,
                "ftd_low": ftd_low,
                "days_after_ftd": i - ftd_idx,
            }

    return {
        "invalidated": False,
        "ftd_low": ftd_low,
        "days_since_ftd": n - 1 - ftd_idx,
    }


def detect_power_trend(history: list[dict]) -> dict:
    """
    Detect Power Trend confirmation signals.

    Power Trend conditions:
    1. 21-day EMA > 50-day SMA
    2. 50-day SMA slope is positive (rising over last 5 days)
    3. Price above 21-day EMA

    Args:
        history: Daily OHLCV in chronological order (need 50+ days)

    Returns:
        Dict with power_trend flag and component checks
    """
    if len(history) < 50:
        return {
            "power_trend": False,
            "reason": "Insufficient data (need 50+ days)",
            "ema_21": None,
            "sma_50": None,
            "price_above_21ema": None,
            "sma_50_rising": None,
        }

    closes = [d.get("close", 0) for d in history]

    # Calculate 21-day EMA (using most recent data)
    ema_21 = _calculate_ema(closes, 21)

    # Calculate 50-day SMA (current)
    sma_50_current = sum(closes[-50:]) / 50

    # Calculate 50-day SMA from 5 days ago
    if len(closes) >= 55:
        sma_50_5d_ago = sum(closes[-55:-5]) / 50
        sma_50_rising = sma_50_current > sma_50_5d_ago
    else:
        sma_50_rising = None

    current_price = closes[-1]
    price_above_21ema = current_price > ema_21
    ema_above_sma = ema_21 > sma_50_current

    power_trend = ema_above_sma and (sma_50_rising is True) and price_above_21ema

    conditions_met = sum(
        [
            ema_above_sma,
            sma_50_rising is True,
            price_above_21ema,
        ]
    )

    return {
        "power_trend": power_trend,
        "conditions_met": conditions_met,
        "ema_21": round(ema_21, 2),
        "sma_50": round(sma_50_current, 2),
        "current_price": round(current_price, 2),
        "ema_above_sma": ema_above_sma,
        "sma_50_rising": sma_50_rising,
        "price_above_21ema": price_above_21ema,
    }


def calculate_ftd_quality_score(market_state: dict) -> dict:
    """
    Calculate FTD quality score (0-100) based on multiple factors.

    Scoring:
    - Base (FTD Day): Day 4-7 = 60pts, Day 8-10 = 50pts
    - Price Gain: >=2.0% = +15, >=1.5% = +10, >=1.25% = +5
    - Volume vs 50-day avg: Above = +10, Below = +0
    - Dual Index Confirm: Both = +15, Single = +0
    - Post-FTD Health (Day 1-5): No dist = +10, Dist Day 4-5 = -5,
                                  Dist Day 3 = -15, Dist Day 1-2 = -30

    Args:
        market_state: Output from get_market_state() with post-FTD analysis

    Returns:
        Dict with total_score, breakdown, signal, and guidance
    """
    score = 0
    breakdown = {}

    # Find the primary FTD data
    sp500 = market_state.get("sp500", {})
    nasdaq = market_state.get("nasdaq", {})
    dual = market_state.get("dual_confirmation", False)

    # Use whichever index confirmed FTD
    ftd_data = None
    ftd_source = None
    for label, idx_data in [("S&P 500", sp500), ("NASDAQ", nasdaq)]:
        ftd = idx_data.get("ftd", {})
        if ftd and ftd.get("ftd_detected"):
            ftd_data = ftd
            ftd_source = label
            break

    if ftd_data is None:
        return {
            "total_score": 0,
            "breakdown": {},
            "signal": "No FTD",
            "guidance": "No Follow-Through Day detected. Stay defensive.",
            "exposure_range": "0-25%",
        }

    # 1. Base score from FTD day number
    day_num = ftd_data.get("ftd_day_number", 0)
    if 4 <= day_num <= 7:
        base = 60
        breakdown["base"] = f"Day {day_num} FTD: +60 (prime window)"
    elif 8 <= day_num <= 10:
        base = 50
        breakdown["base"] = f"Day {day_num} FTD: +50 (late window)"
    else:
        base = 40
        breakdown["base"] = f"Day {day_num} FTD: +40 (out of window)"
    score += base

    # 2. Price gain bonus
    gain = ftd_data.get("gain_pct", 0)
    if gain >= FTD_GAIN_STRONG:
        gain_bonus = 15
        breakdown["gain"] = f"{gain:+.2f}% gain: +15 (strong)"
    elif gain >= FTD_GAIN_RECOMMENDED:
        gain_bonus = 10
        breakdown["gain"] = f"{gain:+.2f}% gain: +10 (recommended)"
    elif gain >= FTD_GAIN_MINIMUM:
        gain_bonus = 5
        breakdown["gain"] = f"{gain:+.2f}% gain: +5 (minimum)"
    else:
        gain_bonus = 0
        breakdown["gain"] = f"{gain:+.2f}% gain: +0"
    score += gain_bonus

    # 3. Volume vs 50-day average
    vol_above = ftd_data.get("volume_above_avg")
    if vol_above is True:
        vol_bonus = 10
        breakdown["volume"] = "Above 50-day avg volume: +10"
    elif vol_above is False:
        vol_bonus = 0
        breakdown["volume"] = "Below 50-day avg volume: +0"
    else:
        vol_bonus = 0
        breakdown["volume"] = "Volume avg data unavailable: +0"
    score += vol_bonus

    # 4. Dual index confirmation
    if dual:
        dual_bonus = 15
        breakdown["dual_confirm"] = "Both S&P 500 + NASDAQ confirmed: +15"
    else:
        dual_bonus = 0
        breakdown["dual_confirm"] = f"Single index ({ftd_source}): +0"
    score += dual_bonus

    # 5. Post-FTD health (distribution days)
    post_ftd = market_state.get("post_ftd_distribution", {})
    dist_count = post_ftd.get("distribution_count", 0)
    days_monitored = post_ftd.get("days_monitored", 0)
    earliest_dist = post_ftd.get("earliest_distribution_day")

    if days_monitored == 0:
        health_adj = 0
        breakdown["post_ftd"] = "Post-FTD data not yet available: +0"
    elif dist_count == 0:
        health_adj = 10
        breakdown["post_ftd"] = f"No post-FTD distribution ({days_monitored} days clean): +10"
    elif earliest_dist is not None and earliest_dist <= 2:
        health_adj = -30
        breakdown["post_ftd"] = f"Distribution on Day {earliest_dist}: -30 (very bearish)"
    elif earliest_dist is not None and earliest_dist == 3:
        health_adj = -15
        breakdown["post_ftd"] = "Distribution on Day 3: -15 (moderately bearish)"
    elif earliest_dist is not None and earliest_dist >= 4:
        health_adj = -5
        breakdown["post_ftd"] = f"Distribution on Day {earliest_dist}: -5 (mild negative)"
    else:
        health_adj = 0
        breakdown["post_ftd"] = "Post-FTD data unavailable: +0"

    # Additional penalty for multiple distribution days (per post_ftd_guide.md)
    if dist_count >= 2:
        health_adj -= 20
        breakdown["post_ftd"] += f" + multiple distributions ({dist_count}x): -20"

    score += health_adj

    # Clamp score
    score = max(0, min(100, score))

    # FTD invalidation overrides all scoring
    inv = market_state.get("ftd_invalidation", {})
    if inv.get("invalidated"):
        breakdown["invalidation"] = (
            f"FTD invalidated on {inv.get('invalidation_date', 'N/A')} "
            f"(Day {inv.get('days_after_ftd', '?')})"
        )
        return {
            "total_score": 0,
            "breakdown": breakdown,
            "signal": "Failed/Invalidated",
            "guidance": "FTD invalidated. Reduce exposure, wait for new rally attempt.",
            "exposure_range": "0-25%",
            "ftd_source": ftd_source,
        }

    # Determine signal and guidance
    if score >= 80:
        signal = "Strong FTD"
        guidance = "Aggressively increase exposure to 75-100%."
        exposure = "75-100%"
    elif score >= 60:
        signal = "Moderate FTD"
        guidance = "Gradually increase exposure to 50-75%."
        exposure = "50-75%"
    elif score >= 40:
        signal = "Weak FTD"
        guidance = "Cautious increase to 25-50%, use tight stops."
        exposure = "25-50%"
    else:
        signal = "Failed/Weak"
        guidance = "Stay defensive, wait for new signal."
        exposure = "0-25%"

    return {
        "total_score": score,
        "breakdown": breakdown,
        "signal": signal,
        "guidance": guidance,
        "exposure_range": exposure,
        "ftd_source": ftd_source,
    }


def assess_post_ftd_health(
    market_state: dict, sp500_history: list[dict], nasdaq_history: list[dict]
) -> dict:
    """
    Full post-FTD health assessment including distribution, invalidation,
    and power trend.

    Args:
        market_state: Output from get_market_state()
        sp500_history: S&P 500 chronological history
        nasdaq_history: NASDAQ chronological history

    Returns:
        Enriched market_state with post-FTD analysis
    """
    # Find which index has the confirmed FTD
    for _label, idx_data, hist in [
        ("sp500", market_state.get("sp500", {}), sp500_history),
        ("nasdaq", market_state.get("nasdaq", {}), nasdaq_history),
    ]:
        ftd = idx_data.get("ftd", {})
        if ftd and ftd.get("ftd_detected") and hist:
            # Find FTD index in history
            ftd_date = ftd.get("ftd_date")
            ftd_idx = None
            for i, d in enumerate(hist):
                if d.get("date") == ftd_date:
                    ftd_idx = i
                    break

            if ftd_idx is not None:
                # Distribution check
                dist = count_post_ftd_distribution(hist, ftd_idx)
                market_state["post_ftd_distribution"] = dist

                # Invalidation check
                inv = check_ftd_invalidation(hist, ftd_idx)
                market_state["ftd_invalidation"] = inv

                if inv.get("invalidated"):
                    market_state["combined_state"] = "FTD_INVALIDATED"

                break  # Use first confirmed FTD index only (matches quality score logic)

    # Power trend check (use S&P 500 as primary)
    if sp500_history and len(sp500_history) >= 50:
        market_state["power_trend"] = detect_power_trend(sp500_history)
    else:
        market_state["power_trend"] = {
            "power_trend": False,
            "reason": "Insufficient S&P 500 data",
        }

    # Calculate quality score
    market_state["quality_score"] = calculate_ftd_quality_score(market_state)

    return market_state


# --- Helper ---

# Import thresholds from rally_tracker
FTD_GAIN_STRONG = 2.0
FTD_GAIN_RECOMMENDED = 1.5
FTD_GAIN_MINIMUM = 1.25


def _calculate_ema(prices: list[float], period: int) -> float:
    """Calculate EMA from chronological price list."""
    if len(prices) < period:
        return sum(prices) / len(prices) if prices else 0

    sma = sum(prices[:period]) / period
    ema = sma
    k = 2 / (period + 1)
    for price in prices[period:]:
        ema = price * k + ema * (1 - k)
    return ema

#!/usr/bin/env python3
"""
FTD Detector - Rally Tracker (State Machine)

Implements a state machine for tracking market correction → rally attempt → FTD sequence.
Supports dual-index tracking (S&P 500 + NASDAQ/QQQ).

States:
  NO_SIGNAL → CORRECTION → RALLY_ATTEMPT → FTD_WINDOW → FTD_CONFIRMED
                   ↑              ↓               ↓              ↓
                   └── RALLY_FAILED ←─────────────┘     FTD_INVALIDATED

O'Neil's FTD Rules:
- Swing low: 3%+ decline from recent high with 3+ down days
- Day 1: first up close (or close in top 50% of range) after swing low
- Day 2-3: close must not breach Day 1 intraday low
- Day 4-10: FTD requires >=1.25% gain on volume > previous day
"""

from enum import Enum
from typing import Optional


class MarketState(Enum):
    NO_SIGNAL = "NO_SIGNAL"
    CORRECTION = "CORRECTION"
    RALLY_ATTEMPT = "RALLY_ATTEMPT"
    FTD_WINDOW = "FTD_WINDOW"
    FTD_CONFIRMED = "FTD_CONFIRMED"
    RALLY_FAILED = "RALLY_FAILED"
    FTD_INVALIDATED = "FTD_INVALIDATED"


# Minimum correction depth to qualify
MIN_CORRECTION_PCT = 3.0
# Minimum down days during correction
MIN_DOWN_DAYS = 3
# FTD window bounds (inclusive)
FTD_DAY_START = 4
FTD_DAY_END = 10
# Minimum FTD gain thresholds
FTD_GAIN_MINIMUM = 1.25
FTD_GAIN_RECOMMENDED = 1.5
FTD_GAIN_STRONG = 2.0


def _is_swing_low(history: list[dict], i: int) -> Optional[dict]:
    """Check if index i in history qualifies as a swing low.

    Returns dict with swing low details, or None.
    """
    n = len(history)
    low_close = history[i].get("close", 0)
    if low_close <= 0:
        return None

    # Look back up to 40 days for a recent high
    search_start = max(0, i - 40)
    recent_high = 0
    recent_high_idx = search_start
    for j in range(search_start, i):
        c = history[j].get("close", 0)
        if c > recent_high:
            recent_high = c
            recent_high_idx = j

    if recent_high <= 0:
        return None

    decline_pct = (low_close - recent_high) / recent_high * 100

    if decline_pct > -MIN_CORRECTION_PCT:
        return None

    # Count down days from high to this point
    down_days = 0
    for j in range(recent_high_idx + 1, i + 1):
        prev_c = history[j - 1].get("close", 0)
        curr_c = history[j].get("close", 0)
        if prev_c > 0 and curr_c < prev_c:
            down_days += 1

    if down_days < MIN_DOWN_DAYS:
        return None

    # Verify it's a local minimum (not lower closes immediately adjacent)
    if i > 0:
        prev_close = history[i - 1].get("close", 0)
        if prev_close > 0 and prev_close < low_close:
            return None
    if i + 1 < n:
        next_close = history[i + 1].get("close", 0)
        if next_close > 0 and next_close < low_close:
            return None

    return {
        "swing_low_idx": i,
        "swing_low_price": low_close,
        "swing_low_date": history[i].get("date", "N/A"),
        "swing_low_low": history[i].get("low", low_close),
        "recent_high_price": recent_high,
        "recent_high_idx": recent_high_idx,
        "recent_high_date": history[recent_high_idx].get("date", "N/A"),
        "decline_pct": round(decline_pct, 2),
        "down_days": down_days,
    }


def find_swing_low(history: list[dict]) -> Optional[dict]:
    """Find the most recent qualifying swing low in chronological history."""
    if not history or len(history) < 5:
        return None
    for i in range(len(history) - 1, 3, -1):
        result = _is_swing_low(history, i)
        if result:
            return result
    return None


def _find_all_swing_lows(history: list[dict], max_count: int = 6) -> list[dict]:
    """Find all qualifying swing lows, most recent first (up to max_count)."""
    if not history or len(history) < 5:
        return []
    results = []
    for i in range(len(history) - 1, 3, -1):
        sl = _is_swing_low(history, i)
        if sl:
            results.append(sl)
            if len(results) >= max_count:
                break
    return results


def track_rally_attempt(history: list[dict], swing_low_idx: int) -> dict:
    """
    Track rally attempt starting after swing low.

    Day 1: First up close OR close in top 50% of day's range after swing low.
    Day 2-3: Close must not breach Day 1 intraday low.
    Invalidation: Close below swing low resets the attempt.

    Args:
        history: Daily OHLCV in chronological order
        swing_low_idx: Index of the swing low in history

    Returns:
        Dict with day1_idx, current_day, rally_days list, invalidated flag, etc.
    """
    n = len(history)
    swing_low_price = history[swing_low_idx].get("close", 0)

    result = {
        "day1_idx": None,
        "day1_date": None,
        "day1_low": None,
        "current_day_count": 0,
        "rally_days": [],
        "invalidated": False,
        "invalidation_reason": None,
        "reset_count": 0,
    }

    if swing_low_idx >= n - 1:
        return result

    # Find Day 1
    day1_idx = None
    for i in range(swing_low_idx + 1, n):
        curr_close = history[i].get("close", 0)
        prev_close = history[i - 1].get("close", 0)
        curr_high = history[i].get("high", curr_close)
        curr_low = history[i].get("low", curr_close)

        # Check invalidation first: close below swing low
        if curr_close < swing_low_price:
            result["invalidated"] = True
            result["invalidation_reason"] = (
                f"Close ${curr_close:.2f} below swing low ${swing_low_price:.2f} "
                f"on {history[i].get('date', 'N/A')}"
            )
            return result

        # Day 1: up close OR close in top 50% of range
        day_range = curr_high - curr_low
        if prev_close > 0 and curr_close > prev_close:
            day1_idx = i
            break
        elif day_range > 0:
            close_position = (curr_close - curr_low) / day_range
            if close_position >= 0.5:
                day1_idx = i
                break

    if day1_idx is None:
        return result

    day1_low = history[day1_idx].get("low", history[day1_idx].get("close", 0))
    result["day1_idx"] = day1_idx
    result["day1_date"] = history[day1_idx].get("date", "N/A")
    result["day1_low"] = day1_low

    # Track days from Day 1 onward
    day_count = 1
    rally_days = [
        {
            "day": 1,
            "idx": day1_idx,
            "date": history[day1_idx].get("date", "N/A"),
            "close": history[day1_idx].get("close", 0),
            "volume": history[day1_idx].get("volume", 0),
        }
    ]

    for i in range(day1_idx + 1, n):
        curr_close = history[i].get("close", 0)
        prev_close = history[i - 1].get("close", 0)
        curr_volume = history[i].get("volume", 0)

        # Invalidation: close below swing low
        if curr_close < swing_low_price:
            result["invalidated"] = True
            result["invalidation_reason"] = (
                f"Close ${curr_close:.2f} below swing low ${swing_low_price:.2f} "
                f"on {history[i].get('date', 'N/A')}"
            )
            break

        # Day 2-3 special check: close must not breach Day 1 intraday low
        day_count += 1
        if day_count <= 3 and curr_close < day1_low:
            result["invalidated"] = True
            result["invalidation_reason"] = (
                f"Day {day_count} close ${curr_close:.2f} below Day 1 low "
                f"${day1_low:.2f} on {history[i].get('date', 'N/A')}"
            )
            break

        change_pct = 0
        if prev_close > 0:
            change_pct = (curr_close - prev_close) / prev_close * 100

        rally_days.append(
            {
                "day": day_count,
                "idx": i,
                "date": history[i].get("date", "N/A"),
                "close": curr_close,
                "volume": curr_volume,
                "change_pct": round(change_pct, 2),
                "volume_vs_prev": (
                    round((curr_volume / history[i - 1].get("volume", 1) - 1) * 100, 1)
                    if history[i - 1].get("volume", 0) > 0
                    else 0
                ),
            }
        )

    result["current_day_count"] = day_count
    result["rally_days"] = rally_days
    return result


def detect_ftd(history: list[dict], rally_data: dict) -> dict:
    """
    Detect Follow-Through Day within the FTD window (Day 4-10).

    FTD Criteria:
    - Day 4-10 of rally attempt
    - Price gain >= 1.25% (minimum), 1.5% (recommended), 2.0% (strong)
    - Volume > previous day (mandatory)
    - Volume > point-in-time 50-day average (bonus, no look-ahead)

    Args:
        history: Daily OHLCV in chronological order
        rally_data: Output from track_rally_attempt()

    Returns:
        Dict with ftd_detected, ftd_day_number, gain_pct, volume details, etc.
    """
    result = {
        "ftd_detected": False,
        "ftd_day_number": None,
        "ftd_date": None,
        "ftd_price": None,
        "ftd_low": None,
        "gain_pct": None,
        "volume": None,
        "prev_day_volume": None,
        "volume_above_avg": None,
        "gain_tier": None,
        "_ftd_idx": None,
    }

    if rally_data.get("invalidated"):
        return result

    rally_days = rally_data.get("rally_days", [])

    for day_info in rally_days:
        day_num = day_info.get("day", 0)
        if day_num < FTD_DAY_START or day_num > FTD_DAY_END:
            continue

        change_pct = day_info.get("change_pct", 0)
        if change_pct < FTD_GAIN_MINIMUM:
            continue

        # Volume must be higher than previous day
        idx = day_info.get("idx", 0)
        curr_volume = day_info.get("volume", 0)
        prev_volume = history[idx - 1].get("volume", 0) if idx > 0 else 0

        if prev_volume <= 0 or curr_volume <= prev_volume:
            continue

        # FTD detected
        if change_pct >= FTD_GAIN_STRONG:
            gain_tier = "strong"
        elif change_pct >= FTD_GAIN_RECOMMENDED:
            gain_tier = "recommended"
        else:
            gain_tier = "minimum"

        # Point-in-time 50-day average volume (no look-ahead)
        lookback_bars = history[max(0, idx - 50) : idx]
        volumes = [d.get("volume", 0) for d in lookback_bars if d.get("volume", 0) > 0]
        pit_avg = sum(volumes) / len(volumes) if volumes else 0
        volume_above_avg = curr_volume > pit_avg if pit_avg > 0 else None

        result.update(
            {
                "ftd_detected": True,
                "ftd_day_number": day_num,
                "ftd_date": day_info.get("date", "N/A"),
                "ftd_price": day_info.get("close", 0),
                "ftd_low": history[idx].get("low", day_info.get("close", 0)),
                "gain_pct": change_pct,
                "volume": curr_volume,
                "prev_day_volume": prev_volume,
                "volume_above_avg": volume_above_avg,
                "gain_tier": gain_tier,
                "_ftd_idx": idx,
            }
        )
        break  # Take the first qualifying FTD

    return result


def calculate_avg_volume(history: list[dict], period: int = 50) -> float:
    """Calculate average volume over the specified period (most recent data)."""
    if not history:
        return 0
    volumes = [d.get("volume", 0) for d in history[-period:] if d.get("volume", 0) > 0]
    return sum(volumes) / len(volumes) if volumes else 0


def analyze_single_index(history: list[dict], index_name: str) -> dict:
    """
    Run full FTD analysis for a single index.

    Args:
        history: Daily OHLCV in chronological order (oldest first)
        index_name: Label (e.g., "S&P 500", "NASDAQ")

    Returns:
        Complete analysis dict for this index
    """
    result = {
        "index": index_name,
        "state": MarketState.NO_SIGNAL.value,
        "swing_low": None,
        "rally_attempt": None,
        "ftd": None,
        "current_price": None,
        "lookback_high": None,
        "correction_depth_pct": None,
    }

    if not history or len(history) < 10:
        result["error"] = "Insufficient data"
        return result

    # Use last 60 trading days for analysis
    lookback = min(60, len(history))
    analysis_window = history[-lookback:]
    len(analysis_window)

    result["current_price"] = analysis_window[-1].get("close", 0)

    # Find the highest close in the window
    max_close = 0
    for d in analysis_window:
        c = d.get("close", 0)
        if c > max_close:
            max_close = c
    result["lookback_high"] = max_close

    if max_close > 0 and result["current_price"] > 0:
        result["correction_depth_pct"] = round(
            (result["current_price"] - max_close) / max_close * 100, 2
        )

    # Do NOT early-return based on current correction depth.
    # A valid FTD may be in progress even if price has recovered near highs.

    swing_lows = _find_all_swing_lows(analysis_window)
    if not swing_lows:
        return result

    # ── Step 1: Process most recent swing low to determine current_state ──
    most_recent_sl = swing_lows[0]
    result["swing_low"] = most_recent_sl
    result["state"] = MarketState.CORRECTION.value

    rally = track_rally_attempt(analysis_window, most_recent_sl["swing_low_idx"])
    result["rally_attempt"] = rally

    if rally["invalidated"]:
        result["state"] = MarketState.RALLY_FAILED.value
    elif rally["day1_idx"] is None:
        pass  # CORRECTION
    else:
        day_count = rally["current_day_count"]
        if day_count < FTD_DAY_START:
            result["state"] = MarketState.RALLY_ATTEMPT.value
        else:
            result["state"] = MarketState.FTD_WINDOW.value
            ftd = detect_ftd(analysis_window, rally)
            result["ftd"] = ftd
            if ftd["ftd_detected"]:
                # Inline invalidation check
                ftd_idx = ftd.get("_ftd_idx")
                if ftd_idx is not None:
                    ftd_low = analysis_window[ftd_idx].get(
                        "low", analysis_window[ftd_idx].get("close", 0)
                    )
                    invalidated = any(
                        analysis_window[j].get("close", 0) < ftd_low
                        for j in range(ftd_idx + 1, len(analysis_window))
                    )
                    if not invalidated:
                        result["state"] = MarketState.FTD_CONFIRMED.value
                    else:
                        result["state"] = MarketState.FTD_INVALIDATED.value
                else:
                    result["state"] = MarketState.FTD_CONFIRMED.value
            elif day_count > FTD_DAY_END:
                result["state"] = MarketState.RALLY_FAILED.value

    # If Step 1 found FTD context (confirmed or invalidated), return immediately
    if result["state"] in (
        MarketState.FTD_CONFIRMED.value,
        MarketState.FTD_INVALIDATED.value,
    ):
        return result

    # ── Step 2: Search older swing lows for a valid FTD ──
    # Handles post-FTD pullback: new swing low exists but FTD low not breached
    current_state = result["state"]

    for older_sl in swing_lows[1:]:
        older_rally = track_rally_attempt(analysis_window, older_sl["swing_low_idx"])
        if older_rally["invalidated"] or older_rally["day1_idx"] is None:
            continue
        if older_rally["current_day_count"] < FTD_DAY_START:
            continue
        older_ftd = detect_ftd(analysis_window, older_rally)
        if not older_ftd["ftd_detected"]:
            continue

        # FTD found — inline invalidation check
        ftd_idx = older_ftd.get("_ftd_idx")
        if ftd_idx is None:
            continue
        ftd_low = analysis_window[ftd_idx].get("low", analysis_window[ftd_idx].get("close", 0))
        invalidated = any(
            analysis_window[j].get("close", 0) < ftd_low
            for j in range(ftd_idx + 1, len(analysis_window))
        )

        if not invalidated:
            # Valid FTD still active through post-FTD pullback
            result["swing_low"] = older_sl
            result["rally_attempt"] = older_rally
            result["ftd"] = older_ftd
            result["state"] = MarketState.FTD_CONFIRMED.value
            return result
        else:
            # Invalidated FTD — STOP (no fallback to even older FTDs)
            # If newer swing low has active rally, keep that state
            active_states = (
                MarketState.RALLY_ATTEMPT.value,
                MarketState.FTD_WINDOW.value,
            )
            if current_state not in active_states:
                result["swing_low"] = older_sl
                result["rally_attempt"] = older_rally
                result["ftd"] = older_ftd
                result["state"] = MarketState.FTD_INVALIDATED.value
            return result

    return result


def get_market_state(sp500_history: list[dict], nasdaq_history: list[dict]) -> dict:
    """
    Analyze both indices and produce a merged market state assessment.

    Priority logic:
    - If either index has FTD_CONFIRMED → overall FTD (single sufficient)
    - If both have FTD_CONFIRMED → strong FTD (dual confirmation)
    - Otherwise, use the more advanced state

    Args:
        sp500_history: S&P 500 daily OHLCV, most recent first (API format)
        nasdaq_history: NASDAQ/QQQ daily OHLCV, most recent first (API format)

    Returns:
        Combined market state with both index analyses
    """
    # Convert to chronological order (oldest first)
    sp500_chrono = list(reversed(sp500_history)) if sp500_history else []
    nasdaq_chrono = list(reversed(nasdaq_history)) if nasdaq_history else []

    sp500_analysis = analyze_single_index(sp500_chrono, "S&P 500")
    nasdaq_analysis = analyze_single_index(nasdaq_chrono, "NASDAQ")

    sp500_state = MarketState(sp500_analysis["state"])
    nasdaq_state = MarketState(nasdaq_analysis["state"])

    # Determine combined state
    sp500_ftd = sp500_state == MarketState.FTD_CONFIRMED
    nasdaq_ftd = nasdaq_state == MarketState.FTD_CONFIRMED

    if sp500_ftd and nasdaq_ftd:
        combined_state = MarketState.FTD_CONFIRMED.value
        dual_confirmation = True
    elif sp500_ftd or nasdaq_ftd:
        combined_state = MarketState.FTD_CONFIRMED.value
        dual_confirmation = False
    else:
        # Use the more advanced (hopeful) state
        # FTD_INVALIDATED above CORRECTION: more informative than bare correction
        state_priority = [
            MarketState.FTD_WINDOW,
            MarketState.RALLY_ATTEMPT,
            MarketState.FTD_INVALIDATED,
            MarketState.CORRECTION,
            MarketState.RALLY_FAILED,
            MarketState.NO_SIGNAL,
        ]
        combined_state = MarketState.NO_SIGNAL.value
        for state in state_priority:
            if sp500_state == state or nasdaq_state == state:
                combined_state = state.value
                break
        dual_confirmation = False

    # Determine which index triggered FTD (confirmed or invalidated)
    ftd_index = None
    if sp500_ftd:
        ftd_index = "S&P 500"
    if nasdaq_ftd:
        ftd_index = "NASDAQ" if ftd_index is None else "Both"

    # Also track invalidated FTD index for reporting
    if ftd_index is None and combined_state == MarketState.FTD_INVALIDATED.value:
        for label, analysis in [("S&P 500", sp500_analysis), ("NASDAQ", nasdaq_analysis)]:
            if analysis.get("state") == MarketState.FTD_INVALIDATED.value:
                ftd_index = label
                break

    return {
        "combined_state": combined_state,
        "dual_confirmation": dual_confirmation,
        "ftd_index": ftd_index,
        "sp500": sp500_analysis,
        "nasdaq": nasdaq_analysis,
    }