from __future__ import annotations

import unittest

from server import (
    resolve_build_workers,
    resolve_extract_workers,
    resolve_generation_strategy,
    resolve_image_delivery_options,
    resolve_memory_reclaim_options,
    resolve_single_generation_mode,
)


class TestGenerationStrategy(unittest.TestCase):
    def test_default_without_performance_uses_page_template_cache(self) -> None:
        self.assertEqual(resolve_generation_strategy({}, total_records=1), "legacy")
        self.assertEqual(resolve_generation_strategy({}, total_records=5), "page_template_cache")

    def test_page_template_cache_requires_min_records(self) -> None:
        cfg = {
            "performance": {
                "generation_strategy": "page_template_cache",
                "template_cache_min_records": 2,
                "single_slide_output": True,
            }
        }
        self.assertEqual(resolve_generation_strategy(cfg, total_records=1), "legacy")
        self.assertEqual(resolve_generation_strategy(cfg, total_records=2), "page_template_cache")

    def test_page_template_cache_respects_single_slide_output(self) -> None:
        cfg = {
            "performance": {
                "generation_strategy": "page_template_cache",
                "template_cache_min_records": 1,
                "single_slide_output": False,
            }
        }
        self.assertEqual(resolve_generation_strategy(cfg, total_records=3), "legacy")

    def test_legacy_strategy_always_returns_legacy(self) -> None:
        cfg = {
            "performance": {
                "generation_strategy": "legacy",
                "template_cache_min_records": 1,
                "single_slide_output": True,
            }
        }
        self.assertEqual(resolve_generation_strategy(cfg, total_records=20), "legacy")

    def test_image_delivery_defaults(self) -> None:
        opts = resolve_image_delivery_options({})
        self.assertEqual(int(opts.get("max_kbps", 0)), 300)
        self.assertEqual(int(opts.get("chunk_size", 0)), 16 * 1024)

    def test_image_delivery_disable_limit(self) -> None:
        cfg = {"performance": {"image_delivery": {"enabled": False, "max_kbps": 999}}}
        opts = resolve_image_delivery_options(cfg)
        self.assertEqual(int(opts.get("max_kbps", -1)), 0)

    def test_single_generation_mode_defaults_enabled(self) -> None:
        self.assertTrue(resolve_single_generation_mode({}))
        self.assertFalse(resolve_single_generation_mode({"performance": {"single_generation_mode": False}}))

    def test_build_workers_default_single(self) -> None:
        self.assertEqual(resolve_build_workers({}, total_records=10), 1)
        cfg = {"performance": {"max_build_workers": 3}}
        self.assertEqual(resolve_build_workers(cfg, total_records=2), 2)

    def test_extract_workers_default_single(self) -> None:
        self.assertEqual(resolve_extract_workers({}), 1)
        cfg = {"performance": {"max_extract_workers": 4}}
        self.assertGreaterEqual(resolve_extract_workers(cfg), 1)

    def test_memory_reclaim_defaults_enabled(self) -> None:
        opts = resolve_memory_reclaim_options({})
        self.assertTrue(opts["enabled"])
        self.assertTrue(opts["gc_collect"])
        self.assertTrue(opts["malloc_trim"])

    def test_memory_reclaim_can_disable(self) -> None:
        opts = resolve_memory_reclaim_options({"performance": {"memory_reclaim": {"enabled": False}}})
        self.assertFalse(opts["enabled"])
        self.assertFalse(opts["gc_collect"])
        self.assertFalse(opts["malloc_trim"])


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