# ------------------------------------
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# ------------------------------------
from ast import Mod
import copy
import decimal
import json
import datetime
from pathlib import Path
from typing import (
    Any,
    Iterable,
    Literal,
    Mapping,
    Sequence,
    Optional,
    overload,
    Union,
)
import pytest
import isodate
import sys
from enum import Enum

from specialwords._utils.model_base import (
    SdkJSONEncoder,
    Model,
    rest_field,
    _is_model,
    rest_discriminator,
    _deserialize,
)

if sys.version_info >= (3, 9):
    from collections.abc import MutableMapping
else:
    from typing import MutableMapping  # type: ignore  # pylint: disable=ungrouped-imports
JSON = MutableMapping[str, Any]  # pylint: disable=unsubscriptable-object


class BasicResource(Model):
    platform_update_domain_count: int = rest_field(
        name="platformUpdateDomainCount"
    )  # How many times the platform update domain has been counted
    platform_fault_domain_count: int = rest_field(
        name="platformFaultDomainCount"
    )  # How many times the platform fault domain has been counted
    virtual_machines: list[Any] = rest_field(name="virtualMachines")  # List of virtual machines

    @overload
    def __init__(
        self,
        *,
        platform_update_domain_count: int,
        platform_fault_domain_count: int,
        virtual_machines: list[Any],
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class ModelWithArgsProperty(Model):
    """A model that has a property named 'args' to test potential conflicts with *args."""

    name: str = rest_field()
    args: list[str] = rest_field()  # property named 'args' which could conflict with *args

    @overload
    def __init__(self, *, name: str, args: list[str]): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class Pet(Model):
    name: str = rest_field()  # my name
    species: str = rest_field()  # my species

    @overload
    def __init__(self, *, name: str, species: str): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_model_and_dict_equal():
    dict_response = {
        "platformUpdateDomainCount": 5,
        "platformFaultDomainCount": 3,
        "virtualMachines": [],
    }
    model = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )

    assert model == dict_response
    assert (
        model.platform_update_domain_count
        == model["platformUpdateDomainCount"]
        == dict_response["platformUpdateDomainCount"]
        == 5
    )
    assert (
        model.platform_fault_domain_count
        == model["platformFaultDomainCount"]
        == dict_response["platformFaultDomainCount"]
        == 3
    )
    assert model.virtual_machines == model["virtualMachines"] == dict_response["virtualMachines"]


def test_model_with_args_property():
    """Test that a model with a property named 'args' works correctly."""
    # Test initialization with keyword arguments
    model = ModelWithArgsProperty(name="test", args=["arg1", "arg2", "arg3"])
    assert model.name == "test"
    assert model.args == ["arg1", "arg2", "arg3"]

    # Test dict-style access
    assert model["name"] == "test"
    assert model["args"] == ["arg1", "arg2", "arg3"]

    # Test equality with dict
    dict_response = {"name": "test", "args": ["arg1", "arg2", "arg3"]}
    assert model == dict_response

    # Test initialization from dict (using positional argument which goes to *args)
    model_from_dict = ModelWithArgsProperty(dict_response)
    assert model_from_dict.name == "test"
    assert model_from_dict.args == ["arg1", "arg2", "arg3"]
    assert model_from_dict == model

    # Test modification of the 'args' property
    model.args = ["new_arg"]
    assert model.args == ["new_arg"]
    assert model["args"] == ["new_arg"]

    # Test dict-style modification of 'args'
    model["args"] = ["modified_arg1", "modified_arg2"]
    assert model.args == ["modified_arg1", "modified_arg2"]

    # Test JSON serialization roundtrip
    json_str = json.dumps(dict(model))
    parsed = json.loads(json_str)
    assert parsed["name"] == "test"
    assert parsed["args"] == ["modified_arg1", "modified_arg2"]


def test_json_roundtrip():
    dict_response = {
        "platformUpdateDomainCount": 5,
        "platformFaultDomainCount": 3,
        "virtualMachines": [],
    }
    model = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    with pytest.raises(TypeError):
        json.dumps(model)
    assert (
        json.dumps(dict(model))
        == '{"platformUpdateDomainCount": 5, "platformFaultDomainCount": 3, "virtualMachines": []}'
    )
    assert json.loads(json.dumps(dict(model))) == model == dict_response


def test_has_no_property():
    dict_response = {
        "platformUpdateDomainCount": 5,
        "platformFaultDomainCount": 3,
        "virtualMachines": [],
        "noProp": "bonjour!",
    }
    model = BasicResource(dict_response)
    assert (
        model.platform_update_domain_count
        == model["platformUpdateDomainCount"]
        == dict_response["platformUpdateDomainCount"]
        == 5
    )
    assert not hasattr(model, "no_prop")
    with pytest.raises(AttributeError) as ex:
        model.no_prop

    assert str(ex.value) == "'BasicResource' object has no attribute 'no_prop'"
    assert model["noProp"] == dict_response["noProp"] == "bonjour!"

    # let's add it to model now

    class BasicResourceWithProperty(BasicResource):
        no_prop: str = rest_field(name="noProp")

    model = BasicResourceWithProperty(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
        no_prop="bonjour!",
    )
    assert model.no_prop == model["noProp"] == dict_response["noProp"] == "bonjour!"


def test_original_and_attr_name_same():
    class MyModel(Model):
        hello: str = rest_field()

        @overload
        def __init__(self, *, hello: str): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    dict_response = {"hello": "nihao"}
    model = MyModel(hello="nihao")
    assert model.hello == model["hello"] == dict_response["hello"]


class OptionalModel(Model):
    optional_str: Optional[str] = rest_field()
    optional_time: Optional[datetime.time] = rest_field()
    optional_dict: Optional[dict[str, Optional[Pet]]] = rest_field(name="optionalDict")
    optional_model: Optional[Pet] = rest_field()
    optional_myself: Optional["OptionalModel"] = rest_field()

    @overload
    def __init__(
        self,
        *,
        optional_str: Optional[str] = None,
        optional_time: Optional[datetime.time] = None,
        optional_dict: Optional[dict[str, Optional[Pet]]] = None,
        optional_myself: Optional["OptionalModel"] = None,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_optional_property():
    dict_response = {
        "optional_str": "hello!",
        "optional_time": None,
        "optionalDict": {
            "Eugene": {
                "name": "Eugene",
                "species": "Dog",
            },
            "Lady": None,
        },
        "optional_model": None,
        "optional_myself": {
            "optional_str": None,
            "optional_time": "11:34:56",
            "optionalDict": None,
            "optional_model": {"name": "Lady", "species": "Newt"},
            "optional_myself": None,
        },
    }

    model = OptionalModel(dict_response)
    assert model.optional_str == model["optional_str"] == "hello!"
    assert model.optional_time == model["optional_time"] == None
    assert (
        model.optional_dict
        == model["optionalDict"]
        == {
            "Eugene": {
                "name": "Eugene",
                "species": "Dog",
            },
            "Lady": None,
        }
    )
    assert model.optional_dict
    assert model.optional_dict["Eugene"].name == model.optional_dict["Eugene"]["name"] == "Eugene"
    assert model.optional_dict["Lady"] is None

    assert (
        model.optional_myself
        == model["optional_myself"]
        == {
            "optional_str": None,
            "optional_time": "11:34:56",
            "optionalDict": None,
            "optional_model": {"name": "Lady", "species": "Newt"},
            "optional_myself": None,
        }
    )
    assert model.optional_myself
    assert model.optional_myself.optional_str is None
    assert model.optional_myself.optional_time == datetime.time(11, 34, 56)
    assert model.optional_myself.optional_dict is None
    assert model.optional_myself.optional_model
    assert model.optional_myself.optional_model.name == "Lady"
    assert model.optional_myself.optional_model.species == "Newt"
    assert model.optional_myself.optional_myself is None


def test_model_pass_in_none():
    model = OptionalModel(optional_str=None)
    assert model.optional_str == None
    with pytest.raises(KeyError):
        model["optionalStr"]


def test_modify_dict():
    model = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )

    # now let's modify the model as a dict
    model["platformUpdateDomainCount"] = 100
    assert model.platform_update_domain_count == model["platformUpdateDomainCount"] == 100


def test_modify_property():
    dict_response = {
        "platformUpdateDomainCount": 5,
        "platformFaultDomainCount": 3,
        "virtualMachines": [],
    }
    model = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )

    # now let's modify the model through it's properties
    model.platform_fault_domain_count = 2000
    model["platformFaultDomainCount"]
    assert model.platform_fault_domain_count == model["platformFaultDomainCount"] == 2000


def test_property_is_a_type():
    class Fish(Model):
        name: str = rest_field()
        species: Literal["Salmon", "Halibut"] = rest_field()

        @overload
        def __init__(self, *, name: str, species: Literal["Salmon", "Halibut"]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Fishery(Model):
        fish: Fish = rest_field()

        @overload
        def __init__(self, *, fish: Fish): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    fishery = Fishery({"fish": {"name": "Benjamin", "species": "Salmon"}})
    assert isinstance(fishery.fish, Fish)
    assert fishery.fish.name == fishery.fish["name"] == fishery["fish"]["name"] == "Benjamin"
    assert fishery.fish.species == fishery.fish["species"] == fishery["fish"]["species"] == "Salmon"


def test_model_initialization():
    class DatetimeModel(Model):
        datetime_value: datetime.datetime = rest_field(name="datetimeValue")

        @overload
        def __init__(self, *, datetime_value: datetime.datetime): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    val_str = "9999-12-31T23:59:59.999000Z"
    val = isodate.parse_datetime(val_str)

    # when initialize model with dict, the dict value is shall be serialized value
    model1 = DatetimeModel({"datetimeValue": val_str})
    assert model1["datetimeValue"] == val_str
    assert model1.datetime_value == val

    # when initialize model with keyword args, the value is deserialized value
    model2 = DatetimeModel(datetime_value=val)
    assert model2["datetimeValue"] == val_str
    assert model2.datetime_value == val

    # what if we initialize with dict but the dict has deserialized value? this case show what happens.
    # Since we always serialize the value before initializing the model from dict, we could still get correct result
    model3 = DatetimeModel({"datetimeValue": val})
    assert model3["datetimeValue"] == val_str
    assert model3.datetime_value == val


def test_model_dict_prop_initialization():
    class DatetimeModel(Model):
        dict_prop: dict[str, datetime.datetime] = rest_field(name="dictProp")

        @overload
        def __init__(self, *, dict_prop: dict[str, datetime.datetime]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    val_str = "9999-12-31T23:59:59.999000Z"
    val = isodate.parse_datetime(val_str)

    # when initialize model with dict, the dict value is shall be serialized value
    model1 = DatetimeModel({"dictProp": {"key1": val_str}})
    assert model1["dictProp"] == {"key1": val_str}
    assert model1.dict_prop == {"key1": val}

    # when initialize model with keyword args, the value is deserialized value
    model2 = DatetimeModel(dict_prop={"key1": val})
    assert model2["dictProp"] == {"key1": val_str}
    assert model2.dict_prop == {"key1": val}

    # what if we initialize with dict but the dict has deserialized value? this case show what happens.
    # Since we always serialize the value before initializing the model from dict, we could still get correct result
    model3 = DatetimeModel({"dictProp": {"key1": val}})
    assert model3["dictProp"] == {"key1": val_str}
    assert model3.dict_prop == {"key1": val}


def test_datetime_deserialization():
    class DatetimeModel(Model):
        datetime_value: datetime.datetime = rest_field(name="datetimeValue")

        @overload
        def __init__(self, *, datetime_value: datetime.datetime): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    val_str = "9999-12-31T23:59:59.999Z"
    val = isodate.parse_datetime(val_str)
    model = DatetimeModel({"datetimeValue": val_str})
    assert model["datetimeValue"] == val_str
    assert model.datetime_value == val

    class BaseModel(Model):
        my_prop: DatetimeModel = rest_field(name="myProp")

    model = BaseModel({"myProp": {"datetimeValue": val_str}})
    assert isinstance(model.my_prop, DatetimeModel)
    model.my_prop["datetimeValue"]
    assert model.my_prop["datetimeValue"] == model["myProp"]["datetimeValue"] == val_str
    assert model.my_prop.datetime_value == val


def test_date_deserialization():
    class DateModel(Model):
        date_value: datetime.date = rest_field(name="dateValue")

        @overload
        def __init__(self, *, date_value: datetime.date): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    val_str = "2016-02-29"
    val = isodate.parse_date(val_str)
    model = DateModel({"dateValue": val_str})
    assert model["dateValue"] == val_str
    assert model.date_value == val

    class BaseModel(Model):
        my_prop: DateModel = rest_field(name="myProp")

    model = BaseModel({"myProp": {"dateValue": val_str}})
    assert isinstance(model.my_prop, DateModel)
    assert model.my_prop["dateValue"] == model["myProp"]["dateValue"] == val_str
    assert model.my_prop.date_value == val


def test_time_deserialization():
    class TimeModel(Model):
        time_value: datetime.time = rest_field(name="timeValue")

        @overload
        def __init__(self, *, time_value: datetime.time): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    val_str = "11:34:56"
    val = datetime.time(11, 34, 56)
    model = TimeModel({"timeValue": val_str})
    assert model["timeValue"] == val_str
    assert model.time_value == val

    class BaseModel(Model):
        my_prop: TimeModel = rest_field(name="myProp")

    model = BaseModel({"myProp": {"timeValue": val_str}})
    assert isinstance(model.my_prop, TimeModel)
    assert model.my_prop["timeValue"] == model["myProp"]["timeValue"] == val_str
    assert model.my_prop.time_value == val


class SimpleRecursiveModel(Model):
    name: str = rest_field()
    me: "SimpleRecursiveModel" = rest_field()

    @overload
    def __init__(self, *, name: str, me: "SimpleRecursiveModel"): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_model_recursion():
    dict_response = {"name": "Snoopy", "me": {"name": "Egg", "me": {"name": "Chicken"}}}

    model = SimpleRecursiveModel(dict_response)
    assert model["name"] == model.name == "Snoopy"
    assert model["me"] == {"name": "Egg", "me": {"name": "Chicken"}}
    assert isinstance(model.me, SimpleRecursiveModel)
    assert model.me["name"] == model.me.name == "Egg"
    assert model.me["me"] == {"name": "Chicken"}
    assert model.me.me.name == "Chicken"


def test_dictionary_deserialization():
    class DictionaryModel(Model):
        prop: dict[str, datetime.datetime] = rest_field()

        @overload
        def __init__(self, *, prop: datetime.datetime): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    val_str = "9999-12-31T23:59:59.999Z"
    val = isodate.parse_datetime(val_str)
    dict_response = {"prop": {"datetime": val_str}}
    model = DictionaryModel(dict_response)
    assert model["prop"] == {"datetime": val_str}
    assert model.prop == {"datetime": val}


def test_attr_and_rest_case():
    class ModelTest(Model):
        our_attr: str = rest_field(name="ourAttr")

        @overload
        def __init__(self, *, our_attr: str): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    test_model = ModelTest({"ourAttr": "camel"})
    assert test_model.our_attr == test_model["ourAttr"] == "camel"

    test_model = ModelTest(ModelTest({"ourAttr": "camel"}))
    assert test_model.our_attr == test_model["ourAttr"] == "camel"

    test_model = ModelTest(our_attr="snake")
    assert test_model.our_attr == test_model["ourAttr"] == "snake"


def test_dictionary_deserialization_model():
    class DictionaryModel(Model):
        prop: dict[str, Pet] = rest_field()

        @overload
        def __init__(self, *, prop: dict[str, Pet]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    dict_response = {
        "prop": {
            "Eugene": {
                "name": "Eugene",
                "species": "Dog",
            },
            "Lady": {
                "name": "Lady",
                "species": "Newt",
            },
        }
    }

    model = DictionaryModel(dict_response)
    assert model["prop"] == {
        "Eugene": {
            "name": "Eugene",
            "species": "Dog",
        },
        "Lady": {
            "name": "Lady",
            "species": "Newt",
        },
    }
    assert model.prop == {
        "Eugene": Pet({"name": "Eugene", "species": "Dog"}),
        "Lady": Pet({"name": "Lady", "species": "Newt"}),
    }
    assert model.prop["Eugene"].name == model.prop["Eugene"]["name"] == "Eugene"
    assert model.prop["Eugene"].species == model.prop["Eugene"]["species"] == "Dog"
    assert model.prop["Lady"].name == model.prop["Lady"]["name"] == "Lady"
    assert model.prop["Lady"].species == model.prop["Lady"]["species"] == "Newt"


def test_list_deserialization():
    class ListModel(Model):
        prop: list[datetime.datetime] = rest_field()

        @overload
        def __init__(self, *, prop: list[datetime.datetime]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    val_str = "9999-12-31T23:59:59.999Z"
    val = isodate.parse_datetime(val_str)
    dict_response = {"prop": [val_str, val_str]}
    model = ListModel(dict_response)
    assert model["prop"] == [val_str, val_str]
    assert model.prop == [val, val]


def test_list_deserialization_model():
    class ListModel(Model):
        prop: list[Pet] = rest_field()

        @overload
        def __init__(self, *, prop: list[Pet]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    dict_response = {
        "prop": [
            {"name": "Eugene", "species": "Dog"},
            {"name": "Lady", "species": "Newt"},
        ]
    }
    model = ListModel(dict_response)
    assert model["prop"] == [
        {"name": "Eugene", "species": "Dog"},
        {"name": "Lady", "species": "Newt"},
    ]
    assert model.prop == [
        Pet({"name": "Eugene", "species": "Dog"}),
        Pet({"name": "Lady", "species": "Newt"}),
    ]
    assert len(model.prop) == 2
    assert model.prop[0].name == model.prop[0]["name"] == "Eugene"
    assert model.prop[0].species == model.prop[0]["species"] == "Dog"
    assert model.prop[1].name == model.prop[1]["name"] == "Lady"
    assert model.prop[1].species == model.prop[1]["species"] == "Newt"


def test_set_deserialization():
    class SetModel(Model):
        prop: set[datetime.datetime] = rest_field()

        @overload
        def __init__(self, *, prop: set[datetime.datetime]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    val_str = "9999-12-31T23:59:59.999Z"
    val = isodate.parse_datetime(val_str)
    dict_response = {"prop": set([val_str, val_str])}
    model = SetModel(dict_response)
    assert model["prop"] == set([val_str, val_str])
    assert model.prop == set([val, val])


def test_tuple_deserialization():
    class TupleModel(Model):
        prop: tuple[str, datetime.datetime] = rest_field()

        @overload
        def __init__(self, *, prop: tuple[str, datetime.datetime]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    val_str = "9999-12-31T23:59:59.999Z"
    val = isodate.parse_datetime(val_str)
    dict_response = {"prop": (val_str, val_str)}
    model = TupleModel(dict_response)
    assert model["prop"] == (val_str, val_str)
    assert model.prop == (val_str, val)


def test_list_of_tuple_deserialization_model():
    class Owner(Model):
        name: str = rest_field()
        pet: Pet = rest_field()

        @overload
        def __init__(self, *, name: str, pet: Pet): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class ListOfTupleModel(Model):
        prop: list[tuple[Pet, Owner]] = rest_field()

        @overload
        def __init__(self, *, prop: list[tuple[Pet, Owner]]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    eugene = {"name": "Eugene", "species": "Dog"}
    lady = {"name": "Lady", "species": "Newt"}
    giacamo = {"name": "Giacamo", "pet": eugene}
    elizabeth = {"name": "Elizabeth", "pet": lady}

    dict_response: dict[str, Any] = {"prop": [(eugene, giacamo), (lady, elizabeth)]}
    model = ListOfTupleModel(dict_response)
    assert (
        model["prop"]
        == model.prop
        == [(eugene, giacamo), (lady, elizabeth)]
        == [(Pet(eugene), Owner(giacamo)), (Pet(lady), Owner(elizabeth))]
    )
    assert len(model.prop[0]) == len(model["prop"][0]) == 2
    assert model.prop[0][0].name == model.prop[0][0]["name"] == "Eugene"
    assert model.prop[0][0].species == model.prop[0][0]["species"] == "Dog"
    assert model.prop[0][1].name == "Giacamo"
    assert model.prop[0][1].pet == model.prop[0][0]
    assert model.prop[0][1].pet.name == model.prop[0][1]["pet"]["name"] == "Eugene"
    assert model.prop[1][0] == model.prop[1][1].pet


class RecursiveModel(Model):
    name: str = rest_field()
    list_of_me: Optional[list["RecursiveModel"]] = rest_field(name="listOfMe")
    dict_of_me: Optional[dict[str, "RecursiveModel"]] = rest_field(name="dictOfMe")
    dict_of_list_of_me: Optional[dict[str, list["RecursiveModel"]]] = rest_field(name="dictOfListOfMe")
    list_of_dict_of_me: Optional[list[dict[str, "RecursiveModel"]]] = rest_field(name="listOfDictOfMe")

    @overload
    def __init__(
        self,
        *,
        name: str,
        list_of_me: Optional[list["RecursiveModel"]] = None,
        dict_of_me: Optional[dict[str, "RecursiveModel"]] = None,
        dict_of_list_of_me: Optional[dict[str, list["RecursiveModel"]]] = None,
        list_of_dict_of_me: Optional[list[dict[str, "RecursiveModel"]]] = None,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_model_recursion_complex():
    dict_response = {
        "name": "it's me!",
        "listOfMe": [
            {
                "name": "it's me!",
                "listOfMe": None,
                "dictOfMe": None,
                "dictOfListOfMe": None,
                "listOfDictOfMe": None,
            }
        ],
        "dictOfMe": {
            "me": {
                "name": "it's me!",
                "listOfMe": None,
                "dictOfMe": None,
                "dictOfListOfMe": None,
                "listOfDictOfMe": None,
            }
        },
        "dictOfListOfMe": {
            "many mes": [
                {
                    "name": "it's me!",
                    "listOfMe": None,
                    "dictOfMe": None,
                    "dictOfListOfMe": None,
                    "listOfDictOfMe": None,
                }
            ]
        },
        "listOfDictOfMe": [
            {
                "me": {
                    "name": "it's me!",
                    "listOfMe": None,
                    "dictOfMe": None,
                    "dictOfListOfMe": None,
                    "listOfDictOfMe": None,
                }
            }
        ],
    }

    model = RecursiveModel(dict_response)
    assert model.name == model["name"] == "it's me!"
    assert model["listOfMe"] == [
        {
            "name": "it's me!",
            "listOfMe": None,
            "dictOfMe": None,
            "dictOfListOfMe": None,
            "listOfDictOfMe": None,
        }
    ]
    assert model.list_of_me == [
        RecursiveModel(
            {
                "name": "it's me!",
                "listOfMe": None,
                "dictOfMe": None,
                "dictOfListOfMe": None,
                "listOfDictOfMe": None,
            }
        )
    ]
    assert model.list_of_me
    assert model.list_of_me[0].name == "it's me!"
    assert model.list_of_me[0].list_of_me is None
    assert isinstance(model.list_of_me, list)
    assert isinstance(model.list_of_me[0], RecursiveModel)

    assert model["dictOfMe"] == {
        "me": {
            "name": "it's me!",
            "listOfMe": None,
            "dictOfMe": None,
            "dictOfListOfMe": None,
            "listOfDictOfMe": None,
        }
    }
    assert model.dict_of_me == {
        "me": RecursiveModel(
            {
                "name": "it's me!",
                "listOfMe": None,
                "dictOfMe": None,
                "dictOfListOfMe": None,
                "listOfDictOfMe": None,
            }
        )
    }

    assert isinstance(model.dict_of_me, dict)
    assert isinstance(model.dict_of_me["me"], RecursiveModel)

    assert model["dictOfListOfMe"] == {
        "many mes": [
            {
                "name": "it's me!",
                "listOfMe": None,
                "dictOfMe": None,
                "dictOfListOfMe": None,
                "listOfDictOfMe": None,
            }
        ]
    }
    assert model.dict_of_list_of_me == {
        "many mes": [
            RecursiveModel(
                {
                    "name": "it's me!",
                    "listOfMe": None,
                    "dictOfMe": None,
                    "dictOfListOfMe": None,
                    "listOfDictOfMe": None,
                }
            )
        ]
    }
    assert isinstance(model.dict_of_list_of_me, dict)
    assert isinstance(model.dict_of_list_of_me["many mes"], list)
    assert isinstance(model.dict_of_list_of_me["many mes"][0], RecursiveModel)

    assert model["listOfDictOfMe"] == [
        {
            "me": {
                "name": "it's me!",
                "listOfMe": None,
                "dictOfMe": None,
                "dictOfListOfMe": None,
                "listOfDictOfMe": None,
            }
        }
    ]
    assert model.list_of_dict_of_me == [
        {
            "me": RecursiveModel(
                {
                    "name": "it's me!",
                    "listOfMe": None,
                    "dictOfMe": None,
                    "dictOfListOfMe": None,
                    "listOfDictOfMe": None,
                }
            )
        }
    ]
    assert isinstance(model.list_of_dict_of_me, list)
    assert isinstance(model.list_of_dict_of_me[0], dict)
    assert isinstance(model.list_of_dict_of_me[0]["me"], RecursiveModel)

    assert model.as_dict() == model == dict_response


def test_literals():
    class LiteralModel(Model):
        species: Literal["Mongoose", "Eagle", "Penguin"] = rest_field()
        age: Literal[1, 2, 3] = rest_field()

        @overload
        def __init__(
            self,
            *,
            species: Literal["Mongoose", "Eagle", "Penguin"],
            age: Literal[1, 2, 3],
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    dict_response = {"species": "Mongoose", "age": 3}
    model = LiteralModel(dict_response)
    assert model.species == model["species"] == "Mongoose"
    assert model.age == model["age"] == 3

    dict_response = {"species": "invalid", "age": 5}
    model = LiteralModel(dict_response)
    assert model["species"] == "invalid"
    assert model["age"] == 5

    assert model.species == "invalid"

    assert model.age == 5


def test_deserialization_callback_override():
    def _callback(obj):
        return [str(entry) for entry in obj]

    class MyModel(Model):
        prop: Sequence[float] = rest_field()

        @overload
        def __init__(self, *, prop: Sequence[float]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    model_without_callback = MyModel(prop=[1.3, 2.4, 3.5])
    assert model_without_callback.prop == [1.3, 2.4, 3.5]
    assert model_without_callback["prop"] == [1.3, 2.4, 3.5]

    class MyModel2(Model):
        prop: Sequence[int] = rest_field(type=_callback)

        @overload
        def __init__(self, *, prop: Any): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    model_with_callback = MyModel2(prop=[1.3, 2.4, 3.5])
    assert model_with_callback.prop == ["1.3", "2.4", "3.5"]
    assert model_with_callback["prop"] == ["1.3", "2.4", "3.5"]


def test_deserialization_callback_override_parent():
    class ParentNoCallback(Model):
        prop: Sequence[float] = rest_field()

        @overload
        def __init__(self, *, prop: Sequence[float]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    def _callback(obj):
        return set([str(entry) for entry in obj])

    class ChildWithCallback(ParentNoCallback):
        prop: Sequence[float] = rest_field(type=_callback)

        @overload
        def __init__(self, *, prop: Sequence[float]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    parent_model = ParentNoCallback(prop=[1, 1, 2, 3])
    assert parent_model.prop == parent_model["prop"] == [1, 1, 2, 3]

    child_model = ChildWithCallback(prop=[1, 1, 2, 3])
    assert child_model.prop == set(["1", "1", "2", "3"])
    assert child_model["prop"] == set(["1", "1", "2", "3"])


def test_inheritance_basic():
    def _callback(obj):
        return [str(e) for e in obj]

    class Parent(Model):
        parent_prop: list[int] = rest_field(name="parentProp", type=_callback)
        prop: str = rest_field()

        @overload
        def __init__(self, *, parent_prop: list[int], prop: str): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Child(Parent):
        pass

    c = Child(parent_prop=[1, 2, 3], prop="hello")
    assert c == {"parentProp": [1, 2, 3], "prop": "hello"}
    assert c.parent_prop == ["1", "2", "3"]
    assert c.prop == "hello"


class ParentA(Model):
    prop: float = rest_field()

    @overload
    def __init__(self, *, prop: Any): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class ParentB(ParentA):
    prop: str = rest_field()
    bcd_prop: Optional[list["ParentB"]] = rest_field(name="bcdProp")

    @overload
    def __init__(self, *, prop: Any, bcd_prop: Optional[list["ParentB"]] = None): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class ParentC(ParentB):
    prop: float = rest_field()
    cd_prop: ParentA = rest_field(name="cdProp")

    @overload
    def __init__(self, *, prop: Any, bcd_prop: list[ParentB], cd_prop: ParentA, **kwargs): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class ChildD(ParentC):
    d_prop: tuple[ParentA, ParentB, ParentC, Optional["ChildD"]] = rest_field(name="dProp")

    @overload
    def __init__(
        self,
        *,
        prop: Any,
        bcd_prop: list[ParentB],
        cd_prop: ParentA,
        d_prop: tuple[ParentA, ParentB, ParentC, Optional["ChildD"]],
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_model_dict_comparisons():
    class Inner(Model):
        prop: str = rest_field()

        @overload
        def __init__(
            self,
            *,
            prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Outer(Model):
        inner: Inner = rest_field()

        @overload
        def __init__(
            self,
            *,
            inner: Inner,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    def _tests(outer):
        assert outer.inner.prop == outer["inner"].prop == outer.inner["prop"] == outer["inner"]["prop"] == "hello"
        assert outer.inner == outer["inner"] == {"prop": "hello"}
        assert outer == {"inner": {"prop": "hello"}}

    _tests(Outer(inner=Inner(prop="hello")))
    _tests(Outer({"inner": {"prop": "hello"}}))


def test_model_dict_comparisons_list():
    class Inner(Model):
        prop: str = rest_field()

        @overload
        def __init__(
            self,
            *,
            prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Outer(Model):
        inner: list[Inner] = rest_field()

        @overload
        def __init__(
            self,
            *,
            inner: list[Inner],
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    def _tests(outer):
        assert (
            outer.inner[0].prop
            == outer["inner"][0].prop
            == outer.inner[0]["prop"]
            == outer["inner"][0]["prop"]
            == "hello"
        )
        assert outer.inner == outer["inner"] == [{"prop": "hello"}]
        assert outer == {"inner": [{"prop": "hello"}]}

    _tests(Outer(inner=[Inner(prop="hello")]))
    _tests(Outer({"inner": [{"prop": "hello"}]}))


def test_model_dict_comparisons_dict():
    class Inner(Model):
        prop: str = rest_field()

        @overload
        def __init__(
            self,
            *,
            prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Outer(Model):
        inner: dict[str, Inner] = rest_field()

        @overload
        def __init__(
            self,
            *,
            inner: dict[str, Inner],
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    def _tests(outer):
        assert (
            outer.inner["key"].prop
            == outer["inner"]["key"].prop
            == outer.inner["key"]["prop"]
            == outer["inner"]["key"]["prop"]
            == "hello"
        )
        assert outer.inner == outer["inner"] == {"key": {"prop": "hello"}}
        with pytest.raises(AttributeError):
            outer.inner.key
        assert outer.inner["key"] == outer["inner"]["key"] == {"prop": "hello"}
        assert outer == {"inner": {"key": {"prop": "hello"}}}

    _tests(Outer(inner={"key": Inner(prop="hello")}))
    _tests(Outer({"inner": {"key": {"prop": "hello"}}}))


def test_inheritance_4_levels():
    a = ParentA(prop=3.4)
    assert a.prop == 3.4
    assert a["prop"] == 3.4
    assert a == {"prop": 3.4}
    assert isinstance(a, Model)

    b = ParentB(prop=3.4, bcd_prop=[ParentB(prop=4.3)])
    assert b.prop == "3.4"
    assert b["prop"] == 3.4
    assert b.bcd_prop == [ParentB(prop=4.3)]
    assert b["bcdProp"] != [{"prop": 4.3, "bcdProp": None}]
    assert b["bcdProp"] == [{"prop": 4.3}]
    assert b.bcd_prop
    assert b.bcd_prop[0].prop == "4.3"
    assert b.bcd_prop[0].bcd_prop is None
    assert b == {"prop": 3.4, "bcdProp": [{"prop": 4.3}]}
    assert isinstance(b, ParentB)
    assert isinstance(b, ParentA)

    c = ParentC(prop=3.4, bcd_prop=[b], cd_prop=a)
    assert c.prop == c["prop"] == 3.4
    assert c.bcd_prop == [b]
    assert c.bcd_prop
    assert isinstance(c.bcd_prop[0], ParentB)
    assert c["bcdProp"] == [b] == [{"prop": 3.4, "bcdProp": [{"prop": 4.3}]}]
    assert c.cd_prop == a
    assert c["cdProp"] == a == {"prop": 3.4}
    assert isinstance(c.cd_prop, ParentA)

    d = ChildD(
        prop=3.4,
        bcd_prop=[b],
        cd_prop=a,
        d_prop=(
            a,
            b,
            c,
            ChildD(prop=3.4, bcd_prop=[b], cd_prop=a, d_prop=(a, b, c, None)),
        ),
    )
    assert d == {
        "prop": 3.4,
        "bcdProp": [b],
        "cdProp": a,
        "dProp": (
            a,
            b,
            c,
            {"prop": 3.4, "bcdProp": [b], "cdProp": a, "dProp": (a, b, c, None)},
        ),
    }
    assert d.prop == d["prop"] == 3.4
    assert d.bcd_prop == [b]
    assert d.bcd_prop
    assert isinstance(d.bcd_prop[0], ParentB)
    assert d.cd_prop == a
    assert isinstance(d.cd_prop, ParentA)
    assert d.d_prop[0] == a  # at a
    assert isinstance(d.d_prop[0], ParentA)
    assert d.d_prop[1] == b
    assert isinstance(d.d_prop[1], ParentB)
    assert d.d_prop[2] == c
    assert isinstance(d.d_prop[2], ParentC)
    assert isinstance(d.d_prop[3], ChildD)

    assert isinstance(d.d_prop[3].d_prop[0], ParentA)
    assert isinstance(d.d_prop[3].d_prop[1], ParentB)
    assert isinstance(d.d_prop[3].d_prop[2], ParentC)
    assert d.d_prop[3].d_prop[3] is None


def test_multiple_inheritance_basic():
    class ParentOne(Model):
        parent_one_prop: str = rest_field(name="parentOneProp")

        @overload
        def __init__(
            self,
            *,
            parent_one_prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class ParentTwo(Model):
        parent_two_prop: int = rest_field(name="parentTwoProp", type=lambda x: str(x))

        @overload
        def __init__(
            self,
            *,
            parent_two_prop: int,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Child(ParentOne, ParentTwo):
        @overload
        def __init__(
            self,
            *,
            parent_one_prop: str,
            parent_two_prop: int,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    c = Child(parent_one_prop="Hello", parent_two_prop=3)
    assert c == {"parentOneProp": "Hello", "parentTwoProp": 3}
    assert c.parent_one_prop == "Hello"
    assert c.parent_two_prop == "3"
    assert isinstance(c, Child)
    assert isinstance(c, ParentOne)
    assert isinstance(c, ParentTwo)


def test_multiple_inheritance_mro():
    class A(Model):
        prop: str = rest_field()

        @overload
        def __init__(self, *, prop: str) -> None: ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class B(Model):
        prop: int = rest_field(type=lambda x: int(x))

        @overload
        def __init__(self, *, prop: str) -> None: ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class C(A, B):
        pass

    assert A(prop="1").prop == "1"
    assert B(prop="1").prop == 1
    assert C(prop="1").prop == "1"  # A should take precedence over B


class Feline(Model):
    meows: bool = rest_field()
    hisses: bool = rest_field()
    siblings: Optional[list["Feline"]] = rest_field()

    @overload
    def __init__(
        self,
        *,
        meows: bool,
        hisses: bool,
        siblings: Optional[list["Feline"]] = None,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class Owner(Model):
    first_name: str = rest_field(name="firstName", type=lambda x: x.capitalize())
    last_name: str = rest_field(name="lastName", type=lambda x: x.capitalize())

    @overload
    def __init__(
        self,
        *,
        first_name: str,
        last_name: str,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class PetModel(Model):
    name: str = rest_field()
    owner: Owner = rest_field()

    @overload
    def __init__(self, *, name: str, owner: Owner): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class Cat(PetModel, Feline):
    likes_milk: bool = rest_field(name="likesMilk", type=lambda x: True)

    @overload
    def __init__(
        self,
        *,
        name: str,
        owner: Owner,
        meows: bool,
        hisses: bool,
        likes_milk: bool,
        siblings: Optional[list[Feline]],
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class CuteThing(Model):
    how_cute_am_i: float = rest_field(name="howCuteAmI")

    @overload
    def __init__(self, *, how_cute_am_i: float): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class Kitten(Cat, CuteThing):
    eats_mice_yet: bool = rest_field(name="eatsMiceYet")

    @overload
    def __init__(
        self,
        *,
        name: str,
        owner: Owner,
        meows: bool,
        hisses: bool,
        likes_milk: bool,
        siblings: Optional[list[Feline]],
        how_cute_am_i: float,
        eats_mice_yet: bool,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_multiple_inheritance_complex():
    cat = Cat(
        name="Stephanie",
        owner=Owner(first_name="cecil", last_name="cai"),  # gets capitalized in attr
        meows=True,
        hisses=True,
        likes_milk=False,  # likes_milk will change to True on the attribute
        siblings=[Feline(meows=True, hisses=False)],
    )
    assert cat == {
        "name": "Stephanie",
        "owner": {
            "firstName": "cecil",
            "lastName": "cai",
        },
        "meows": True,
        "hisses": True,
        "likesMilk": False,
        "siblings": [
            {
                "meows": True,
                "hisses": False,
            }
        ],
    }
    assert cat.name == "Stephanie"
    assert isinstance(cat.owner, Owner)
    assert cat.owner.first_name == "Cecil"
    assert cat.owner.last_name == "Cai"
    assert cat.meows
    assert cat.hisses
    assert cat.likes_milk
    assert cat.siblings
    assert len(cat.siblings) == 1
    assert isinstance(cat.siblings[0], Feline)

    kitten = Kitten(
        name="Stephanie",
        owner=Owner(first_name="cecil", last_name="cai"),  # gets capitalized in attr
        meows=True,
        hisses=True,
        likes_milk=False,  # likes_milk will change to True on the attribute
        siblings=[Feline(meows=True, hisses=False)],
        how_cute_am_i=1.0,
        eats_mice_yet=True,
    )
    assert kitten != {
        "name": "Stephanie",
        "owner": {
            "firstName": "cecil",
            "lastName": "cai",
        },
        "meows": True,
        "hisses": True,
        "likesMilk": False,
        "siblings": [{"meows": True, "hisses": False, "siblings": None}],  # we don't automatically set None here
        "howCuteAmI": 1.0,
        "eatsMiceYet": True,
    }
    assert kitten == {
        "name": "Stephanie",
        "owner": {
            "firstName": "cecil",
            "lastName": "cai",
        },
        "meows": True,
        "hisses": True,
        "likesMilk": False,
        "siblings": [
            {
                "meows": True,
                "hisses": False,
            }
        ],
        "howCuteAmI": 1.0,
        "eatsMiceYet": True,
    }
    assert kitten.name == "Stephanie"
    assert isinstance(kitten.owner, Owner)
    assert kitten.owner.first_name == "Cecil"
    assert kitten.owner.last_name == "Cai"
    assert kitten.meows
    assert kitten.hisses
    assert kitten.likes_milk
    assert kitten.siblings
    assert len(kitten.siblings) == 1
    assert isinstance(kitten.siblings[0], Feline)
    assert kitten.eats_mice_yet
    assert kitten.how_cute_am_i == 1.0
    assert isinstance(kitten, PetModel)
    assert isinstance(kitten, Cat)
    assert isinstance(kitten, Feline)
    assert isinstance(kitten, CuteThing)


class A(Model):
    b: "B" = rest_field()

    @overload
    def __init__(self, b: "B"): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class B(Model):
    c: "C" = rest_field()

    @overload
    def __init__(self, *, c: "C"): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class C(Model):
    d: str = rest_field()

    @overload
    def __init__(self, *, d: str): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_nested_creation():
    a = A({"b": {"c": {"d": "hello"}}})
    assert isinstance(a["b"], Model)
    assert isinstance(a["b"]["c"], Model)
    assert a["b"]["c"] == a["b"].c == a.b.c == {"d": "hello"}

    assert (
        a["b"]["c"]["d"]
        == a["b"].c.d
        == a.b["c"].d
        == a["b"]["c"].d
        == a["b"].c["d"]
        == a.b["c"]["d"]
        == a.b.c.d
        == "hello"
    )


def test_nested_setting():
    a = A({"b": {"c": {"d": "hello"}}})

    # set with dict
    a["b"]["c"]["d"] = "setwithdict"
    assert (
        a["b"]["c"]["d"]
        == a["b"].c.d
        == a.b["c"].d
        == a["b"]["c"].d
        == a["b"].c["d"]
        == a.b["c"]["d"]
        == a.b.c.d
        == "setwithdict"
    )

    # set with attr
    a.b.c.d = "setwithattr"
    assert a["b"]["c"]["d"] == "setwithattr"
    assert (
        a["b"]["c"]["d"]
        == a["b"].c.d
        == a.b["c"].d
        == a["b"]["c"].d
        == a["b"].c["d"]
        == a.b["c"]["d"]
        == a.b.c.d
        == "setwithattr"
    )


class BaseModel(Model):
    inner_model: "InnerModel" = rest_field(name="innerModel")

    @overload
    def __init__(self, *, inner_model: "InnerModel"): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class InnerModel(Model):
    datetime_field: datetime.datetime = rest_field(name="datetimeField")

    @overload
    def __init__(self, *, datetime_field: datetime.datetime): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_nested_deserialization():
    serialized_datetime = "9999-12-31T23:59:59.999Z"

    model = BaseModel({"innerModel": {"datetimeField": serialized_datetime}})
    assert model.inner_model["datetimeField"] == model["innerModel"]["datetimeField"] == serialized_datetime
    assert (
        model.inner_model.datetime_field
        == model["innerModel"].datetime_field
        == isodate.parse_datetime(serialized_datetime)
    )

    new_serialized_datetime = "2022-12-31T23:59:59.999Z"
    model.inner_model.datetime_field = isodate.parse_datetime(new_serialized_datetime)
    assert model.inner_model["datetimeField"] == "2022-12-31T23:59:59.999000Z"


class X(Model):
    y: "Y" = rest_field()

    @overload
    def __init__(self, *, y: "Y"): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class Y(Model):
    z: "Z" = rest_field()

    @overload
    def __init__(self, *, z: "Z"): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class Z(Model):
    z_val: datetime.datetime = rest_field(name="zVal")

    @overload
    def __init__(self, *, z_val: datetime.datetime): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_nested_update():
    serialized_datetime = "9999-12-31T23:59:59.999Z"
    parsed_datetime = isodate.parse_datetime(serialized_datetime)
    x = X({"y": {"z": {"zVal": serialized_datetime}}})
    assert x.y.z.z_val == x["y"].z.z_val == x.y["z"].z_val == x["y"]["z"].z_val == parsed_datetime
    assert x.y.z["zVal"] == x.y["z"]["zVal"] == x["y"].z["zVal"] == x["y"]["z"]["zVal"] == serialized_datetime


def test_deserialization_is():
    # test without datetime deserialization
    a = A({"b": {"c": {"d": "hello"}}})
    assert a.b is a.b
    assert a.b.c is a.b.c
    assert a.b.c.d is a.b.c.d

    serialized_datetime = "9999-12-31T23:59:59.999Z"
    x = X({"y": {"z": {"zVal": serialized_datetime}}})
    assert x.y is x.y
    assert x.y.z is x.y.z

    assert x.y.z.z_val == isodate.parse_datetime(serialized_datetime)


class InnerModelWithReadonly(Model):
    normal_property: str = rest_field(name="normalProperty")
    readonly_property: str = rest_field(name="readonlyProperty", visibility=["read"])

    @overload
    def __init__(self, *, normal_property: str): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class ModelWithReadonly(Model):
    normal_property: str = rest_field(name="normalProperty")
    readonly_property: str = rest_field(name="readonlyProperty", visibility=["read"])
    inner_model: InnerModelWithReadonly = rest_field(name="innerModel")

    @overload
    def __init__(self, *, normal_property: str): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


def test_readonly():
    # we pass the dict to json, so readonly shouldn't show up in the JSON version
    value = {
        "normalProperty": "normal",
        "readonlyProperty": "readonly",
        "innerModel": {"normalProperty": "normal", "readonlyProperty": "readonly"},
    }
    model = ModelWithReadonly(value)
    assert model.as_dict(exclude_readonly=True) == {
        "normalProperty": "normal",
        "innerModel": {"normalProperty": "normal"},
    }
    assert json.loads(json.dumps(model, cls=SdkJSONEncoder)) == value
    assert model == value
    assert model["readonlyProperty"] == model.readonly_property == "readonly"
    assert model["innerModel"]["readonlyProperty"] == model.inner_model.readonly_property == "readonly"


def test_readonly_set():
    value = {
        "normalProperty": "normal",
        "readonlyProperty": "readonly",
        "innerModel": {"normalProperty": "normal", "readonlyProperty": "readonly"},
    }

    model = ModelWithReadonly(value)
    assert model.normal_property == model["normalProperty"] == "normal"
    assert model.readonly_property == model["readonlyProperty"] == "readonly"
    assert model.inner_model.normal_property == model.inner_model["normalProperty"] == "normal"
    assert model.inner_model.readonly_property == model.inner_model["readonlyProperty"] == "readonly"

    assert model.as_dict(exclude_readonly=True) == {
        "normalProperty": "normal",
        "innerModel": {"normalProperty": "normal"},
    }
    assert json.loads(json.dumps(model, cls=SdkJSONEncoder)) == value

    model["normalProperty"] = "setWithDict"
    model["readonlyProperty"] = "setWithDict"
    model.inner_model["normalProperty"] = "setWithDict"
    model.inner_model["readonlyProperty"] = "setWithDict"

    assert model.normal_property == model["normalProperty"] == "setWithDict"
    assert model.readonly_property == model["readonlyProperty"] == "setWithDict"
    assert model.inner_model.normal_property == model.inner_model["normalProperty"] == "setWithDict"
    assert model.inner_model.readonly_property == model.inner_model["readonlyProperty"] == "setWithDict"
    assert model.as_dict(exclude_readonly=True) == {
        "normalProperty": "setWithDict",
        "innerModel": {"normalProperty": "setWithDict"},
    }
    assert json.loads(json.dumps(model, cls=SdkJSONEncoder)) == {
        "normalProperty": "setWithDict",
        "readonlyProperty": "setWithDict",
        "innerModel": {
            "normalProperty": "setWithDict",
            "readonlyProperty": "setWithDict",
        },
    }


def test_incorrect_initialization():
    class MyModel(Model):
        id: int = rest_field()
        field: str = rest_field()

        @overload
        def __init__(
            self,
            *,
            id: int,
            field: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    with pytest.raises(TypeError):
        MyModel(1, "field")

    with pytest.raises(TypeError):
        MyModel(id=1, field="field", unknown="me")


def test_serialization_initialization_and_setting():
    serialized_datetime = "9999-12-31T23:59:59.999000Z"
    parsed_datetime = isodate.parse_datetime(serialized_datetime)

    # pass in parsed
    z = Z(z_val=parsed_datetime)
    assert z.z_val == parsed_datetime
    assert z["zVal"] == serialized_datetime

    # pass in dict
    z = Z({"zVal": serialized_datetime})
    assert z.z_val == parsed_datetime
    assert z["zVal"] == serialized_datetime

    # assert setting
    serialized_datetime = "2022-12-31T23:59:59.999000Z"
    z.z_val = isodate.parse_datetime(serialized_datetime)
    assert z["zVal"] == serialized_datetime


def test_copy_of_input():
    class TestModel(Model):
        data: list[int] = rest_field()

        @overload
        def __init__(self, *, data: list[int]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    raw = [1, 2, 3]
    m = TestModel(data=raw)
    assert not m.data is raw
    assert m.data == raw
    raw.append(4)
    assert m.data == [1, 2, 3]


def test_inner_model_custom_serializer():
    class InnerModel(Model):
        prop: str = rest_field(type=lambda x: x[::-1])

        @overload
        def __init__(self, *, prop: str): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class OuterModel(Model):
        inner: InnerModel = rest_field()

        @overload
        def __init__(self, *, inner: InnerModel): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    outer = OuterModel({"inner": {"prop": "hello"}})
    assert outer.inner["prop"] == outer["inner"]["prop"] == "hello"
    assert outer.inner.prop == outer["inner"].prop == "olleh"  # cspell: ignore olleh


def test_default_value():
    class MyModel(Model):
        prop_default_str: str = rest_field(name="propDefaultStr", default="hello")
        prop_optional_str: Optional[str] = rest_field(name="propOptionalStr", default=None)
        prop_default_int: int = rest_field(name="propDefaultInt", default=1)
        prop_optional_int: Optional[int] = rest_field(name="propOptionalInt", default=None)

        @overload
        def __init__(
            self,
            *,
            prop_default_str: str = "hello",
            prop_optional_str: Optional[str] = "propOptionalStr",
            prop_default_int: int = 1,
            prop_optional_int: Optional[int] = None,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    my_model = MyModel()
    assert my_model.prop_default_str == my_model["propDefaultStr"] == "hello"
    assert my_model.prop_optional_str is my_model["propOptionalStr"] is None
    assert my_model.prop_default_int == my_model["propDefaultInt"] == 1
    assert my_model.prop_optional_int is my_model["propOptionalInt"] is None
    assert my_model == {
        "propDefaultStr": "hello",
        "propOptionalStr": None,
        "propDefaultInt": 1,
        "propOptionalInt": None,
    }

    my_model = MyModel(prop_default_str="goodbye")
    assert my_model.prop_default_str == my_model["propDefaultStr"] == "goodbye"
    assert my_model.prop_optional_str is my_model["propOptionalStr"] is None
    assert my_model.prop_default_int == my_model["propDefaultInt"] == 1
    assert my_model.prop_optional_int is my_model["propOptionalInt"] is None
    assert my_model == {
        "propDefaultStr": "goodbye",
        "propOptionalStr": None,
        "propDefaultInt": 1,
        "propOptionalInt": None,
    }

    my_model = MyModel(prop_optional_int=4)
    assert my_model.prop_default_str == my_model["propDefaultStr"] == "hello"
    assert my_model.prop_optional_str is my_model["propOptionalStr"] is None
    assert my_model.prop_default_int == my_model["propDefaultInt"] == 1
    assert my_model.prop_optional_int == my_model["propOptionalInt"] == 4
    assert my_model == {
        "propDefaultStr": "hello",
        "propOptionalStr": None,
        "propDefaultInt": 1,
        "propOptionalInt": 4,
    }

    my_model = MyModel({"propDefaultInt": 5})
    assert my_model.prop_default_str == my_model["propDefaultStr"] == "hello"
    assert my_model.prop_optional_str is my_model["propOptionalStr"] is None
    assert my_model.prop_default_int == my_model["propDefaultInt"] == 5
    assert my_model.prop_optional_int is my_model["propOptionalInt"] is None
    assert my_model == {
        "propDefaultStr": "hello",
        "propOptionalStr": None,
        "propDefaultInt": 5,
        "propOptionalInt": None,
    }


def test_pass_models_in_dict():
    class Inner(Model):
        str_property: str = rest_field(name="strProperty")

        @overload
        def __init__(
            self,
            *,
            str_property: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Outer(Model):
        inner_property: Inner = rest_field(name="innerProperty")

        @overload
        def __init__(
            self,
            *,
            inner_property: Inner,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    def _tests(model: Outer):
        assert (
            {"innerProperty": {"strProperty": "hello"}}
            == {"innerProperty": Inner(str_property="hello")}
            == {"innerProperty": Inner({"strProperty": "hello"})}
            == Outer(inner_property=Inner(str_property="hello"))
            == Outer(inner_property=Inner({"strProperty": "hello"}))
            == Outer({"innerProperty": {"strProperty": "hello"}})
            == Outer({"innerProperty": Inner(str_property="hello")})
            == Outer({"innerProperty": Inner({"strProperty": "hello"})})
            == model
        )

    _tests(Outer(inner_property=Inner(str_property="hello")))
    _tests(Outer(inner_property=Inner({"strProperty": "hello"})))
    _tests(Outer({"innerProperty": {"strProperty": "hello"}}))
    _tests(Outer({"innerProperty": Inner(str_property="hello")}))
    _tests(Outer({"innerProperty": Inner({"strProperty": "hello"})}))


def test_mutability_list():
    class Inner(Model):
        str_property: str = rest_field(name="strProperty")

        @overload
        def __init__(
            self,
            *,
            str_property: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Middle(Model):
        inner_property: list[Inner] = rest_field(name="innerProperty")
        prop: str = rest_field()

        @overload
        def __init__(
            self,
            *,
            inner_property: list[Inner],
            prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Outer(Model):
        middle_property: Middle = rest_field(name="middleProperty")

        @overload
        def __init__(
            self,
            *,
            middle_property: Model,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    original_dict = {
        "middleProperty": {
            "innerProperty": [{"strProperty": "hello"}],
            "prop": "original",
        }
    }
    model = Outer(original_dict)
    assert model is not original_dict

    # set with dict syntax
    assert model.middle_property is model["middleProperty"]
    middle_property = model.middle_property
    middle_property["prop"] = "new"
    assert model["middleProperty"] is model.middle_property is middle_property
    assert model["middleProperty"]["prop"] == model.middle_property.prop == "new"

    # set with attr syntax
    middle_property.prop = "newest"
    assert model["middleProperty"] is model.middle_property is middle_property
    assert model["middleProperty"]["prop"] == model.middle_property.prop == "newest"

    # modify innerproperty list
    assert model["middleProperty"]["innerProperty"][0] is model.middle_property.inner_property[0]
    assert (
        model["middleProperty"]["innerProperty"][0]
        is model.middle_property["innerProperty"][0]
        is model["middleProperty"].inner_property[0]
        is model.middle_property.inner_property[0]
    )
    inner_property = model["middleProperty"]["innerProperty"][0]

    # set with dict syntax
    inner_property["strProperty"] = "nihao"
    assert (
        model["middleProperty"]["innerProperty"][0]
        is model.middle_property["innerProperty"][0]
        is model["middleProperty"].inner_property[0]
        is model.middle_property.inner_property[0]
    )
    assert (
        model["middleProperty"]["innerProperty"][0]["strProperty"]
        == model.middle_property["innerProperty"][0]["strProperty"]
        == model["middleProperty"].inner_property[0]["strProperty"]
        == model.middle_property.inner_property[0]["strProperty"]
        == model["middleProperty"]["innerProperty"][0].str_property
        == model.middle_property["innerProperty"][0].str_property
        == model["middleProperty"].inner_property[0].str_property
        == model.middle_property.inner_property[0].str_property
        == "nihao"
    )


def test_mutability_dict():
    class Inner(Model):
        str_property: str = rest_field(name="strProperty")

        @overload
        def __init__(
            self,
            *,
            str_property: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Middle(Model):
        inner_property: dict[str, Inner] = rest_field(name="innerProperty")
        prop: str = rest_field()

        @overload
        def __init__(
            self,
            *,
            inner_property: dict[str, Inner],
            prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Outer(Model):
        middle_property: Middle = rest_field(name="middleProperty")

        @overload
        def __init__(
            self,
            *,
            middle_property: Model,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    original_dict = {
        "middleProperty": {
            "innerProperty": {"inner": {"strProperty": "hello"}},
            "prop": "original",
        }
    }
    model = Outer(original_dict)
    assert model is not original_dict

    # set with dict syntax
    assert model.middle_property is model["middleProperty"]
    middle_property = model.middle_property
    middle_property["prop"] = "new"
    assert model["middleProperty"] is model.middle_property is middle_property
    assert (
        model["middleProperty"]["prop"]
        == model["middleProperty"].prop
        == model.middle_property.prop
        == model.middle_property["prop"]
        == "new"
    )

    # set with attr syntax
    middle_property.prop = "newest"
    assert model["middleProperty"] is model.middle_property is middle_property
    assert model["middleProperty"]["prop"] == model.middle_property.prop == "newest"

    # modify innerproperty list
    assert model["middleProperty"]["innerProperty"]["inner"] is model.middle_property.inner_property["inner"]
    assert (
        model["middleProperty"]["innerProperty"]["inner"]
        is model.middle_property["innerProperty"]["inner"]
        is model["middleProperty"].inner_property["inner"]
        is model.middle_property.inner_property["inner"]
    )
    inner_property = model["middleProperty"]["innerProperty"]["inner"]

    # set with dict syntax
    inner_property["strProperty"] = "nihao"
    assert (
        model["middleProperty"]["innerProperty"]["inner"]
        is model.middle_property["innerProperty"]["inner"]
        is model["middleProperty"].inner_property["inner"]
        is model.middle_property.inner_property["inner"]
    )
    assert (
        model["middleProperty"]["innerProperty"]["inner"]["strProperty"]
        == model.middle_property["innerProperty"]["inner"]["strProperty"]
        == model["middleProperty"].inner_property["inner"]["strProperty"]
        == model.middle_property.inner_property["inner"]["strProperty"]
        == model["middleProperty"]["innerProperty"]["inner"].str_property
        == model.middle_property["innerProperty"]["inner"].str_property
        == model["middleProperty"].inner_property["inner"].str_property
        == model.middle_property.inner_property["inner"].str_property
        == "nihao"
    )


def test_del_model():
    class TestModel(Model):
        x: Optional[int] = rest_field()

    my_dict = {}
    my_dict["x"] = None

    assert my_dict["x"] is None

    my_model = TestModel({})
    my_model["x"] = None

    assert my_model["x"] is my_model.x is None

    my_model = TestModel({"x": 7})
    my_model.x = None

    assert "x" not in my_model
    assert my_model.x is None

    with pytest.raises(KeyError):
        del my_model["x"]
    my_model.x = 8

    del my_model["x"]
    assert "x" not in my_model
    assert my_model.x is my_model.get("x") is None

    with pytest.raises(AttributeError):
        del my_model.x
    my_model.x = None
    assert "x" not in my_model
    assert my_model.x is my_model.get("x") is None


def test_pop_model():
    class Inner(Model):
        str_property: str = rest_field(name="strProperty")

        @overload
        def __init__(
            self,
            *,
            str_property: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Middle(Model):
        inner_property: dict[str, Inner] = rest_field(name="innerProperty")
        prop: str = rest_field()

        @overload
        def __init__(
            self,
            *,
            inner_property: dict[str, Inner],
            prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class Outer(Model):
        middle_property: Middle = rest_field(name="middleProperty")

        @overload
        def __init__(
            self,
            *,
            middle_property: Model,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    original_dict = {
        "middleProperty": {
            "innerProperty": {"inner": {"strProperty": "hello"}},
            "prop": "original",
        }
    }
    model_dict = Outer(original_dict)  # model we will access with dict syntax
    model_attr = Outer(original_dict)  # model we will access with attr syntax

    assert model_dict is not original_dict is not model_attr
    assert (
        original_dict["middleProperty"]["innerProperty"]["inner"].pop("strProperty")
        == model_dict["middleProperty"]["innerProperty"]["inner"].pop("strProperty")
        == model_attr.middle_property.inner_property["inner"].pop("strProperty")
        == "hello"
    )

    with pytest.raises(KeyError):
        original_dict["middleProperty"]["innerProperty"]["inner"].pop("strProperty")
    with pytest.raises(KeyError):
        model_dict["middleProperty"]["innerProperty"]["inner"].pop("strProperty")
    with pytest.raises(KeyError):
        model_attr.middle_property.inner_property["inner"].pop("strProperty")


def test_contains():
    class ParentA(Model):
        a_prop: str = rest_field(name="aProp")

        @overload
        def __init__(
            self,
            *,
            a_prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class ParentB(Model):
        b_prop: str = rest_field(name="bProp")

        @overload
        def __init__(
            self,
            *,
            b_prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    class ChildC(ParentA, ParentB):
        c_prop: str = rest_field(name="cProp")

        @overload
        def __init__(
            self,
            *,
            a_prop: str,
            b_prop: str,
            c_prop: str,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    parent_a_dict = {"aProp": "a"}
    assert "aProp" in parent_a_dict

    parent_a = ParentA(parent_a_dict)
    assert "aProp" in parent_a
    assert not "a_prop" in parent_a

    parent_a.a_prop = None  # clear it out
    assert "aProp" not in parent_a

    parent_b_dict = {"bProp": "b"}
    assert "bProp" in parent_b_dict

    parent_b = ParentB(parent_b_dict)
    assert "bProp" in parent_b
    assert "b_prop" not in parent_b

    parent_b.b_prop = None  # clear it out
    assert "bProp" not in parent_b

    props = ["aProp", "bProp", "cProp"]
    child_c_dict = {"aProp": "a", "bProp": "b", "cProp": "c"}
    assert all(p for p in props if p in child_c_dict)

    child_c = ChildC(child_c_dict)
    assert all(p for p in props if p in child_c)
    assert not any(p for p in ["a_prop", "b_prop", "c_prop"] if p in child_c)

    child_c.a_prop = None
    child_c.b_prop = None
    child_c.c_prop = None

    assert not any(p for p in props if p in child_c)


def test_iter():
    dict_response = {
        "platformUpdateDomainCount": 5,
        "platformFaultDomainCount": 3,
        "virtualMachines": [],
    }
    assert isinstance(iter(dict_response), Iterable)
    model = BasicResource(dict_response)
    assert isinstance(iter(model), Iterable)

    assert (
        list(iter(dict_response))
        == list(iter(model))
        == ["platformUpdateDomainCount", "platformFaultDomainCount", "virtualMachines"]
    )


def test_len():
    dict_response = {
        "platformUpdateDomainCount": 5,
        "platformFaultDomainCount": 3,
        "virtualMachines": [],
    }
    model = BasicResource(dict_response)
    assert len(dict_response) == len(model) == 3

    dict_response.pop("platformUpdateDomainCount")
    model.pop("platformUpdateDomainCount")
    assert len(dict_response) == len(model) == 2


def test_keys():
    class Inner(Model):
        str_prop: str = rest_field(name="strProp")

    class Outer(Model):
        inner_prop: Inner = rest_field(name="innerProp")

    outer_dict = {"innerProp": {"strProp": "hello"}}
    outer = Outer(outer_dict)
    assert outer.keys() == outer_dict.keys()
    outer_dict["newProp"] = "hello"
    outer["newProp"] = "hello"

    assert outer.keys() == outer_dict.keys()

    outer_dict.pop("newProp")
    outer.pop("newProp")
    assert outer_dict.keys() == outer.keys()


def test_values():
    class Inner(Model):
        str_prop: str = rest_field(name="strProp")

    class Outer(Model):
        inner_prop: Inner = rest_field(name="innerProp")

    outer_dict = {"innerProp": {"strProp": "hello"}}
    outer = Outer(outer_dict)

    assert list(outer.values()) == list(outer_dict.values())
    assert len(outer.values()) == len(outer_dict.values()) == 1
    assert list(outer.values())[0]["strProp"] == list(outer_dict.values())[0]["strProp"] == "hello"

    outer_dict["innerProp"]["strProp"] = "goodbye"
    outer.inner_prop.str_prop = "goodbye"

    assert list(outer.inner_prop.values()) == list(outer_dict["innerProp"].values())


def test_items():
    class Inner(Model):
        str_prop: str = rest_field(name="strProp")

    class Outer(Model):
        inner_prop: Inner = rest_field(name="innerProp")

    outer_dict = {"innerProp": {"strProp": "hello"}}
    outer = Outer(outer_dict)

    assert list(outer.items()) == list(outer_dict.items())

    outer_dict["innerProp"]["strProp"] = "goodbye"
    outer.inner_prop.str_prop = "goodbye"

    assert list(outer.inner_prop.items()) == list(outer_dict["innerProp"].items())

    outer_dict["newProp"] = "bonjour"
    outer["newProp"] = "bonjour"

    assert list(outer.items()) == list(outer_dict.items())


def test_get():
    class MyModel(Model):
        prop: str = rest_field()
        rest_prop: str = rest_field(name="restProp")

    my_dict = {"prop": "hello", "restProp": "bonjour"}
    my_model = MyModel(my_dict)

    assert my_dict.get("prop") == my_model.get("prop") == "hello"
    my_dict["prop"] = "nihao"
    my_model.prop = "nihao"

    assert my_dict.get("prop") == my_model.get("prop") == "nihao"

    my_dict["restProp"] = "buongiorno"
    my_model.rest_prop = "buongiorno"

    assert my_dict.get("restProp") == my_model.get("restProp") == "buongiorno"
    assert my_dict.get("rest_prop") is None  # attr case should not work here

    my_dict["newProp"] = "i'm new"
    my_model["newProp"] = "i'm new"

    assert my_dict.get("newProp") == my_model.get("newProp") == "i'm new"
    assert my_dict.get("nonexistent") is my_model.get("nonexistent") is None

    assert my_dict.get("nonexistent", 0) == my_model.get("nonexistent", 0) == 0


def test_pop():
    class MyModel(Model):
        prop: str = rest_field()
        rest_prop: str = rest_field(name="restProp")

    my_dict = {"prop": "hello", "restProp": "bonjour"}
    my_model = MyModel(my_dict)

    assert my_dict.pop("prop") == my_model.pop("prop") == "hello"
    with pytest.raises(KeyError):
        my_dict.pop("prop")
    with pytest.raises(KeyError):
        my_model.pop("prop")

    my_dict["prop"] = "nihao"
    my_model.prop = "nihao"

    assert my_dict.pop("prop") == my_model.pop("prop") == "nihao"

    with pytest.raises(KeyError):
        my_dict.pop("prop")
    with pytest.raises(KeyError):
        my_model.pop("prop")

    my_dict["restProp"] = "buongiorno"
    my_model.rest_prop = "buongiorno"

    assert my_dict.pop("restProp") == my_model.pop("restProp") == "buongiorno"
    with pytest.raises(KeyError):
        my_dict.pop("rest_prop")  # attr case should not work here

    my_dict["newProp"] = "i'm new"
    my_model["newProp"] = "i'm new"

    assert my_dict.pop("newProp") == my_model.pop("newProp") == "i'm new"
    assert my_dict.pop("nonexistent", 0) == my_model.pop("nonexistent", 0) == 0


def test_popitem():
    class ModelA(Model):
        a_str_prop: str = rest_field(name="aStrProp")

    class ModelB(Model):
        b_str_prop: str = rest_field(name="bStrProp")

    class ModelC(Model):
        c_str_prop: str = rest_field(name="cStrProp")

    class MainModel(Model):
        a_prop: ModelA = rest_field(name="aProp")
        b_prop: ModelB = rest_field(name="bProp")
        c_prop: ModelC = rest_field(name="cProp")

    my_dict = {
        "aProp": {"aStrProp": "a"},
        "bProp": {"bStrProp": "b"},
        "cProp": {"cStrProp": "c"},
    }

    def _tests(my_dict: dict[str, Any], my_model: MainModel):
        my_dict = copy.deepcopy(my_dict)  # so we don't get rid of the dict each time we run tests

        # pop c prop
        dict_popitem = my_dict.popitem()
        model_popitem = my_model.popitem()
        assert dict_popitem[0] == model_popitem[0] == "cProp"
        assert dict_popitem[1]["cStrProp"] == model_popitem[1]["cStrProp"] == model_popitem[1].c_str_prop == "c"

        # pop b prop
        dict_popitem = my_dict.popitem()
        model_popitem = my_model.popitem()
        assert dict_popitem[0] == model_popitem[0] == "bProp"
        assert dict_popitem[1]["bStrProp"] == model_popitem[1]["bStrProp"] == model_popitem[1].b_str_prop == "b"

        # pop a prop
        dict_popitem = my_dict.popitem()
        model_popitem = my_model.popitem()
        assert dict_popitem[0] == model_popitem[0] == "aProp"
        assert dict_popitem[1]["aStrProp"] == model_popitem[1]["aStrProp"] == model_popitem[1].a_str_prop == "a"

        with pytest.raises(KeyError):
            my_dict.popitem()

        with pytest.raises(KeyError):
            my_model.popitem()

    _tests(my_dict, MainModel(my_dict))
    _tests(
        my_dict,
        MainModel(
            a_prop=ModelA(a_str_prop="a"),
            b_prop=ModelB(b_str_prop="b"),
            c_prop=ModelC(c_str_prop="c"),
        ),
    )


def test_clear():
    class ModelA(Model):
        a_str_prop: str = rest_field(name="aStrProp")

    class ModelB(Model):
        b_str_prop: str = rest_field(name="bStrProp")

    class ModelC(Model):
        c_str_prop: str = rest_field(name="cStrProp")

    class MainModel(Model):
        a_prop: ModelA = rest_field(name="aProp")
        b_prop: ModelB = rest_field(name="bProp")
        c_prop: ModelC = rest_field(name="cProp")

    my_dict = {
        "aProp": {"aStrProp": "a"},
        "bProp": {"bStrProp": "b"},
        "cProp": {"cStrProp": "c"},
    }

    def _tests(my_dict: dict[str, Any], my_model: MainModel):
        my_dict = copy.deepcopy(my_dict)  # so we don't get rid of the dict each time we run tests

        assert my_dict["aProp"] == my_model.a_prop == my_model["aProp"] == {"aStrProp": "a"}
        my_dict.clear()
        my_model.clear()
        assert my_dict == my_model == {}

        assert my_model.a_prop is None
        assert my_model.b_prop is None
        assert my_model.c_prop is None

        my_dict.clear()
        my_model.clear()
        assert my_dict == my_model == {}

    _tests(my_dict, MainModel(my_dict))
    _tests(
        my_dict,
        MainModel(
            a_prop=ModelA(a_str_prop="a"),
            b_prop=ModelB(b_str_prop="b"),
            c_prop=ModelC(c_str_prop="c"),
        ),
    )


def test_update():
    class ModelA(Model):
        a_str_prop: str = rest_field(name="aStrProp")

    class ModelB(Model):
        b_str_prop: str = rest_field(name="bStrProp")

    class ModelC(Model):
        c_str_prop: str = rest_field(name="cStrProp")

    class MainModel(Model):
        a_prop: ModelA = rest_field(name="aProp")
        b_prop: ModelB = rest_field(name="bProp")
        c_prop: ModelC = rest_field(name="cProp")

    my_dict = {
        "aProp": {"aStrProp": "a"},
        "bProp": {"bStrProp": "b"},
        "cProp": {"cStrProp": "c"},
    }

    def _tests(my_dict: dict[str, Any], my_model: MainModel):
        my_dict = copy.deepcopy(my_dict)  # so we don't get rid of the dict each time we run tests

        assert my_dict["aProp"] == my_model.a_prop == my_model["aProp"] == {"aStrProp": "a"}
        my_dict.update({"aProp": {"aStrProp": "newA"}})
        my_model.a_prop.update({"aStrProp": "newA"})
        assert my_dict["aProp"] == my_model.a_prop == my_model["aProp"] == {"aStrProp": "newA"}

        my_dict["bProp"].update({"newBProp": "hello"})
        my_model.b_prop.update({"newBProp": "hello"})

        assert my_dict["bProp"] == my_model.b_prop == my_model["bProp"] == {"bStrProp": "b", "newBProp": "hello"}

        my_dict.update({"dProp": "hello"})
        my_model.update({"dProp": "hello"})

        assert my_dict["dProp"] == my_model["dProp"] == "hello"

    _tests(my_dict, MainModel(my_dict))
    _tests(
        my_dict,
        MainModel(
            a_prop=ModelA(a_str_prop="a"),
            b_prop=ModelB(b_str_prop="b"),
            c_prop=ModelC(c_str_prop="c"),
        ),
    )


def test_setdefault():
    class Inner(Model):
        str_prop: str = rest_field(name="strProp", default="modelDefault")

    class Outer(Model):
        inner_prop: Inner = rest_field(name="innerProp")

    og_dict = {"innerProp": {}}
    og_dict["innerProp"].setdefault("strProp", "actualDefault")
    og_model = Outer(og_dict)
    og_model.inner_prop.setdefault("strProp", "actualDefault")

    assert og_dict["innerProp"] == og_model["innerProp"] == og_model.inner_prop == {"strProp": "actualDefault"}

    assert (
        og_dict["innerProp"].setdefault("strProp")
        == og_model["innerProp"].setdefault("strProp")
        == og_model.inner_prop.setdefault("strProp")
        == "actualDefault"
    )

    assert og_dict.setdefault("newProp") is og_model.setdefault("newProp") is None
    assert og_dict["newProp"] is og_model["newProp"] is None


def test_repr():
    class ModelA(Model):
        a_str_prop: str = rest_field(name="aStrProp")

    class ModelB(Model):
        b_str_prop: str = rest_field(name="bStrProp")

    class ModelC(Model):
        c_str_prop: str = rest_field(name="cStrProp")

    class MainModel(Model):
        a_prop: ModelA = rest_field(name="aProp")
        b_prop: ModelB = rest_field(name="bProp")
        c_prop: ModelC = rest_field(name="cProp")

    my_dict = {
        "aProp": {"aStrProp": "a"},
        "bProp": {"bStrProp": "b"},
        "cProp": {"cStrProp": "c"},
    }

    assert repr(my_dict) == repr(MainModel(my_dict))


##### REWRITE BODY COMPLEX INTO THIS FILE #####


def test_complex_basic():
    class Basic(Model):
        id: Optional[int] = rest_field(default=None)
        name: Optional[str] = rest_field(default=None)
        color: Optional[Literal["cyan", "Magenta", "YELLOW", "blacK"]] = rest_field(default=None)

        @overload
        def __init__(
            self,
            *,
            id: Optional[int] = None,
            name: Optional[str] = None,
            color: Optional[Literal["cyan", "Magenta", "YELLOW", "blacK"]] = None,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    basic = Basic(id=2, name="abc", color="Magenta")
    assert basic == {"id": 2, "name": "abc", "color": "Magenta"}

    basic.id = 3
    basic.name = "new_name"
    basic.color = "blacK"

    assert basic == {"id": 3, "name": "new_name", "color": "blacK"}

    basic["id"] = 4
    basic["name"] = "newest_name"
    basic["color"] = "YELLOW"

    assert basic == {"id": 4, "name": "newest_name", "color": "YELLOW"}


def test_complex_boolean_wrapper():
    class BooleanWrapper(Model):
        field_true: Optional[bool] = rest_field(default=None)
        field_false: Optional[bool] = rest_field(default=None)

        @overload
        def __init__(
            self,
            *,
            field_true: Optional[bool] = None,
            field_false: Optional[bool] = None,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    bool_model = BooleanWrapper(field_true=True, field_false=False)
    assert bool_model == {"field_true": True, "field_false": False}
    bool_model.field_true = False
    bool_model.field_false = True
    assert bool_model == {"field_true": False, "field_false": True}

    bool_model["field_true"] = True
    bool_model["field_false"] = False
    assert bool_model == {"field_true": True, "field_false": False}


def test_complex_byte_wrapper():
    class ByteWrapper(Model):
        default: Optional[bytes] = rest_field(default=None)
        base64: Optional[bytes] = rest_field(default=None, format="base64")
        base64url: Optional[bytes] = rest_field(default=None, format="base64url")
        list_base64: Optional[list[bytes]] = rest_field(default=None, format="base64")
        map_base64url: Optional[dict[str, bytes]] = rest_field(default=None, format="base64url")

        @overload
        def __init__(
            self,
            *,
            default: Optional[bytes] = None,
            base64: Optional[bytes] = None,
            base64url: Optional[bytes] = None,
            list_base64: Optional[list[bytes]] = None,
            map_base64url: Optional[dict[str, bytes]] = None,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    byte_string = bytes("test", "utf-8")
    mod = ByteWrapper(
        default=byte_string,
        base64=byte_string,
        base64url=byte_string,
        list_base64=[byte_string, byte_string],
        map_base64url={"key1": byte_string, "key2": byte_string},
    )
    decoded = "dGVzdA=="
    decoded_urlsafe = "dGVzdA"

    def _tests(mod: ByteWrapper):
        assert mod == {
            "default": decoded,
            "base64": decoded,
            "base64url": decoded_urlsafe,
            "list_base64": [decoded, decoded],
            "map_base64url": {"key1": decoded_urlsafe, "key2": decoded_urlsafe},
        }
        assert mod.default == byte_string
        assert mod.base64 == byte_string
        assert mod.base64url == byte_string
        assert mod.list_base64 == [byte_string, byte_string]
        assert mod.map_base64url == {"key1": byte_string, "key2": byte_string}
        assert mod["default"] == decoded
        assert mod["base64"] == decoded
        assert mod["base64url"] == decoded_urlsafe
        assert mod["list_base64"] == [decoded, decoded]
        assert mod["map_base64url"] == {
            "key1": decoded_urlsafe,
            "key2": decoded_urlsafe,
        }

    _tests(mod)
    mod.default = byte_string
    mod.base64 = byte_string
    mod.base64url = byte_string
    mod.list_base64 = [byte_string, byte_string]
    mod.map_base64url = {"key1": byte_string, "key2": byte_string}
    _tests(mod)
    mod["default"] = decoded
    mod["base64"] = decoded
    mod["base64url"] = decoded_urlsafe
    mod["list_base64"] = [decoded, decoded]
    mod["map_base64url"] = {"key1": decoded_urlsafe, "key2": decoded_urlsafe}
    _tests(mod)


def test_complex_byte_array_wrapper():
    class ByteArrayWrapper(Model):
        default: Optional[bytearray] = rest_field(default=None)
        base64: Optional[bytearray] = rest_field(default=None, format="base64")
        base64url: Optional[bytearray] = rest_field(default=None, format="base64url")
        list_base64: Optional[list[bytearray]] = rest_field(default=None, format="base64")
        map_base64url: Optional[dict[str, bytearray]] = rest_field(default=None, format="base64url")

        @overload
        def __init__(
            self,
            *,
            default: Optional[bytearray] = None,
            base64: Optional[bytearray] = None,
            base64url: Optional[bytearray] = None,
            list_base64: Optional[list[bytearray]] = None,
            map_base64url: Optional[dict[str, bytearray]] = None,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    byte_array = bytearray("test".encode("utf-8"))
    decoded = "dGVzdA=="
    decoded_urlsafe = "dGVzdA"

    def _tests(model: ByteArrayWrapper):
        assert model == {
            "default": decoded,
            "base64": decoded,
            "base64url": decoded_urlsafe,
            "list_base64": [decoded, decoded],
            "map_base64url": {"key1": decoded_urlsafe, "key2": decoded_urlsafe},
        }
        assert model.default == byte_array
        assert model.base64 == byte_array
        assert model.base64url == byte_array
        assert model.list_base64 == [byte_array, byte_array]
        assert model.map_base64url == {"key1": byte_array, "key2": byte_array}
        assert model["default"] == decoded
        assert model["base64"] == decoded
        assert model["base64url"] == decoded_urlsafe
        assert model["list_base64"] == [decoded, decoded]
        assert model["map_base64url"] == {
            "key1": decoded_urlsafe,
            "key2": decoded_urlsafe,
        }

    _tests(
        ByteArrayWrapper(
            default=byte_array,
            base64=byte_array,
            base64url=byte_array,
            list_base64=[byte_array, byte_array],
            map_base64url={"key1": byte_array, "key2": byte_array},
        )
    )
    _tests(
        ByteArrayWrapper(
            {
                "default": decoded,
                "base64": decoded,
                "base64url": decoded_urlsafe,
                "list_base64": [decoded, decoded],
                "map_base64url": {"key1": decoded_urlsafe, "key2": decoded_urlsafe},
            }
        )
    )


def test_complex_datetime_wrapper():
    class DatetimeWrapper(Model):
        default: datetime.datetime = rest_field(default=None)
        rfc3339: datetime.datetime = rest_field(default=None, format="rfc3339")
        rfc7231: datetime.datetime = rest_field(default=None, format="rfc7231")
        unix: datetime.datetime = rest_field(default=None, format="unix-timestamp")
        list_rfc3339: list[datetime.datetime] = rest_field(default=None, format="rfc3339")
        dict_rfc7231: dict[str, datetime.datetime] = rest_field(default=None, format="rfc7231")

        @overload
        def __init__(
            self,
            *,
            default: Optional[datetime.datetime] = None,
            rfc3339: Optional[datetime.datetime] = None,
            rfc7231: Optional[datetime.datetime] = None,
            unix: Optional[datetime.datetime] = None,
            list_rfc3339: Optional[list[datetime.datetime]] = None,
            dict_rfc7231: Optional[dict[str, datetime.datetime]] = None,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    rfc3339 = "2023-06-27T06:11:09Z"
    rfc7231 = "Tue, 27 Jun 2023 06:11:09 GMT"
    unix = 1687846269
    dt = datetime.datetime(2023, 6, 27, 6, 11, 9, tzinfo=datetime.timezone.utc)

    def _tests(model: DatetimeWrapper):
        assert model["default"] == rfc3339
        assert model["rfc3339"] == rfc3339
        assert model["rfc7231"] == rfc7231
        assert model["unix"] == unix
        assert model["list_rfc3339"] == [rfc3339, rfc3339]
        assert model["dict_rfc7231"] == {"key1": rfc7231, "key2": rfc7231}
        assert model.default == model.rfc3339 == model.rfc7231 == model.unix == dt
        assert model.list_rfc3339 == [dt, dt]
        assert model.dict_rfc7231 == {"key1": dt, "key2": dt}

    _tests(
        DatetimeWrapper(
            default=dt,
            rfc3339=dt,
            rfc7231=dt,
            unix=dt,
            list_rfc3339=[dt, dt],
            dict_rfc7231={"key1": dt, "key2": dt},
        )
    )
    _tests(
        DatetimeWrapper(
            {
                "default": rfc3339,
                "rfc3339": rfc3339,
                "rfc7231": rfc7231,
                "unix": unix,
                "list_rfc3339": [rfc3339, rfc3339],
                "dict_rfc7231": {"key1": rfc7231, "key2": rfc7231},
            }
        )
    )


def test_complex_date_wrapper():
    class DateWrapper(Model):
        field: datetime.date = rest_field(default=None)
        leap: datetime.date = rest_field(default=None)

        @overload
        def __init__(
            self,
            *,
            field: Optional[datetime.date] = None,
            leap: Optional[datetime.date] = None,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    field = "0001-01-01"
    leap = "2016-02-29"

    def _tests(model: DateWrapper):
        assert model.field == isodate.parse_date(field)
        assert model["field"] == field

        assert model.leap == isodate.parse_date(leap)
        assert model["leap"] == leap

        model.field = isodate.parse_date(leap)
        assert model.field == isodate.parse_date(leap)
        assert model["field"] == leap

        model["field"] = field
        assert model.field == isodate.parse_date(field)
        assert model["field"] == field

    _tests(DateWrapper({"field": field, "leap": leap}))
    _tests(DateWrapper(field=isodate.parse_date(field), leap=isodate.parse_date(leap)))


class DictionaryWrapper(Model):
    default_program: dict[str, str] = rest_field(name="defaultProgram", default=None)

    @overload
    def __init__(
        self,
        *,
        default_program: Optional[dict[str, str]] = None,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


default_program = {
    "txt": "notepad",
    "bmp": "mspaint",
    "xls": "excel",
    "exe": "",
    "": None,
}


@pytest.mark.parametrize(
    "model",
    [
        DictionaryWrapper({"defaultProgram": default_program}),
        DictionaryWrapper(default_program=default_program),
    ],
)
def test_complex_dictionary_wrapper(model: DictionaryWrapper):
    assert model == {"defaultProgram": default_program}
    assert model.default_program == model["defaultProgram"] == default_program


@pytest.mark.parametrize(
    "model",
    [DictionaryWrapper({"defaultProgram": {}}), DictionaryWrapper(default_program={})],
)
def test_complex_dictionary_wrapper_empty(model: DictionaryWrapper):
    assert model == {"defaultProgram": {}}
    assert model.default_program == model["defaultProgram"] == {}


@pytest.mark.parametrize(
    "model",
    [
        DictionaryWrapper({"defaultProgram": None}),
        DictionaryWrapper(default_program=None),
    ],
)
def test_complex_dictionary_wrapper_none(model: DictionaryWrapper):
    assert model == {"defaultProgram": None}
    assert model.default_program is None


class ArrayWrapper(Model):
    array: Optional[list[str]] = rest_field(default=None)

    @overload
    def __init__(
        self,
        *,
        array: Optional[list[str]] = None,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


array_value = [
    "1, 2, 3, 4",
    "",
    None,
    "&S#$(*Y",
    "The quick brown fox jumps over the lazy dog",
]


@pytest.mark.parametrize("model", [ArrayWrapper(array=array_value), ArrayWrapper({"array": array_value})])
def test_complex_array_wrapper(model: ArrayWrapper):
    assert model == {"array": array_value}
    assert model.array == model["array"] == array_value

    model.array = None
    with pytest.raises(KeyError):
        model["array"]
    assert model.array is None

    model["array"] = [1, 2, 3, 4, 5]
    assert model.array == ["1", "2", "3", "4", "5"]
    assert model["array"] == ["1", "2", "3", "4", "5"]


@pytest.mark.parametrize("model", [ArrayWrapper(array=[]), ArrayWrapper({"array": []})])
def test_complex_array_wrapper_empty(model: ArrayWrapper):
    assert model == {"array": []}
    assert model.array == model["array"] == []

    model.array = ["bonjour"]
    assert model.array == model["array"] == ["bonjour"]


@pytest.mark.parametrize("model", [ArrayWrapper(array=None), ArrayWrapper({"array": None})])
def test_complex_array_wrapper_none(model: ArrayWrapper):
    assert model == {"array": None}
    assert model.array is model["array"] is None

    model.array = ["bonjour"]
    assert model.array == model["array"] == ["bonjour"]


class PetComplex(Model):
    id: Optional[int] = rest_field(default=None)
    name: Optional[str] = rest_field(default=None)

    @overload
    def __init__(
        self,
        *,
        id: Optional[int] = None,
        name: Optional[str] = None,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class DogComplex(PetComplex):
    food: Optional[str] = rest_field(default=None)

    @overload
    def __init__(
        self,
        *,
        id: Optional[int] = None,
        name: Optional[str] = None,
        food: Optional[str] = None,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


class CatComplex(PetComplex):
    color: Optional[str] = rest_field(default=None)
    hates: Optional[list[DogComplex]] = rest_field(default=None)

    @overload
    def __init__(
        self,
        *,
        id: Optional[int] = None,
        name: Optional[str] = None,
        food: Optional[str] = None,
        color: Optional[str] = None,
        hates: Optional[list[DogComplex]] = None,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any], /): ...

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


@pytest.mark.parametrize(
    "model",
    [
        CatComplex(
            id=2,
            name="Siamese",
            hates=[
                DogComplex(id=1, name="Potato", food="tomato"),
                DogComplex(id=-1, name="Tomato", food="french fries"),
            ],
        ),
        CatComplex(
            id=2,
            name="Siamese",
            hates=[
                DogComplex(id=1, name="Potato", food="tomato"),
                {"id": -1, "name": "Tomato", "food": "french fries"},
            ],
        ),
        CatComplex(
            id=2,
            name="Siamese",
            hates=[
                {"id": 1, "name": "Potato", "food": "tomato"},
                {"id": -1, "name": "Tomato", "food": "french fries"},
            ],
        ),
    ],
)
def test_complex_inheritance(model):
    assert model.id == model["id"] == 2
    assert model.name == model["name"] == "Siamese"
    assert model.hates
    assert model.hates[1] == model["hates"][1] == {"id": -1, "name": "Tomato", "food": "french fries"}
    model["breed"] = "persian"
    model["color"] = "green"
    with pytest.raises(AttributeError):
        model.breed
    assert model == {
        "id": 2,
        "name": "Siamese",
        "color": "green",
        "breed": "persian",
        "hates": [
            DogComplex(id=1, name="Potato", food="tomato"),
            DogComplex(id=-1, name="Tomato", food="french fries"),
        ],
    }


def test_required_prop_not_passed():
    class ModelWithRequiredProperty(Model):
        required_property: int = rest_field(name="requiredProperty")

        @overload
        def __init__(
            self,
            *,
            required_property: int,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    model = ModelWithRequiredProperty()
    assert model.required_property is None
    with pytest.raises(KeyError):
        model["requiredProperty"]

    model = ModelWithRequiredProperty({})
    assert model.required_property is None
    with pytest.raises(KeyError):
        model["requiredProperty"]


def test_null_serialization(core_library):
    dict_response = {
        "name": "it's me!",
        "listOfMe": [
            {
                "name": "it's me!",
            }
        ],
        "dictOfMe": {
            "me": {
                "name": "it's me!",
            }
        },
        "dictOfListOfMe": {
            "many mes": [
                {
                    "name": "it's me!",
                }
            ]
        },
        "listOfDictOfMe": None,
    }
    model = RecursiveModel(dict_response)
    assert json.loads(json.dumps(model, cls=SdkJSONEncoder)) == dict_response

    assert model.as_dict() == dict_response

    model.list_of_me = core_library.serialization.NULL
    model.dict_of_me = None
    model.list_of_dict_of_me = [
        {
            "me": {
                "name": "it's me!",
            }
        }
    ]
    model.dict_of_list_of_me["many mes"][0].list_of_me = core_library.serialization.NULL
    model.dict_of_list_of_me["many mes"][0].dict_of_me = None
    model.list_of_dict_of_me[0]["me"].list_of_me = core_library.serialization.NULL
    model.list_of_dict_of_me[0]["me"].dict_of_me = None

    assert json.loads(json.dumps(model, cls=SdkJSONEncoder)) == {
        "name": "it's me!",
        "listOfMe": None,
        "dictOfListOfMe": {
            "many mes": [
                {
                    "name": "it's me!",
                    "listOfMe": None,
                }
            ]
        },
        "listOfDictOfMe": [
            {
                "me": {
                    "name": "it's me!",
                    "listOfMe": None,
                }
            }
        ],
    }

    assert model.as_dict() == {
        "name": "it's me!",
        "listOfMe": None,
        "dictOfListOfMe": {
            "many mes": [
                {
                    "name": "it's me!",
                    "listOfMe": None,
                }
            ]
        },
        "listOfDictOfMe": [
            {
                "me": {
                    "name": "it's me!",
                    "listOfMe": None,
                }
            }
        ],
    }


class UnionBaseModel(Model):
    name: str = rest_field()

    @overload
    def __init__(self, *, name: str): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class UnionModel1(UnionBaseModel):
    prop1: int = rest_field()

    @overload
    def __init__(self, *, name: str, prop1: int): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class UnionModel2(UnionBaseModel):
    prop2: int = rest_field()

    @overload
    def __init__(self, *, name: str, prop2: int): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


MyNamedUnion = Union["UnionModel1", "UnionModel2"]


class ModelWithNamedUnionProperty(Model):
    named_union: "MyNamedUnion" = rest_field(name="namedUnion")

    @overload
    def __init__(self, *, named_union: "MyNamedUnion"): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class ModelWithSimpleUnionProperty(Model):
    simple_union: Union[int, list[int]] = rest_field(name="simpleUnion")

    @overload
    def __init__(self, *, simple_union: Union[int, list[int]]): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


def test_union():
    simple = ModelWithSimpleUnionProperty(simple_union=1)
    assert simple.simple_union == simple["simpleUnion"] == 1
    simple = ModelWithSimpleUnionProperty(simple_union=[1, 2])
    assert simple.simple_union == simple["simpleUnion"] == [1, 2]
    named = ModelWithNamedUnionProperty()
    assert not _is_model(named.named_union)
    named.named_union = UnionModel1(name="model1", prop1=1)
    assert _is_model(named.named_union)
    assert named.named_union == named["namedUnion"] == {"name": "model1", "prop1": 1}
    named = ModelWithNamedUnionProperty(named_union=UnionModel2(name="model2", prop2=2))
    assert named.named_union == named["namedUnion"] == {"name": "model2", "prop2": 2}
    named = ModelWithNamedUnionProperty({"namedUnion": {"name": "model2", "prop2": 2}})
    assert named.named_union == named["namedUnion"] == {"name": "model2", "prop2": 2}


def test_as_dict():
    class CatComplex(PetComplex):
        color: Optional[str] = rest_field(default=None)
        hates: Optional[list[DogComplex]] = rest_field(default=None, visibility=["read"])

        @overload
        def __init__(
            self,
            *,
            id: Optional[int] = None,
            name: Optional[str] = None,
            food: Optional[str] = None,
            color: Optional[str] = None,
            hates: Optional[list[DogComplex]] = None,
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    model = CatComplex(
        id=2,
        name="Siamese",
        hates=[
            DogComplex(id=1, name="Potato", food="tomato"),
            DogComplex(id=-1, name="Tomato", food="french fries"),
        ],
    )
    assert model.as_dict(exclude_readonly=True) == {
        "id": 2,
        "name": "Siamese",
        "color": None,
    }


class Fish(Model):
    __mapping__: dict[str, Model] = {}
    age: int = rest_field()
    kind: Literal[None] = rest_discriminator(name="kind")

    @overload
    def __init__(
        self,
        *,
        age: int,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
        self.kind: Literal[None] = None


class Shark(Fish, discriminator="shark"):
    __mapping__: dict[str, Model] = {}
    kind: Literal["shark"] = rest_discriminator(name="kind")
    sharktype: Literal[None] = rest_discriminator(name="sharktype")

    @overload
    def __init__(
        self,
        *,
        age: int,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
        self.kind: Literal["shark"] = "shark"
        self.sharktype: Literal[None] = None


class GoblinShark(Shark, discriminator="goblin"):
    sharktype: Literal["goblin"] = rest_discriminator(name="sharktype")

    @overload
    def __init__(
        self,
        *,
        age: int,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
        self.sharktype: Literal["goblin"] = "goblin"


class Salmon(Fish, discriminator="salmon"):
    kind: Literal["salmon"] = rest_discriminator(name="kind")
    friends: Optional[list["Fish"]] = rest_field()
    hate: Optional[dict[str, "Fish"]] = rest_field()
    partner: Optional["Fish"] = rest_field()

    @overload
    def __init__(
        self,
        *,
        age: int,
        friends: Optional[list["Fish"]] = None,
        hate: Optional[dict[str, "Fish"]] = None,
        partner: Optional["Fish"] = None,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
        self.kind: Literal["salmon"] = "salmon"


class SawShark(Shark, discriminator="saw"):
    sharktype: Literal["saw"] = rest_discriminator(name="sharktype")

    @overload
    def __init__(
        self,
        *,
        age: int,
    ): ...

    @overload
    def __init__(self, mapping: Mapping[str, Any]): ...

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
        self.sharktype: Literal["saw"] = "saw"


def test_discriminator():
    input = {
        "age": 1,
        "kind": "salmon",
        "partner": {
            "age": 2,
            "kind": "shark",
            "sharktype": "saw",
        },
        "friends": [
            {
                "age": 2,
                "kind": "salmon",
                "partner": {
                    "age": 3,
                    "kind": "salmon",
                },
                "hate": {
                    "key1": {
                        "age": 4,
                        "kind": "salmon",
                    },
                    "key2": {
                        "age": 2,
                        "kind": "shark",
                        "sharktype": "goblin",
                    },
                },
            },
            {
                "age": 3,
                "kind": "shark",
                "sharktype": "goblin",
            },
        ],
        "hate": {
            "key3": {
                "age": 3,
                "kind": "shark",
                "sharktype": "saw",
            },
            "key4": {
                "age": 2,
                "kind": "salmon",
                "friends": [
                    {
                        "age": 1,
                        "kind": "salmon",
                    },
                    {
                        "age": 4,
                        "kind": "shark",
                        "sharktype": "goblin",
                    },
                ],
            },
        },
    }

    model = Salmon(input)
    assert model == input
    assert model.partner.age == 2
    assert model.partner == SawShark(age=2)
    assert model.friends[0].hate["key2"] == GoblinShark(age=2)


def test_body_bytes_format():
    assert json.dumps(bytes("test", "utf-8"), cls=SdkJSONEncoder) == '"dGVzdA=="'
    assert json.dumps(bytearray("test", "utf-8"), cls=SdkJSONEncoder) == '"dGVzdA=="'
    assert json.dumps(bytes("test", "utf-8"), cls=SdkJSONEncoder, format="base64") == '"dGVzdA=="'
    assert json.dumps(bytes("test", "utf-8"), cls=SdkJSONEncoder, format="base64url") == '"dGVzdA"'
    assert json.dumps(bytearray("test", "utf-8"), cls=SdkJSONEncoder, format="base64") == '"dGVzdA=="'
    assert json.dumps(bytearray("test", "utf-8"), cls=SdkJSONEncoder, format="base64url") == '"dGVzdA"'

    assert (
        json.dumps([bytes("test", "utf-8"), bytes("test", "utf-8")], cls=SdkJSONEncoder) == '["dGVzdA==", "dGVzdA=="]'
    )
    assert (
        json.dumps([bytearray("test", "utf-8"), bytearray("test", "utf-8")], cls=SdkJSONEncoder)
        == '["dGVzdA==", "dGVzdA=="]'
    )
    assert (
        json.dumps(
            [bytes("test", "utf-8"), bytes("test", "utf-8")],
            cls=SdkJSONEncoder,
            format="base64",
        )
        == '["dGVzdA==", "dGVzdA=="]'
    )
    assert (
        json.dumps(
            [bytes("test", "utf-8"), bytes("test", "utf-8")],
            cls=SdkJSONEncoder,
            format="base64url",
        )
        == '["dGVzdA", "dGVzdA"]'
    )
    assert (
        json.dumps(
            [bytearray("test", "utf-8"), bytearray("test", "utf-8")],
            cls=SdkJSONEncoder,
            format="base64",
        )
        == '["dGVzdA==", "dGVzdA=="]'
    )
    assert (
        json.dumps(
            [bytearray("test", "utf-8"), bytearray("test", "utf-8")],
            cls=SdkJSONEncoder,
            format="base64url",
        )
        == '["dGVzdA", "dGVzdA"]'
    )

    assert (
        json.dumps(
            {"a": bytes("test", "utf-8"), "b": bytes("test", "utf-8")},
            cls=SdkJSONEncoder,
        )
        == '{"a": "dGVzdA==", "b": "dGVzdA=="}'
    )
    assert (
        json.dumps(
            {"a": bytearray("test", "utf-8"), "b": bytearray("test", "utf-8")},
            cls=SdkJSONEncoder,
        )
        == '{"a": "dGVzdA==", "b": "dGVzdA=="}'
    )
    assert (
        json.dumps(
            {"a": bytes("test", "utf-8"), "b": bytes("test", "utf-8")},
            cls=SdkJSONEncoder,
            format="base64",
        )
        == '{"a": "dGVzdA==", "b": "dGVzdA=="}'
    )
    assert (
        json.dumps(
            {"a": bytes("test", "utf-8"), "b": bytes("test", "utf-8")},
            cls=SdkJSONEncoder,
            format="base64url",
        )
        == '{"a": "dGVzdA", "b": "dGVzdA"}'
    )
    assert (
        json.dumps(
            {"a": bytearray("test", "utf-8"), "b": bytearray("test", "utf-8")},
            cls=SdkJSONEncoder,
            format="base64",
        )
        == '{"a": "dGVzdA==", "b": "dGVzdA=="}'
    )
    assert (
        json.dumps(
            {"a": bytearray("test", "utf-8"), "b": bytearray("test", "utf-8")},
            cls=SdkJSONEncoder,
            format="base64url",
        )
        == '{"a": "dGVzdA", "b": "dGVzdA"}'
    )


def test_decimal_deserialization():
    class DecimalModel(Model):
        decimal_value: decimal.Decimal = rest_field(name="decimalValue")

        @overload
        def __init__(self, *, decimal_value: decimal.Decimal): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    model = DecimalModel({"decimalValue": 0.33333})
    assert model["decimalValue"] == 0.33333
    assert model.decimal_value == decimal.Decimal("0.33333")

    class BaseModel(Model):
        my_prop: DecimalModel = rest_field(name="myProp")

    model = BaseModel({"myProp": {"decimalValue": 0.33333}})
    assert isinstance(model.my_prop, DecimalModel)
    assert model.my_prop["decimalValue"] == model["myProp"]["decimalValue"] == 0.33333
    assert model.my_prop.decimal_value == decimal.Decimal("0.33333")


def test_decimal_serialization():
    assert json.dumps(decimal.Decimal("0.33333"), cls=SdkJSONEncoder) == "0.33333"
    assert (
        json.dumps([decimal.Decimal("0.33333"), decimal.Decimal("0.33333")], cls=SdkJSONEncoder) == "[0.33333, 0.33333]"
    )
    assert (
        json.dumps(
            {"a": decimal.Decimal("0.33333"), "b": decimal.Decimal("0.33333")},
            cls=SdkJSONEncoder,
        )
        == '{"a": 0.33333, "b": 0.33333}'
    )


def test_int_as_str_deserialization():
    class IntAsStrModel(Model):
        int_as_str_value: int = rest_field(name="intAsStrValue", format="str")

    model = IntAsStrModel({"intAsStrValue": "123"})
    assert model["intAsStrValue"] == "123"
    assert model.int_as_str_value == 123

    class BaseModel(Model):
        my_prop: IntAsStrModel = rest_field(name="myProp")

    model = BaseModel({"myProp": {"intAsStrValue": "123"}})
    assert isinstance(model.my_prop, IntAsStrModel)
    assert model.my_prop["intAsStrValue"] == model["myProp"]["intAsStrValue"] == "123"
    assert model.my_prop.int_as_str_value == 123


def test_deserialize():
    expected = {"name": "name", "role": "role"}
    result = _deserialize(JSON, expected)
    assert result == expected


def test_enum_deserialization():
    class MyEnum(Enum):
        A = "a"
        B = "b"

    class ModelWithEnumProperty(Model):
        enum_property: Union[str, MyEnum] = rest_field(name="enumProperty")
        enum_property_optional: Optional[Union[str, MyEnum]] = rest_field(name="enumPropertyOptional")
        enum_property_optional_none: Optional[Union[str, MyEnum]] = rest_field(name="enumPropertyOptionalNone")

    raw_input = {
        "enumProperty": "a",
        "enumPropertyOptional": "b",
        "enumPropertyOptionalNone": None,
    }

    def check_func(target: ModelWithEnumProperty):
        assert target.enum_property == MyEnum.A
        assert target["enumProperty"] == "a"
        assert isinstance(target.enum_property, Enum)
        assert isinstance(target["enumProperty"], str)

        assert target.enum_property_optional == MyEnum.B
        assert target["enumPropertyOptional"] == "b"
        assert isinstance(target.enum_property_optional, Enum)
        assert isinstance(target["enumPropertyOptional"], str)

        assert target.enum_property_optional_none is None
        assert target["enumPropertyOptionalNone"] is None

    model = ModelWithEnumProperty(raw_input)
    check_func(model)

    result = _deserialize(list[ModelWithEnumProperty], [raw_input])
    for item in result:
        check_func(item)


def test_not_mutating_original_dict():
    class MyInnerModel(Model):
        property: str = rest_field()

    class MyModel(Model):
        property: MyInnerModel = rest_field()

    origin = {"property": {"property": "hello"}}

    dpg_model = MyModel(origin)
    assert dpg_model["property"]["property"] == "hello"

    origin["property"]["property"] = "world"
    assert dpg_model["property"]["property"] == "hello"


def test_model_init_io():
    class BytesModel(Model):
        property: bytes = rest_field()

    JPG = Path(__file__).parent.parent / "data/image.jpg"
    with open(JPG, "rb") as f:
        b = BytesModel({"property": f})
        assert b.property == f
        assert b["property"] == f
    with open(JPG, "rb") as f:
        b = BytesModel(property=f)
        assert b.property == f
        assert b["property"] == f


def test_additional_properties_serialization():
    value = {
        "name": "test",
        "modelProp": {"name": "test"},
        "stringProp": "string",
        "intProp": 1,
        "floatProp": 1.0,
        "boolProp": True,
        "listProp": [1, 2, 3],
        "dictProp": {"key": "value"},
        "noneProp": None,
        "datetimeProp": "2023-06-27T06:11:09Z",
        "durationProp": "P1D",
    }

    class NormalModel(Model):
        prop: str = rest_field(name="name")

    class AdditionalPropertiesModel(Model):
        name: str = rest_field(name="name")

    model = AdditionalPropertiesModel(name="test")
    prop = NormalModel(prop="test")
    model["modelProp"] = prop
    model["stringProp"] = "string"
    model["intProp"] = 1
    model["floatProp"] = 1.0
    model["boolProp"] = True
    model["listProp"] = [1, 2, 3]
    model["dictProp"] = {"key": "value"}
    model["noneProp"] = None
    model["datetimeProp"] = datetime.datetime(2023, 6, 27, 6, 11, 9, tzinfo=datetime.timezone.utc)
    model["durationProp"] = datetime.timedelta(days=1)

    assert json.loads(json.dumps(model, cls=SdkJSONEncoder)) == value


class Animal(Model):
    __mapping__: dict[str, Model] = {}
    kind: str = rest_discriminator(name="kind")
    name: str = rest_field()

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)


class AnotherPet(Animal, discriminator="pet"):
    __mapping__: dict[str, Model] = {}
    kind: Literal["pet"] = rest_discriminator(name="kind")
    trained: bool = rest_field()

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
        self.kind = "pet"


class AnotherDog(AnotherPet, discriminator="dog"):
    kind: Literal["dog"] = rest_discriminator(name="kind")
    breed: str = rest_field()

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
        self.kind = "dog"


def test_multi_layer_discriminator():
    pet = {"kind": "pet", "name": "Buddy", "trained": True}

    dog = {"kind": "dog", "name": "Rex", "trained": True, "breed": "German Shepherd"}

    model_pet = AnotherPet(pet)
    assert model_pet == pet

    model_dog = AnotherDog(dog)
    assert model_dog == dog

    assert _deserialize(Animal, pet) == model_pet
    assert _deserialize(Animal, dog) == model_dog
    assert _deserialize(AnotherPet, dog) == model_dog

    assert AnotherPet(name="Buddy", trained=True) == model_pet
    assert AnotherDog(name="Rex", trained=True, breed="German Shepherd") == model_dog


def test_array_encode_comma_delimited():
    """Test commaDelimited format for array of strings"""

    class CommaDelimitedModel(Model):
        colors: list[str] = rest_field(format="commaDelimited")

        @overload
        def __init__(self, *, colors: list[str]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    # Test serialization: list[str] -> comma-delimited string
    model = CommaDelimitedModel(colors=["blue", "red", "green"])
    assert model.colors == ["blue", "red", "green"]
    assert model["colors"] == "blue,red,green"

    # Test deserialization: comma-delimited string -> list[str]
    model = CommaDelimitedModel({"colors": "blue,red,green"})
    assert model.colors == ["blue", "red", "green"]
    assert model["colors"] == "blue,red,green"

    # Test with empty list
    model = CommaDelimitedModel(colors=[])
    assert model.colors == []
    assert model["colors"] == ""

    # Test with single item
    model = CommaDelimitedModel(colors=["blue"])
    assert model.colors == ["blue"]
    assert model["colors"] == "blue"


def test_array_encode_pipe_delimited():
    """Test pipeDelimited format for array of strings"""

    class PipeDelimitedModel(Model):
        colors: list[str] = rest_field(format="pipeDelimited")

        @overload
        def __init__(self, *, colors: list[str]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    # Test serialization: list[str] -> pipe-delimited string
    model = PipeDelimitedModel(colors=["blue", "red", "green"])
    assert model.colors == ["blue", "red", "green"]
    assert model["colors"] == "blue|red|green"

    # Test deserialization: pipe-delimited string -> list[str]
    model = PipeDelimitedModel({"colors": "blue|red|green"})
    assert model.colors == ["blue", "red", "green"]
    assert model["colors"] == "blue|red|green"

    # Test with empty list
    model = PipeDelimitedModel(colors=[])
    assert model.colors == []
    assert model["colors"] == ""


def test_array_encode_space_delimited():
    """Test spaceDelimited format for array of strings"""

    class SpaceDelimitedModel(Model):
        colors: list[str] = rest_field(format="spaceDelimited")

        @overload
        def __init__(self, *, colors: list[str]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    # Test serialization: list[str] -> space-delimited string
    model = SpaceDelimitedModel(colors=["blue", "red", "green"])
    assert model.colors == ["blue", "red", "green"]
    assert model["colors"] == "blue red green"

    # Test deserialization: space-delimited string -> list[str]
    model = SpaceDelimitedModel({"colors": "blue red green"})
    assert model.colors == ["blue", "red", "green"]
    assert model["colors"] == "blue red green"

    # Test with empty list
    model = SpaceDelimitedModel(colors=[])
    assert model.colors == []
    assert model["colors"] == ""


def test_array_encode_newline_delimited():
    """Test newlineDelimited format for array of strings"""

    class NewlineDelimitedModel(Model):
        colors: list[str] = rest_field(format="newlineDelimited")

        @overload
        def __init__(self, *, colors: list[str]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    # Test serialization: list[str] -> newline-delimited string
    model = NewlineDelimitedModel(colors=["blue", "red", "green"])
    assert model.colors == ["blue", "red", "green"]
    assert model["colors"] == "blue\nred\ngreen"

    # Test deserialization: newline-delimited string -> list[str]
    model = NewlineDelimitedModel({"colors": "blue\nred\ngreen"})
    assert model.colors == ["blue", "red", "green"]
    assert model["colors"] == "blue\nred\ngreen"

    # Test with empty list
    model = NewlineDelimitedModel(colors=[])
    assert model.colors == []
    assert model["colors"] == ""


def test_array_encode_optional():
    """Test array encoding with optional fields"""

    class OptionalEncodedModel(Model):
        colors: Optional[list[str]] = rest_field(default=None, format="commaDelimited")

        @overload
        def __init__(self, *, colors: Optional[list[str]] = None): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    # Test with None
    model = OptionalEncodedModel(colors=None)
    assert model.colors is None
    assert model["colors"] is None

    # Test with value
    model = OptionalEncodedModel(colors=["blue", "red"])
    assert model.colors == ["blue", "red"]
    assert model["colors"] == "blue,red"

    # Test deserialization with None
    model = OptionalEncodedModel({"colors": None})
    assert model.colors is None


def test_array_encode_modification():
    """Test modifying array-encoded fields"""

    class ModifiableModel(Model):
        colors: list[str] = rest_field(format="commaDelimited")

        @overload
        def __init__(self, *, colors: list[str]): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    model = ModifiableModel(colors=["blue", "red"])
    assert model.colors == ["blue", "red"]
    assert model["colors"] == "blue,red"

    # Modify through property
    model.colors = ["green", "yellow", "purple"]
    assert model.colors == ["green", "yellow", "purple"]
    assert model["colors"] == "green,yellow,purple"

    # Modify through dict access
    model["colors"] = "orange,pink"
    assert model.colors == ["orange", "pink"]
    assert model["colors"] == "orange,pink"


def test_array_encode_json_roundtrip():
    """Test JSON serialization and deserialization with array encoding"""

    class JsonModel(Model):
        pipe_colors: list[str] = rest_field(name="pipeColors", format="pipeDelimited")
        comma_colors: list[str] = rest_field(name="commaColors", format="commaDelimited")

        @overload
        def __init__(
            self,
            *,
            pipe_colors: list[str],
            comma_colors: list[str],
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    model = JsonModel(
        pipe_colors=["blue", "red", "green"],
        comma_colors=["small", "medium", "large"],
    )

    # Serialize to JSON
    json_str = json.dumps(dict(model), cls=SdkJSONEncoder)
    assert json.loads(json_str) == {
        "pipeColors": "blue|red|green",
        "commaColors": "small,medium,large",
    }

    # Deserialize from JSON
    deserialized = JsonModel(json.loads(json_str))
    assert deserialized.pipe_colors == ["blue", "red", "green"]
    assert deserialized.comma_colors == ["small", "medium", "large"]


def test_array_encode_with_special_characters():
    """Test array encoding with strings containing special characters"""

    class SpecialCharsModel(Model):
        comma_values: list[str] = rest_field(name="commaValues", format="commaDelimited")
        pipe_values: list[str] = rest_field(name="pipeValues", format="pipeDelimited")

        @overload
        def __init__(
            self,
            *,
            comma_values: list[str],
            pipe_values: list[str],
        ): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    # Test with strings that might contain delimiters
    # Note: In real usage, the strings should not contain the delimiter character
    # This test documents current behavior
    model = SpecialCharsModel(
        comma_values=["value with spaces", "another-value", "value_3"],
        pipe_values=["path/to/file", "another-path", "final.path"],
    )

    assert model.comma_values == ["value with spaces", "another-value", "value_3"]
    assert model["commaValues"] == "value with spaces,another-value,value_3"

    assert model.pipe_values == ["path/to/file", "another-path", "final.path"]
    assert model["pipeValues"] == "path/to/file|another-path|final.path"


def test_dictionary_set():
    """Test that dictionary mutations via attribute syntax persist and sync to dictionary syntax."""

    class MyModel(Model):
        my_dict: dict[str, int] = rest_field(visibility=["read", "create", "update", "delete", "query"])

    # Test 1: Basic mutation via attribute syntax
    m = MyModel(my_dict={"a": 1, "b": 2})
    assert m.my_dict == {"a": 1, "b": 2}

    # Test 2: Add new key via attribute syntax and verify it persists
    m.my_dict["c"] = 3
    assert m.my_dict["c"] == 3
    assert m.my_dict == {"a": 1, "b": 2, "c": 3}

    # Test 3: Verify mutation is reflected in dictionary syntax
    assert m["my_dict"] == {"a": 1, "b": 2, "c": 3}

    # Test 4: Modify existing key via attribute syntax
    m.my_dict["a"] = 100
    assert m.my_dict["a"] == 100
    assert m["my_dict"]["a"] == 100

    # Test 5: Delete key via attribute syntax
    del m.my_dict["b"]
    assert "b" not in m.my_dict
    assert "b" not in m["my_dict"]

    # Test 6: Update via dict methods
    m.my_dict.update({"d": 4, "e": 5})
    assert m.my_dict["d"] == 4
    assert m.my_dict["e"] == 5
    assert m["my_dict"]["d"] == 4

    # Test 7: Clear via attribute syntax and verify via dictionary syntax
    m.my_dict.clear()
    assert len(m.my_dict) == 0
    assert len(m["my_dict"]) == 0

    # Test 8: Reassign entire dictionary via attribute syntax
    m.my_dict = {"x": 10, "y": 20}
    assert m.my_dict == {"x": 10, "y": 20}
    assert m["my_dict"] == {"x": 10, "y": 20}

    # Test 9: Mutation after reassignment
    m.my_dict["z"] = 30
    assert m.my_dict["z"] == 30
    assert m["my_dict"]["z"] == 30

    # Test 10: Access via dictionary syntax first, then mutate via attribute syntax
    m.my_dict["w"] = 40
    assert m["my_dict"]["w"] == 40

    # Test 11: Multiple accesses maintain same cached object
    dict_ref1 = m.my_dict
    dict_ref2 = m.my_dict
    assert dict_ref1 is dict_ref2
    dict_ref1["new_key"] = 999
    assert dict_ref2["new_key"] == 999
    assert m.my_dict["new_key"] == 999


def test_list_set():
    """Test that list mutations via attribute syntax persist and sync to dictionary syntax."""

    class MyModel(Model):
        my_list: list[int] = rest_field(visibility=["read", "create", "update", "delete", "query"])

    # Test 1: Basic mutation via attribute syntax
    m = MyModel(my_list=[1, 2, 3])
    assert m.my_list == [1, 2, 3]

    # Test 2: Append via attribute syntax and verify it persists
    m.my_list.append(4)
    assert m.my_list == [1, 2, 3, 4]

    # Test 3: Verify mutation is reflected in dictionary syntax
    assert m["my_list"] == [1, 2, 3, 4]

    # Test 4: Modify existing element via attribute syntax
    m.my_list[0] = 100
    assert m.my_list[0] == 100
    assert m["my_list"][0] == 100

    # Test 5: Extend list via attribute syntax
    m.my_list.extend([5, 6])
    assert m.my_list == [100, 2, 3, 4, 5, 6]
    assert m["my_list"] == [100, 2, 3, 4, 5, 6]

    # Test 6: Remove element via attribute syntax
    m.my_list.remove(2)
    assert 2 not in m.my_list
    assert 2 not in m["my_list"]

    # Test 7: Pop element
    popped = m.my_list.pop()
    assert popped == 6
    assert 6 not in m.my_list
    assert 6 not in m["my_list"]

    # Test 8: Insert element
    m.my_list.insert(0, 999)
    assert m.my_list[0] == 999
    assert m["my_list"][0] == 999

    # Test 9: Clear via attribute syntax
    m.my_list.clear()
    assert len(m.my_list) == 0
    assert len(m["my_list"]) == 0

    # Test 10: Reassign entire list via attribute syntax
    m.my_list = [10, 20, 30]
    assert m.my_list == [10, 20, 30]
    assert m["my_list"] == [10, 20, 30]

    # Test 11: Mutation after reassignment
    m.my_list.append(40)
    assert m.my_list == [10, 20, 30, 40]
    assert m["my_list"] == [10, 20, 30, 40]

    # Test 12: Multiple accesses maintain same cached object
    list_ref1 = m.my_list
    list_ref2 = m.my_list
    assert list_ref1 is list_ref2
    list_ref1.append(50)
    assert 50 in list_ref2
    assert 50 in m.my_list


def test_set_collection():
    """Test that set mutations via attribute syntax persist and sync to dictionary syntax."""

    class MyModel(Model):
        my_set: set[int] = rest_field(visibility=["read", "create", "update", "delete", "query"])

    # Test 1: Basic mutation via attribute syntax
    m = MyModel(my_set={1, 2, 3})
    assert m.my_set == {1, 2, 3}

    # Test 2: Add via attribute syntax and verify it persists
    m.my_set.add(4)
    assert 4 in m.my_set

    # Test 3: Verify mutation is reflected in dictionary syntax
    assert 4 in m["my_set"]

    # Test 4: Remove element via attribute syntax
    m.my_set.remove(2)
    assert 2 not in m.my_set
    assert 2 not in m["my_set"]

    # Test 5: Update set via attribute syntax
    m.my_set.update({5, 6, 7})
    assert m.my_set == {1, 3, 4, 5, 6, 7}
    assert m["my_set"] == {1, 3, 4, 5, 6, 7}

    # Test 6: Discard element
    m.my_set.discard(1)
    assert 1 not in m.my_set
    assert 1 not in m["my_set"]

    # Test 7: Clear via attribute syntax
    m.my_set.clear()
    assert len(m.my_set) == 0
    assert len(m["my_set"]) == 0

    # Test 8: Reassign entire set via attribute syntax
    m.my_set = {10, 20, 30}
    assert m.my_set == {10, 20, 30}
    assert m["my_set"] == {10, 20, 30}

    # Test 9: Mutation after reassignment
    m.my_set.add(40)
    assert 40 in m.my_set
    assert 40 in m["my_set"]

    # Test 10: Multiple accesses maintain same cached object
    set_ref1 = m.my_set
    set_ref2 = m.my_set
    assert set_ref1 is set_ref2
    set_ref1.add(50)
    assert 50 in set_ref2
    assert 50 in m.my_set


def test_dictionary_set_datetime():
    """Test that dictionary with datetime values properly serializes/deserializes."""
    from datetime import datetime, timezone

    class MyModel(Model):
        my_dict: dict[str, datetime] = rest_field(visibility=["read", "create", "update", "delete", "query"])

    # Test 1: Initialize with datetime values
    dt1 = datetime(2023, 1, 15, 10, 30, 45, tzinfo=timezone.utc)
    dt2 = datetime(2023, 6, 20, 14, 15, 30, tzinfo=timezone.utc)
    m = MyModel(my_dict={"created": dt1, "updated": dt2})

    # Test 2: Access via attribute syntax returns datetime objects
    assert isinstance(m.my_dict["created"], datetime)
    assert isinstance(m.my_dict["updated"], datetime)
    assert m.my_dict["created"] == dt1
    assert m.my_dict["updated"] == dt2

    # Test 3: Access via dictionary syntax returns serialized strings (ISO format)
    dict_access = m["my_dict"]
    assert isinstance(dict_access["created"], str)
    assert isinstance(dict_access["updated"], str)
    assert dict_access["created"] == "2023-01-15T10:30:45Z"
    assert dict_access["updated"] == "2023-06-20T14:15:30Z"

    # Test 4: Mutate via attribute syntax with new datetime
    dt3 = datetime(2023, 12, 25, 18, 0, 0, tzinfo=timezone.utc)
    m.my_dict["holiday"] = dt3
    assert m.my_dict["holiday"] == dt3

    # Test 5: Verify mutation is serialized in dictionary syntax
    assert m["my_dict"]["holiday"] == "2023-12-25T18:00:00Z"

    # Test 6: Update existing datetime via attribute syntax
    dt4 = datetime(2024, 1, 1, 0, 0, 0, tzinfo=timezone.utc)
    m.my_dict["created"] = dt4
    assert m.my_dict["created"] == dt4
    assert m["my_dict"]["created"] == "2024-01-01T00:00:00Z"

    # Test 7: Verify all datetimes are deserialized correctly after mutation
    assert isinstance(m.my_dict["created"], datetime)
    assert isinstance(m.my_dict["updated"], datetime)
    assert isinstance(m.my_dict["holiday"], datetime)

    # Test 8: Use dict update method with datetimes
    dt5 = datetime(2024, 6, 15, 12, 30, 0, tzinfo=timezone.utc)
    dt6 = datetime(2024, 7, 4, 16, 45, 0, tzinfo=timezone.utc)
    m.my_dict.update({"event1": dt5, "event2": dt6})
    assert m.my_dict["event1"] == dt5
    assert m["my_dict"]["event1"] == "2024-06-15T12:30:00Z"

    # Test 9: Reassign entire dictionary with new datetimes
    dt7 = datetime(2025, 1, 1, 0, 0, 0, tzinfo=timezone.utc)
    dt8 = datetime(2025, 12, 31, 23, 59, 59, tzinfo=timezone.utc)
    m.my_dict = {"start": dt7, "end": dt8}
    assert m.my_dict["start"] == dt7
    assert m.my_dict["end"] == dt8
    assert m["my_dict"]["start"] == "2025-01-01T00:00:00Z"
    assert m["my_dict"]["end"] == "2025-12-31T23:59:59Z"

    # Test 10: Cached object maintains datetime type
    dict_ref1 = m.my_dict
    dict_ref2 = m.my_dict
    assert dict_ref1 is dict_ref2
    assert isinstance(dict_ref1["start"], datetime)
    assert isinstance(dict_ref2["start"], datetime)


def test_eq_same_model_instances():
    """Two model instances with the same data should be equal."""
    model1 = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    model2 = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    assert model1 == model2


def test_eq_different_model_data():
    """Two model instances with different data should not be equal."""
    model1 = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    model2 = BasicResource(
        platform_update_domain_count=10,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    assert model1 != model2


def test_eq_model_constructed_from_dict():
    """A model created via kwargs and a model created from a dict should be equal."""
    dict_response = {
        "platformUpdateDomainCount": 5,
        "platformFaultDomainCount": 3,
        "virtualMachines": [],
    }
    model_from_kwargs = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    model_from_dict = BasicResource(dict_response)
    assert model_from_kwargs == model_from_dict


def test_eq_model_equal_to_plain_dict():
    """A model should be equal to a plain dict with matching data (backward compat)."""
    dict_response = {
        "platformUpdateDomainCount": 5,
        "platformFaultDomainCount": 3,
        "virtualMachines": [],
    }
    model = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    assert model == dict_response


def test_eq_model_not_equal_to_non_model_types():
    """A model should not be equal to strings, ints, None, or lists."""
    model = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    assert model != "some string"
    assert model != 42
    assert model != None  # noqa: E711
    assert model != []
    assert model != True  # noqa: E712


def test_eq_different_model_types_same_data():
    """Two different model types with the same underlying _data should be equal
    since isinstance checks against _MyMutableMapping, not the specific subclass."""
    model1 = Pet(name="test", species="dog")

    class AnotherModel(Model):
        name: str = rest_field()
        species: str = rest_field()

        @overload
        def __init__(self, *, name: str, species: str): ...

        @overload
        def __init__(self, mapping: Mapping[str, Any], /): ...

        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)

    model2 = AnotherModel(name="test", species="dog")
    assert model1 == model2


def test_ne_is_inverse_of_eq():
    """__ne__ should return the inverse of __eq__."""
    model1 = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    model2 = BasicResource(
        platform_update_domain_count=5,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    model3 = BasicResource(
        platform_update_domain_count=10,
        platform_fault_domain_count=3,
        virtual_machines=[],
    )
    assert not (model1 != model2)
    assert model1 != model3


def test_eq_nested_models():
    """Two models with identical nested model children should be equal."""
    model1 = OptionalModel(
        optional_str="hello",
        optional_time=datetime.time(11, 34, 56),
        optional_dict={
            "buddy": Pet(name="Buddy", species="Dog"),
        },
        optional_myself=OptionalModel(optional_str="inner"),
    )
    model2 = OptionalModel(
        optional_str="hello",
        optional_time=datetime.time(11, 34, 56),
        optional_dict={
            "buddy": Pet(name="Buddy", species="Dog"),
        },
        optional_myself=OptionalModel(optional_str="inner"),
    )
    assert model1 == model2

    # Change the nested model's data — they should no longer be equal
    model2_different_inner = OptionalModel(
        optional_str="hello",
        optional_time=datetime.time(11, 34, 56),
        optional_dict={
            "buddy": Pet(name="Buddy", species="Dog"),
        },
        optional_myself=OptionalModel(optional_str="different"),
    )
    assert model1 != model2_different_inner

    # Change the nested Pet — they should no longer be equal
    model2_different_pet = OptionalModel(
        optional_str="hello",
        optional_time=datetime.time(11, 34, 56),
        optional_dict={
            "buddy": Pet(name="Max", species="Cat"),
        },
        optional_myself=OptionalModel(optional_str="inner"),
    )
    assert model1 != model2_different_pet
