"""
Наблюдения для урока «Поверхностное и глубокое копирование».

ЗАПУСК (числа урока сняты на 3.13.7):

    for v in 3.11 3.12 3.13 3.14; do python$v bench/copy/graph.py; done

ЗДЕСЬ НЕТ ЗАМЕРОВ ВРЕМЕНИ. Всё, что печатает этот скрипт, — ответы на вопросы
«тот же это объект или другой» и «сколько раз вызвался метод». Такие
утверждения от машины не зависят и обязаны совпасть у любого, кто запустит
скрипт на той же версии. Время меряется отдельно, в `cost.py`.

ПОЧЕМУ ВЕЗДЕ `is`, А НЕ `==`. Вопрос урока — не «равны ли значения», а
«один ли это объект». Равенство здесь ничего не различает: у поверхностной и
глубокой копии списка `==` даёт True одинаково, а разница между ними видна
только по `is` на вложенном уровне.
"""

import copy
import pickle
import sys


def header(title: str) -> None:
    print(f"\n--- {title} ---")


def observe_levels() -> None:
    """Сколько уровней копируется: верхний, все или ни одного."""
    header("1. Глубина копирования")

    inner = [1, 2]
    orig = [inner, inner]

    assigned = orig
    shallow = copy.copy(orig)
    deep = copy.deepcopy(orig)

    rows = [
        ("b = a", assigned),
        ("copy.copy(a)", shallow),
        ("copy.deepcopy(a)", deep),
    ]
    print(f"{'операция':<20} {'верх тот же':>12} {'вложенный тот же':>18}")
    for name, obj in rows:
        print(f"{name:<20} {str(obj is orig):>12} {str(obj[0] is orig[0]):>18}")

    print("\nчто это значит на практике: пишем во вложенный список")
    for name, obj in rows:
        probe_inner = [1, 2]
        probe = [probe_inner, probe_inner]
        made = {"b = a": probe, "copy.copy(a)": copy.copy(probe), "copy.deepcopy(a)": copy.deepcopy(probe)}[name]
        made[0].append(99)
        print(f"{name:<20} оригинал стал {probe[0]}")


def observe_sharing_preserved() -> None:
    """Главное недоразумение: глубокая копия копирует ГРАФ, а не каждую ссылку."""
    header("2. Глубокая копия сохраняет общность")

    shared = {"config": 1}
    orig = {"a": shared, "b": shared}
    deep = copy.deepcopy(orig)

    print("в оригинале один объект на два ключа:", orig["a"] is orig["b"])
    print("в глубокой копии тоже один:         ", deep["a"] is deep["b"])
    print("и он не тот же, что в оригинале:    ", deep["a"] is not orig["a"])

    print("\nдве отдельные глубокие копии между собой ничего не делят:")
    d1 = copy.deepcopy(orig)
    d2 = copy.deepcopy(orig)
    print("  d1['a'] is d2['a']:", d1["a"] is d2["a"])

    print("\nтаблицу можно заполнить заранее — тогда объект не будет скопирован:")
    memo = {id(shared): shared}
    kept = copy.deepcopy(orig, memo)
    print("  copy.deepcopy(orig, {id(shared): shared})['a'] is shared:", kept["a"] is shared)


def observe_cycles() -> None:
    """Ради чего таблица заведена: рекурсивные структуры."""
    header("3. Циклы")

    a = []
    a.append(a)
    b = copy.deepcopy(a)
    print("список, содержащий сам себя, копируется:", b is not a, "и цикл сохранён:", b[0] is b)

    node = {"name": "root"}
    node["self"] = node
    c = copy.deepcopy(node)
    print("словарь со ссылкой на себя:            ", c is not node, "и цикл сохранён:", c["self"] is c)


def observe_atomic() -> None:
    """Два списка «атомарных» типов в copy.py — и они РАЗНЫЕ."""
    header("4. Что возвращается как есть")

    samples = [
        ("int", 42),
        ("str", "abc"),
        ("tuple (внутри неизменяемое)", (1, 2)),
        ("tuple (внутри список)", ([1],)),
        ("frozenset", frozenset({1, 2})),
        ("slice", slice(1, 5)),
        ("range", range(3)),
        ("функция", observe_atomic),
        ("тип", int),
    ]
    print(f"{'объект':<30} {'copy вернул тот же':>20} {'deepcopy вернул тот же':>24}")
    for name, obj in samples:
        print(f"{name:<30} {str(copy.copy(obj) is obj):>20} {str(copy.deepcopy(obj) is obj):>24}")

    print("\nЧитать так: расхождение в строке — не ошибка, а два разных списка")
    print("в Lib/copy.py. Неизменяемость объекта тут ни при чём.")


def observe_no_init() -> None:
    """Ни copy, ни deepcopy не вызывают __init__."""
    header("5. __init__ не вызывается")

    calls = []

    class Connection:
        def __init__(self, dsn: str) -> None:
            calls.append("init")
            self.dsn = dsn
            self.socket = object()

    original = Connection("postgres://…")
    calls.clear()

    shallow = copy.copy(original)
    deep = copy.deepcopy(original)

    print("вызовов __init__ на две копии:", len(calls))
    print("поверхностная копия делит socket с оригиналом:", shallow.socket is original.socket)
    print("глубокая копия socket не делит:              ", deep.socket is not original.socket)
    print("__dict__ у глубокой копии свой:              ", deep.__dict__ is not original.__dict__)


def observe_hooks() -> None:
    """Класс может перехватить обе операции."""
    header("6. __copy__ и __deepcopy__")

    log = []

    class Handle:
        def __init__(self, name: str) -> None:
            self.name = name
            self.buffer = [1, 2, 3]

        def __copy__(self):
            log.append("__copy__")
            return Handle(self.name)

        def __deepcopy__(self, memo):
            log.append("__deepcopy__")
            new = Handle(self.name)
            memo[id(self)] = new
            new.buffer = copy.deepcopy(self.buffer, memo)
            return new

    h = Handle("h")
    copy.copy(h)
    copy.deepcopy(h)
    print("вызвано:", log)

    print("\nпорядок поиска в deepcopy, по Lib/copy.py:")
    print("  атомарный тип → таблица типов → подкласс type → __deepcopy__ →")
    print("  copyreg.dispatch_table → __reduce_ex__(4) → __reduce__")


def observe_depth() -> None:
    """Глубокая копия рекурсивна — и упирается в предел рекурсии."""
    header("7. Предел вложенности")

    def nest(n: int) -> list:
        root: list = []
        cur = root
        for _ in range(n):
            nxt: list = []
            cur.append(nxt)
            cur = nxt
        return root

    limit = sys.getrecursionlimit()
    lo, hi = 1, 20000
    while lo < hi:
        mid = (lo + hi) // 2
        try:
            copy.deepcopy(nest(mid))
            lo = mid + 1
        except RecursionError:
            hi = mid
    print(f"sys.getrecursionlimit() = {limit}")
    print(f"deepcopy ломается на вложенности {lo} — примерно {limit / lo:.1f} кадра на уровень")


def observe_alternatives() -> None:
    """Чем часто подменяют deepcopy — и что при этом теряется."""
    header("8. Чем подменяют")

    import json

    inner = [1]
    orig = [inner, inner]

    p = pickle.loads(pickle.dumps(orig))
    j = json.loads(json.dumps(orig))
    print("общность объектов сохраняет pickle:", p[0] is p[1], " json:", j[0] is j[1])

    cyc: list = []
    cyc.append(cyc)
    print("цикл переживает pickle:", pickle.loads(pickle.dumps(cyc))[0] is not None)
    try:
        json.dumps(cyc)
        print("цикл переживает json: True")
    except ValueError as exc:
        print(f"цикл переживает json: нет — {type(exc).__name__}: {exc}")

    print("\njson ещё и меняет типы:")
    src = {1: (2, 3)}
    back = json.loads(json.dumps(src))
    print(f"  {src!r} → {back!r}")


def main() -> None:
    print(f"Python {sys.version.split()[0]}")
    observe_levels()
    observe_sharing_preserved()
    observe_cycles()
    observe_atomic()
    observe_no_init()
    observe_hooks()
    observe_depth()
    observe_alternatives()


if __name__ == "__main__":
    main()