"""Tests for the experimental semantic_rle context engine plugin."""

from __future__ import annotations

from agent.context_engine import ContextEngine
from plugins.context_engine import discover_context_engines, load_context_engine
from plugins.context_engine.semantic_rle import SemanticRLEEngine


def _messages() -> list[dict[str, str]]:
    return [
        {"role": "system", "content": "You are Hermes."},
        {"role": "user", "content": "server alpha.example is the current deployment target"},
        {"role": "assistant", "content": "Noted: server alpha.example."},
        {"role": "user", "content": "decision: use postgres for the ledger"},
        {"role": "assistant", "content": "I will use postgres."},
        {"role": "user", "content": "todo: compare misses against baseline"},
        {"role": "assistant", "content": "Added comparison todo."},
        {"role": "user", "content": "unresolved question: how often to compact?"},
        {"role": "assistant", "content": "We can measure compaction cadence."},
        {"role": "user", "content": "server beta.example is the current deployment target now"},
        {"role": "assistant", "content": "Switched to beta.example."},
        {"role": "user", "content": "hot tail user message"},
        {"role": "assistant", "content": "hot tail assistant message"},
    ]


def test_semantic_rle_satisfies_abc_and_returns_valid_messages():
    engine = SemanticRLEEngine(hot_tail_messages=4)
    assert isinstance(engine, ContextEngine)
    assert engine.name == "semantic_rle"

    result = engine.compress(_messages())

    assert isinstance(result, list)
    assert all("role" in message and "content" in message for message in result)
    assert result[0]["role"] == "system"
    assert any("Semantic RLE context ledger" in message["content"] for message in result)


def test_hot_tail_preserved_verbatim():
    engine = SemanticRLEEngine(hot_tail_messages=4)
    messages = _messages()

    result = engine.compress(messages)

    assert result[-4:] == messages[-4:]


def test_server_supersession_marks_old_fact_inactive():
    engine = SemanticRLEEngine(hot_tail_messages=2)

    result = engine.compress(_messages())
    summary = "\n".join(str(message["content"]) for message in result if message["role"] == "system")

    assert "server: beta.example" in summary
    assert "[superseded by beta.example] server: alpha.example" in summary


def test_fake_tokens_and_ip_like_strings_are_redacted_to_refs():
    engine = SemanticRLEEngine(hot_tail_messages=2)
    fake_token = "sk-test_abcdefghijklmnopqrstuvwxyz1234567890"
    fake_pat = "ghp_abcdefghijklmnopqrstuvwxyz1234567890"
    messages = [
        {"role": "user", "content": f"api_key={fake_token} server 203.0.113.9"},
        {"role": "assistant", "content": f"token: {fake_pat}"},
        {"role": "user", "content": "tail one"},
        {"role": "assistant", "content": "tail two"},
        {"role": "user", "content": "tail three"},
    ]

    result = engine.compress(messages)
    rendered = "\n".join(str(message["content"]) for message in result)

    assert fake_token not in rendered
    assert fake_pat not in rendered
    assert "203.0.113.9" not in rendered
    assert "credential_ref:credential:" in rendered
    assert "[REDACTED_IP]" in rendered


def test_deterministic_failure_path_returns_original_messages(monkeypatch):
    engine = SemanticRLEEngine(hot_tail_messages=2)
    messages = _messages()

    def explode(*args, **kwargs):
        raise RuntimeError("boom")

    monkeypatch.setattr(engine, "_build_ledger", explode)

    assert engine.compress(messages) == messages


def test_plugin_discovery_and_explicit_load_without_global_activation():
    discovered = {name: (description, available) for name, description, available in discover_context_engines()}

    assert "semantic_rle" in discovered
    assert discovered["semantic_rle"][1] is True

    engine = load_context_engine("semantic_rle")
    assert isinstance(engine, SemanticRLEEngine)
    assert engine.name == "semantic_rle"