import importlib.util
import json
import os
import tempfile
import unittest
from pathlib import Path


class CoreTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.temp = tempfile.TemporaryDirectory()
        root = Path(cls.temp.name)
        for name in ("source", "view", "cache", "state"):
            (root / name).mkdir()
        (root / "cache" / ".pretranscode-cache").touch()
        os.environ.update({
            "SOURCE_ROOT": str(root / "source"),
            "VIEW_ROOT": str(root / "view"),
            "CACHE_ROOT": str(root / "cache"),
            "STATE_ROOT": str(root / "state"),
            "JELLYFIN_LIBRARY_ROOT": "/library",
            "JELLYFIN_ORIGINAL_ROOT": "/original",
            "JELLYFIN_CACHE_ROOT": "/cached",
        })
        spec = importlib.util.spec_from_file_location("pretranscode", Path(__file__).parents[1] / "pretranscode.py")
        cls.module = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(cls.module)
        cls.root = root

    @classmethod
    def tearDownClass(cls):
        cls.temp.cleanup()

    def test_paths_are_configurable(self):
        m = self.module
        self.assertEqual(m.relative_source("/library/tv/Show/episode.mkv"), "tv/Show/episode.mkv")
        self.assertEqual(m.source_target("tv/Show/episode.mkv"), "/original/tv/Show/episode.mkv")
        self.assertTrue(m.cache_target("tv/Show/episode.mkv").startswith("/cached/files/"))

    def test_series_lock_key(self):
        m = self.module
        self.assertEqual(m.item_key("tv/Show/Season 1/Episode.mkv"), "series:Show")
        self.assertEqual(m.item_key("movies/Movie/file.mkv"), "item:movies/Movie/file.mkv")

    def test_fixed_codec_blacklist(self):
        manager = self.module.Manager()
        self.assertTrue(manager.incompatible({"codec": "hevc", "bit_depth": 10}))
        self.assertTrue(manager.incompatible({"codec": "h264", "bit_depth": 10}))
        self.assertFalse(manager.incompatible({"codec": "h264", "bit_depth": 8}))
        self.assertFalse(manager.incompatible({"codec": "av1", "bit_depth": 10}))

    def test_quality_filters_are_global(self):
        manager = self.module.Manager()
        sdr = manager.ffmpeg_command(Path("show.mkv"), Path("out.mkv.partial"), {})
        hdr = manager.ffmpeg_command(
            Path("show.HDR10.mkv"), Path("out.mkv.partial"), {"color_transfer": "smpte2084"}
        )
        self.assertIn("zscale=dither=error_diffusion,format=yuv420p", sdr)
        self.assertIn("18", sdr)
        self.assertTrue(any("tonemap=tonemap=hable" in value for value in hdr))
        self.assertIn("bt709", hdr)

    def test_cache_requires_matching_source_fingerprint(self):
        m = self.module
        manager = m.Manager()
        relative = "movies/Test/Test.mkv"
        source = self.root / "source" / relative
        source.parent.mkdir(parents=True, exist_ok=True)
        source.write_bytes(b"original")
        output, manifest = manager.cache_paths(relative)
        output.write_bytes(b"cached")
        manifest.write_text(json.dumps({
            "relative": relative,
            "source_fingerprint": m.fingerprint(source),
            "encode_profile": m.ENCODE_PROFILE,
        }))
        self.assertTrue(manager.cache_valid(relative))
        source.write_bytes(b"changed")
        self.assertFalse(manager.cache_valid(relative))

    def test_smaller_cache_limit_evicts_oldest_content(self):
        m = self.module
        manager = m.Manager()
        relative = "movies/Resize/Resize.mkv"
        source = self.root / "source" / relative
        source.parent.mkdir(parents=True, exist_ok=True)
        source.write_bytes(b"original")
        output, manifest = manager.cache_paths(relative)
        output.write_bytes(b"cached rendition")
        manifest.write_text(json.dumps({
            "relative": relative,
            "source_fingerprint": m.fingerprint(source),
            "encode_profile": m.ENCODE_PROFILE,
        }))
        manager.ensure_link(relative, m.cache_target(relative))
        old_limit = m.CACHE_MAX_BYTES
        try:
            m.CACHE_MAX_BYTES = 1
            manager.enforce_cache_limit()
        finally:
            m.CACHE_MAX_BYTES = old_limit
        self.assertFalse(output.exists())
        self.assertEqual(os.readlink(self.root / "view" / relative), m.source_target(relative))


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