"""Tests for custom patterns module."""

import pytest
from pathlib import Path

from gitignore_cli.custom_patterns import (
    CustomPattern,
    CustomPatternManager,
)


class TestCustomPattern:
    """Tests for CustomPattern class."""

    def test_custom_pattern_creation(self):
        """Test creating a CustomPattern instance."""
        pattern = CustomPattern(pattern="*.log", description="Log files")

        assert pattern.pattern == "*.log"
        assert pattern.description == "Log files"
        assert pattern.enabled is True

    def test_custom_pattern_disabled(self):
        """Test creating a disabled CustomPattern."""
        pattern = CustomPattern(pattern="*.tmp", enabled=False)

        assert pattern.enabled is False

    def test_custom_pattern_to_dict(self):
        """Test converting pattern to dictionary."""
        pattern = CustomPattern(pattern="*.log", description="Logs", enabled=True)
        data = pattern.to_dict()

        assert data["pattern"] == "*.log"
        assert data["description"] == "Logs"
        assert data["enabled"] is True

    def test_custom_pattern_from_dict(self):
        """Test creating pattern from dictionary."""
        data = {
            "pattern": "*.tmp",
            "description": "Temporary files",
            "enabled": False,
        }
        pattern = CustomPattern.from_dict(data)

        assert pattern.pattern == "*.tmp"
        assert pattern.description == "Temporary files"
        assert pattern.enabled is False

    def test_custom_pattern_repr(self):
        """Test pattern string representation."""
        pattern = CustomPattern(pattern="*.log")
        repr_str = repr(pattern)

        assert "*.log" in repr_str


class TestCustomPatternManager:
    """Tests for CustomPatternManager class."""

    def test_add_pattern(self, custom_pattern_manager: CustomPatternManager):
        """Test adding a custom pattern."""
        result = custom_pattern_manager.add_pattern("*.log", "Log files")

        assert result is True
        assert custom_pattern_manager.count() == 1

    def test_add_duplicate_pattern(self, custom_pattern_manager: CustomPatternManager):
        """Test adding a duplicate pattern."""
        custom_pattern_manager.add_pattern("*.log")

        result = custom_pattern_manager.add_pattern("*.log")
        assert result is False

    def test_remove_pattern(self, custom_pattern_manager: CustomPatternManager):
        """Test removing a custom pattern."""
        custom_pattern_manager.add_pattern("*.log")

        result = custom_pattern_manager.remove_pattern("*.log")
        assert result is True
        assert custom_pattern_manager.count() == 0

    def test_remove_nonexistent_pattern(self, custom_pattern_manager: CustomPatternManager):
        """Test removing a pattern that doesn't exist."""
        result = custom_pattern_manager.remove_pattern("*.nonexistent")
        assert result is False

    def test_list_patterns(self, custom_pattern_manager: CustomPatternManager):
        """Test listing custom patterns."""
        custom_pattern_manager.add_pattern("*.log", "Log files")
        custom_pattern_manager.add_pattern("*.tmp")
        custom_pattern_manager.toggle_pattern("*.tmp")

        patterns = custom_pattern_manager.list_patterns(include_disabled=True)
        assert len(patterns) == 2

        enabled = custom_pattern_manager.list_patterns(include_disabled=False)
        assert len(enabled) == 1

    def test_get_enabled_patterns(self, custom_pattern_manager: CustomPatternManager):
        """Test getting enabled pattern strings."""
        custom_pattern_manager.add_pattern("*.log")
        custom_pattern_manager.add_pattern("*.tmp")
        custom_pattern_manager.toggle_pattern("*.tmp")

        patterns = custom_pattern_manager.get_enabled_patterns()
        assert "*.log" in patterns
        assert "*.tmp" not in patterns

    def test_toggle_pattern(self, custom_pattern_manager: CustomPatternManager):
        """Test toggling a pattern's enabled state."""
        custom_pattern_manager.add_pattern("*.log")

        new_state = custom_pattern_manager.toggle_pattern("*.log")
        assert new_state is False

        new_state = custom_pattern_manager.toggle_pattern("*.log")
        assert new_state is True

    def test_toggle_nonexistent_pattern(self, custom_pattern_manager: CustomPatternManager):
        """Test toggling a nonexistent pattern."""
        result = custom_pattern_manager.toggle_pattern("*.nonexistent")
        assert result is None

    def test_get_patterns_content(self, custom_pattern_manager: CustomPatternManager):
        """Test getting patterns content string."""
        custom_pattern_manager.add_pattern("*.log")
        custom_pattern_manager.add_pattern("*.tmp")

        content = custom_pattern_manager.get_patterns_content()

        assert "*.log" in content
        assert "*.tmp" in content

    def test_count_patterns(self, custom_pattern_manager: CustomPatternManager):
        """Test counting patterns."""
        assert custom_pattern_manager.count() == 0

        custom_pattern_manager.add_pattern("*.log")
        custom_pattern_manager.add_pattern("*.tmp")

        assert custom_pattern_manager.count() == 2

    def test_count_enabled(self, custom_pattern_manager: CustomPatternManager):
        """Test counting enabled patterns."""
        custom_pattern_manager.add_pattern("*.log")
        custom_pattern_manager.add_pattern("*.tmp")
        custom_pattern_manager.toggle_pattern("*.tmp")

        assert custom_pattern_manager.count_enabled() == 1