"""
Замер цены копирования для урока «Поверхностное и глубокое копирование».

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

    python3.13 bench/copy/cost.py
    python3.14 bench/copy/cost.py

ЧТО МОЖНО СРАВНИВАТЬ. Только строки внутри одного блока одного запуска: они
меряются подряд, на одной и той же структуре данных, в одинаковых условиях.
Абсолютные микросекунды с другой машины сравнивать нельзя, между версиями —
тоже: 3.12 собран GCC, а 3.13 и 3.14 Clang.

ПОЧЕМУ min, А НЕ СРЕДНЕЕ. Всё, что мешает (планировщик, соседний процесс,
сборка мусора), делает замер только МЕДЛЕННЕЕ. Минимум из семи повторов —
ближайшая к правде оценка; среднее меряет ещё и шум машины.

ЧЕГО ЭТОТ СКРИПТ НЕ ГОВОРИТ. Он не говорит, что pickle «лучше» deepcopy.
Он говорит только про время. Что при этом теряется — общность объектов, циклы,
типы — печатает `graph.py`, и без него блок 3 читать нельзя.
"""

import copy
import json
import pickle
import sys
import timeit


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


def us(stmt: str, env: dict, number: int) -> float:
    """Микросекунды на одну операцию: минимум из семи повторов."""
    return min(timeit.repeat(stmt, globals=env, number=number, repeat=7)) / number * 1e6


def make_records(n: int) -> list:
    """Структура, похожая на то, что копируют в реальном коде: три уровня."""
    return [{"id": i, "tags": ["a", "b"], "meta": {"x": i}} for i in range(n)]


def bench_shallow() -> None:
    header("1. Пять способов поверхностной копии (список из 1000 записей)")

    data = make_records(1000)
    env = {"data": data, "copy": copy}
    rows = [
        ("data[:]", "data[:]"),
        ("list(data)", "list(data)"),
        ("data.copy()", "data.copy()"),
        ("copy.copy(data)", "copy.copy(data)"),
        ("[x for x in data]", "[x for x in data]"),
    ]
    results = [(name, us(stmt, env, 2000)) for name, stmt in rows]
    best = min(v for _, v in results)
    print(f"{'способ':<20} {'мкс':>8} {'к лучшему':>10}")
    for name, value in results:
        print(f"{name:<20} {value:>8.2f} {value / best:>9.2f}x")
    print("\nВсе пять делают одно и то же: новый список, те же объекты внутри.")


def bench_object_count() -> None:
    header("2. Цена глубокой копии — по числу объектов, а не байтов")

    flat = list(range(10000))
    nested = [[i] for i in range(10000)]
    env = {"flat": flat, "nested": nested, "copy": copy}

    a = us("copy.deepcopy(flat)", env, 20)
    b = us("copy.deepcopy(nested)", env, 20)
    print(f"{'10000 int в списке':<32} {a:>10.2f} мкс")
    print(f"{'10000 списков по одному int':<32} {b:>10.2f} мкс")
    print(f"\nразница: {b / a:.1f}x при одинаковом числе чисел")
    print("int — атомарный тип: deepcopy возвращает его как есть, не копируя.")


def bench_alternatives() -> None:
    """ВСЕ ПЯТЬ СТРОК — ОДИН ЗАМЕР, ОДНА СТРУКТУРА.

    Поверхностная копия стоит здесь же, а не в отдельном блоке, намеренно:
    иначе её микросекунды и микросекунды остальных пришли бы из разных
    прогонов, и отношение между ними считалось бы по числам, снятым в разное
    время. Читать её как «ещё один способ сделать глубокую копию» нельзя —
    она копирует только верхний уровень, и в таблице это помечено.
    """
    header("3. Одна структура, пять способов получить «копию» (1000 записей)")

    data = make_records(1000)
    env = {"data": data, "copy": copy, "pickle": pickle, "json": json}
    rows = [
        ("data[:] (не глубокая)", "data[:]", 2000),
        ("copy.deepcopy", "copy.deepcopy(data)", 20),
        ("pickle туда-обратно", "pickle.loads(pickle.dumps(data))", 20),
        ("json туда-обратно", "json.loads(json.dumps(data))", 20),
        (
            "руками, по форме",
            "[{'id': d['id'], 'tags': list(d['tags']), 'meta': dict(d['meta'])} for d in data]",
            20,
        ),
    ]
    results = [(name, us(stmt, env, number)) for name, stmt, number in rows]
    base = dict(results)["copy.deepcopy"]
    print(f"{'способ':<24} {'мкс':>10} {'к deepcopy':>12}")
    for name, value in results:
        print(f"{name:<24} {value:>10.2f} {base / value:>11.1f}x")
    print("\nЧитать вместе с graph.py, раздел 8: быстрее — не значит то же самое.")
    print("json теряет типы и падает на циклах, ручной способ знает форму данных.")


def main() -> None:
    print(f"Python {sys.version.split()[0]}")
    bench_shallow()
    bench_object_count()
    bench_alternatives()


if __name__ == "__main__":
    main()