"""`functools.lru_cache` compatible memoizing function decorators."""

import collections
import functools
import random
import time
import warnings

try:
    from threading import RLock
except ImportError:
    from dummy_threading import RLock

from .keys import hashkey, typedkey

__all__ = ('lfu_cache', 'lru_cache', 'rr_cache', 'ttl_cache')


class _NLock:
    def __enter__(self):
        pass

    def __exit__(self, *exc):
        pass

_CacheInfo = collections.namedtuple('CacheInfo', [
    'hits', 'misses', 'maxsize', 'currsize'
])

_marker = object()


def _deprecated(message, level=2):
    warnings.warn('%s is deprecated' % message, DeprecationWarning, level)


def _cache(cache, typed=False, context=_marker):
    def decorator(func):
        key = typedkey if typed else hashkey
        if context is _marker:
            lock = RLock()
        elif context is None:
            lock = _NLock()
        else:
            lock = context()
        stats = [0, 0]

        def cache_info():
            with lock:
                hits, misses = stats
                maxsize = cache.maxsize
                currsize = cache.currsize
            return _CacheInfo(hits, misses, maxsize, currsize)

        def cache_clear():
            with lock:
                try:
                    cache.clear()
                finally:
                    stats[:] = [0, 0]

        def wrapper(*args, **kwargs):
            k = key(*args, **kwargs)
            with lock:
                try:
                    v = cache[k]
                    stats[0] += 1
                    return v
                except KeyError:
                    stats[1] += 1
            v = func(*args, **kwargs)
            try:
                with lock:
                    cache[k] = v
            except ValueError:
                pass  # value too large
            return v
        functools.update_wrapper(wrapper, func)
        if not hasattr(wrapper, '__wrapped__'):
            wrapper.__wrapped__ = func  # Python < 3.2
        wrapper.cache_info = cache_info
        wrapper.cache_clear = cache_clear
        return wrapper
    return decorator


def lfu_cache(maxsize=128, typed=False, getsizeof=None, lock=_marker):
    """Decorator to wrap a function with a memoizing callable that saves
    up to `maxsize` results based on a Least Frequently Used (LFU)
    algorithm.

    """
    from .lfu import LFUCache
    if lock is not _marker:
        _deprecated("Passing 'lock' to lfu_cache()", 3)
    return _cache(LFUCache(maxsize, getsizeof), typed, lock)


def lru_cache(maxsize=128, typed=False, getsizeof=None, lock=_marker):
    """Decorator to wrap a function with a memoizing callable that saves
    up to `maxsize` results based on a Least Recently Used (LRU)
    algorithm.

    """
    from .lru import LRUCache
    if lock is not _marker:
        _deprecated("Passing 'lock' to lru_cache()", 3)
    return _cache(LRUCache(maxsize, getsizeof), typed, lock)


def rr_cache(maxsize=128, choice=random.choice, typed=False, getsizeof=None,
             lock=_marker):
    """Decorator to wrap a function with a memoizing callable that saves
    up to `maxsize` results based on a Random Replacement (RR)
    algorithm.

    """
    from .rr import RRCache
    if lock is not _marker:
        _deprecated("Passing 'lock' to rr_cache()", 3)
    return _cache(RRCache(maxsize, choice, getsizeof), typed, lock)


def ttl_cache(maxsize=128, ttl=600, timer=time.time, typed=False,
              getsizeof=None, lock=_marker):
    """Decorator to wrap a function with a memoizing callable that saves
    up to `maxsize` results based on a Least Recently Used (LRU)
    algorithm with a per-item time-to-live (TTL) value.
    """
    from .ttl import TTLCache
    if lock is not _marker:
        _deprecated("Passing 'lock' to ttl_cache()", 3)
    return _cache(TTLCache(maxsize, ttl, timer, getsizeof), typed, lock)