meshai/tests/test_pipeline_digest.py

"""Tests for Phase 2.3a DigestAccumulator.

20 tests covering:
- Accumulator active/since_last behavior (6 tests)
- Renderer output (8 tests)
- Excluded toggles (3 tests)
- Pipeline integration (3 tests)
"""

import time
from unittest.mock import MagicMock, patch

import pytest

from meshai.notifications.events import make_event
from meshai.notifications.pipeline import (
    build_pipeline_components,
    DigestAccumulator,
    Digest,
)
from meshai.notifications.categories import get_toggle, ALERT_CATEGORIES
from meshai.config import Config


# ============================================================
# ACCUMULATOR ACTIVE/SINCE_LAST TESTS
# ============================================================

def test_enqueue_adds_to_active():
    """Enqueue one routine Event with no expires → active_count == 1."""
    acc = DigestAccumulator()
    event = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        title="Wind Advisory",
    )
    acc.enqueue(event)
    assert acc.active_count() == 1
    assert acc.since_last_count() == 0


def test_enqueue_same_id_updates_in_place():
    """Enqueue same id twice → still 1 active, title updated."""
    acc = DigestAccumulator()
    event1 = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        id="abc",
        title="initial",
    )
    event2 = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        id="abc",
        title="updated",
    )
    acc.enqueue(event1)
    acc.enqueue(event2)
    assert acc.active_count() == 1
    # Check the held event's title
    toggle = "weather"
    events = acc._active.get(toggle, [])
    assert len(events) == 1
    assert events[0].title == "updated"


def test_two_different_ids_both_active():
    """Two different routine events → both active."""
    acc = DigestAccumulator()
    event1 = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        id="ev1",
        title="Event 1",
    )
    event2 = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        id="ev2",
        title="Event 2",
    )
    acc.enqueue(event1)
    acc.enqueue(event2)
    assert acc.active_count() == 2


def test_resolution_marker_in_title_moves_active_to_since_last():
    """Resolution marker in title moves matching active to since_last."""
    acc = DigestAccumulator()
    event1 = make_event(
        source="test",
        category="wildfire_proximity",
        severity="priority",
        group_key="fire:42",
        title="Snake River Fire",
    )
    acc.enqueue(event1)
    assert acc.active_count() == 1
    assert acc.since_last_count() == 0

    event2 = make_event(
        source="test",
        category="wildfire_proximity",
        severity="priority",
        group_key="fire:42",
        title="Snake River Fire ended",
    )
    acc.enqueue(event2)
    assert acc.active_count() == 0
    assert acc.since_last_count() == 1


def test_expired_event_via_tick_moves_to_since_last():
    """tick() moves expired events from active to since_last."""
    acc = DigestAccumulator()
    base_time = 1000000.0

    # Monkeypatch _now to control time
    acc._now = lambda: base_time

    event = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        title="Temporary Warning",
        expires=base_time + 60,  # expires in 60 seconds
    )
    acc.enqueue(event)
    assert acc.active_count() == 1
    assert acc.since_last_count() == 0

    # Tick at base_time + 30 → still active
    moved = acc.tick(now=base_time + 30)
    assert moved == 0
    assert acc.active_count() == 1

    # Tick at base_time + 120 → expired, moved to since_last
    moved = acc.tick(now=base_time + 120)
    assert moved == 1
    assert acc.active_count() == 0
    assert acc.since_last_count() == 1


def test_render_digest_clears_since_last_but_keeps_active():
    """render_digest() clears since_last but preserves active."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Add an active event
    active_event = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        title="Ongoing Storm",
    )
    acc.enqueue(active_event)

    # Add an event that becomes since_last via resolution marker
    resolved_event = make_event(
        source="test",
        category="road_closure",
        severity="routine",
        group_key="roads:99",
        title="US-93 reopened at MP 47",
    )
    acc.enqueue(resolved_event)

    # Now we should have 1 active, 1 since_last
    assert acc.active_count() == 1
    assert acc.since_last_count() == 1

    # Render digest
    digest = acc.render_digest(now=base_time)
    assert len(digest.active) > 0
    assert len(digest.since_last) > 0

    # After render: active preserved, since_last cleared
    assert acc.active_count() == 1
    assert acc.since_last_count() == 0

    # Second render has only active
    digest2 = acc.render_digest(now=base_time + 10)
    assert len(digest2.active) > 0
    assert len(digest2.since_last) == 0


# ============================================================
# RENDERER TESTS
# ============================================================

def test_render_full_lists_active_and_since_last_with_labels():
    """Full render includes ACTIVE NOW, SINCE LAST DIGEST, toggle labels."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Weather event (active)
    weather_event = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        title="Wind Advisory until 21:00",
    )
    acc.enqueue(weather_event)

    # Roads event with resolution marker → since_last
    roads_event = make_event(
        source="test",
        category="road_closure",
        severity="routine",
        title="US-93 reopened at MP 47",
    )
    acc.enqueue(roads_event)

    digest = acc.render_digest(now=base_time)

    assert "ACTIVE NOW:" in digest.full
    assert "[Weather]" in digest.full
    assert "Wind Advisory" in digest.full
    assert "SINCE LAST DIGEST:" in digest.full
    assert "[Roads]" in digest.full
    assert "US-93" in digest.full


def test_render_mesh_compact_under_char_limit():
    """mesh_compact is <= 200 chars with new per-toggle line format."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Add 10 events across 4 toggles
    categories = [
        ("weather_warning", "Weather Event"),
        ("weather_warning", "Weather Event 2"),
        ("weather_warning", "Weather Event 3"),
        ("wildfire_proximity", "Fire Event"),
        ("wildfire_proximity", "Fire Event 2"),
        ("battery_warning", "Mesh Event"),
        ("battery_warning", "Mesh Event 2"),
        ("battery_warning", "Mesh Event 3"),
        ("road_closure", "Road Event"),
        ("road_closure", "Road Event 2"),
    ]
    for i, (cat, title) in enumerate(categories):
        event = make_event(
            source="test",
            category=cat,
            severity="routine",
            id=f"ev{i}",
            title=title,
        )
        acc.enqueue(event)

    digest = acc.render_digest(now=base_time)
    assert len(digest.mesh_compact) <= 200
    assert digest.mesh_compact.startswith("DIGEST ")
    assert "ACTIVE NOW" in digest.mesh_compact
    # Check for toggle label lines
    lines = digest.mesh_compact.split("\n")
    bracket_lines = [l for l in lines if l.startswith("[")]
    assert len(bracket_lines) > 0, "Should have lines starting with toggle labels"


def test_render_mesh_compact_empty_shows_no_alerts_message():
    """Empty accumulator renders 'No alerts since last digest' in mesh_compact."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    digest = acc.render_digest(now=base_time)
    assert "No alerts since last digest" in digest.mesh_compact
    assert "DIGEST " in digest.mesh_compact
    assert "All quiet" not in digest.mesh_compact


def test_render_full_handles_empty_accumulator():
    """Empty accumulator → is_empty() True, shows 'No alerts since last digest'."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    digest = acc.render_digest(now=base_time)
    assert digest.is_empty() is True
    assert "No alerts since last digest" in digest.full
    assert "ACTIVE NOW" not in digest.full
    assert "ACTIVE NOW: nothing" not in digest.full


def test_render_orders_toggles_by_priority():
    """Toggles appear in TOGGLE_ORDER sequence in full output."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Add one event each for weather, mesh_health, and fire
    # (intentionally out of order)
    mesh_event = make_event(
        source="test",
        category="battery_warning",  # maps to mesh_health toggle
        severity="routine",
        title="Mesh battery low",
    )
    fire_event = make_event(
        source="test",
        category="wildfire_proximity",
        severity="routine",
        title="Fire nearby",
    )
    weather_event = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        title="Storm coming",
    )
    acc.enqueue(mesh_event)
    acc.enqueue(fire_event)
    acc.enqueue(weather_event)

    digest = acc.render_digest(now=base_time)

    # In TOGGLE_ORDER: weather, fire, ..., mesh_health
    weather_pos = digest.full.find("[Weather]")
    fire_pos = digest.full.find("[Fire]")
    mesh_pos = digest.full.find("[Mesh]")

    assert weather_pos < fire_pos, "Weather should appear before Fire"
    assert fire_pos < mesh_pos, "Fire should appear before Mesh"


def test_format_event_line_does_not_append_expires_hint():
    """_format_event_line() does NOT append '(until HH:MM)' anymore."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    event = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        title="Severe Thunderstorm Warning",
        expires=base_time + 3600,  # 1 hour in future
    )

    line = acc._format_event_line(event)
    assert "until " not in line
    assert "(" not in line


def test_mesh_compact_shows_one_line_per_toggle():
    """Each toggle gets exactly one line, with (+N) for overflow."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Add 2 weather events, 1 fire event, 1 mesh event
    acc.enqueue(make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        id="w1",
        title="Weather Event 1",
    ))
    acc.enqueue(make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        id="w2",
        title="Weather Event 2",
    ))
    acc.enqueue(make_event(
        source="test",
        category="wildfire_proximity",
        severity="routine",
        id="f1",
        title="Fire Event",
    ))
    acc.enqueue(make_event(
        source="test",
        category="battery_warning",
        severity="routine",
        id="m1",
        title="Mesh Event",
    ))

    digest = acc.render_digest(now=base_time)

    # Count occurrences of each toggle label
    weather_count = digest.mesh_compact.count("[Weather]")
    fire_count = digest.mesh_compact.count("[Fire]")
    mesh_count = digest.mesh_compact.count("[Mesh]")

    assert weather_count == 1, "Should have exactly one [Weather] line"
    assert fire_count == 1, "Should have exactly one [Fire] line"
    assert mesh_count == 1, "Should have exactly one [Mesh] line"

    # Weather line should have (+1) since there are 2 weather events
    weather_line = [l for l in digest.mesh_compact.split("\n") if "[Weather]" in l][0]
    assert "(+1)" in weather_line


def test_mesh_compact_active_and_resolved_sections():
    """mesh_compact has ACTIVE NOW and RESOLVED sections when both present."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Add 1 active weather event
    acc.enqueue(make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        title="Storm Warning",
    ))

    # Add 1 resolution event for roads (contains "reopened")
    acc.enqueue(make_event(
        source="test",
        category="road_closure",
        severity="routine",
        title="US-93 reopened at MP 47",
    ))

    digest = acc.render_digest(now=base_time)

    assert "ACTIVE NOW" in digest.mesh_compact
    assert "RESOLVED" in digest.mesh_compact

    # Weather should appear before RESOLVED, Roads after
    active_pos = digest.mesh_compact.find("ACTIVE NOW")
    resolved_pos = digest.mesh_compact.find("RESOLVED")
    weather_pos = digest.mesh_compact.find("[Weather]")
    roads_pos = digest.mesh_compact.find("[Roads]")

    assert weather_pos > active_pos, "[Weather] should be after ACTIVE NOW"
    assert weather_pos < resolved_pos, "[Weather] should be before RESOLVED"
    assert roads_pos > resolved_pos, "[Roads] should be after RESOLVED"


def test_mesh_compact_line_truncates_long_headline():
    """Long headlines are truncated in mesh_compact."""
    acc = DigestAccumulator()
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Create a 200-char summary
    long_summary = "A" * 200
    acc.enqueue(make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        title="Weather Event",
        summary=long_summary,
    ))

    digest = acc.render_digest(now=base_time)

    # The [Weather] line should be shorter than the raw summary
    weather_line = [l for l in digest.mesh_compact.split("\n") if "[Weather]" in l][0]
    assert len(weather_line) < len(long_summary)
    # Overall mesh_compact should still fit within limit
    assert len(digest.mesh_compact) <= 200


# ============================================================
# EXCLUDED TOGGLES TESTS
# ============================================================

def test_rf_propagation_events_excluded_from_digest_by_default():
    """rf_propagation toggle is excluded by default."""
    acc = DigestAccumulator()  # default config
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Find a category that maps to rf_propagation
    rf_category = None
    for cat_id, cat_info in ALERT_CATEGORIES.items():
        if cat_info.get("toggle") == "rf_propagation":
            rf_category = cat_id
            break

    assert rf_category is not None, "Should find an rf_propagation category"

    event = make_event(
        source="test",
        category=rf_category,
        severity="routine",
        title="HF Blackout",
    )
    acc.enqueue(event)

    # Should NOT be in active
    assert acc.active_count() == 0

    digest = acc.render_digest(now=base_time)
    assert "[RF]" not in digest.full


def test_excluded_toggles_parameter_overrides_default():
    """excluded_toggles=[] allows rf_propagation events."""
    acc = DigestAccumulator(excluded_toggles=[])  # no exclusions
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Find a category that maps to rf_propagation
    rf_category = None
    for cat_id, cat_info in ALERT_CATEGORIES.items():
        if cat_info.get("toggle") == "rf_propagation":
            rf_category = cat_id
            break

    event = make_event(
        source="test",
        category=rf_category,
        severity="routine",
        title="HF Blackout",
    )
    acc.enqueue(event)

    # Should BE in active
    assert acc.active_count() == 1

    digest = acc.render_digest(now=base_time)
    assert "[RF]" in digest.full


def test_excluded_toggles_can_exclude_multiple():
    """excluded_toggles can exclude multiple toggles."""
    acc = DigestAccumulator(excluded_toggles=["rf_propagation", "tracking"])
    base_time = 1000000.0
    acc._now = lambda: base_time

    # Find categories for rf_propagation and tracking
    rf_category = None
    for cat_id, cat_info in ALERT_CATEGORIES.items():
        if cat_info.get("toggle") == "rf_propagation":
            rf_category = cat_id
            break

    # tracking toggle - there may not be categories for it in ALERT_CATEGORIES,
    # so we'll use a fake category that will fall back to "other" normally,
    # but we need to test the exclusion mechanism. Use an existing one if available.
    tracking_category = None
    for cat_id, cat_info in ALERT_CATEGORIES.items():
        if cat_info.get("toggle") == "tracking":
            tracking_category = cat_id
            break

    # Even if no tracking category exists, test that rf_propagation is excluded
    if rf_category:
        acc.enqueue(make_event(
            source="test",
            category=rf_category,
            severity="routine",
            title="HF Blackout",
        ))

    # For tracking, if no category maps to it, the test still validates
    # that the exclusion list works for multiple entries
    assert acc.active_count() == 0


# ============================================================
# PIPELINE INTEGRATION TESTS
# ============================================================

def test_pipeline_routes_routine_event_to_accumulator():
    """Routine event via bus.emit ends up in DigestAccumulator."""
    config = Config()
    bus, inhibitor, grouper, severity_router, dispatcher, digest = \
        build_pipeline_components(config)

    event = make_event(
        source="test",
        category="weather_warning",
        severity="routine",
        title="Test routine event",
    )

    # Flush through grouper
    grouper.flush_all()
    bus.emit(event)
    grouper.flush_all()

    assert digest.active_count() == 1


def test_pipeline_routes_immediate_event_to_dispatcher_not_accumulator():
    """Immediate event goes to dispatcher, not accumulator."""
    config = Config()
    bus, inhibitor, grouper, severity_router, dispatcher, digest = \
        build_pipeline_components(config)

    # Mock the severity_router's immediate handler (already bound to dispatcher.dispatch)
    mock_immediate = MagicMock()
    severity_router._immediate = mock_immediate

    event = make_event(
        source="test",
        category="weather_warning",
        severity="immediate",
        title="Test immediate event",
    )

    grouper.flush_all()
    bus.emit(event)
    grouper.flush_all()

    # Immediate handler should have been called
    assert mock_immediate.called
    # Accumulator should have nothing
    assert digest.active_count() == 0