"""Memory-Anreicherung: nur für Adapter mit accepts_memory, je Ausschnitt gegen die Matrix geprüft."""
import unittest

from aria_router.classify import PrivacyAssessment
from aria_router.context import MemorySnippet
from aria_router.core import PrivacyTier
from aria_router.gateway import Handling

from tests.helpers import GatewayTestCase


class Provider:
    def __init__(self, snippets):
        self.snippets = snippets
        self.calls = []

    def snippets_for(self, request, backend):
        self.calls.append(backend)
        return list(self.snippets)


class MemoryEnrichmentTests(GatewayTestCase):
    def test_memory_filtered_per_snippet_for_codex(self):
        provider = Provider([
            MemorySnippet("brain/a.md", "Kontext Alpha", PrivacyTier.PUBLIC),
            MemorySnippet("brain/b.md", "BMW Termin morgen", PrivacyTier.PUBLIC),
            MemorySnippet("brain/c.md", "neutraler Satz"),
        ])
        gateway = self.gateway(memory_provider=provider)
        result = gateway.handle(self.request(1, "#public Frage"))
        self.assertEqual((result.handling, result.backend), (Handling.REPLY, "codex"))
        stdin = gateway.adapters["codex"].runner.calls[0].stdin.decode()
        self.assertIn("Kontext Alpha", stdin)
        self.assertNotIn("BMW", stdin)
        self.assertNotIn("neutraler Satz", stdin)
        record = self.decision_records(gateway)[-1]
        self.assertEqual(record["memory"], {"offered": 3, "used": 1, "rejected": 2})
        self.assertEqual(record["final_privacy"], "public")

    def test_memory_not_offered_to_claude_channel(self):
        provider = Provider([MemorySnippet("brain/a.md", "Kontext Alpha", PrivacyTier.PUBLIC)])
        gateway = self.gateway(memory_provider=provider)
        result = gateway.handle(self.request(2, "hallo"))
        self.assertEqual(result.handling, Handling.FORWARD_TO_CLAUDE_CHANNEL)
        self.assertEqual(provider.calls, [])
        self.assertEqual(self.sink.delivered[0]["params"]["content"], "hallo")

    def test_memory_respects_context_limit(self):
        provider = Provider([MemorySnippet("brain/a.md", "x" * 400, PrivacyTier.PUBLIC)])
        gateway = self.gateway({"backends": {"codex": {"max_context_bytes": 200}}}, memory_provider=provider)
        gateway.handle(self.request(3, "#public Frage"))
        self.assertNotIn("xxxx", gateway.adapters["codex"].runner.calls[0].stdin.decode())

    def test_final_reclassification_blocks(self):
        provider = Provider([MemorySnippet("brain/a.md", "Kontext Alpha", PrivacyTier.PUBLIC)])
        gateway = self.gateway(memory_provider=provider)
        real = gateway._classifier.classify

        def stub(envelope):
            # Simulierter Klassifikatorfehler: erst die Gesamtsicht ist vertraulich.
            if envelope.memory and envelope.prompt:
                return PrivacyAssessment(PrivacyTier.CONFIDENTIAL, ("test.stub",),
                                         (("prompt", PrivacyTier.CONFIDENTIAL),))
            return real(envelope)

        gateway._classifier.classify = stub
        result = gateway.handle(self.request(4, "#public Frage"))
        self.assertEqual((result.handling, result.code), (Handling.BLOCKED, "PRIVACY_CHANGED_BY_ENRICHMENT"))
        self.assertEqual(gateway.adapters["codex"].runner.calls, [])


if __name__ == "__main__":
    unittest.main()