"""Tests for watchlist.py — verifies config-driven flood/hysteresis behaviour.

WBD Unit 2 test spec:
  - Promotion logic with MicroConfig(flood_promote_top_n=30) promotes up to 30 (not 5).
  - Flood trigger fires when eligible-count >= config flood_threshold.
  - Hysteresis bonus uses config value.
"""

from __future__ import annotations

import sys
import os
from datetime import datetime, timezone
from unittest.mock import MagicMock

sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

from src.micro_scanner.config import MicroConfig
from src.micro_scanner.contracts import CandidateScore
from src.micro_scanner.watchlist import WatchlistManager


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


def _make_score(
    symbol: str, score: float = 0.80, status: str = "dormant"
) -> CandidateScore:
    return CandidateScore(
        symbol=symbol,
        score=score,
        scored_at=datetime.now(timezone.utc),
        data_freshness={"_v": 1},
        is_valid=True,
        status=status,  # type: ignore[arg-type]
    )


def _make_conn(watchlist_size: int = 0, open_positions: set | None = None) -> MagicMock:
    """Build a mock psycopg.Connection whose execute/fetchone/fetchall return
    sensible values for the promotion/demotion path."""
    conn = MagicMock()

    # fetchone() used by _get_watchlist_size → {"count": N}
    count_row = {"count": watchlist_size}

    # fetchall() used by _get_open_position_symbols and _do_demotions active list
    open_pos_rows = [{"symbol": s} for s in (open_positions or set())]

    # We need to vary the return based on the SQL executed.
    size_result = MagicMock()
    size_result.fetchone.return_value = count_row
    size_result.rowcount = 0

    open_pos_result = MagicMock()
    open_pos_result.fetchall.return_value = open_pos_rows
    open_pos_result.rowcount = 0

    promote_result = MagicMock()
    promote_result.rowcount = 1  # each UPDATE "succeeds"

    def execute_side_effect(sql, *args, **kwargs):
        sql_stripped = sql.strip() if isinstance(sql, str) else str(sql)
        if "COUNT(*)" in sql_stripped:
            return size_result
        if "micro_positions" in sql_stripped:
            return open_pos_result
        if "INSERT INTO micro_coin_candidates" in sql_stripped:
            r = MagicMock()
            r.rowcount = 0
            return r
        if (
            "UPDATE micro_coin_candidates" in sql_stripped
            and "SET status = 'active'" in sql_stripped
        ):
            r = MagicMock()
            r.rowcount = 1
            return r
        # deferred update or other
        r = MagicMock()
        r.rowcount = 0
        return r

    conn.execute.side_effect = execute_side_effect
    conn.commit.return_value = None
    return conn


# ---------------------------------------------------------------------------
# Tests: flood_promote_top_n is read from config
# ---------------------------------------------------------------------------


class TestFloodPromoteTopN:
    """flood_promote_top_n from MicroConfig controls how many are promoted during a flood."""

    def test_promotes_up_to_config_top_n_30(self):
        """With flood_promote_top_n=30 and 35 eligible symbols, exactly 30 should be promoted."""
        cfg = MicroConfig(
            flood_threshold=20,
            flood_promote_top_n=30,
            score_entry_threshold=0.50,
            watchlist_max=100,
        )
        manager = WatchlistManager(cfg)

        # 35 eligible symbols — above flood_threshold (20)
        scores = [_make_score(f"SYM{i:03d}", score=0.80) for i in range(35)]

        conn = _make_conn(watchlist_size=0)

        promoted = manager._do_promotions(scores, conn)

        # The promote result mock returns rowcount=1 so all to_promote entries get added.
        assert len(promoted) == 30, f"Expected 30 promotions, got {len(promoted)}"

    def test_default_top_n_5_when_flood(self):
        """Default config: only 5 promoted when flood threshold exceeded."""
        cfg = MicroConfig(
            flood_threshold=20,
            flood_promote_top_n=5,
            score_entry_threshold=0.50,
            watchlist_max=100,
        )
        manager = WatchlistManager(cfg)

        scores = [_make_score(f"SYM{i:03d}", score=0.80) for i in range(25)]
        conn = _make_conn(watchlist_size=0)

        promoted = manager._do_promotions(scores, conn)
        assert len(promoted) == 5, f"Expected 5 promotions, got {len(promoted)}"

    def test_no_flood_promotes_up_to_capacity(self):
        """Below flood_threshold — promotes up to available capacity, not capped at top_n."""
        cfg = MicroConfig(
            flood_threshold=20,
            flood_promote_top_n=5,
            score_entry_threshold=0.50,
            watchlist_max=100,
        )
        manager = WatchlistManager(cfg)

        # Only 10 eligible — below flood threshold of 20
        scores = [_make_score(f"SYM{i:03d}", score=0.80) for i in range(10)]
        conn = _make_conn(watchlist_size=0)

        promoted = manager._do_promotions(scores, conn)
        # All 10 should be promoted (capacity is 100, flood not triggered)
        assert len(promoted) == 10, f"Expected 10 promotions, got {len(promoted)}"


# ---------------------------------------------------------------------------
# Tests: flood_threshold is read from config
# ---------------------------------------------------------------------------


class TestFloodThreshold:
    """flood_threshold from MicroConfig controls when flood handling fires."""

    def test_flood_fires_at_config_threshold(self):
        """Flood triggers when eligible count > config flood_threshold."""
        cfg = MicroConfig(
            flood_threshold=10,  # custom lower threshold
            flood_promote_top_n=3,
            score_entry_threshold=0.50,
            watchlist_max=100,
        )
        manager = WatchlistManager(cfg)

        # 12 eligible — exceeds flood_threshold of 10
        scores = [_make_score(f"SYM{i:03d}", score=0.80) for i in range(12)]
        conn = _make_conn(watchlist_size=0)

        promoted = manager._do_promotions(scores, conn)
        # Flood fired → only flood_promote_top_n=3 promoted
        assert len(promoted) == 3, (
            f"Expected 3 flood-capped promotions, got {len(promoted)}"
        )

    def test_flood_does_not_fire_at_exactly_threshold(self):
        """Flood triggers only when eligible > threshold (strictly greater than)."""
        cfg = MicroConfig(
            flood_threshold=10,
            flood_promote_top_n=3,
            score_entry_threshold=0.50,
            watchlist_max=100,
        )
        manager = WatchlistManager(cfg)

        # Exactly 10 eligible — equal to threshold, should NOT trigger flood
        scores = [_make_score(f"SYM{i:03d}", score=0.80) for i in range(10)]
        conn = _make_conn(watchlist_size=0)

        promoted = manager._do_promotions(scores, conn)
        # No flood — all 10 promoted (capacity=100)
        assert len(promoted) == 10, (
            f"Expected 10 promotions without flood, got {len(promoted)}"
        )

    def test_old_constant_value_still_triggers_flood(self):
        """The old hardcoded value (20) still works correctly via config default."""
        cfg = MicroConfig(
            flood_threshold=20,  # matches old _FLOOD_THRESHOLD constant
            flood_promote_top_n=5,
            score_entry_threshold=0.50,
            watchlist_max=100,
        )
        manager = WatchlistManager(cfg)

        scores = [_make_score(f"SYM{i:03d}", score=0.80) for i in range(21)]
        conn = _make_conn(watchlist_size=0)

        promoted = manager._do_promotions(scores, conn)
        assert len(promoted) == 5, f"Expected 5 (flood capped), got {len(promoted)}"


# ---------------------------------------------------------------------------
# Tests: hysteresis_bonus is read from config
# ---------------------------------------------------------------------------


class TestHysteresisBonus:
    """hysteresis_bonus from MicroConfig sets the extra threshold when watchlist is full."""

    def test_custom_hysteresis_blocks_low_score(self):
        """With hysteresis_bonus=0.20 and full watchlist, symbols scoring < threshold+0.20 are blocked."""
        cfg = MicroConfig(
            hysteresis_bonus=0.20,
            score_entry_threshold=0.50,
            watchlist_max=5,
            flood_threshold=20,
            flood_promote_top_n=5,
        )
        manager = WatchlistManager(cfg)

        # Watchlist is full (5 active). Effective threshold becomes 0.50 + 0.20 = 0.70.
        # Score 0.65 is above entry_threshold but below effective hysteresis threshold.
        scores = [_make_score("LOWSYM", score=0.65)]
        conn = _make_conn(watchlist_size=5)

        promoted = manager._do_promotions(scores, conn)
        assert len(promoted) == 0, (
            "Symbol below hysteresis threshold should not be promoted"
        )

    def test_custom_hysteresis_allows_high_score(self):
        """With hysteresis_bonus=0.20 and full watchlist, a symbol scoring >= threshold+0.20 passes."""
        cfg = MicroConfig(
            hysteresis_bonus=0.20,
            score_entry_threshold=0.50,
            watchlist_max=5,
            flood_threshold=20,
            flood_promote_top_n=5,
        )
        manager = WatchlistManager(cfg)

        # Score 0.75 >= 0.50 + 0.20 = 0.70, should pass hysteresis
        # But capacity=0 (full), so to_promote = eligible[:0] = []
        # Wait — when full, capacity <= 0 → to_promote = eligible[:capacity] = []
        # Actually when flood doesn't fire and capacity <= 0: to_promote = [] always.
        # Hysteresis only filters the eligible list; capacity constraint still applies.
        # So we test that the effective threshold is computed from config (no DB promotion possible
        # when full without flood — that's expected behaviour, just confirm no raise).
        scores = [_make_score("HIGHSYM", score=0.75)]
        conn = _make_conn(watchlist_size=5)

        # Should run without error; capacity=0 so nothing promoted, but hysteresis was applied
        promoted = manager._do_promotions(scores, conn)
        assert promoted == []  # full watchlist with no flood = no promotion regardless

    def test_default_hysteresis_matches_old_constant(self):
        """Default hysteresis_bonus=0.10 matches the old _HYSTERESIS_BONUS=0.10 constant."""
        cfg = MicroConfig()
        assert cfg.hysteresis_bonus == 0.10

    def test_hysteresis_debug_log_emitted_when_full(self):
        """When watchlist is full, watchlist_full_hysteresis_applied debug event is emitted."""
        import structlog.testing

        cfg = MicroConfig(
            hysteresis_bonus=0.15,
            score_entry_threshold=0.50,
            watchlist_max=5,
            flood_threshold=20,
            flood_promote_top_n=5,
        )
        manager = WatchlistManager(cfg)

        scores = [_make_score("SYM001", score=0.70)]
        conn = _make_conn(watchlist_size=5)

        with structlog.testing.capture_logs() as captured:
            manager._do_promotions(scores, conn)

        hysteresis_events = [
            e for e in captured if e.get("event") == "watchlist_full_hysteresis_applied"
        ]
        assert len(hysteresis_events) == 1
        # effective threshold = 0.50 + 0.15 = 0.65
        assert abs(hysteresis_events[0]["threshold"] - 0.65) < 1e-9


# ---------------------------------------------------------------------------
# Tests: deprecated constants remain in module with correct values
# ---------------------------------------------------------------------------


class TestDeprecatedConstants:
    """Deprecated module-level constants must remain with their original values."""

    def test_deprecated_flood_threshold_value(self):
        from src.micro_scanner.watchlist import _FLOOD_THRESHOLD

        assert _FLOOD_THRESHOLD == 20

    def test_deprecated_flood_promote_top_n_value(self):
        from src.micro_scanner.watchlist import _FLOOD_PROMOTE_TOP_N

        assert _FLOOD_PROMOTE_TOP_N == 5

    def test_deprecated_hysteresis_bonus_value(self):
        from src.micro_scanner.watchlist import _HYSTERESIS_BONUS

        assert _HYSTERESIS_BONUS == 0.10