# -*- coding: utf-8 -*-
"""
MenuCacheService: Úložiště mezipaměti menu v rámci procesu.
Ukládá často používaná data menu do paměti pro rychlý opětovný přístup ve stejném procesu.
"""

from time import time
from resources.lib.utils.log_utils import get_logger

log = get_logger()


class MenuCacheService(object):
    """
    Správce mezipaměti menu na straně služby (v rámci procesu).
    Ukládá hotové n-tice menu (url, popisek, isFolder) pro okamžité vykreslení.
    Ideální pro vzorce rychlého opakovaného přístupu ve stejném procesu.
    """

    def __init__(self):
        """Inicializace úložiště mezipaměti v paměti."""
        self.cache = {}  # url -> { items: [...], časová značka, počet }

    def save_menu(self, url: str, items_list: list, max_age: int = 300) -> bool:
        """
        Uloží položky menu do mezipaměti v paměti.
        
        Args:
            url: Identifikátor/URL menu
            items_list: Seznam položek menu (n-tice nebo seznamy)
            max_age: Životnost (TTL) v sekundách
        
        Returns:
            True, pokud bylo uloženo
        """
        try:
            # Uloží položky tak, jak jsou (n-tice jsou preferovány, ale seznamy také fungují)
            cache_entry = {
                'items': list(items_list),  # Převod na seznam pro jistotu
                'timestamp': time(),
                'max_age': max_age,
                'count': len(items_list)
            }
            self.cache[url] = cache_entry
            log.info(f"[MenuCacheService] Saved {len(items_list)} items for {url[:30]} (TTL: {max_age}s)")
            return True
        except Exception as e:
            log.warning(f"[MenuCacheService] Save failed: {e}")
            return False

    def get_menu(self, url: str):
        """
        Načte menu z mezipaměti, pokud je platné a nevypršelo.
        
        Args:
            url: Identifikátor menu
        
        Returns:
            Slovník s 'items', 'count', 'timestamp' nebo None při neúspěchu/vypršení
        """
        try:
            cached = self.cache.get(url)
            if not cached:
                return None

            age = time() - cached['timestamp']
            max_age = cached.get('max_age', 300)

            if age > max_age:
                log.info(f"[MenuCacheService] Cache expired for {url[:30]} (age: {age:.1f}s)")
                self.invalidate_menu(url)
                return None

            log.info(f"[MenuCacheService] Cache HIT for {url[:30]} (age: {age:.1f}s, {cached['count']} items)")
            return cached

        except Exception as e:
            log.warning(f"[MenuCacheService] Get failed: {e}")
            return None

    def invalidate_menu(self, url: str = None) -> None:
        """
        Odstraní položku(y) z mezipaměti.
        
        Args:
            url: Konkrétní URL k vymazání, nebo None pro vymazání všeho
        """
        try:
            if url:
                if url in self.cache:
                    del self.cache[url]
                    log.info(f"[MenuCacheService] Invalidated {url[:30]}")
            else:
                old_count = len(self.cache)
                self.cache = {}
                log.info(f"[MenuCacheService] Cleared all {old_count} cached menus")
        except Exception as e:
            log.warning(f"[MenuCacheService] Invalidate failed: {e}")

    def get_stats(self) -> dict:
        """Vrátí statistiky mezipaměti."""
        return {
            'entries': len(self.cache),
            'urls': list(self.cache.keys())[:5]  # Prvních 5 pro účely ladění
        }


# Globální instance (singleton)
_cache_service = None


def get_menu_cache_service() -> MenuCacheService:
    """Získá nebo vytvoří globální instanci MenuCacheService."""
    global _cache_service
    if _cache_service is None:
        _cache_service = MenuCacheService()
    return _cache_service
