# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
"""Comprehensive tests for reflection-driven auto-generated ``__ffi_init__``.

This file exercises:
1. metadata emitted by C++ for auto-init traits
2. Python ``__init__`` signature generation
3. constructor behavior across positional/kw-only/default/init=False combinations
4. low-level KWARGS protocol via TypeAttrColumn __ffi_init__ lookup
5. inheritance behavior for auto-generated init
6. copy/deepcopy/replace interplay with auto-init objects
7. re-initialization, isinstance checks, and instance isolation
"""

# ruff: noqa: D102
from __future__ import annotations

import copy
import inspect
from typing import Any

import pytest
from tvm_ffi import core
from tvm_ffi.dataclasses import py_class
from tvm_ffi.testing import (
    TestCompare,
    TestHash,
    TestIntPair,
    _TestCxxAutoInit,
    _TestCxxAutoInitAllInitOff,
    _TestCxxAutoInitChild,
    _TestCxxAutoInitKwOnlyDefaults,
    _TestCxxAutoInitParent,
    _TestCxxAutoInitSimple,
    _TestCxxClassDerived,
    _TestCxxClassDerivedDerived,
    _TestCxxNoAutoInit,
)
from tvm_ffi.testing.testing import requires_py313


def _ffi_init(obj: Any, *args: Any) -> None:
    """Look up __ffi_init__ from the TypeAttrColumn and call it via __init_handle_by_constructor__."""
    type_index = type(obj).__tvm_ffi_type_info__.type_index
    ffi_init = core._lookup_type_attr(type_index, "__ffi_init__")
    assert ffi_init is not None, f"No __ffi_init__ TypeAttrColumn entry for {type(obj)}"
    obj.__init_handle_by_constructor__(ffi_init, *args)


def _field_map(type_cls: type) -> dict[str, Any]:
    return {field.name: field for field in getattr(type_cls, "__tvm_ffi_type_info__").fields}


def _method_metadata(type_cls: type, method_name: str) -> dict[str, Any]:
    type_info = getattr(type_cls, "__tvm_ffi_type_info__")
    for method in type_info.methods:
        if method.name == method_name:
            return method.metadata
    raise AssertionError(f"Cannot find method metadata: {type_cls.__name__}.{method_name}")


class TestAutoInitMetadata:
    def test_auto_init_method_marked(self) -> None:
        type_info = getattr(_TestCxxAutoInit, "__tvm_ffi_type_info__")
        ffi_init = core._lookup_type_attr(type_info.type_index, "__ffi_init__")
        assert ffi_init is not None
        # Auto-generated init is only in TypeAttrColumn, not in the method list
        assert not any(m.name == "__ffi_init__" for m in type_info.methods)

    def test_field_bitmask_init_kw_only_and_defaults(self) -> None:
        fields = _field_map(_TestCxxAutoInit)
        assert fields["a"].c_init is True
        assert fields["b"].c_init is False
        assert fields["b"].c_has_default is True
        assert fields["c"].c_kw_only is True
        assert fields["c"].c_init is True
        assert fields["d"].c_has_default is True

    def test_all_init_off_field_bitmask(self) -> None:
        fields = _field_map(_TestCxxAutoInitAllInitOff)
        assert fields["x"].c_init is False
        assert fields["x"].c_has_default is True
        assert fields["y"].c_init is False
        assert fields["y"].c_has_default is True
        assert fields["z"].c_init is False
        assert fields["z"].c_has_default is False

    def test_kw_only_defaults_field_bitmask(self) -> None:
        fields = _field_map(_TestCxxAutoInitKwOnlyDefaults)
        assert fields["p_default"].c_has_default is True
        assert fields["k_required"].c_kw_only is True
        assert fields["k_default"].c_kw_only is True
        assert fields["k_default"].c_has_default is True
        assert fields["hidden"].c_init is False
        assert fields["hidden"].c_has_default is True


class TestAutoInitSignature:
    def test_auto_init_signature_layout(self) -> None:
        sig = inspect.signature(_TestCxxAutoInit.__init__)
        assert tuple(sig.parameters) == ("self", "a", "d", "c")
        assert sig.parameters["a"].kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
        assert sig.parameters["d"].kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
        assert sig.parameters["c"].kind == inspect.Parameter.KEYWORD_ONLY

    def test_auto_init_signature_required_vs_default(self) -> None:
        sig = inspect.signature(_TestCxxAutoInit.__init__)
        assert sig.parameters["a"].default is inspect.Parameter.empty
        assert sig.parameters["c"].default is inspect.Parameter.empty
        assert sig.parameters["d"].default is not inspect.Parameter.empty

    def test_simple_signature(self) -> None:
        sig = inspect.signature(_TestCxxAutoInitSimple.__init__)
        assert tuple(sig.parameters) == ("self", "x", "y")
        assert all(
            p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
            for p in (sig.parameters["x"], sig.parameters["y"])
        )

    def test_all_init_off_signature_is_no_arg(self) -> None:
        sig = inspect.signature(_TestCxxAutoInitAllInitOff.__init__)
        assert tuple(sig.parameters) == ("self",)

    def test_kw_only_defaults_signature_layout(self) -> None:
        sig = inspect.signature(_TestCxxAutoInitKwOnlyDefaults.__init__)
        assert tuple(sig.parameters) == (
            "self",
            "p_required",
            "p_default",
            "k_required",
            "k_default",
        )
        assert sig.parameters["p_required"].kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
        assert sig.parameters["p_default"].kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
        assert sig.parameters["k_required"].kind == inspect.Parameter.KEYWORD_ONLY
        assert sig.parameters["k_default"].kind == inspect.Parameter.KEYWORD_ONLY
        assert sig.parameters["p_required"].default is inspect.Parameter.empty
        assert sig.parameters["k_required"].default is inspect.Parameter.empty
        assert sig.parameters["p_default"].default is not inspect.Parameter.empty
        assert sig.parameters["k_default"].default is not inspect.Parameter.empty

    def test_inheritance_signature_includes_parent_fields(self) -> None:
        sig = inspect.signature(_TestCxxAutoInitChild.__init__)
        # Required positional params must precede default ones in Python,
        # so child_required comes before parent_default.
        assert tuple(sig.parameters) == (
            "self",
            "parent_required",
            "child_required",
            "parent_default",
            "child_kw_only",
        )
        assert sig.parameters["child_kw_only"].kind == inspect.Parameter.KEYWORD_ONLY
        assert sig.parameters["parent_default"].default is not inspect.Parameter.empty

    def test_init_false_field_not_in_signature(self) -> None:
        """B is init=False and should not appear in signature."""
        sig = inspect.signature(_TestCxxAutoInit.__init__)
        assert "b" not in sig.parameters

    def test_hidden_field_not_in_signature(self) -> None:
        """Hidden is init=False and should not appear in signature."""
        sig = inspect.signature(_TestCxxAutoInitKwOnlyDefaults.__init__)
        assert "hidden" not in sig.parameters

    def test_kw_only_params_after_positional(self) -> None:
        """Keyword-only params should come after positional in the signature."""
        sig = inspect.signature(_TestCxxAutoInit.__init__)
        params = list(sig.parameters.values())
        saw_kw_only = False
        for p in params[1:]:  # skip self
            if p.kind == inspect.Parameter.KEYWORD_ONLY:
                saw_kw_only = True
            elif saw_kw_only:
                assert p.kind == inspect.Parameter.KEYWORD_ONLY, (
                    f"Parameter {p.name} is {p.kind} after a KEYWORD_ONLY param"
                )

    def test_child_signature_required_before_optional(self) -> None:
        """The child signature should have all required positional before optional."""
        sig = inspect.signature(_TestCxxAutoInitChild.__init__)
        params = list(sig.parameters.values())[1:]  # skip self
        positional = [p for p in params if p.kind != inspect.Parameter.KEYWORD_ONLY]
        saw_default = False
        for p in positional:
            if p.default is not inspect.Parameter.empty:
                saw_default = True
            elif saw_default:
                pytest.fail(f"Required param '{p.name}' appears after a default param")


class TestAutoInitConstruction:
    def test_auto_init_minimal_required(self) -> None:
        obj = _TestCxxAutoInit(1, c=3)
        assert obj.a == 1
        assert obj.b == 42
        assert obj.c == 3
        assert obj.d == 99

    def test_auto_init_all_keyword_arguments(self) -> None:
        obj = _TestCxxAutoInit(a=10, c=30, d=20)
        assert obj.a == 10
        assert obj.b == 42
        assert obj.c == 30
        assert obj.d == 20

    def test_auto_init_keyword_order_irrelevant(self) -> None:
        obj = _TestCxxAutoInit(c=7, d=8, a=9)
        assert obj.a == 9
        assert obj.c == 7
        assert obj.d == 8
        assert obj.b == 42

    def test_auto_init_second_positional_maps_to_d(self) -> None:
        obj = _TestCxxAutoInit(1, 2, c=3)
        assert obj.a == 1
        assert obj.d == 2
        assert obj.c == 3
        assert obj.b == 42

    def test_mutate_fields_after_construction(self) -> None:
        obj = _TestCxxAutoInit(1, c=2)
        obj.b = 100
        obj.c = 999
        assert obj.b == 100
        assert obj.c == 999


class TestAutoInitErrors:
    def test_missing_required_positional(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInit(c=3)  # ty: ignore[missing-argument]

    def test_missing_required_kw_only(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInit(1)  # ty: ignore[missing-argument]

    def test_kw_only_rejects_positional(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInit(1, 2, 3)  # ty: ignore[missing-argument, too-many-positional-arguments]

    def test_duplicate_argument_detection(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInit(1, 2, c=3, d=4)  # ty: ignore[parameter-already-assigned]

    def test_unexpected_keyword(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInit(1, c=2, nope=3)  # ty: ignore[unknown-argument]

    def test_init_false_field_rejected_in_python_init(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInit(1, b=2, c=3)  # ty: ignore[unknown-argument]

    def test_type_mismatch_for_required_positional(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInit("x", c=2)  # ty: ignore[invalid-argument-type]

    def test_type_mismatch_for_kw_only(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInit(1, c="x")  # ty: ignore[invalid-argument-type]

    def test_type_mismatch_for_defaultable_positional(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInit(1, d="x", c=3)  # ty: ignore[invalid-argument-type]

    def test_init_false_field_rejected_via_dict_unpacking(self) -> None:
        """B is init=False, rejected even when passed via **dict."""
        with pytest.raises(TypeError):
            _TestCxxAutoInit(**{"a": 1, "c": 2, "b": 3})

    def test_positional_and_keyword_same_field(self) -> None:
        """Providing a field both positionally and as keyword should error."""
        with pytest.raises(TypeError):
            _TestCxxAutoInit(1, a=2, c=3)  # ty: ignore[parameter-already-assigned]

    def test_none_for_required_integer_field(self) -> None:
        """Passing None where an int64_t is expected should raise TypeError."""
        with pytest.raises(TypeError):
            _TestCxxAutoInitSimple(None, 1)  # ty: ignore[invalid-argument-type]

    def test_none_for_keyword_integer_field(self) -> None:
        """Passing None as keyword where int64_t is expected."""
        with pytest.raises(TypeError):
            _TestCxxAutoInitSimple(x=None, y=1)  # ty: ignore[invalid-argument-type]


class TestAutoInitLowLevelFfiInit:
    def test_low_level_kwargs_protocol(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        _ffi_init(obj, core.KWARGS, "a", 1, "c", 3)
        assert obj.a == 1
        assert obj.b == 42
        assert obj.c == 3
        assert obj.d == 99

    def test_low_level_kwargs_even_pairs_required(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError):
            _ffi_init(obj, core.KWARGS, "a", 1, "c")

    def test_low_level_kwargs_duplicate_name(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError):
            _ffi_init(obj, core.KWARGS, "a", 1, "a", 2, "c", 3)

    def test_low_level_kwargs_unknown_name(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError):
            _ffi_init(obj, core.KWARGS, "a", 1, "unknown", 2, "c", 3)

    def test_low_level_kwargs_key_must_be_string(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError):
            _ffi_init(obj, core.KWARGS, 1, 2, "a", 3, "c", 4)

    def test_low_level_positional_too_many(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError):
            _ffi_init(obj, 1, 2, 3, 4)

    def test_low_level_missing_required(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError):
            _ffi_init(obj, 1)

    def test_low_level_kw_only_field_rejected_positionally(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError):
            _ffi_init(obj, 1, 2)

    def test_low_level_init_false_field_rejected(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError):
            _ffi_init(obj, core.KWARGS, "a", 1, "b", 2, "c", 3)

    def test_low_level_kwargs_all_init_fields_explicit(self) -> None:
        """Providing all init=True fields via KWARGS."""
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        _ffi_init(obj, core.KWARGS, "a", 10, "c", 30, "d", 40)
        assert obj.a == 10
        assert obj.b == 42  # init=False, default
        assert obj.c == 30
        assert obj.d == 40

    def test_low_level_kwargs_empty_string_key(self) -> None:
        """Empty string as keyword name should be rejected as unknown."""
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError, match="unexpected keyword"):
            _ffi_init(obj, core.KWARGS, "", 1, "a", 2, "c", 3)

    def test_low_level_kwargs_odd_kv_count(self) -> None:
        """Odd number of key-value args after KWARGS sentinel."""
        obj = _TestCxxAutoInitSimple.__new__(_TestCxxAutoInitSimple)
        with pytest.raises(TypeError):
            _ffi_init(obj, core.KWARGS, "x")

    def test_low_level_positional_only_simple(self) -> None:
        """Positional-only mode (no KWARGS sentinel)."""
        obj = _TestCxxAutoInitSimple.__new__(_TestCxxAutoInitSimple)
        _ffi_init(obj, 10, 20)
        assert obj.x == 10
        assert obj.y == 20

    def test_low_level_zero_args_missing_required(self) -> None:
        """Zero args for a type that requires them."""
        obj = _TestCxxAutoInitSimple.__new__(_TestCxxAutoInitSimple)
        with pytest.raises(TypeError, match="missing required"):
            _ffi_init(obj)

    def test_low_level_kwargs_sentinel_only_no_kv_pairs(self) -> None:
        """KWARGS sentinel with zero key-value pairs; required fields still missing."""
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError, match="missing required"):
            _ffi_init(obj, core.KWARGS)

    def test_low_level_kwargs_positional_then_sentinel_no_kv(self) -> None:
        """Positional args followed by KWARGS sentinel but no key-value pairs."""
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        # a=1 positionally, sentinel, no KV pairs → c is still missing
        with pytest.raises(TypeError, match="missing required"):
            _ffi_init(obj, 1, core.KWARGS)

    def test_low_level_child_positional_routing(self) -> None:
        """Verify the inheritance positional fix at the raw __ffi_init__ level.

        After stable_partition, pos_indices should be:
        [parent_required, child_required, parent_default]
        So 2 positional args map to parent_required=1, child_required=2.
        """
        obj = _TestCxxAutoInitChild.__new__(_TestCxxAutoInitChild)
        _ffi_init(obj, 1, 2, core.KWARGS, "child_kw_only", 3)
        assert obj.parent_required == 1
        assert obj.child_required == 2
        assert obj.parent_default == 5  # default
        assert obj.child_kw_only == 3

    def test_low_level_child_all_three_positional(self) -> None:
        """Three positional args for child at the raw protocol level."""
        obj = _TestCxxAutoInitChild.__new__(_TestCxxAutoInitChild)
        _ffi_init(obj, 1, 2, 3, core.KWARGS, "child_kw_only", 4)
        assert obj.parent_required == 1
        assert obj.child_required == 2
        assert obj.parent_default == 3
        assert obj.child_kw_only == 4

    def test_low_level_child_too_many_positional(self) -> None:
        """Four positional args exceed the 3 positional slots for child."""
        obj = _TestCxxAutoInitChild.__new__(_TestCxxAutoInitChild)
        with pytest.raises(TypeError, match="positional"):
            _ffi_init(obj, 1, 2, 3, 4, core.KWARGS, "child_kw_only", 5)


class TestAutoInitSimple:
    def test_simple_positional(self) -> None:
        obj = _TestCxxAutoInitSimple(10, 20)
        assert obj.x == 10
        assert obj.y == 20

    def test_simple_keyword(self) -> None:
        obj = _TestCxxAutoInitSimple(x=10, y=20)
        assert obj.x == 10
        assert obj.y == 20

    def test_simple_mixed(self) -> None:
        obj = _TestCxxAutoInitSimple(10, y=20)
        assert obj.x == 10
        assert obj.y == 20

    def test_simple_missing_required(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitSimple(x=10)  # ty: ignore[missing-argument]

    def test_simple_too_many_positional(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitSimple(1, 2, 3)  # ty: ignore[too-many-positional-arguments]

    def test_simple_unexpected_keyword(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitSimple(x=1, y=2, z=3)  # ty: ignore[unknown-argument]

    def test_simple_low_level_kwargs(self) -> None:
        obj = _TestCxxAutoInitSimple.__new__(_TestCxxAutoInitSimple)
        _ffi_init(obj, core.KWARGS, "x", 10, "y", 20)
        assert obj.x == 10
        assert obj.y == 20

    def test_zero_values(self) -> None:
        obj = _TestCxxAutoInitSimple(0, 0)
        assert obj.x == 0
        assert obj.y == 0

    def test_negative_values(self) -> None:
        obj = _TestCxxAutoInitSimple(-1, -9999999)
        assert obj.x == -1
        assert obj.y == -9999999

    def test_large_values(self) -> None:
        large = 2**62
        obj = _TestCxxAutoInitSimple(large, -large)
        assert obj.x == large
        assert obj.y == -large

    def test_float_for_integer_field(self) -> None:
        """Passing float where int64_t is expected - should truncate or error."""
        try:
            obj = _TestCxxAutoInitSimple(1.5, 2)  # ty: ignore[invalid-argument-type]
            assert isinstance(obj.x, int)
        except TypeError:
            pass  # Also acceptable

    def test_bool_for_integer_field(self) -> None:
        """Booleans are valid ints in Python but should work correctly."""
        obj = _TestCxxAutoInitSimple(True, False)
        assert obj.x == 1
        assert obj.y == 0


class TestAutoInitAllInitOff:
    def test_no_arg_constructor(self) -> None:
        obj = _TestCxxAutoInitAllInitOff()
        assert obj.x == 7
        assert obj.y == 9
        assert obj.z == 1234

    def test_rejects_positional_args(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitAllInitOff(1)  # ty: ignore[too-many-positional-arguments]

    def test_rejects_keyword_args(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitAllInitOff(x=1)  # ty: ignore[unknown-argument]

    def test_low_level_empty_init(self) -> None:
        obj = _TestCxxAutoInitAllInitOff.__new__(_TestCxxAutoInitAllInitOff)
        _ffi_init(obj)
        assert obj.x == 7
        assert obj.y == 9
        assert obj.z == 1234

    def test_mutate_fields(self) -> None:
        obj = _TestCxxAutoInitAllInitOff()
        obj.x = 101
        obj.y = 202
        obj.z = 303
        assert (obj.x, obj.y, obj.z) == (101, 202, 303)

    def test_empty_kwargs_dict_star(self) -> None:
        """Passing **{} should be fine (empty kwargs)."""
        obj = _TestCxxAutoInitAllInitOff(**{})
        assert obj.x == 7

    def test_low_level_rejects_positional(self) -> None:
        obj = _TestCxxAutoInitAllInitOff.__new__(_TestCxxAutoInitAllInitOff)
        with pytest.raises(TypeError):
            _ffi_init(obj, 1)


class TestAutoInitKwOnlyDefaults:
    def test_minimal_required(self) -> None:
        obj = _TestCxxAutoInitKwOnlyDefaults(1, k_required=2)
        assert obj.p_required == 1
        assert obj.p_default == 11
        assert obj.k_required == 2
        assert obj.k_default == 22
        assert obj.hidden == 33

    def test_override_defaults(self) -> None:
        obj = _TestCxxAutoInitKwOnlyDefaults(p_required=1, p_default=4, k_required=5, k_default=6)
        assert obj.p_required == 1
        assert obj.p_default == 4
        assert obj.k_required == 5
        assert obj.k_default == 6
        assert obj.hidden == 33

    def test_missing_required_positional(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitKwOnlyDefaults(k_required=2)  # ty: ignore[missing-argument]

    def test_missing_required_kw_only(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitKwOnlyDefaults(1)  # ty: ignore[missing-argument]

    def test_kw_only_rejects_positional(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitKwOnlyDefaults(1, 2, 3)  # ty: ignore[missing-argument, too-many-positional-arguments]

    def test_hidden_init_false_field_not_accepted(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitKwOnlyDefaults(1, k_required=2, hidden=4)  # ty: ignore[unknown-argument]

    def test_type_mismatch(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitKwOnlyDefaults("x", k_required=2)  # ty: ignore[invalid-argument-type]

    def test_low_level_kwargs_call(self) -> None:
        obj = _TestCxxAutoInitKwOnlyDefaults.__new__(_TestCxxAutoInitKwOnlyDefaults)
        _ffi_init(obj, core.KWARGS, "p_required", 1, "k_required", 2)
        assert obj.p_required == 1
        assert obj.p_default == 11
        assert obj.k_required == 2
        assert obj.k_default == 22
        assert obj.hidden == 33

    def test_kw_only_via_dict_unpacking(self) -> None:
        """Verify kw_only fields work via **dict."""
        kwargs = {"k_required": 100, "k_default": 200}
        obj = _TestCxxAutoInitKwOnlyDefaults(1, **kwargs)
        assert obj.p_required == 1
        assert obj.p_default == 11  # default
        assert obj.k_required == 100
        assert obj.k_default == 200
        assert obj.hidden == 33  # init=False default


class TestAutoInitInheritance:
    def test_parent_constructor(self) -> None:
        obj = _TestCxxAutoInitParent(10)
        assert obj.parent_required == 10
        assert obj.parent_default == 5

    def test_parent_all_keyword(self) -> None:
        obj = _TestCxxAutoInitParent(parent_required=10, parent_default=20)
        assert obj.parent_required == 10
        assert obj.parent_default == 20

    def test_parent_positional_then_keyword(self) -> None:
        obj = _TestCxxAutoInitParent(10, parent_default=20)
        assert obj.parent_required == 10
        assert obj.parent_default == 20

    def test_child_constructor_uses_parent_and_child_fields(self) -> None:
        obj = _TestCxxAutoInitChild(parent_required=1, child_required=2, child_kw_only=3)
        assert obj.parent_required == 1
        assert obj.parent_default == 5
        assert obj.child_required == 2
        assert obj.child_kw_only == 3

    def test_child_all_keyword_with_parent_default_override(self) -> None:
        # fmt: off
        obj = _TestCxxAutoInitChild(parent_required=1, child_required=2, parent_default=99, child_kw_only=3)
        # fmt: on
        assert obj.parent_required == 1
        assert obj.child_required == 2
        assert obj.parent_default == 99
        assert obj.child_kw_only == 3

    def test_child_missing_parent_required(self) -> None:
        with pytest.raises(TypeError):
            _TestCxxAutoInitChild(child_required=2, child_kw_only=3)  # ty: ignore[missing-argument]

    def test_child_two_positional_args_routes_correctly(self) -> None:
        """Calling Child(1, 2, child_kw_only=3) should set parent_required=1, child_required=2.

        The Python signature is:
          (self, parent_required, child_required, parent_default=..., *, child_kw_only)
        So positional arg 0 = parent_required, positional arg 1 = child_required.
        """
        obj = _TestCxxAutoInitChild(1, 2, child_kw_only=3)
        assert obj.parent_required == 1
        assert obj.child_required == 2
        assert obj.parent_default == 5  # should use the default
        assert obj.child_kw_only == 3

    def test_child_three_positional_args_no_silent_swap(self) -> None:
        """Calling Child(1, 2, 3, child_kw_only=4) should map correctly.

        Python signature order: parent_required=1, child_required=2, parent_default=3
        """
        obj = _TestCxxAutoInitChild(1, 2, 3, child_kw_only=4)
        assert obj.parent_required == 1
        assert obj.child_required == 2
        assert obj.parent_default == 3
        assert obj.child_kw_only == 4

    def test_child_one_positional_rest_keyword(self) -> None:
        """Mix of positional and keyword to verify correct mapping."""
        obj = _TestCxxAutoInitChild(10, child_required=20, parent_default=30, child_kw_only=40)
        assert obj.parent_required == 10
        assert obj.child_required == 20
        assert obj.parent_default == 30
        assert obj.child_kw_only == 40


class TestAutoInitCopyBehavior:
    """Test copy/deepcopy/replace interplay with auto-init objects."""

    def test_shallow_copy(self) -> None:
        obj = _TestCxxAutoInitSimple(10, 20)
        obj_copy = copy.copy(obj)
        assert obj_copy.x == 10
        assert obj_copy.y == 20
        assert not obj.same_as(obj_copy)

    def test_deepcopy(self) -> None:
        obj = _TestCxxAutoInitSimple(10, 20)
        obj_copy = copy.deepcopy(obj)
        assert obj_copy.x == 10
        assert obj_copy.y == 20
        assert not obj.same_as(obj_copy)

    @requires_py313
    def test_replace(self) -> None:
        obj = _TestCxxAutoInit(1, c=3)
        replaced = copy.replace(obj, a=100, c=300)  # type: ignore[attr-defined]
        assert replaced.a == 100
        assert replaced.b == 42
        assert replaced.c == 300
        assert replaced.d == 99

    def test_copy_preserves_init_false_field(self) -> None:
        """After construction, mutating the init=False field and copying."""
        obj = _TestCxxAutoInit(1, c=3)
        assert obj.b == 42
        obj.b = 999
        assert obj.b == 999
        obj_copy = copy.copy(obj)
        assert obj_copy.b == 999

    def test_copy_preserves_default_override(self) -> None:
        """Override a default field, then copy should preserve the override."""
        obj = _TestCxxAutoInit(1, c=3, d=55)
        obj_copy = copy.copy(obj)
        assert obj_copy.d == 55

    def test_deepcopy_all_init_off(self) -> None:
        """Deepcopy of an object with all fields init=False."""
        obj = _TestCxxAutoInitAllInitOff()
        obj.x = 111
        obj.y = 222
        obj.z = 333
        obj_copy = copy.deepcopy(obj)
        assert obj_copy.x == 111
        assert obj_copy.y == 222
        assert obj_copy.z == 333
        assert not obj.same_as(obj_copy)

    @requires_py313
    def test_replace_kw_only_defaults(self) -> None:
        obj = _TestCxxAutoInitKwOnlyDefaults(1, k_required=2)
        replaced = copy.replace(obj, k_required=99, p_default=88)  # type: ignore[attr-defined]
        assert replaced.p_required == 1
        assert replaced.p_default == 88
        assert replaced.k_required == 99
        assert replaced.k_default == 22
        assert replaced.hidden == 33


class TestAutoInitReinitialization:
    """Test what happens when __ffi_init__ is called multiple times."""

    def test_reinit_changes_handle(self) -> None:
        """Calling __ffi_init__ again should create a new underlying object."""
        obj = _TestCxxAutoInit(1, c=3)
        original_handle = obj.__chandle__()
        assert obj.a == 1

        _ffi_init(obj, core.KWARGS, "a", 100, "c", 300)
        assert obj.a == 100
        assert obj.c == 300
        assert obj.__chandle__() != original_handle

    def test_reinit_resets_init_false_field(self) -> None:
        """Re-initialization should reset init=False fields to defaults."""
        obj = _TestCxxAutoInit(1, c=3)
        obj.b = 999
        assert obj.b == 999

        _ffi_init(obj, core.KWARGS, "a", 2, "c", 4)
        assert obj.b == 42  # reset to default


class TestAutoInitTypeChecks:
    """Verify isinstance relationships for auto-init objects."""

    def test_parent_isinstance(self) -> None:
        obj = _TestCxxAutoInitParent(1)
        assert isinstance(obj, _TestCxxAutoInitParent)
        assert isinstance(obj, core.Object)

    def test_child_isinstance_parent(self) -> None:
        obj = _TestCxxAutoInitChild(parent_required=1, child_required=2, child_kw_only=3)
        assert isinstance(obj, _TestCxxAutoInitChild)
        assert isinstance(obj, _TestCxxAutoInitParent)
        assert isinstance(obj, core.Object)

    def test_parent_not_isinstance_child(self) -> None:
        """A parent object should not pass isinstance check for a child class."""
        obj = _TestCxxAutoInitParent(1)
        assert not isinstance(obj, _TestCxxAutoInitChild)


class TestAutoInitInstanceIsolation:
    """Verify that multiple instances don't share mutable state."""

    def test_separate_instances_are_independent(self) -> None:
        a = _TestCxxAutoInitSimple(1, 2)
        b = _TestCxxAutoInitSimple(3, 4)
        assert a.x == 1
        assert b.x == 3
        assert not a.same_as(b)

    def test_mutating_one_instance_doesnt_affect_another(self) -> None:
        a = _TestCxxAutoInit(1, c=3)
        b = _TestCxxAutoInit(1, c=3)
        assert a.b == 42
        assert b.b == 42
        a.b = 999
        assert a.b == 999
        assert b.b == 42

    def test_all_init_off_instances_are_independent(self) -> None:
        a = _TestCxxAutoInitAllInitOff()
        b = _TestCxxAutoInitAllInitOff()
        a.x = 100
        assert b.x == 7


class TestAutoInitReinitInitOffNoDefault:
    """Test reinit behavior for init=False fields with and without reflection defaults."""

    def test_reinit_init_false_with_default_resets(self) -> None:
        """Fields b (init=False, default=42) should reset to default on reinit."""
        obj = _TestCxxAutoInit(1, c=3)
        obj.b = 999
        _ffi_init(obj, core.KWARGS, "a", 2, "c", 4)
        assert obj.b == 42

    def test_reinit_init_false_without_reflection_default(self) -> None:
        """Field z has init=False AND no reflection default (c_has_default=False).

        On reinit, z should get whatever the C++ creator sets (1234).
        """
        obj = _TestCxxAutoInitAllInitOff()
        assert obj.z == 1234
        obj.z = 9999
        assert obj.z == 9999
        # Reinit via low-level call
        _ffi_init(obj)
        # z has no reflection default, so creator's C++ default (1234) is used
        assert obj.z == 1234


class TestAutoInitErrorMessages:
    """Verify that error messages name the correct field after pos_indices reordering."""

    def test_missing_child_required_names_correct_field(self) -> None:
        """When child_required is missing, error should mention 'child_required'."""
        with pytest.raises(TypeError, match="child_required"):
            _TestCxxAutoInitChild(parent_required=1, child_kw_only=3)  # ty: ignore[missing-argument]

    def test_missing_parent_required_names_correct_field(self) -> None:
        """When parent_required is missing, error should mention 'parent_required'."""
        with pytest.raises(TypeError, match="parent_required"):
            _TestCxxAutoInitChild(child_required=2, child_kw_only=3)  # ty: ignore[missing-argument]

    def test_missing_kw_only_names_correct_field(self) -> None:
        """When child_kw_only is missing, error should mention 'child_kw_only'."""
        with pytest.raises(TypeError, match="child_kw_only"):
            _TestCxxAutoInitChild(parent_required=1, child_required=2)  # ty: ignore[missing-argument]

    def test_too_many_positional_error_message(self) -> None:
        """Error for too many positional args should mention the correct count."""
        with pytest.raises(TypeError, match="3 positional"):
            _TestCxxAutoInitChild(1, 2, 3, 4, child_kw_only=5)  # ty: ignore[too-many-positional-arguments]

    def test_unexpected_keyword_error_message(self) -> None:
        """Error for unknown keyword should mention the keyword name."""
        with pytest.raises(TypeError, match="bogus"):
            _TestCxxAutoInit(1, c=2, bogus=3)  # ty: ignore[unknown-argument]

    def test_duplicate_arg_error_message(self) -> None:
        """Error for duplicate argument should mention the field name."""
        with pytest.raises(TypeError, match=r"multiple values.*a"):
            _TestCxxAutoInit(1, c=2, a=3)  # ty: ignore[parameter-already-assigned]


class TestAutoInitLowLevelKwOnlyDefaults:
    """Low-level KWARGS protocol tests for the KwOnlyDefaults type."""

    def test_low_level_positional_plus_kwargs_kw_only(self) -> None:
        """Positional arg for p_required, then KWARGS for kw_only fields."""
        obj = _TestCxxAutoInitKwOnlyDefaults.__new__(_TestCxxAutoInitKwOnlyDefaults)
        _ffi_init(obj, 1, core.KWARGS, "k_required", 2)
        assert obj.p_required == 1
        assert obj.p_default == 11
        assert obj.k_required == 2
        assert obj.k_default == 22
        assert obj.hidden == 33

    def test_low_level_two_positional_plus_kwargs(self) -> None:
        """Two positional args (p_required, p_default) then KWARGS for kw_only."""
        obj = _TestCxxAutoInitKwOnlyDefaults.__new__(_TestCxxAutoInitKwOnlyDefaults)
        _ffi_init(obj, 1, 2, core.KWARGS, "k_required", 3, "k_default", 4)
        assert obj.p_required == 1
        assert obj.p_default == 2
        assert obj.k_required == 3
        assert obj.k_default == 4
        assert obj.hidden == 33

    def test_low_level_all_via_kwargs(self) -> None:
        """All init=True fields via KWARGS, no positional."""
        obj = _TestCxxAutoInitKwOnlyDefaults.__new__(_TestCxxAutoInitKwOnlyDefaults)
        _ffi_init(
            obj, core.KWARGS, "p_required", 10, "p_default", 20, "k_required", 30, "k_default", 40
        )
        assert obj.p_required == 10
        assert obj.p_default == 20
        assert obj.k_required == 30
        assert obj.k_default == 40
        assert obj.hidden == 33


class TestClassLevelInitFalse:
    """init(false) passed to ObjectDef constructor suppresses __ffi_init__."""

    def test_no_ffi_init_method(self) -> None:
        type_index = getattr(_TestCxxNoAutoInit, "__tvm_ffi_type_info__").type_index
        ffi_init = core._lookup_type_attr(type_index, "__ffi_init__")
        assert ffi_init is None

    def test_has_fields(self) -> None:
        type_info = getattr(_TestCxxNoAutoInit, "__tvm_ffi_type_info__")
        field_names = [f.name for f in type_info.fields]
        assert field_names == ["x", "y"]

    def test_direct_construction_raises(self) -> None:
        with pytest.raises(TypeError, match="cannot be constructed directly"):
            _TestCxxNoAutoInit(1, 2)  # ty: ignore[too-many-positional-arguments]

    def test_has_shallow_copy(self) -> None:
        type_info = getattr(_TestCxxNoAutoInit, "__tvm_ffi_type_info__")
        # __ffi_shallow_copy__ is now TypeAttrColumn only, not a method
        fn = core._lookup_type_attr(type_info.type_index, "__ffi_shallow_copy__")
        assert fn is not None


# ###########################################################################
#  kw_only error message regression tests
# ###########################################################################


class TestKwOnlyErrorMessages:
    """Verify that error messages distinguish keyword-only from positional."""

    def test_missing_kw_only_error_says_keyword_only(self) -> None:
        """Missing required kw_only field should say 'keyword-only'."""
        with pytest.raises(TypeError, match="keyword-only"):
            _TestCxxAutoInit(1)  # ty: ignore[missing-argument]

    def test_missing_positional_error_does_not_say_keyword_only(self) -> None:
        """Missing required positional field should NOT say 'keyword-only'."""
        with pytest.raises(TypeError, match="missing required argument") as exc_info:
            _TestCxxAutoInit(c=3)  # ty: ignore[missing-argument]
        assert "keyword-only" not in str(exc_info.value)

    def test_child_missing_kw_only_error_says_keyword_only(self) -> None:
        """Inherited kw_only field should produce 'keyword-only' error."""
        with pytest.raises(TypeError, match="keyword-only"):
            _TestCxxAutoInitChild(parent_required=1, child_required=2)  # ty: ignore[missing-argument]

    def test_kw_only_defaults_missing_error(self) -> None:
        """KwOnlyDefaults type: missing k_required should say 'keyword-only'."""
        with pytest.raises(TypeError, match="keyword-only"):
            _TestCxxAutoInitKwOnlyDefaults(1)  # ty: ignore[missing-argument]

    def test_low_level_kw_only_error_says_keyword_only(self) -> None:
        """Low-level __ffi_init__ also gives 'keyword-only' error."""
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        with pytest.raises(TypeError, match="keyword-only"):
            _ffi_init(obj, 1)


# ###########################################################################
#  __ffi_init__ TypeMethod registration regression tests
#
#  These tests verify that def(init<>) in C++ registers __ffi_init__ as a
#  TypeMethod (not just TypeAttrColumn), preserving type_schema metadata.
#  They also verify the __ffi_init__ instance method wrapper and the MISSING
#  sentinel used for default parameter values.
#  See commit 2987899a for the original fix.
# ###########################################################################


class TestFfiInitAsTypeMethod:
    """Verify that classes using ``def(init<>)`` expose __ffi_init__ as a TypeMethod."""

    @pytest.mark.parametrize("cls", [TestIntPair, TestCompare, TestHash])
    def test_explicit_init_has_ffi_init_type_method(self, cls: type) -> None:
        type_info = cls.__tvm_ffi_type_info__  # ty: ignore[unresolved-attribute]
        method_names = {m.name for m in type_info.methods}
        assert "__ffi_init__" in method_names

    def test_auto_init_does_not_have_ffi_init_type_method(self) -> None:
        type_info = _TestCxxAutoInit.__tvm_ffi_type_info__  # ty: ignore[unresolved-attribute]
        method_names = {m.name for m in type_info.methods}
        assert "__ffi_init__" not in method_names

    @pytest.mark.parametrize("cls", [TestIntPair, TestCompare, TestHash])
    def test_ffi_init_type_method_has_func(self, cls: type) -> None:
        type_info = cls.__tvm_ffi_type_info__  # ty: ignore[unresolved-attribute]
        for method in type_info.methods:
            if method.name == "__ffi_init__":
                assert method.func is not None
                break
        else:
            pytest.fail(f"__ffi_init__ not found in {cls.__name__} methods")  # ty: ignore[invalid-argument-type]


class TestFfiInitAsInstanceMethod:
    """Verify that __ffi_init__ is available as a callable method on registered classes."""

    def test_explicit_init_class_has_ffi_init_attr(self) -> None:
        assert hasattr(TestIntPair, "__ffi_init__")

    def test_auto_init_class_has_ffi_init_attr(self) -> None:
        assert hasattr(_TestCxxAutoInit, "__ffi_init__")

    def test_ffi_init_constructs_explicit_init_object(self) -> None:
        obj = TestIntPair.__new__(TestIntPair)
        obj.__ffi_init__(10, 20)  # ty: ignore[unresolved-attribute]
        assert obj.a == 10
        assert obj.b == 20
        assert obj.sum() == 30

    def test_ffi_init_constructs_auto_init_object(self) -> None:
        obj = _TestCxxAutoInitSimple.__new__(_TestCxxAutoInitSimple)
        obj.__ffi_init__(7, 8)  # ty: ignore[unresolved-attribute]
        assert obj.x == 7
        assert obj.y == 8

    def test_ffi_init_with_kwargs_protocol(self) -> None:
        obj = _TestCxxAutoInit.__new__(_TestCxxAutoInit)
        obj.__ffi_init__(a=1, c=3)  # ty: ignore[unresolved-attribute]
        assert obj.a == 1
        assert obj.b == 42
        assert obj.c == 3
        assert obj.d == 99


class TestFfiInitTypeOwnerGuard:
    """Verify the type-owner guard prevents subclass misuse of __ffi_init__."""

    def test_same_type_ffi_init_succeeds(self) -> None:
        obj = TestIntPair.__new__(TestIntPair)
        TestIntPair.__ffi_init__(obj, 1, 2)  # ty: ignore[unresolved-attribute]
        assert obj.a == 1
        assert obj.b == 2

    def test_subclass_ffi_init_raises_type_error(self) -> None:
        obj = _TestCxxClassDerivedDerived.__new__(_TestCxxClassDerivedDerived)
        with pytest.raises(TypeError, match="not supported"):
            _TestCxxClassDerived.__ffi_init__(obj, 1, 2, 3.0)  # ty: ignore[unresolved-attribute]


class TestMissingSentinelDefaults:
    """Verify that auto-generated __init__ signatures use core.MISSING for defaults."""

    def test_default_params_use_core_missing(self) -> None:
        sig = inspect.signature(_TestCxxAutoInit.__init__)
        d_param = sig.parameters["d"]
        assert d_param.default is not inspect.Parameter.empty
        assert d_param.default is core.MISSING

    def test_kw_only_default_uses_core_missing(self) -> None:
        sig = inspect.signature(_TestCxxAutoInitKwOnlyDefaults.__init__)
        assert sig.parameters["k_default"].default is core.MISSING
        assert sig.parameters["p_default"].default is core.MISSING

    def test_required_params_have_no_default(self) -> None:
        sig = inspect.signature(_TestCxxAutoInit.__init__)
        assert sig.parameters["a"].default is inspect.Parameter.empty
        assert sig.parameters["c"].default is inspect.Parameter.empty

    def test_missing_not_sent_to_ffi(self) -> None:
        """MISSING sentinel values should be stripped, not forwarded to C++."""
        obj = _TestCxxAutoInitKwOnlyDefaults(p_required=1, k_required=2)
        assert obj.p_default == 11
        assert obj.k_default == 22
        assert obj.hidden == 33

    def test_derived_class_defaults(self) -> None:
        obj = _TestCxxClassDerived(v_i64=1, v_i32=2, v_f64=3.0)
        assert obj.v_f32 == 8.0


class TestFfiInitDualRegistration:
    """Verify __ffi_init__ is available from both TypeMethod and TypeAttrColumn."""

    @pytest.mark.parametrize("cls", [TestIntPair, TestCompare])
    def test_explicit_init_in_type_attr_column(self, cls: type) -> None:
        type_info = cls.__tvm_ffi_type_info__  # ty: ignore[unresolved-attribute]
        ffi_init = core._lookup_type_attr(type_info.type_index, "__ffi_init__")
        assert ffi_init is not None

    def test_auto_init_in_type_attr_column(self) -> None:
        type_info = _TestCxxAutoInit.__tvm_ffi_type_info__  # ty: ignore[unresolved-attribute]
        ffi_init = core._lookup_type_attr(type_info.type_index, "__ffi_init__")
        assert ffi_init is not None

    def test_explicit_init_method_and_attr_produce_same_result(self) -> None:
        type_info = TestIntPair.__tvm_ffi_type_info__  # ty: ignore[unresolved-attribute]
        method_func = None
        for method in type_info.methods:
            if method.name == "__ffi_init__":
                method_func = method.func
                break
        assert method_func is not None
        attr_func = core._lookup_type_attr(type_info.type_index, "__ffi_init__")
        assert attr_func is not None
        obj1 = TestIntPair.__new__(TestIntPair)
        obj1.__init_handle_by_constructor__(method_func, 10, 20)
        obj2 = TestIntPair.__new__(TestIntPair)
        obj2.__init_handle_by_constructor__(attr_func, 10, 20)
        assert obj1.a == obj2.a == 10
        assert obj1.b == obj2.b == 20


# ###########################################################################
#  Python 3.14 annotation regression (PEP 749)
#
#  Python 3.14 stores annotations lazily via __annotate_func__ instead of
#  directly in cls.__dict__["__annotations__"].  This broke @py_class field
#  discovery when it used cls.__dict__.get("__annotations__", {}).
# ###########################################################################


@py_class("testing.PyClassSimple")
class _PyClassSimple(core.Object):
    x: int
    y: int


@py_class("testing.PyClassWithDefault")
class _PyClassWithDefault(core.Object):
    a: int
    b: int = 42


class TestPyClassAnnotationDiscovery:
    """Regression: @py_class must discover fields on Python 3.14+ (PEP 749)."""

    def test_fields_registered(self) -> None:
        ti: core.TypeInfo = _PyClassSimple.__tvm_ffi_type_info__  # type: ignore[unresolved-attribute]
        names = [f.name for f in ti.fields]
        assert names == ["x", "y"]

    def test_construct_kwargs(self) -> None:
        obj = _PyClassSimple(x=1, y=2)
        assert obj.x == 1
        assert obj.y == 2

    def test_construct_positional(self) -> None:
        obj = _PyClassSimple(10, 20)
        assert obj.x == 10
        assert obj.y == 20

    def test_default_field(self) -> None:
        obj = _PyClassWithDefault(a=7)
        assert obj.a == 7
        assert obj.b == 42

    def test_override_default(self) -> None:
        obj = _PyClassWithDefault(a=1, b=2)
        assert obj.a == 1
        assert obj.b == 2