"""Tests for the test case generator."""

import re
import pytest
from regex_humanizer.test_generator import (
    TestCaseGenerator,
    generate_test_cases,
)


class TestTestCaseGenerator:
    """Test cases for TestCaseGenerator."""

    def test_generate_simple_literal(self):
        """Test generating test cases for a simple literal."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("hello", count=3)

        assert len(matching) >= 1
        assert "hello" in matching or len(matching[0]) > 0

    def test_generate_character_class(self):
        """Test generating test cases for a character class."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("[abc]", count=3)

        assert len(matching) >= 1
        assert len(matching[0]) == 1
        assert matching[0] in ["a", "b", "c"]

    def test_generate_quantifier_plus(self):
        """Test generating test cases for plus quantifier."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("a+", count=3)

        assert len(matching) >= 1
        assert "a" in matching[0]

    def test_generate_quantifier_star(self):
        """Test generating test cases for star quantifier."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("b*", count=3)

        assert len(matching) >= 1
        assert all("b" in m for m in matching)

    def test_generate_quantifier_question(self):
        """Test generating test cases for question quantifier."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("c?", count=3)

        assert len(matching) >= 1
        assert len(matching[0]) <= 1

    def test_generate_digit_class(self):
        """Test generating test cases for digit class."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("\\d+", count=3)

        assert len(matching) >= 1
        assert matching[0].isdigit()

    def test_generate_word_class(self):
        """Test generating test cases for word class."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("\\w+", count=3)

        assert len(matching) >= 1

    def test_generate_non_matching_simple(self):
        """Test generating non-matching test cases."""
        generator = TestCaseGenerator("pcre")
        non_matching = generator.generate_non_matching("hello", count=3)

        assert len(non_matching) >= 1
        pattern = re.compile("hello")
        for test_str in non_matching:
            assert pattern.search(test_str) is None

    def test_generate_non_matching_character_class(self):
        """Test generating non-matching cases for character class."""
        generator = TestCaseGenerator("pcre")
        non_matching = generator.generate_non_matching("[abc]", count=3)

        assert len(non_matching) >= 1
        for test_str in non_matching:
            if len(test_str) > 0:
                assert test_str[0] not in ["a", "b", "c"]

    def test_generate_phone_pattern(self):
        """Test generating test cases for phone pattern."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("\\d{3}-\\d{4}", count=3)

        assert len(matching) >= 1
        assert "-" in matching[0]
        parts = matching[0].split("-")
        assert len(parts) == 2
        assert len(parts[0]) == 3
        assert len(parts[1]) == 4

    def test_generate_with_flavor_js(self):
        """Test generating test cases with JavaScript flavor."""
        generator = TestCaseGenerator("javascript")
        matching = generator.generate_matching("test", count=2)

        assert len(matching) >= 1

    def test_generate_with_flavor_python(self):
        """Test generating test cases with Python flavor."""
        generator = TestCaseGenerator("python")
        matching = generator.generate_matching("test", count=2)

        assert len(matching) >= 1

    def test_generate_matching_count(self):
        """Test that correct number of matching cases are generated."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("a", count=10)

        assert len(matching) <= 10

    def test_generate_non_matching_count(self):
        """Test that correct number of non-matching cases are generated."""
        generator = TestCaseGenerator("pcre")
        non_matching = generator.generate_non_matching("a", count=10)

        assert len(non_matching) <= 10

    def test_generate_complex_pattern(self):
        """Test generating test cases for a complex pattern."""
        pattern = r"^(?:http|https)://[\w.-]+\.(?:com|org|net)$"
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching(pattern, count=3)

        assert len(matching) >= 1

    def test_generate_test_cases_function(self):
        """Test the generate_test_cases convenience function."""
        result = generate_test_cases("test", flavor="pcre", matching_count=2, non_matching_count=2)

        assert "pattern" in result
        assert "flavor" in result
        assert "matching" in result
        assert "non_matching" in result
        assert len(result["matching"]) >= 1
        assert len(result["non_matching"]) >= 1

    def test_generate_group_pattern(self):
        """Test generating test cases for a pattern with groups."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("(hello)\\s+(world)", count=3)

        assert len(matching) >= 1
        assert " " in matching[0] or len(matching[0]) > 5

    def test_generate_alternation(self):
        """Test generating test cases for alternation."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("cat|dog", count=3)

        assert len(matching) >= 1
        assert matching[0] in ["cat", "dog"]

    def test_generate_empty_pattern(self):
        """Test generating test cases for an empty pattern."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("", count=3)

        assert len(matching) >= 0

    def test_generate_anchored_pattern(self):
        """Test generating test cases for anchored patterns."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("^start", count=3)

        assert len(matching) >= 1
        assert matching[0].startswith("start")

    def test_generate_dotted_pattern(self):
        """Test generating test cases for a pattern with dots."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("a.b", count=3)

        assert len(matching) >= 1
        assert len(matching[0]) == 3
        assert matching[0][0] == "a"
        assert matching[0][1] != "."


class TestTestCaseGeneratorEdgeCases:
    """Test edge cases for TestCaseGenerator."""

    def test_generate_with_max_length(self):
        """Test that max_length is respected."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("a+", count=5, max_length=5)

        for m in matching:
            if len(m) > 0:
                assert len(m) <= 5

    def test_generate_nested_groups(self):
        """Test generating test cases for nested groups."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("((a)(b))", count=3)

        assert len(matching) >= 1

    def test_generate_quantifier_range(self):
        """Test generating test cases for range quantifier."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("a{2,4}", count=3)

        assert len(matching) >= 1
        assert 2 <= len(matching[0]) <= 4
        assert matching[0] == "a" * len(matching[0])

    def test_generate_lookahead_pattern(self):
        """Test generating test cases for a lookahead pattern."""
        generator = TestCaseGenerator("pcre")
        matching = generator.generate_matching("(?=test)", count=3)

        assert len(matching) >= 0