"""Unit tests for patterns."""

import pytest
from vibeguard.patterns.definitions import Severity, Pattern, Issue
from vibeguard.patterns.manager import PatternManager


class TestPatternDefinitions:
    """Tests for pattern definitions."""

    def test_severity_order(self):
        """Test severity ordering."""
        assert Severity.CRITICAL.value == "critical"
        assert Severity.ERROR.value == "error"
        assert Severity.WARNING.value == "warning"
        assert Severity.INFO.value == "info"

    def test_pattern_creation(self):
        """Test pattern creation."""
        pattern = Pattern(
            id="TEST001",
            name="Test Pattern",
            description="A test pattern",
            severity=Severity.WARNING,
            languages=["python"],
            message="Test message",
            suggestion="Test suggestion",
        )

        assert pattern.id == "TEST001"
        assert pattern.name == "Test Pattern"
        assert pattern.severity == Severity.WARNING
        assert "python" in pattern.languages

    def test_issue_to_dict(self):
        """Test issue to dictionary conversion."""
        issue = Issue(
            pattern_id="TEST001",
            file="test.py",
            line=10,
            severity=Severity.WARNING,
            message="Test message",
            suggestion="Test suggestion",
        )

        result = issue.to_dict()

        assert result["pattern"] == "TEST001"
        assert result["file"] == "test.py"
        assert result["line"] == 10
        assert result["severity"] == "warning"


class TestPatternManager:
    """Tests for pattern manager."""

    def test_load_patterns(self):
        """Test loading all patterns."""
        manager = PatternManager()
        manager.load_all_patterns()

        assert len(manager.patterns) > 0

    def test_get_pattern(self):
        """Test getting a pattern by ID."""
        manager = PatternManager()
        manager.load_all_patterns()

        pattern = manager.get_pattern("PY001")
        assert pattern is not None
        assert pattern.id == "PY001"

    def test_get_patterns_by_language(self):
        """Test getting patterns for a specific language."""
        manager = PatternManager()
        manager.load_all_patterns()

        python_patterns = manager.get_patterns_by_language("python")
        assert len(python_patterns) > 0

        for pattern in python_patterns:
            assert "python" in pattern.languages or "all" in pattern.languages

    def test_get_patterns_by_severity(self):
        """Test getting patterns by severity."""
        manager = PatternManager()
        manager.load_all_patterns()

        error_patterns = manager.get_patterns_by_severity(Severity.ERROR)
        for pattern in error_patterns:
            assert pattern.severity == Severity.ERROR

    def test_to_dict(self):
        """Test converting patterns to dictionary."""
        manager = PatternManager()
        manager.load_all_patterns()

        result = manager.to_dict()

        assert isinstance(result, dict)
        assert len(result) > 0
        for pattern_id, pattern_data in result.items():
            assert "id" in pattern_data
            assert "name" in pattern_data
            assert "severity" in pattern_data

    def test_pattern_categories(self):
        """Test that patterns have proper categories."""
        manager = PatternManager()
        manager.load_all_patterns()

        for pattern in manager.patterns.values():
            assert pattern.category is not None
            assert len(pattern.category) > 0