"""Tests for pattern generation functionality."""

from src.generators.merge import PatternMerger
from src.generators.pattern import PatternGenerator


class TestPatternGenerator:
    """Tests for PatternGenerator class."""

    def test_generate_python_patterns(self):
        """Test generation of Python patterns."""
        generator = PatternGenerator()
        content = generator.generate(languages=["python"])
        assert "__pycache__/" in content
        assert "*.py[cod]" in content
        assert ".venv/" in content

    def test_generate_nodejs_patterns(self):
        """Test generation of Node.js patterns."""
        generator = PatternGenerator()
        content = generator.generate(languages=["nodejs"])
        assert "node_modules/" in content
        assert "*.log" in content

    def test_generate_django_patterns(self):
        """Test generation of Django patterns."""
        generator = PatternGenerator()
        content = generator.generate(frameworks=["django"])
        assert "db.sqlite3" in content
        assert "media/" in content

    def test_generate_react_patterns(self):
        """Test generation of React patterns."""
        generator = PatternGenerator()
        content = generator.generate(frameworks=["react"])
        assert "build/" in content
        assert ".next/" in content

    def test_generate_vscode_patterns(self):
        """Test generation of VSCode patterns."""
        generator = PatternGenerator()
        content = generator.generate(ides=["vscode"])
        assert ".vscode/" in content

    def test_generate_jetbrains_patterns(self):
        """Test generation of JetBrains patterns."""
        generator = PatternGenerator()
        content = generator.generate(ides=["jetbrains"])
        assert ".idea/" in content

    def test_generate_macos_patterns(self):
        """Test generation of macOS patterns."""
        generator = PatternGenerator()
        content = generator.generate(os_list=["macos"])
        assert ".DS_Store" in content

    def test_generate_windows_patterns(self):
        """Test generation of Windows patterns."""
        generator = PatternGenerator()
        content = generator.generate(os_list=["windows"])
        assert "Thumbs.db" in content

    def test_generate_linux_patterns(self):
        """Test generation of Linux patterns."""
        generator = PatternGenerator()
        content = generator.generate(os_list=["linux"])
        assert "*~" in content

    def test_generate_custom_patterns(self):
        """Test generation of custom patterns."""
        generator = PatternGenerator()
        content = generator.generate(custom_patterns=["custom_dir/", "*.custom"])
        assert "custom_dir/" in content
        assert "*.custom" in content

    def test_generate_empty_when_no_options(self):
        """Test that empty content is generated when no options provided."""
        generator = PatternGenerator()
        content = generator.generate()
        assert ".DS_Store" in content
        assert "Thumbs.db" in content

    def test_get_supported_languages(self):
        """Test getting list of supported languages."""
        generator = PatternGenerator()
        languages = generator.get_supported_languages()
        assert "python" in languages
        assert "nodejs" in languages
        assert "go" in languages

    def test_get_supported_frameworks(self):
        """Test getting list of supported frameworks."""
        generator = PatternGenerator()
        frameworks = generator.get_supported_frameworks()
        assert "django" in frameworks
        assert "react" in frameworks
        assert "flask" in frameworks

    def test_get_supported_ides(self):
        """Test getting list of supported IDEs."""
        generator = PatternGenerator()
        ides = generator.get_supported_ides()
        assert "vscode" in ides
        assert "jetbrains" in ides

    def test_get_supported_os(self):
        """Test getting list of supported operating systems."""
        generator = PatternGenerator()
        os_list = generator.get_supported_os()
        assert "macos" in os_list
        assert "windows" in os_list
        assert "linux" in os_list

    def test_validate_valid_pattern(self):
        """Test validation of valid patterns."""
        generator = PatternGenerator()
        is_valid, error = generator.validate_pattern("*.log")
        assert is_valid is True
        assert error == ""

    def test_validate_empty_pattern(self):
        """Test validation of empty patterns."""
        generator = PatternGenerator()
        is_valid, error = generator.validate_pattern("")
        assert is_valid is False
        assert "empty" in error.lower()

    def test_validate_comment_pattern(self):
        """Test validation of comment patterns."""
        generator = PatternGenerator()
        is_valid, error = generator.validate_pattern("# This is a comment")
        assert is_valid is True

    def test_validate_negation_pattern(self):
        """Test validation of negation patterns."""
        generator = PatternGenerator()
        is_valid, error = generator.validate_pattern("!important.txt")
        assert is_valid is True


class TestPatternMerger:
    """Tests for PatternMerger class."""

    def test_merge_priority(self):
        """Test merging patterns with priority strategy."""
        merger = PatternMerger()
        patterns_by_category = {
            "os": ["*.log"],
            "language": ["node_modules/", "*.pyc"],
        }
        merged, conflicts = merger.merge(patterns_by_category)
        assert len(conflicts) == 0

    def test_merge_deduplication(self):
        """Test that merging deduplicates patterns."""
        merger = PatternMerger()
        patterns_by_category = {
            "language": ["*.log", "*.log"],
            "framework": ["*.log"],
        }
        merged, conflicts = merger.merge(patterns_by_category)
        log_count = sum(1 for p in merged if "*.log" in p)
        assert log_count == 1

    def test_deduplicate_method(self):
        """Test deduplicate method directly."""
        merger = PatternMerger()
        patterns = ["*.log", "*.log", "node_modules/", "*.log"]
        unique = merger.deduplicate(patterns)
        assert len(unique) == 2

    def test_merge_empty_categories(self):
        """Test merging with empty categories."""
        merger = PatternMerger()
        merged, conflicts = merger.merge({})
        assert merged == []

    def test_merge_with_custom_patterns(self):
        """Test merging with custom patterns."""
        merger = PatternMerger()
        patterns_by_category = {
            "language": ["*.pyc"],
        }
        merged, conflicts = merger.merge(patterns_by_category, custom_patterns=["custom.txt"])
        assert "custom.txt" in merged

    def test_get_pattern_sources(self):
        """Test getting pattern sources."""
        merger = PatternMerger()
        patterns = ["*.log", "node_modules/", ".DS_Store"]
        sources = merger.get_pattern_sources(patterns)
        assert "os" in sources or "other" in sources

    def test_resolve_conflict_keep_existing(self):
        """Test conflict resolution keeping existing."""
        merger = PatternMerger()
        result = merger.resolve_conflict("new.txt", "old.txt", "keep_existing")
        assert result == "old.txt"

    def test_resolve_conflict_keep_new(self):
        """Test conflict resolution keeping new."""
        merger = PatternMerger()
        result = merger.resolve_conflict("new.txt", "old.txt", "keep_new")
        assert result == "new.txt"