import unittest
from datetime import datetime
from types import SimpleNamespace

from routes.streams import _serialize


class StreamAccessSerializationTest(unittest.TestCase):
    def make_stream(self, **overrides):
        values = {
            "id": 1,
            "title": "Hidden program",
            "description": None,
            "cover_url": None,
            "status": SimpleNamespace(value="pending"),
            "scheduled_at": datetime(2026, 8, 20, 12, 0),
            "started_at": None,
            "ended_at": None,
            "multicast_enabled": False,
            "replay_file": None,
            "chapters_json": "[]",
            "transcode_profile": "default",
            "homepage_visible": False,
            "remote_control_enabled": True,
            "stream_key": "private-key",
            "created_at": datetime(2026, 8, 19, 12, 0),
        }
        values.update(overrides)
        return SimpleNamespace(**values)

    def test_public_serialization_excludes_private_stream_key(self):
        payload = _serialize(self.make_stream(), include_private=False)
        self.assertNotIn("stream_key", payload)
        self.assertFalse(payload["homepage_visible"])
        self.assertTrue(payload["remote_control_enabled"])

    def test_admin_serialization_includes_private_stream_key(self):
        payload = _serialize(self.make_stream(), include_private=True)
        self.assertEqual(payload["stream_key"], "private-key")

    def test_program_statuses_are_preserved(self):
        for status in ("pending", "live", "ended", "cancelled"):
            with self.subTest(status=status):
                payload = _serialize(self.make_stream(status=SimpleNamespace(value=status)), include_private=False)
                self.assertEqual(payload["status"], status)


class AccessContractTest(unittest.TestCase):
    def test_hidden_program_uses_private_direct_url_contract(self):
        stream = StreamAccessSerializationTest().make_stream(homepage_visible=False)
        public_payload = _serialize(stream, include_private=False)
        admin_payload = _serialize(stream, include_private=True)
        self.assertFalse(public_payload["homepage_visible"])
        self.assertNotIn("stream_key", public_payload)
        self.assertEqual(admin_payload["stream_key"], "private-key")

    def test_remote_control_flag_is_enforced_by_contract(self):
        enabled = _serialize(
            StreamAccessSerializationTest().make_stream(remote_control_enabled=True),
            include_private=False,
        )
        disabled = _serialize(
            StreamAccessSerializationTest().make_stream(remote_control_enabled=False),
            include_private=False,
        )
        self.assertTrue(enabled["remote_control_enabled"])
        self.assertFalse(disabled["remote_control_enabled"])


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