import pytest

from regexsolver._generated.models import Cardinality as GeneratedCardinality
from regexsolver._generated.models import (
    CardinalityBigInteger,
    CardinalityInfinite,
    CardinalityInteger,
    TermFair,
    TermRegex,
)
from regexsolver._generated.models import Length as GeneratedLength
from regexsolver._generated.models import Term as GeneratedTerm
from regexsolver._generated.models.term_fair_metadata import TermFairMetadata
from regexsolver.models.cardinality import BigInteger, Cardinality, Infinite, Integer
from regexsolver.models.length import Length
from regexsolver.models.term import FairTerm, RegexTerm, Term


def test_term_creation_regex():
    term = Term.regex("abc")
    assert isinstance(term, RegexTerm)
    assert term.get_value() == "abc"
    assert isinstance(term.to_dto(), GeneratedTerm)


def test_term_creation_fair():
    term = Term.fair("fair_payload")
    assert isinstance(term, FairTerm)
    assert term.get_value() == "fair_payload"


def test_term_from_dto_regex():
    gen_term = GeneratedTerm(TermRegex(type="regex", value="abc"))
    term = Term.from_dto(gen_term)
    assert isinstance(term, RegexTerm)
    assert term.get_value() == "abc"


def test_term_from_dto_fair():
    gen_term = GeneratedTerm(TermFair(type="fair", value="payload"))
    term = Term.from_dto(gen_term)
    assert isinstance(term, FairTerm)
    assert term.get_value() == "payload"


def test_cardinality_integer():
    c = Integer(10)
    assert c.value == 10
    assert c.is_empty() is False
    assert c.is_empty_string() is False
    assert c.is_total() is False
    assert repr(c) == "<Cardinality::Integer(10)>"


def test_cardinality_from_dto_integer():
    gen_card = GeneratedCardinality(CardinalityInteger(type="integer", value=10))
    c = Cardinality.from_dto(gen_card)
    assert isinstance(c, Integer)
    assert c.value == 10


def test_cardinality_from_dto_big_integer():
    gen_card = GeneratedCardinality(CardinalityBigInteger(type="bigInteger"))
    c = Cardinality.from_dto(gen_card)
    assert isinstance(c, BigInteger)


def test_cardinality_from_dto_infinite():
    gen_card = GeneratedCardinality(CardinalityInfinite(type="infinite"))
    c = Cardinality.from_dto(gen_card)
    assert isinstance(c, Infinite)


def test_cardinality_integer_zero():
    c = Integer(0)
    assert c.is_empty() is True
    assert c.is_empty_string() is False


def test_cardinality_integer_one():
    c = Integer(1)
    assert c.is_empty() is False
    assert c.is_empty_string() is None  # Per implementation


def test_cardinality_big_integer():
    c = BigInteger()
    assert c.is_empty() is False
    assert c.is_empty_string() is False
    assert c.is_total() is False
    assert repr(c) == "<Cardinality::BigInteger>"


def test_cardinality_infinite():
    c = Infinite()
    assert c.is_empty() is False
    assert c.is_empty_string() is False
    assert repr(c) == "<Cardinality::Infinite>"


def test_length():
    length = Length(min=1, max=5)
    assert length.min == 1
    assert length.max == 5
    assert length.is_empty() is False
    assert length.is_empty_string() is False
    assert length.is_total() is False
    assert repr(length) == "<Length: min=1, max=5>"


def test_length_from_dto():
    gen_len = GeneratedLength(type="length", min=1, max=5)
    length_obj = Length.from_dto(gen_len)
    assert length_obj.min == 1
    assert length_obj.max == 5


def test_length_empty():
    length = Length(min=None, max=None)
    assert length.is_empty() is True


def test_length_empty_string():
    length = Length(min=0, max=0)
    assert length.is_empty_string() is True


def test_length_total_candidate():
    length = Length(min=0, max=None)
    assert length.is_total() is None  # Implementation returns None if it COULD be total


def test_term_properties_caching():
    term = Term.regex("abc")
    assert term._cardinality is None

    c = Integer(5)
    term._cardinality = c
    # Simulate AsyncRegexSolverClient behavior
    term._set_properties_mixin(c)

    assert term._cardinality == c
    # Since Integer(5).is_empty() is False, it should set _empty to False
    assert term._empty is False


def test_term_get_fair_and_pattern():
    regex_term = Term.regex("abc")
    assert regex_term.get_pattern() == "abc"
    assert regex_term.get_fair() is None

    fair_term = Term.fair("payload")
    assert fair_term.get_fair() == "payload"
    assert fair_term.get_pattern() is None

    fair_term._pattern = "abc"
    assert fair_term.get_pattern() == "abc"


def test_term_serialize_deserialize():
    term = Term.regex("abc")
    serialized = term.serialize()
    assert serialized == "regex=abc"
    assert str(term) == "regex=abc"

    deserialized = Term.deserialize(serialized)
    assert deserialized == term
    assert hash(deserialized) == hash(term)

    fair_term = Term.fair("payload")
    assert Term.deserialize(fair_term.serialize()) == fair_term

    assert Term.deserialize("invalid") is None
    assert Term.deserialize("unknown=value") is None


def test_term_matches():
    term = Term.regex("a.b")
    assert term.matches("axb") is True
    assert term.matches("a\nb") is True  # DOTALL
    assert term.matches("ab") is False
    assert term.matches("axxb") is False  # anchored (fullmatch)

    fair_term = Term.fair("payload")
    # Matches the new Java-aligned behavior of throwing an exception
    with pytest.raises(RuntimeError, match="not defined yet"):
        fair_term.matches("abc")


# --- FairTerm.is_deterministic ---


def test_fair_term_is_deterministic_unknown_by_default():
    term = Term.fair("payload")
    assert isinstance(term, FairTerm)
    assert term.is_deterministic is None


def test_fair_term_public_factory_has_no_deterministic_param():
    with pytest.raises(TypeError):
        Term.fair("payload", deterministic=True)  # type: ignore[call-arg]


def test_from_dto_fair_with_deterministic_true():
    dto = GeneratedTerm(
        TermFair(
            type="fair", value="payload", metadata=TermFairMetadata(deterministic=True)
        )
    )
    term = Term.from_dto(dto)
    assert isinstance(term, FairTerm)
    assert term.is_deterministic is True


def test_from_dto_fair_with_deterministic_false():
    dto = GeneratedTerm(
        TermFair(
            type="fair", value="payload", metadata=TermFairMetadata(deterministic=False)
        )
    )
    term = Term.from_dto(dto)
    assert isinstance(term, FairTerm)
    assert term.is_deterministic is False


def test_from_dto_fair_without_metadata():
    dto = GeneratedTerm(TermFair(type="fair", value="payload"))
    term = Term.from_dto(dto)
    assert isinstance(term, FairTerm)
    assert term.is_deterministic is None


# --- metadata is never sent to the server ---


def test_fair_term_to_dto_excludes_metadata():
    # FairTerm.to_dto() always builds a fresh TermFair without metadata —
    # metadata is never round-tripped back to the server.
    term = Term.from_dto(
        GeneratedTerm(
            TermFair(
                type="fair",
                value="payload",
                metadata=TermFairMetadata(deterministic=True),
            )
        )
    )
    instance = term.to_dto().actual_instance
    assert instance is not None
    dto_dict = instance.to_dict()
    assert "metadata" not in dto_dict
    assert dto_dict == {"type": "fair", "value": "payload"}


# --- deterministic + response_format validation ---


def _make_client():
    from regexsolver.clients.asynchronous import AsyncRegexSolverClient

    return AsyncRegexSolverClient.__new__(AsyncRegexSolverClient)


def test_build_options_deterministic_with_fair_format_ok():
    from regexsolver.models.response_format import ResponseFormat

    client = _make_client()
    opts = client._build_options(
        response_format=ResponseFormat.FAIR, deterministic=True
    )
    assert opts.response is not None
    assert opts.response.fair is not None
    assert opts.response.fair.deterministic is True


def test_build_options_deterministic_without_format_ok():
    client = _make_client()
    opts = client._build_options(deterministic=True)
    assert opts.response is not None
    assert opts.response.fair is not None
    assert opts.response.fair.deterministic is True


def test_build_options_deterministic_with_regex_format_raises():
    from regexsolver.models.response_format import ResponseFormat

    client = _make_client()
    with pytest.raises(ValueError, match="deterministic"):
        client._build_options(response_format=ResponseFormat.REGEX, deterministic=True)


def test_build_options_deterministic_with_any_format_raises():
    from regexsolver.models.response_format import ResponseFormat

    client = _make_client()
    with pytest.raises(ValueError, match="deterministic"):
        client._build_options(response_format=ResponseFormat.ANY, deterministic=True)


def test_build_options_deterministic_with_string_regex_raises():
    client = _make_client()
    with pytest.raises(ValueError, match="deterministic"):
        client._build_options(response_format="regex", deterministic=True)