class BlockedIpMiddleware:

    def _get_mem_cache(self, key):
        cache_val = cache.get(key)
        if cache_val is not None:
            return cache_val
        else:
            self._cache()
        return cache.get(key)

    def _set_mem_cache(self, key, value):
        cache.set(key, value)

    def _cache(self):
        ips = {}
        masks = set()
        for line in open(settings.BLOCKED_IPS_FILE_PATH):
            line = line.strip()
            if not line:
                continue
            if line[-1] == '*':
                masks.add(line[:-2])
            else:
                ips[line] = None
        self._append_blocked_ips(ips)
        self._set_mem_cache(ips_cache_key, ips)
        self._set_mem_cache(masks_cache_key, masks)

    def _append_blocked_ips(self, ips):
        for blocked_ip in BlockedIp.objects.all():
            ips[blocked_ip.ip] = blocked_ip.created

    def _cut_last_number(self, ip):
        return '.'.join(ip.split('.')[:-1])

    def process_request(self, request):
        x_forwarded_for_header = request.META.get('HTTP_X_FORWARDED_FOR', '')

        reload_cache = request.META.get('HTTP_RELOAD_BLOCKED_IPS', False)
        if reload_cache:
            self._cache()

        response = http.HttpResponseForbidden('<h1>404</h1><div>No page found</div>')
        time_minus_20_min = timezone.make_aware(datetime.datetime.now() - datetime.timedelta(minutes=20),
                                                timezone.get_default_timezone())
        blocked_ips = self._get_mem_cache(ips_cache_key)
        if x_forwarded_for_header in blocked_ips and (blocked_ips[x_forwarded_for_header] is None or
                                                      blocked_ips[x_forwarded_for_header] < time_minus_20_min):
            return response
        x_forwarded_for_header_cut = self._cut_last_number(x_forwarded_for_header)
        if x_forwarded_for_header_cut in self._get_mem_cache(masks_cache_key):
            return response
        return None