"""Profile the optimized _api check functions.

Compares OLD style (kwargs, inline check) vs NEW style (curried, cached).
"""

import difflib
import itertools
import timeit
import numpy as np

N = 500_000


# ============================================================================
# OLD IMPLEMENTATIONS (exact code from before the changes)
# ============================================================================

def old_check_isinstance(types, /, **kwargs):
    """Exact old implementation."""
    none_type = type(None)
    types = ((types,) if isinstance(types, type) else
             (none_type,) if types is None else
             tuple(none_type if tp is None else tp for tp in types))

    def type_name(tp):
        return ("None" if tp is none_type
                else tp.__qualname__ if tp.__module__ == "builtins"
                else f"{tp.__module__}.{tp.__qualname__}")

    for k, v in kwargs.items():
        if not isinstance(v, types):
            names = [*map(type_name, types)]
            if "None" in names:
                names.remove("None")
                names.append("None")
            raise TypeError(
                "{!r} must be an instance of {}, not a {}".format(
                    k,
                    ", ".join(names[:-1]) + " or " + names[-1]
                    if len(names) > 1 else names[0],
                    type_name(type(v))))


def old_check_in_list(values, /, *, _print_supported_values=True, **kwargs):
    """Exact old implementation."""
    if not kwargs:
        raise TypeError("No argument to check!")
    for key, val in kwargs.items():
        try:
            exists = val in values
        except ValueError:
            exists = False
        if not exists:
            msg = f"{val!r} is not a valid value for {key}"
            if _print_supported_values:
                msg += f"; supported values are {', '.join(map(repr, values))}"
            raise ValueError(msg)


def old_check_shape(shape, /, **kwargs):
    """Exact old implementation."""
    for k, v in kwargs.items():
        data_shape = v.shape

        if (len(data_shape) != len(shape)
                or any(s != t and t is not None for s, t in zip(data_shape, shape))):
            dim_labels = iter(itertools.chain(
                'NMLKJIH',
                (f"D{i}" for i in itertools.count())))
            text_shape = ", ".join([str(n) if n is not None else next(dim_labels)
                                    for n in shape[::-1]][::-1])
            if len(shape) == 1:
                text_shape += ","

            raise ValueError(
                f"{k!r} must be {len(shape)}D with shape ({text_shape}), "
                f"but your input has shape {v.shape}"
            )


def old_check_getitem(mapping, /, _error_cls=ValueError, **kwargs):
    """Exact old implementation."""
    if len(kwargs) != 1:
        raise ValueError("check_getitem takes a single keyword argument")
    (k, v), = kwargs.items()
    try:
        return mapping[v]
    except KeyError:
        if len(mapping) > 5:
            if len(best := difflib.get_close_matches(v, mapping.keys(), cutoff=0.5)):
                suggestion = f"Did you mean one of {best}?"
            else:
                suggestion = ""
        else:
            suggestion = f"Supported values are {', '.join(map(repr, mapping))}"
        raise _error_cls(f"{v!r} is not a valid value for {k}. {suggestion}") from None


# ============================================================================
# PROFILING
# ============================================================================

def profile_all():
    from matplotlib import _api

    print(f"Profiling _api check functions ({N:,} iterations)")
    print("=" * 75)
    print()
    print(f"{'Function':<20} {'Old':>10} {'New+Cache':>12} {'New-Cache':>12} {'Speedup':>10}")
    print("-" * 75)

    # --- check_isinstance ---
    types = (int, float)
    value = 1.0

    # Warm up
    old_check_isinstance(types, v=value)
    t_old = timeit.timeit(lambda: old_check_isinstance(types, v=value), number=N)

    t_new_hit = timeit.timeit(lambda: _api.check_isinstance(types)("v", value), number=N)

    def new_miss():
        _api.check_isinstance.cache_clear()
        return _api.check_isinstance(types)("v", value)
    t_new_miss = timeit.timeit(new_miss, number=N)

    old_us = t_old * 1e6 / N
    hit_us = t_new_hit * 1e6 / N
    miss_us = t_new_miss * 1e6 / N
    print(f"{'check_isinstance':<20} {old_us:>9.2f}µs {hit_us:>11.2f}µs {miss_us:>11.2f}µs {t_old/t_new_hit:>9.1f}x")

    # --- check_in_list ---
    values = ("left", "center", "right")
    value = "center"

    # Warm up
    old_check_in_list(values, v=value)
    t_old = timeit.timeit(lambda: old_check_in_list(values, v=value), number=N)

    t_new_hit = timeit.timeit(lambda: _api.check_in_list(values)("v", value), number=N)

    def new_miss():
        _api._check_in_tuple.cache_clear()
        return _api.check_in_list(values)("v", value)
    t_new_miss = timeit.timeit(new_miss, number=N)

    old_us = t_old * 1e6 / N
    hit_us = t_new_hit * 1e6 / N
    miss_us = t_new_miss * 1e6 / N
    print(f"{'check_in_list':<20} {old_us:>9.2f}µs {hit_us:>11.2f}µs {miss_us:>11.2f}µs {t_old/t_new_hit:>9.1f}x")

    # --- check_shape ---
    shape = (None, 2)
    arr = np.array([[1, 2], [3, 4]])

    # Warm up
    old_check_shape(shape, arr=arr)
    t_old = timeit.timeit(lambda: old_check_shape(shape, arr=arr), number=N)

    t_new_hit = timeit.timeit(lambda: _api.check_shape(shape)("arr", arr), number=N)

    def new_miss():
        _api.check_shape.cache_clear()
        return _api.check_shape(shape)("arr", arr)
    t_new_miss = timeit.timeit(new_miss, number=N)

    old_us = t_old * 1e6 / N
    hit_us = t_new_hit * 1e6 / N
    miss_us = t_new_miss * 1e6 / N
    print(f"{'check_shape':<20} {old_us:>9.2f}µs {hit_us:>11.2f}µs {miss_us:>11.2f}µs {t_old/t_new_hit:>9.1f}x")

    # --- check_getitem (no caching in new impl) ---
    mapping = {"left": 0, "center": 0.5, "right": 1}
    value = "center"

    # Warm up
    old_check_getitem(mapping, v=value)
    t_old = timeit.timeit(lambda: old_check_getitem(mapping, v=value), number=N)
    t_new = timeit.timeit(lambda: _api.check_getitem(mapping)("v", value), number=N)

    old_us = t_old * 1e6 / N
    new_us = t_new * 1e6 / N
    print(f"{'check_getitem':<20} {old_us:>9.2f}µs {new_us:>11.2f}µs {'N/A':>12} {t_old/t_new:>9.1f}x")

    print("-" * 75)
    print()
    print("Notes:")
    print("  - 'Old' = kwargs-based API (before changes)")
    print("  - 'New+Cache' = curried API with cache hit (typical usage)")
    print("  - 'New-Cache' = curried API with cache miss every call")
    print("  - 'Speedup' = Old / New+Cache")
    print()


if __name__ == "__main__":
    profile_all()