"""Tests for the regex translator."""

import pytest
from regex_humanizer.translator import RegexTranslator, translate_regex


class TestRegexTranslator:
    """Test cases for RegexTranslator."""

    def test_translate_simple_literal(self):
        """Test translating a simple literal."""
        result = translate_regex("hello")
        assert "hello" in result.lower() or "hello" in result

    def test_translate_character_class(self):
        """Test translating a character class."""
        result = translate_regex("[a-z]")
        assert "any" in result.lower() and ("a" in result.lower() or "z" in result.lower())

    def test_translate_negated_class(self):
        """Test translating a negated character class."""
        result = translate_regex("[^0-9]")
        assert "except" in result.lower() or "not" in result.lower()

    def test_translate_digit_class(self):
        """Test translating digit shorthand."""
        result = translate_regex("\\d")
        assert "digit" in result.lower()

    def test_translate_non_digit_class(self):
        """Test translating non-digit shorthand."""
        result = translate_regex("\\D")
        assert "non-digit" in result.lower() or "non digit" in result.lower()

    def test_translate_word_class(self):
        """Test translating word character shorthand."""
        result = translate_regex("\\w")
        assert "word" in result.lower()

    def test_translate_whitespace_class(self):
        """Test translating whitespace shorthand."""
        result = translate_regex("\\s")
        assert "whitespace" in result.lower()

    def test_translate_plus_quantifier(self):
        """Test translating plus quantifier."""
        result = translate_regex("a+")
        assert "one or more" in result.lower() or "1 or more" in result.lower()

    def test_translate_star_quantifier(self):
        """Test translating star quantifier."""
        result = translate_regex("b*")
        assert "zero or more" in result.lower() or "0 or more" in result.lower()

    def test_translate_question_quantifier(self):
        """Test translating question mark quantifier."""
        result = translate_regex("c?")
        assert "optional" in result.lower() or "0 or 1" in result.lower()

    def test_translate_range_quantifier(self):
        """Test translating range quantifier."""
        result = translate_regex("a{2,5}")
        assert "between" in result.lower() and ("2" in result or "2" in result.lower())

    def test_translate_exact_quantifier(self):
        """Test translating exact count quantifier."""
        result = translate_regex("x{3}")
        assert "exactly" in result.lower() and "3" in result

    def test_translate_lazy_quantifier(self):
        """Test translating lazy quantifier."""
        result = translate_regex(".+?")
        assert "lazy" in result.lower()

    def test_translate_capturing_group(self):
        """Test translating a capturing group."""
        result = translate_regex("(test)")
        assert "capturing" in result.lower() or "group" in result.lower()

    def test_translate_non_capturing_group(self):
        """Test translating a non-capturing group."""
        result = translate_regex("(?:test)")
        assert "non-capturing" in result.lower()

    def test_translate_named_group(self):
        """Test translating a named group."""
        result = translate_regex("(?P<name>test)")
        assert "name" in result.lower() or "named" in result.lower()

    def test_translate_lookahead(self):
        """Test translating a positive lookahead."""
        result = translate_regex("(?=test)")
        assert "followed" in result.lower()

    def test_translate_negative_lookahead(self):
        """Test translating a negative lookahead."""
        result = translate_regex("(?!test)")
        assert "not followed" in result.lower() or "not" in result.lower()

    def test_translate_lookbehind(self):
        """Test translating a lookbehind."""
        result = translate_regex("(?<=test)")
        assert "preceded" in result.lower()

    def test_translate_negative_lookbehind(self):
        """Test translating a negative lookbehind."""
        result = translate_regex("(?<!test)")
        assert "not preceded" in result.lower()

    def test_translate_anchor_start(self):
        """Test translating a start anchor."""
        result = translate_regex("^start")
        assert "start" in result.lower()

    def test_translate_anchor_end(self):
        """Test translating an end anchor."""
        result = translate_regex("end$")
        assert "end" in result.lower()

    def test_translate_word_boundary(self):
        """Test translating a word boundary."""
        result = translate_regex("\\bword\\b")
        assert "word boundary" in result.lower()

    def test_translate_dot(self):
        """Test translating a dot."""
        result = translate_regex(".")
        assert "any" in result.lower() and "character" in result.lower()

    def test_translate_alternation(self):
        """Test translating alternation."""
        result = translate_regex("cat|dog")
        assert "cat" in result.lower() or "dog" in result.lower()

    def test_translate_complex_pattern(self):
        """Test translating a complex pattern."""
        pattern = r"^\d{3}-\d{4}$"
        result = translate_regex(pattern)

        assert len(result) > 0
        assert "digit" in result.lower() or "3" in result

    def test_translate_email_pattern(self):
        """Test translating an email pattern."""
        pattern = r"[a-z]+@[a-z]+\.[a-z]+"
        result = translate_regex(pattern)

        assert "any" in result.lower() or "@" in result

    def test_translate_url_pattern(self):
        """Test translating a URL pattern."""
        pattern = r"https?://[^\\s]+"
        result = translate_regex(pattern)

        assert len(result) > 0

    def test_translate_escaped_char(self):
        """Test translating an escaped character."""
        result = translate_regex("\\.")
        assert "." in result or "period" in result.lower()

    def test_translate_whitespace_literal(self):
        """Test translating a literal space."""
        result = translate_regex(" ")
        assert "space" in result.lower()

    def test_translate_tab_literal(self):
        """Test translating a tab character."""
        result = translate_regex("\\t")
        assert "escape" in result.lower() or "\\t" in result or "tab" in result.lower()

    def test_translate_backreference(self):
        """Test translating a backreference."""
        result = translate_regex(r"(a)\\1")
        assert "same as" in result.lower() or "capture" in result.lower() or "\\1" in result

    def test_translate_empty_pattern(self):
        """Test translating an empty pattern."""
        result = translate_regex("")
        assert len(result) >= 0

    def test_translate_with_js_flavor(self):
        """Test translating with JavaScript flavor."""
        result = translate_regex("test", flavor="javascript")
        assert len(result) > 0

    def test_translate_with_python_flavor(self):
        """Test translating with Python flavor."""
        result = translate_regex("test", flavor="python")
        assert len(result) > 0


class TestRegexTranslatorClass:
    """Test the RegexTranslator class directly."""

    def test_translator_initialization(self):
        """Test translator initialization with default flavor."""
        translator = RegexTranslator()
        assert translator.flavor == "pcre"

    def test_translator_custom_flavor(self):
        """Test translator initialization with custom flavor."""
        translator = RegexTranslator("javascript")
        assert translator.flavor == "javascript"

    def test_translate_returns_string(self):
        """Test that translate returns a string."""
        translator = RegexTranslator()
        result = translator.translate("test")
        assert isinstance(result, str)

    def test_translate_empty_sequence(self):
        """Test translating an empty sequence node."""
        from regex_humanizer.parser import RegexParser, NodeType, RegexNode

        parser = RegexParser("")
        ast = parser.parse()
        translator = RegexTranslator()

        result = translator._translate_node(ast)
        assert isinstance(result, str)