from sqlalchemy.orm import Session
from models.settings import SystemSettings
from typing import Optional, Dict, Any
import json

class SettingsService:
    """Service for managing system settings."""
    
    @staticmethod
    def get_setting(db: Session, key: str, default: Any = None) -> Any:
        """Get a setting value by key."""
        setting = db.query(SystemSettings).filter(SystemSettings.key == key).first()
        if not setting:
            return default
        
        # Essayer de convertir en type approprié
        value = setting.value
        
        # Booléens
        if value.lower() in ['true', 'false']:
            return value.lower() == 'true'
        
        # Nombres entiers
        try:
            return int(value)
        except ValueError:
            pass
        
        # Nombres flottants
        try:
            return float(value)
        except ValueError:
            pass
        
        # JSON
        if value.startswith('{') or value.startswith('['):
            try:
                return json.loads(value)
            except json.JSONDecodeError:
                pass
        
        # Liste séparée par des virgules
        if ',' in value and not value.startswith('{') and not value.startswith('['):
            return [item.strip() for item in value.split(',')]
        
        return value
    
    @staticmethod
    def get_upload_limits(db: Session) -> Dict[str, Any]:
        """Get all upload-related settings."""
        return {
            "max_album_size_mb": SettingsService.get_setting(db, "max_album_size_mb", 100),
            "max_vlog_size_mb": SettingsService.get_setting(db, "max_vlog_size_mb", 500),
            "max_image_size_mb": SettingsService.get_setting(db, "max_image_size_mb", 10),
            "max_video_size_mb": SettingsService.get_setting(db, "max_video_size_mb", 100),
            "allowed_image_types": SettingsService.get_setting(db, "allowed_image_types", 
                ["image/jpeg", "image/png", "image/gif", "image/webp"]),
            "allowed_video_types": SettingsService.get_setting(db, "allowed_video_types", 
                ["video/mp4", "video/mpeg", "video/quicktime", "video/webm"])
        }
    
    @staticmethod
    def get_max_upload_size(db: Session, content_type: str) -> int:
        """Get max upload size for a specific content type."""
        if content_type.startswith('image/'):
            max_size_mb = SettingsService.get_setting(db, "max_image_size_mb", 10)
            max_size_bytes = max_size_mb * 1024 * 1024
            print(f"DEBUG - Image upload limit: {max_size_mb}MB = {max_size_bytes} bytes")
            return max_size_bytes
        elif content_type.startswith('video/'):
            max_size_mb = SettingsService.get_setting(db, "max_video_size_mb", 100)
            max_size_bytes = max_size_mb * 1024 * 1024
            print(f"DEBUG - Video upload limit: {max_size_mb}MB = {max_size_bytes} bytes")
            return max_size_bytes
        else:
            default_size = 10 * 1024 * 1024  # 10MB par défaut
            print(f"DEBUG - Default upload limit: 10MB = {default_size} bytes")
            return default_size
    
    @staticmethod
    def is_file_type_allowed(db: Session, content_type: str) -> bool:
        """Check if a file type is allowed."""
        if content_type.startswith('image/'):
            allowed_types = SettingsService.get_setting(db, "allowed_image_types", 
                ["image/jpeg", "image/png", "image/gif", "image/webp"])
        elif content_type.startswith('video/'):
            allowed_types = SettingsService.get_setting(db, "allowed_video_types", 
                ["video/mp4", "video/mpeg", "video/quicktime", "video/webm"])
        else:
            return False
        
        return content_type in allowed_types