from sqlalchemy.orm import Session
from app.models.auth.access_model import Access
from typing import List, Any
from app.core.redis import sync_redis_client
import json
from app.models.auth.module_access_model import ModuleAccess
from app.models.auth.module_model import Module
from sqlalchemy.orm import joinedload
from datetime import datetime

class AccessService:
    
    @staticmethod
    def get_all_accesses(db: Session, category: str = None) -> List[any]:
        
        cache_key = f"saas:access:v2:all:{category if category else 'full'}"
        cached_data = sync_redis_client.client.get(cache_key) if sync_redis_client.client else None
        
        if cached_data:
            try:
                data_list = json.loads(cached_data)
                class SimpleAccess:
                    def __init__(self, **kwargs):
                        for k, v in kwargs.items():
                            setattr(self, k, v)
                
                deserialized_list = []
                for item in data_list:
                    if "created_at" in item and item["created_at"]:
                        try:
                            item["created_at"] = datetime.fromisoformat(item["created_at"])
                        except ValueError:
                             item["created_at"] = None
                    deserialized_list.append(SimpleAccess(**item))
                    
                return deserialized_list
            except Exception as e:
                pass

        query = db.query(Access)
        
        if category:
            query = query.filter(Access.category == category)
        
        saas_accesses = query.all()
        for access in saas_accesses:
            access.module_name = "SaaS (Internal)"
        
        module_query = db.query(ModuleAccess).options(joinedload(ModuleAccess.module))
        
        if category:
            module_query = module_query.filter(ModuleAccess.category == category)
        
        module_accesses = module_query.all()
        
        for ma in module_accesses:
            if ma.module:
                ma.module_name = ma.module.module_name
        
        result = saas_accesses + module_accesses
        
        try:
            if sync_redis_client.client:
                serialized = []
                for item in result:
                    serialized.append({
                        "id": str(item.id),
                        "access_code": item.access_code,
                        "name": item.name,
                        "category": item.category,
                        "parent_id": str(item.parent_id) if item.parent_id else None,
                        "module_name": getattr(item, "module_name", None),
                        "created_at": item.created_at.isoformat() if item.created_at else None,
                    })
                
                sync_redis_client.client.set(cache_key, json.dumps(serialized), ex=3600) # 1 hour cache
        except Exception as e:
            pass
            
        return result
    
    @staticmethod
    def get_access_categories(db: Session) -> List[str]:
        categories = db.query(Access.category).distinct().all()
        module_categories = db.query(ModuleAccess.category).distinct().all()
        
        all_cats = set([cat[0] for cat in categories] + [cat[0] for cat in module_categories])
        return list(all_cats)