from collections import defaultdict
from dataclasses import dataclass, field, _asdict_inner
from time import time
from typing import NamedTuple, Union, Optional

from decimal import Decimal


@dataclass
class Node:
    children: dict[str, "Node"] | None


def dict_proxy(arg):
    return dict(arg)


class Child(NamedTuple):
    child: Union["Child", None]


@dataclass
class NTContainer:
    child: Child


@dataclass
class P:
    ps: list["P"]


@dataclass
class RecipeParams:
    diets: list[str] = field(default_factory=lambda: [])
    ingredients: list[str] = field(default_factory=lambda: [])
    limit: Optional[int] = None
    recipe_ids: set[str] = field(default_factory=lambda: set())
    search_str: Optional[str] = None
    seconds_min: Optional[int] = None
    seconds_max: Optional[int] = None
    tags: list[str] = field(default_factory=lambda: [])
    username: Optional[str] = None
    uses_recipe_id: Optional[str] = None


@dataclass
class T:
    children: tuple["T", ...]

class X:
    def __init__(self, a, b):
        self.a = a
        self.b = b


@dataclass
class AtomicTypesAndFallThroughTypes:
    s: str
    i: int
    f: float
    d: Decimal
    x: X

@dataclass
class DefDict:
    dd: defaultdict[str, int]


ex_1 = Node(
    {"a": Node(None),
     "b": Node({}),
     "c": Node({"d": Node(None)})}
)
ex_2 = NTContainer(
    Child(child=Child(child=None))
)
ex_3 = P([P([]), P([]), P([P([])])])

ex_4 = RecipeParams(
    diets=["vegan", "vegetarian"],
    ingredients=["carrot", "olive oil", "salt"],
    limit=10,
    seconds_max=3600,
)
ex_5 = T(
    (T(
        (T(
            ()),
        )),
    ),
)


ex_6 = AtomicTypesAndFallThroughTypes(
    s="abcdefg",
    i=12345,
    f=1.1,
    d=Decimal("3.14"),
    x=X(1,2)
)

dd = defaultdict(int)
dd["a"] = 1
dd["b"] = 2
ex_7 = DefDict(dd)

total_duration = 0.0
for label, dataclass_instance, dict_factory in [
    ("non-dict dict_factory", ex_1, dict_proxy),
    ("namedtuple child", ex_2, dict),
    ("list child", ex_3, dict),
    ("recipe params", ex_4, dict),
    ("tuples", ex_5, dict),
    ("unoptimized", ex_6, dict),
    ("defaultdict", ex_7, dict)
]:
    start = time()
    for i in range(100000):
        _asdict_inner(dataclass_instance, dict_factory=dict_proxy)

    result = time() - start

    print(f"{label}: {result}")
    total_duration += result

print(f"total: {total_duration}")