Chan/crypto_wyckoff/rules/event_rules.py

"""Event rules: Spring/SOS/LPS/UTAD/SC/AR/ST/..."""

from __future__ import annotations

from typing import Any

from crypto_wyckoff.domain_models import WyckoffCycle, WyckoffEvent, WyckoffPhase
from crypto_wyckoff.rules.base import RuleHit, WyckoffRule


def _f(ctx: dict[str, Any], key: str, default: float = 0.0) -> float:
    v = ctx.get("features", {}).get(key, default)
    try:
        return float(v) if v is not None else default
    except (TypeError, ValueError):
        return default


def _cycle(ctx: dict[str, Any]) -> str:
    return (ctx.get("cycle") or {}).get("cycle") or ""


def _phase(ctx: dict[str, Any]) -> str:
    return (ctx.get("phase") or {}).get("phase") or ""


class SpringRule(WyckoffRule):
    rule_id = "event_spring"
    category = "event"
    timeframes = ("1d",)

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        cycle = _cycle(context)
        if cycle not in (WyckoffCycle.ACCUMULATION.value, WyckoffCycle.RE_ACCUMULATION.value,
                         WyckoffCycle.MARKUP.value):
            # Allow spring only in accumulative contexts; Decision will filter MTF
            if cycle == WyckoffCycle.DISTRIBUTION.value:
                pass  # still detect for facts but lower confidence
        pierce = _f(context, "pierce_below_range")
        reclaim = _f(context, "reclaim_speed")
        vol_ratio = _f(context, "volume_ratio")
        close_in_range = _f(context, "close_back_in_range")
        if pierce >= 0.002 and close_in_range >= 0.5 and reclaim >= 0.3:
            strength = min(98.0, 50 + pierce * 2000 + reclaim * 20 + (15 if vol_ratio < 1.2 else 5))
            return RuleHit(
                rule_id=self.rule_id,
                event=WyckoffEvent.SPRING.value,
                confidence=strength,
                score=strength,
                reasons=[
                    f"跌破区间后收回 (pierce={pierce:.3%})",
                    f"回收速度={reclaim:.2f}",
                    f"量比={vol_ratio:.2f}",
                ],
                metrics={"pierce": pierce, "reclaim": reclaim, "volume_ratio": vol_ratio},
            )
        return None


class TestRule(WyckoffRule):
    rule_id = "event_test"
    category = "event"
    timeframes = ("1d", "1w")

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        pos = _f(context, "range_position")
        vol_ratio = _f(context, "volume_ratio")
        near_low = pos < 0.2
        if near_low and vol_ratio < 0.85:
            return RuleHit(
                rule_id=self.rule_id,
                event=WyckoffEvent.TEST.value,
                confidence=68.0,
                score=65.0,
                reasons=["低位缩量回测"],
            )
        return None


class SOSRule(WyckoffRule):
    rule_id = "event_sos"
    category = "event"
    timeframes = ("1d", "1w")

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        breakout = _f(context, "breakout_above_range")
        vol_ratio = _f(context, "volume_ratio")
        close = _f(context, "close")
        ma20 = _f(context, "ma20")
        if breakout >= 0.0 and vol_ratio >= 1.2 and close > ma20:
            conf = min(95.0, 70 + vol_ratio * 8)
            return RuleHit(
                rule_id=self.rule_id,
                event=WyckoffEvent.SOS.value,
                confidence=conf,
                score=conf,
                reasons=["放量突破区间上沿 (SOS)"],
                metrics={"vol_ratio": vol_ratio},
            )
        return None


class LPSRule(WyckoffRule):
    rule_id = "event_lps"
    category = "event"
    timeframes = ("1d", "1w")

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        # Pullback hold above broken range / MA20 after prior strength
        pullback = _f(context, "pullback_hold")
        vol_ratio = _f(context, "volume_ratio")
        above_ma = _f(context, "close") > _f(context, "ma20")
        if pullback >= 0.5 and above_ma and vol_ratio <= 1.1:
            return RuleHit(
                rule_id=self.rule_id,
                event=WyckoffEvent.LPS.value,
                confidence=74.0,
                score=76.0,
                reasons=["突破后缩量回踩支撑 (LPS)"],
            )
        return None


class SCRule(WyckoffRule):
    rule_id = "event_sc"
    category = "event"
    timeframes = ("1w", "1d")

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        vol_ratio = _f(context, "volume_ratio")
        bar_range = _f(context, "bar_range_atr")
        pos = _f(context, "range_position")
        if vol_ratio >= 1.8 and bar_range >= 1.5 and pos < 0.35:
            return RuleHit(
                rule_id=self.rule_id,
                event=WyckoffEvent.SC.value,
                confidence=72.0,
                score=70.0,
                reasons=["低位放量宽幅，疑似 Selling Climax"],
            )
        return None


class ARRule(WyckoffRule):
    rule_id = "event_ar"
    category = "event"
    timeframes = ("1w", "1d")

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        # Automatic rally: bounce from lows
        bounce = _f(context, "bounce_from_low")
        if bounce >= 0.04:
            return RuleHit(
                rule_id=self.rule_id,
                event=WyckoffEvent.AR.value,
                confidence=65.0,
                score=62.0,
                reasons=["低点后自动反弹 (AR)"],
            )
        return None


class STRule(WyckoffRule):
    rule_id = "event_st"
    category = "event"
    timeframes = ("1w", "1d")

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        pos = _f(context, "range_position")
        vol_ratio = _f(context, "volume_ratio")
        if 0.15 < pos < 0.45 and vol_ratio < 1.0:
            return RuleHit(
                rule_id=self.rule_id,
                event=WyckoffEvent.ST.value,
                confidence=60.0,
                score=58.0,
                reasons=["次级测试 (ST)"],
            )
        return None


class UTADRule(WyckoffRule):
    rule_id = "event_utad"
    category = "event"
    timeframes = ("1w", "1d")

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        cycle = _cycle(context)
        pierce_up = _f(context, "pierce_above_range")
        fail = _f(context, "fail_back_into_range")
        if cycle in (WyckoffCycle.DISTRIBUTION.value, WyckoffCycle.RE_DISTRIBUTION.value,
                     WyckoffCycle.MARKUP.value):
            if pierce_up >= 0.002 and fail >= 0.5:
                return RuleHit(
                    rule_id=self.rule_id,
                    event=WyckoffEvent.UTAD.value,
                    confidence=76.0,
                    score=74.0,
                    reasons=["冲高失败回到区间 (UTAD)"],
                )
        return None


class JumpRule(WyckoffRule):
    rule_id = "event_jump"
    category = "event"
    timeframes = ("1d",)

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        gap = _f(context, "gap_up_pct")
        vol_ratio = _f(context, "volume_ratio")
        if gap >= 0.03 and vol_ratio >= 1.3:
            return RuleHit(
                rule_id=self.rule_id,
                event=WyckoffEvent.JUMP.value,
                confidence=70.0,
                score=72.0,
                reasons=["放量向上跳跃 (Jump)"],
            )
        return None


class BackupRule(WyckoffRule):
    rule_id = "event_backup"
    category = "event"
    timeframes = ("1d",)

    def evaluate(self, context: dict[str, Any]) -> RuleHit | None:
        pullback = _f(context, "pullback_hold")
        after_jump = _f(context, "after_strength")
        if after_jump >= 0.5 and pullback >= 0.5:
            return RuleHit(
                rule_id=self.rule_id,
                event=WyckoffEvent.BACKUP.value,
                confidence=68.0,
                score=70.0,
                reasons=["跳跃后回踩 (Backup)"],
            )
        return None


def build_rules() -> list[WyckoffRule]:
    return [
        SpringRule(),
        UTADRule(),
        SOSRule(),
        LPSRule(),
        SCRule(),
        JumpRule(),
        BackupRule(),
        TestRule(),
        ARRule(),
        STRule(),
    ]