from functools import wraps, WRAPPER_ASSIGNMENTS

from django.http.response import HttpResponse

from common.cache.storage import AppDownloadShortShowCache


def get_cache(alias):
    from django.core.cache import caches
    return caches[alias]


def set_short_show_cache(short, cache_key):
    short_show_cache = AppDownloadShortShowCache("ShortDownloadView".lower(), short)
    key_list = short_show_cache.get_storage_cache()

    if key_list and isinstance(key_list, list):
        key_list.append(cache_key)
        key_list = list(set(key_list))
    else:
        key_list = [cache_key]
    short_show_cache.set_storage_cache(key_list, 600)


class CacheResponse:
    """
    Store/Receive and return cached `HttpResponse` based on DRF response.
    .. note::
        This decorator will render and discard the original DRF response in
        favor of Django's `HttpResponse`. The allows the cache to retain a
        smaller memory footprint and eliminates the need to re-render
        responses on each request. Furthermore it eliminates the risk for users
        to unknowingly cache whole Serializers and QuerySets.
    """

    def __init__(self,
                 timeout=None,
                 key_func=None,
                 cache=None,
                 cache_errors=None):
        if timeout is None:
            self.timeout = None
        else:
            self.timeout = timeout

        if key_func is None:
            self.key_func = ''
        else:
            self.key_func = key_func

        if cache_errors is None:
            self.cache_errors = True
        else:
            self.cache_errors = cache_errors

        self.cache = get_cache(cache or 'default')

    def __call__(self, func):
        this = self

        @wraps(func, assigned=WRAPPER_ASSIGNMENTS)
        def inner(self, request, *args, **kwargs):
            return this.process_cache_response(
                view_instance=self,
                view_method=func,
                request=request,
                args=args,
                kwargs=kwargs,
            )

        return inner

    def process_cache_response(self,
                               view_instance,
                               view_method,
                               request,
                               args,
                               kwargs):

        key = self.calculate_key(
            view_instance=view_instance,
            view_method=view_method,
            request=request,
            args=args,
            kwargs=kwargs
        )

        timeout = self.calculate_timeout(view_instance=view_instance)

        response_triple = self.cache.get(key)
        if not response_triple:
            # render response to create and cache the content byte string
            response = view_method(view_instance, request, *args, **kwargs)
            response = view_instance.finalize_response(request, response, *args, **kwargs)
            response.render()

            if not response.status_code >= 400 or self.cache_errors:
                # django 3.0 has not .items() method, django 3.2 has not ._headers
                if hasattr(response, '_headers'):
                    headers = response._headers.copy()
                else:
                    headers = {k: (k, v) for k, v in response.items()}
                response_triple = (
                    response.rendered_content,
                    response.status_code,
                    headers
                )
                short = kwargs.get("short", '')
                set_short_show_cache(short, key)
                self.cache.set(key, response_triple, timeout)
        else:
            # build smaller Django HttpResponse
            content, status, headers = response_triple
            response = HttpResponse(content=content, status=status)
            for k, v in headers.values():
                response[k] = v
        if not hasattr(response, '_closable_objects'):
            response._closable_objects = []

        return response

    def calculate_key(self,
                      view_instance,
                      view_method,
                      request,
                      args,
                      kwargs):
        if isinstance(self.key_func, str):
            key_func = getattr(view_instance, self.key_func)
        else:
            key_func = self.key_func
        return key_func(
            view_instance=view_instance,
            view_method=view_method,
            request=request,
            args=args,
            kwargs=kwargs,
        )

    def calculate_timeout(self, view_instance, **_):
        if isinstance(self.timeout, str):
            self.timeout = getattr(view_instance, self.timeout)
        return self.timeout


cache_response = CacheResponse