import pytest
from src.core.file_manager import FileManager
from src.core.tag_manager import TagManager
from src.core.tag import Tag


class TestFileManager:
    """Testy pro třídu FileManager"""

    @pytest.fixture
    def tag_manager(self):
        """Fixture pro TagManager"""
        return TagManager()

    @pytest.fixture
    def file_manager(self, tag_manager, temp_global_config):
        """Fixture pro FileManager"""
        return FileManager(tag_manager)

    @pytest.fixture
    def temp_dir(self, tmp_path):
        """Fixture pro dočasný adresář s testovacími soubory"""
        # Vytvoření struktury souborů
        (tmp_path / "file1.txt").write_text("content1")
        (tmp_path / "file2.txt").write_text("content2")
        (tmp_path / "file3.jpg").write_text("image")

        # Podsložka
        subdir = tmp_path / "subdir"
        subdir.mkdir()
        (subdir / "file4.txt").write_text("content4")

        return tmp_path

    @pytest.fixture
    def temp_global_config(self, tmp_path, monkeypatch):
        """Fixture pro dočasný global config soubor"""
        config_path = tmp_path / "test_config.json"
        import src.core.config as config_module
        monkeypatch.setattr(config_module, 'GLOBAL_CONFIG_FILE', config_path)
        return config_path

    def test_file_manager_creation(self, file_manager, tag_manager):
        """Test vytvoření FileManager"""
        assert file_manager.filelist == []
        assert file_manager.folders == []
        assert file_manager.tagmanager == tag_manager
        assert file_manager.global_config is not None
        assert file_manager.folder_configs == {}
        assert file_manager.current_folder is None

    def test_file_manager_append_folder(self, file_manager, temp_dir):
        """Test přidání složky"""
        file_manager.append(temp_dir)

        assert temp_dir in file_manager.folders
        assert len(file_manager.filelist) > 0
        assert file_manager.current_folder == temp_dir

    def test_file_manager_append_folder_finds_all_files(self, file_manager, temp_dir):
        """Test že append najde všechny soubory včetně podsložek"""
        file_manager.append(temp_dir)

        # Měli bychom najít file1.txt, file2.txt, file3.jpg, subdir/file4.txt
        # (ne .!tag soubory)
        filenames = {f.filename for f in file_manager.filelist}
        assert "file1.txt" in filenames
        assert "file2.txt" in filenames
        assert "file3.jpg" in filenames
        assert "file4.txt" in filenames

    def test_file_manager_ignores_tag_files(self, file_manager, temp_dir):
        """Test že .!tag soubory jsou ignorovány"""
        # Vytvoření .!tag souboru
        (temp_dir / ".file1.txt.!tag").write_text('{"tags": []}')

        file_manager.append(temp_dir)

        filenames = {f.filename for f in file_manager.filelist}
        assert ".file1.txt.!tag" not in filenames

    def test_file_manager_ignores_curator_config_files(self, file_manager, temp_dir):
        """Test že Curator config soubory jsou ignorovány"""
        (temp_dir / ".Curator.!ftag").write_text('{}')  # Folder config
        (temp_dir / ".Curator.!gtag").write_text('{}')  # Global config

        file_manager.append(temp_dir)

        filenames = {f.filename for f in file_manager.filelist}
        assert ".Curator.!ftag" not in filenames
        assert ".Curator.!gtag" not in filenames


    def test_file_manager_updates_last_folder(self, file_manager, temp_dir):
        """Test aktualizace last_folder v global configu"""
        file_manager.append(temp_dir)

        assert file_manager.global_config["last_folder"] == str(temp_dir)

    def test_file_manager_updates_recent_folders(self, file_manager, temp_dir):
        """Test aktualizace recent_folders"""
        file_manager.append(temp_dir)

        assert str(temp_dir) in file_manager.global_config["recent_folders"]
        assert file_manager.global_config["recent_folders"][0] == str(temp_dir)

    def test_file_manager_recent_folders_max_10(self, file_manager, tmp_path):
        """Test že recent_folders má max 10 položek"""
        for i in range(15):
            folder = tmp_path / f"folder{i}"
            folder.mkdir()
            (folder / "file.txt").write_text("content")
            file_manager.append(folder)

        assert len(file_manager.global_config["recent_folders"]) <= 10

    def test_file_manager_loads_folder_config(self, file_manager, temp_dir):
        """Test že se načte folder config při append"""
        file_manager.append(temp_dir)

        assert temp_dir in file_manager.folder_configs
        assert "ignore_patterns" in file_manager.folder_configs[temp_dir]


class TestFileManagerIgnorePatterns:
    """Testy pro ignore patterns"""

    @pytest.fixture
    def tag_manager(self):
        return TagManager()

    @pytest.fixture
    def temp_global_config(self, tmp_path, monkeypatch):
        config_path = tmp_path / "test_config.json"
        import src.core.config as config_module
        monkeypatch.setattr(config_module, 'GLOBAL_CONFIG_FILE', config_path)
        return config_path

    @pytest.fixture
    def file_manager(self, tag_manager, temp_global_config):
        return FileManager(tag_manager)

    @pytest.fixture
    def temp_dir(self, tmp_path):
        (tmp_path / "file1.txt").write_text("content1")
        (tmp_path / "file2.txt").write_text("content2")
        (tmp_path / "file3.jpg").write_text("image")
        subdir = tmp_path / "subdir"
        subdir.mkdir()
        (subdir / "file4.txt").write_text("content4")
        return tmp_path

    def test_ignore_patterns_by_extension(self, file_manager, temp_dir):
        """Test ignorování souborů podle přípony"""
        from src.core.config import save_folder_config
        save_folder_config(temp_dir, {"ignore_patterns": ["*.jpg"], "custom_tags": {}, "recursive": True})

        file_manager.append(temp_dir)

        filenames = {f.filename for f in file_manager.filelist}
        assert "file3.jpg" not in filenames
        assert "file1.txt" in filenames

    def test_ignore_patterns_path(self, file_manager, temp_dir):
        """Test ignorování podle celé cesty"""
        from src.core.config import save_folder_config
        save_folder_config(temp_dir, {"ignore_patterns": ["*/subdir/*"], "custom_tags": {}, "recursive": True})

        file_manager.append(temp_dir)

        filenames = {f.filename for f in file_manager.filelist}
        assert "file4.txt" not in filenames
        assert "file1.txt" in filenames

    def test_multiple_ignore_patterns(self, file_manager, temp_dir):
        """Test více ignore patternů najednou"""
        from src.core.config import save_folder_config
        save_folder_config(temp_dir, {"ignore_patterns": ["*.jpg", "*/subdir/*"], "custom_tags": {}, "recursive": True})

        file_manager.append(temp_dir)

        filenames = {f.filename for f in file_manager.filelist}
        assert "file3.jpg" not in filenames
        assert "file4.txt" not in filenames
        assert "file1.txt" in filenames
        assert "file2.txt" in filenames

    def test_set_ignore_patterns(self, file_manager, temp_dir):
        """Test nastavení ignore patterns přes metodu"""
        file_manager.append(temp_dir)
        file_manager.set_ignore_patterns(["*.tmp", "*.log"])

        patterns = file_manager.get_ignore_patterns()
        assert patterns == ["*.tmp", "*.log"]

    def test_get_ignore_patterns_empty(self, file_manager, temp_dir):
        """Test získání prázdných ignore patterns"""
        file_manager.append(temp_dir)

        patterns = file_manager.get_ignore_patterns()
        assert patterns == []


class TestFileManagerFolderConfig:
    """Testy pro folder config management"""

    @pytest.fixture
    def tag_manager(self):
        return TagManager()

    @pytest.fixture
    def temp_global_config(self, tmp_path, monkeypatch):
        config_path = tmp_path / "test_config.json"
        import src.core.config as config_module
        monkeypatch.setattr(config_module, 'GLOBAL_CONFIG_FILE', config_path)
        return config_path

    @pytest.fixture
    def file_manager(self, tag_manager, temp_global_config):
        return FileManager(tag_manager)

    @pytest.fixture
    def temp_dir(self, tmp_path):
        (tmp_path / "file1.txt").write_text("content")
        return tmp_path

    def test_get_folder_config_current(self, file_manager, temp_dir):
        """Test získání configu pro aktuální složku"""
        file_manager.append(temp_dir)

        config = file_manager.get_folder_config()
        assert "ignore_patterns" in config

    def test_get_folder_config_specific(self, file_manager, temp_dir, tmp_path):
        """Test získání configu pro specifickou složku"""
        folder2 = tmp_path / "folder2"
        folder2.mkdir()
        (folder2 / "file.txt").write_text("content")

        file_manager.append(temp_dir)
        file_manager.append(folder2)

        config = file_manager.get_folder_config(temp_dir)
        assert config is not None

    def test_get_folder_config_no_current(self, file_manager):
        """Test získání configu když není current folder"""
        config = file_manager.get_folder_config()
        assert config == {}

    def test_save_folder_config(self, file_manager, temp_dir):
        """Test uložení folder configu"""
        file_manager.append(temp_dir)

        new_config = {"ignore_patterns": ["*.test"], "custom_tags": {}, "recursive": False}
        file_manager.save_folder_config(config=new_config)

        loaded = file_manager.get_folder_config()
        assert loaded["ignore_patterns"] == ["*.test"]
        assert loaded["recursive"] is False


class TestFileManagerTagOperations:
    """Testy pro operace s tagy"""

    @pytest.fixture
    def tag_manager(self):
        return TagManager()

    @pytest.fixture
    def temp_global_config(self, tmp_path, monkeypatch):
        config_path = tmp_path / "test_config.json"
        import src.core.config as config_module
        monkeypatch.setattr(config_module, 'GLOBAL_CONFIG_FILE', config_path)
        return config_path

    @pytest.fixture
    def file_manager(self, tag_manager, temp_global_config):
        return FileManager(tag_manager)

    @pytest.fixture
    def temp_dir(self, tmp_path):
        (tmp_path / "file1.txt").write_text("content1")
        (tmp_path / "file2.txt").write_text("content2")
        (tmp_path / "file3.txt").write_text("content3")
        return tmp_path

    def test_assign_tag_to_file_objects_tag_object(self, file_manager, temp_dir):
        """Test přiřazení Tag objektu k souborům"""
        file_manager.append(temp_dir)
        files = file_manager.filelist[:2]
        tag = Tag("Video", "HD")

        file_manager.assign_tag_to_file_objects(files, tag)

        for f in files:
            assert tag in f.tags

    def test_assign_tag_string_with_category(self, file_manager, temp_dir):
        """Test přiřazení tagu jako string s kategorií"""
        file_manager.append(temp_dir)
        files = file_manager.filelist[:1]

        file_manager.assign_tag_to_file_objects(files, "Video/4K")

        tag_paths = {tag.full_path for tag in files[0].tags}
        assert "Video/4K" in tag_paths

    def test_assign_tag_string_without_category(self, file_manager, temp_dir):
        """Test přiřazení tagu bez kategorie (default)"""
        file_manager.append(temp_dir)
        files = file_manager.filelist[:1]

        file_manager.assign_tag_to_file_objects(files, "SimpleTag")

        tag_paths = {tag.full_path for tag in files[0].tags}
        assert "default/SimpleTag" in tag_paths

    def test_assign_tag_no_duplicate(self, file_manager, temp_dir):
        """Test že tag není přidán dvakrát"""
        file_manager.append(temp_dir)
        files = file_manager.filelist[:1]
        tag = Tag("Video", "HD")

        file_manager.assign_tag_to_file_objects(files, tag)
        file_manager.assign_tag_to_file_objects(files, tag)

        count = sum(1 for t in files[0].tags if t == tag)
        assert count == 1

    def test_remove_tag_from_file_objects(self, file_manager, temp_dir):
        """Test odstranění tagu ze souborů"""
        file_manager.append(temp_dir)
        files = file_manager.filelist[:2]
        tag = Tag("Video", "HD")

        file_manager.assign_tag_to_file_objects(files, tag)
        file_manager.remove_tag_from_file_objects(files, tag)

        for f in files:
            assert tag not in f.tags

    def test_remove_tag_string(self, file_manager, temp_dir):
        """Test odstranění tagu jako string"""
        file_manager.append(temp_dir)
        files = file_manager.filelist[:1]

        file_manager.assign_tag_to_file_objects(files, "Video/HD")
        file_manager.remove_tag_from_file_objects(files, "Video/HD")

        tag_paths = {tag.full_path for tag in files[0].tags}
        assert "Video/HD" not in tag_paths

    def test_callback_on_tag_change(self, file_manager, temp_dir):
        """Test callback při změně tagů"""
        file_manager.append(temp_dir)
        callback_calls = []

        def callback(filelist):
            callback_calls.append(len(filelist))

        file_manager.on_files_changed = callback
        file_manager.assign_tag_to_file_objects([file_manager.filelist[0]], Tag("Test", "Tag"))

        assert len(callback_calls) == 1


class TestFileManagerFiltering:
    """Testy pro filtrování souborů"""

    @pytest.fixture
    def tag_manager(self):
        return TagManager()

    @pytest.fixture
    def temp_global_config(self, tmp_path, monkeypatch):
        config_path = tmp_path / "test_config.json"
        import src.core.config as config_module
        monkeypatch.setattr(config_module, 'GLOBAL_CONFIG_FILE', config_path)
        return config_path

    @pytest.fixture
    def file_manager(self, tag_manager, temp_global_config):
        return FileManager(tag_manager)

    @pytest.fixture
    def temp_dir(self, tmp_path):
        (tmp_path / "file1.txt").write_text("content1")
        (tmp_path / "file2.txt").write_text("content2")
        (tmp_path / "file3.txt").write_text("content3")
        return tmp_path

    def test_filter_empty_tags_returns_all(self, file_manager, temp_dir):
        """Test filtrace bez tagů vrací všechny soubory"""
        file_manager.append(temp_dir)

        filtered = file_manager.filter_files_by_tags([])
        assert len(filtered) == len(file_manager.filelist)

    def test_filter_none_returns_all(self, file_manager, temp_dir):
        """Test filtrace s None vrací všechny soubory"""
        file_manager.append(temp_dir)

        filtered = file_manager.filter_files_by_tags(None)
        assert len(filtered) == len(file_manager.filelist)

    def test_filter_by_single_tag(self, file_manager, temp_dir):
        """Test filtrace podle jednoho tagu"""
        file_manager.append(temp_dir)
        tag = Tag("Video", "HD")
        files_to_tag = file_manager.filelist[:2]
        file_manager.assign_tag_to_file_objects(files_to_tag, tag)

        filtered = file_manager.filter_files_by_tags([tag])
        assert len(filtered) == 2
        for f in filtered:
            assert tag in f.tags

    def test_filter_by_multiple_tags_and_logic(self, file_manager, temp_dir):
        """Test filtrace podle více tagů (AND logika)"""
        file_manager.append(temp_dir)
        tag1 = Tag("Video", "HD")
        tag2 = Tag("Audio", "Stereo")

        # První soubor má oba tagy
        file_manager.assign_tag_to_file_objects([file_manager.filelist[0]], tag1)
        file_manager.assign_tag_to_file_objects([file_manager.filelist[0]], tag2)

        # Druhý soubor má jen první tag
        file_manager.assign_tag_to_file_objects([file_manager.filelist[1]], tag1)

        filtered = file_manager.filter_files_by_tags([tag1, tag2])
        assert len(filtered) == 1
        assert filtered[0] == file_manager.filelist[0]

    def test_filter_by_tag_strings(self, file_manager, temp_dir):
        """Test filtrace podle tagů jako stringy"""
        file_manager.append(temp_dir)
        file_manager.assign_tag_to_file_objects([file_manager.filelist[0]], "Video/HD")

        filtered = file_manager.filter_files_by_tags(["Video/HD"])
        assert len(filtered) == 1

    def test_filter_no_match(self, file_manager, temp_dir):
        """Test filtrace když nic neodpovídá"""
        file_manager.append(temp_dir)

        filtered = file_manager.filter_files_by_tags([Tag("NonExistent", "Tag")])
        assert len(filtered) == 0


class TestFileManagerLegacy:
    """Testy pro zpětnou kompatibilitu"""

    @pytest.fixture
    def tag_manager(self):
        return TagManager()

    @pytest.fixture
    def temp_global_config(self, tmp_path, monkeypatch):
        config_path = tmp_path / "test_config.json"
        import src.core.config as config_module
        monkeypatch.setattr(config_module, 'GLOBAL_CONFIG_FILE', config_path)
        return config_path

    @pytest.fixture
    def file_manager(self, tag_manager, temp_global_config):
        return FileManager(tag_manager)

    def test_config_property_returns_global(self, file_manager):
        """Test že property config vrací global_config"""
        assert file_manager.config is file_manager.global_config

    def test_config_property_modifiable(self, file_manager):
        """Test že změny přes config property se projeví"""
        file_manager.config["test_key"] = "test_value"
        assert file_manager.global_config["test_key"] == "test_value"


class TestFileManagerEdgeCases:
    """Testy pro edge cases"""

    @pytest.fixture
    def tag_manager(self):
        return TagManager()

    @pytest.fixture
    def temp_global_config(self, tmp_path, monkeypatch):
        config_path = tmp_path / "test_config.json"
        import src.core.config as config_module
        monkeypatch.setattr(config_module, 'GLOBAL_CONFIG_FILE', config_path)
        return config_path

    @pytest.fixture
    def file_manager(self, tag_manager, temp_global_config):
        return FileManager(tag_manager)

    def test_empty_filelist_operations(self, file_manager):
        """Test operací s prázdným filelistem"""
        filtered = file_manager.filter_files_by_tags([Tag("Video", "HD")])
        assert filtered == []

        # Přiřazení tagů na prázdný seznam
        file_manager.assign_tag_to_file_objects([], Tag("Video", "HD"))
        assert len(file_manager.filelist) == 0

    def test_assign_tag_to_empty_list(self, file_manager):
        """Test přiřazení tagu prázdnému seznamu souborů"""
        file_manager.assign_tag_to_file_objects([], Tag("Test", "Tag"))
        # Nemělo by vyhodit výjimku

    def test_remove_nonexistent_tag(self, file_manager, tmp_path):
        """Test odstranění neexistujícího tagu"""
        (tmp_path / "file.txt").write_text("content")
        file_manager.append(tmp_path)

        # Nemělo by vyhodit výjimku
        file_manager.remove_tag_from_file_objects(file_manager.filelist, Tag("NonExistent", "Tag"))

    def test_multiple_folders(self, file_manager, tmp_path):
        """Test práce s více složkami"""
        folder1 = tmp_path / "folder1"
        folder2 = tmp_path / "folder2"
        folder1.mkdir()
        folder2.mkdir()
        (folder1 / "file1.txt").write_text("content1")
        (folder2 / "file2.txt").write_text("content2")

        file_manager.append(folder1)
        file_manager.append(folder2)

        assert len(file_manager.folders) == 2
        filenames = {f.filename for f in file_manager.filelist}
        assert "file1.txt" in filenames
        assert "file2.txt" in filenames

    def test_folder_with_special_characters(self, file_manager, tmp_path):
        """Test složky se speciálními znaky v názvu"""
        special_folder = tmp_path / "složka s českou diakritikou"
        special_folder.mkdir()
        (special_folder / "soubor.txt").write_text("obsah")

        file_manager.append(special_folder)

        filenames = {f.filename for f in file_manager.filelist}
        assert "soubor.txt" in filenames

    def test_file_with_special_characters(self, file_manager, tmp_path):
        """Test souboru se speciálními znaky v názvu"""
        (tmp_path / "soubor s mezerami.txt").write_text("content")
        (tmp_path / "čeština.txt").write_text("obsah")

        file_manager.append(tmp_path)

        filenames = {f.filename for f in file_manager.filelist}
        assert "soubor s mezerami.txt" in filenames
        assert "čeština.txt" in filenames


class TestPoolManagement:
    """Testy pro pool a copy-as-is složky"""

    @pytest.fixture
    def temp_global_config(self, tmp_path, monkeypatch):
        config_path = tmp_path / "test_config.json"
        import src.core.config as config_module
        monkeypatch.setattr(config_module, 'GLOBAL_CONFIG_FILE', config_path)
        return config_path

    @pytest.fixture
    def file_manager(self, temp_global_config):
        return FileManager(TagManager())

    def test_set_pool_creates_top_level_folders(self, file_manager, tmp_path):
        pool = tmp_path / "pool"
        file_manager.set_pool_dir(pool)

        assert (pool / "Filmy").is_dir()
        assert (pool / "Seriály").is_dir()
        assert file_manager.pool_dir == pool

    def test_import_movie_copies_and_indexes(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        source = tmp_path / "raw.mkv"
        source.write_bytes(b"x" * 10)

        movie = file_manager.import_movie(source, "Matrix", "https://csfd.cz/film/1")

        assert movie.file_path == tmp_path / "pool" / "Filmy" / "Matrix.mkv"
        assert source.exists()  # non-destructive copy
        assert movie.title == "Matrix"
        assert movie.csfd_link == "https://csfd.cz/film/1"
        assert file_manager.index.get(movie.file_path) is not None

    def test_import_movie_move_removes_source(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        source = tmp_path / "raw.mkv"
        source.write_bytes(b"x" * 10)

        movie = file_manager.import_movie(source, "Matrix", move=True)

        assert movie.file_path == tmp_path / "pool" / "Filmy" / "Matrix.mkv"
        assert movie.file_path.exists()
        assert not source.exists()  # moved, not copied

    def test_filmoteka_category_roots_from_schema(self, file_manager):
        file_manager.set_tag_schema([
            {"category": "Žánr", "csfd_field": "genres", "transform": None, "filmoteka_root": ""},
            {"category": "Rok", "csfd_field": "year", "transform": None, "filmoteka_root": "Dle roku"},
            {"category": "Herec", "csfd_field": "actors", "transform": None, "filmoteka_root": None},
        ])
        roots = file_manager.filmoteka_category_roots()
        assert roots == {"Žánr": "", "Rok": "Dle roku"}  # None-root excluded
        assert "Herec" not in roots

    def test_import_movie_suffix_keeps_both(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        (tmp_path / "a.mkv").write_bytes(b"a")
        (tmp_path / "b.mkv").write_bytes(b"b")
        first = file_manager.import_movie(tmp_path / "a.mkv", "Matrix")
        second = file_manager.import_movie(tmp_path / "b.mkv", "Matrix")  # default suffix

        assert first.file_path.name == "Matrix.mkv"
        assert second.file_path.name == "Matrix_1.mkv"
        assert len(file_manager.filelist) == 2

    def test_import_movie_replace_evicts_existing(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        (tmp_path / "a.mkv").write_bytes(b"a")
        (tmp_path / "b.mkv").write_bytes(b"bb")
        first = file_manager.import_movie(tmp_path / "a.mkv", "Matrix")
        first.add_tag("Žánr/Akční")
        old_path = first.file_path

        second = file_manager.import_movie(
            tmp_path / "b.mkv", "Matrix", csfd_link="x", on_conflict="replace")

        assert second.file_path.name == "Matrix.mkv"
        assert second.file_path == old_path  # same name reused
        assert second.file_path.read_bytes() == b"bb"  # new content in place
        assert [f.file_path.name for f in file_manager.filelist] == ["Matrix.mkv"]
        # index record reflects the new import (fresh metadata, old tags dropped)
        record = file_manager.index.get(second.file_path)
        assert record is not None
        assert record["csfd_link"] == "x"
        assert record["tags"] == []
        assert second.tags == []

    def test_import_movie_replace_across_extensions(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        (tmp_path / "a.mkv").write_bytes(b"a")
        (tmp_path / "b.mp4").write_bytes(b"b")
        file_manager.import_movie(tmp_path / "a.mkv", "Matrix")
        file_manager.import_movie(tmp_path / "b.mp4", "Matrix", on_conflict="replace")

        names = [f.file_path.name for f in file_manager.filelist]
        assert names == ["Matrix.mp4"]
        assert not (tmp_path / "pool" / "Filmy" / "Matrix.mkv").exists()

    def test_import_movie_skip_returns_none(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        (tmp_path / "a.mkv").write_bytes(b"a")
        (tmp_path / "b.mkv").write_bytes(b"b")
        file_manager.import_movie(tmp_path / "a.mkv", "Matrix")
        result = file_manager.import_movie(tmp_path / "b.mkv", "Matrix", on_conflict="skip")

        assert result is None
        assert len(file_manager.filelist) == 1

    def test_rename_movie_renames_file_and_reindexes(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        source = tmp_path / "raw.mkv"
        source.write_bytes(b"x" * 10)
        movie = file_manager.import_movie(source, "Matrix")
        movie.add_tag("Žánr/Sci-Fi")
        old_path = movie.file_path

        file_manager.rename_movie(movie, "Matrix Reloaded")

        new_path = tmp_path / "pool" / "Filmy" / "Matrix Reloaded.mkv"
        assert movie.file_path == new_path
        assert new_path.exists()
        assert not old_path.exists()
        assert movie.title == "Matrix Reloaded"
        # metadata moved to the new key, old key gone, tags preserved
        assert file_manager.index.get(new_path) is not None
        assert file_manager.index.get(old_path) is None
        # a fresh manager reading the index sees the renamed file with its tags
        reloaded = FileManager(TagManager())
        reloaded.set_pool_dir(tmp_path / "pool")
        reloaded.load_pool_movies()
        assert [f.filename for f in reloaded.filelist] == ["Matrix Reloaded.mkv"]
        assert "Žánr/Sci-Fi" in {t.full_path for t in reloaded.filelist[0].tags}

    def test_rename_movie_preserves_extension(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        source = tmp_path / "raw.mp4"
        source.write_bytes(b"x")
        movie = file_manager.import_movie(source, "Film")

        file_manager.rename_movie(movie, "Jiný název")

        assert movie.file_path.name == "Jiný název.mp4"

    def test_rename_movie_rejects_existing_name(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        (tmp_path / "a.mkv").write_bytes(b"a")
        (tmp_path / "b.mkv").write_bytes(b"b")
        first = file_manager.import_movie(tmp_path / "a.mkv", "Already")
        second = file_manager.import_movie(tmp_path / "b.mkv", "Other")

        with pytest.raises(FileExistsError):
            file_manager.rename_movie(second, "Already")
        # second movie is left untouched
        assert second.file_path.name == "Other.mkv"
        assert first.file_path.exists()

    def test_rename_movie_rejects_empty_name(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        (tmp_path / "a.mkv").write_bytes(b"a")
        movie = file_manager.import_movie(tmp_path / "a.mkv", "Name")

        with pytest.raises(ValueError):
            file_manager.rename_movie(movie, "   ")

    def test_load_pool_movies_reads_from_index(self, file_manager, tmp_path):
        file_manager.set_pool_dir(tmp_path / "pool")
        source = tmp_path / "raw.mkv"
        source.write_bytes(b"x" * 10)
        file_manager.import_movie(source, "Matrix", "https://csfd.cz/film/1")

        reloaded = FileManager(TagManager())
        reloaded.set_pool_dir(tmp_path / "pool")
        reloaded.load_pool_movies()

        assert len(reloaded.filelist) == 1
        assert reloaded.filelist[0].title == "Matrix"

    def test_copyasis_folders_default_and_set(self, file_manager):
        assert file_manager.copyasis_folders == ["Seriály"]

        file_manager.set_copyasis_folders(["Seriály", " Dokumenty ", ""])
        assert file_manager.copyasis_folders == ["Seriály", "Dokumenty"]