from __future__ import annotations

import base64
import unittest
from pathlib import Path

from kimu.audio_protocol import AudioProtocolError, decode_audio_frame, normalise_vad


class Increment46RuntimeHardeningTests(unittest.TestCase):
    def test_vad_values_are_typed_and_bounded(self):
        defaults = {
            "threshold": 0.3,
            "min_silence_duration_ms": 550,
            "min_speech_duration_ms": 200,
            "max_speech_duration_s": 45,
            "speech_pad_ms": 250,
        }
        value = normalise_vad(
            {
                "threshold": "4",
                "min_silence_duration_ms": -20,
                "min_speech_duration_ms": "bad",
                "max_speech_duration_s": 9999,
                "speech_pad_ms": 3000,
                "unknown": "ignored",
            },
            defaults,
        )
        self.assertEqual(value["type"], "server_vad")
        self.assertEqual(value["threshold"], 0.95)
        self.assertEqual(value["min_silence_duration_ms"], 100)
        self.assertEqual(value["min_speech_duration_ms"], 200)
        self.assertEqual(value["max_speech_duration_s"], 300)
        self.assertEqual(value["speech_pad_ms"], 2000)
        self.assertNotIn("unknown", value)

    def test_audio_frame_is_strict_bounded_pcm16(self):
        raw = b"\x01\x02" * 16
        self.assertEqual(decode_audio_frame(base64.b64encode(raw).decode(), 64), raw)
        with self.assertRaises(AudioProtocolError) as invalid:
            decode_audio_frame("not-base64!", 64)
        self.assertEqual(invalid.exception.code, "KIMU_AUDIO_FRAME_INVALID")
        with self.assertRaises(AudioProtocolError) as alignment:
            decode_audio_frame(base64.b64encode(b"123").decode(), 64)
        self.assertEqual(alignment.exception.code, "KIMU_AUDIO_FRAME_ALIGNMENT")
        with self.assertRaises(AudioProtocolError) as too_large:
            decode_audio_frame(base64.b64encode(b"12" * 40).decode(), 64)
        self.assertEqual(too_large.exception.code, "KIMU_AUDIO_FRAME_TOO_LARGE")

    def test_source_uses_latest_context_and_active_stream_close(self):
        gateway = Path("src/kimu/conversation_gateway.py").read_text()
        app = Path("src/kimu/app.py").read_text()
        self.assertIn("ORDER BY created_at DESC,rowid DESC", gateway)
        self.assertIn("LIMIT ?", gateway)
        self.assertIn("RUN_RESPONSES", app)
        self.assertIn("cancel_event=cancel", app)
        self.assertIn("response_callback=active_response", app)
        self.assertIn("response.close()", app)

    def test_swarm_rejection_is_terminal_and_installer_is_gateway_tolerant(self):
        advanced = Path("src/kimu/advanced.py").read_text()
        installer = Path("install.sh").read_text()
        self.assertIn("KIMU_SWARM_APPROVAL_REJECTED", advanced)
        self.assertIn("UPDATE swarms SET status='failed'", advanced)
        self.assertNotIn("pip install --upgrade pip", installer)
        self.assertIn("KIMU_WHEELHOUSE", installer)
        self.assertIn("scripts/check.py || true", installer)
        verifier = Path("verify.sh").read_text()
        runner = Path("run.sh").read_text()
        env_example = Path(".env.example").read_text()
        self.assertIn("ignoring incomplete .venv", verifier)
        self.assertIn(".kimu-runtime-ready", runner)
        self.assertIn("KIMU_WORKERS=1", env_example)
        config = Path("src/kimu/config.py").read_text()
        app = Path("src/kimu/app.py").read_text()
        self.assertIn('"WORKER_COUNT": env_int("KIMU_WORKERS", 1, 1, 64)', config)
        self.assertIn("and single_worker_safe", app)
        self.assertIn('"single_worker_required"', app)


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