import logging
import sys
import time
import functools
import asyncio
from datetime import datetime
from typing import Any, Callable
import traceback

class KubyLogger:
    def __init__(self, name="KubyBot"):
        self.logger = logging.getLogger(name)
        self.logger.setLevel(logging.DEBUG)
        
        # Créer le format de log
        formatter = logging.Formatter(
            '[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s:%(lineno)d] %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S'
        )
        
        # Console handler
        console_handler = logging.StreamHandler(sys.stdout)
        console_handler.setFormatter(formatter)
        console_handler.setLevel(logging.DEBUG)
        self.logger.addHandler(console_handler)
        
        # File handler
        file_handler = logging.FileHandler('kuby_logs.log')
        file_handler.setFormatter(formatter)
        file_handler.setLevel(logging.DEBUG)
        self.logger.addHandler(file_handler)
        
        # Error file handler
        error_handler = logging.FileHandler('kuby_errors.log')
        error_handler.setLevel(logging.ERROR)
        error_handler.setFormatter(formatter)
        self.logger.addHandler(error_handler)
        
        # Audit file handler for security events
        audit_handler = logging.FileHandler('kuby_audit.log')
        audit_handler.setLevel(logging.INFO)
        audit_formatter = logging.Formatter(
            '[AUDIT] [%(asctime)s] [%(levelname)s] [%(funcName)s] %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S'
        )
        audit_handler.setFormatter(audit_formatter)
        self.logger.addHandler(audit_handler)
    
    def debug(self, message, **kwargs):
        self.logger.debug(message, **kwargs)
    
    def info(self, message, **kwargs):
        self.logger.info(message, **kwargs)
    
    def warning(self, message, **kwargs):
        self.logger.warning(message, **kwargs)
    
    def error(self, message, **kwargs):
        self.logger.error(message, **kwargs)
    
    def critical(self, message, **kwargs):
        self.logger.critical(message, **kwargs)
    
    def audit(self, message, **kwargs):
        """Special audit logging for security events"""
        self.logger.log(25, f"AUDIT: {message}", **kwargs)
    
    def performance(self, message, duration=None, **kwargs):
        """Performance logging with timing information"""
        if duration is not None:
            self.logger.info(f"PERFORMANCE: {message} - Duration: {duration:.3f}s", **kwargs)
        else:
            self.logger.info(f"PERFORMANCE: {message}", **kwargs)

# Performance decorator
def log_performance(func: Callable) -> Callable:
    """Decorator to log function performance"""
    @functools.wraps(func)
    async def async_wrapper(*args, **kwargs):
        start_time = time.time()
        kuby_logger.debug(f"Entering {func.__name__} with args: {args}, kwargs: {kwargs}")
        try:
            result = await func(*args, **kwargs)
            duration = time.time() - start_time
            kuby_logger.performance(f"Completed {func.__name__}", duration=duration)
            return result
        except Exception as e:
            duration = time.time() - start_time
            kuby_logger.error(f"Error in {func.__name__} after {duration:.3f}s: {str(e)}")
            kuby_logger.error(traceback.format_exc())
            raise
    
    @functools.wraps(func)
    def sync_wrapper(*args, **kwargs):
        start_time = time.time()
        kuby_logger.debug(f"Entering {func.__name__} with args: {args}, kwargs: {kwargs}")
        try:
            result = func(*args, **kwargs)
            duration = time.time() - start_time
            kuby_logger.performance(f"Completed {func.__name__}", duration=duration)
            return result
        except Exception as e:
            duration = time.time() - start_time
            kuby_logger.error(f"Error in {func.__name__} after {duration:.3f}s: {str(e)}")
            kuby_logger.error(traceback.format_exc())
            raise
    
    if asyncio.iscoroutinefunction(func):
        return async_wrapper
    return sync_wrapper

# Instance globale du logger
kuby_logger = KubyLogger()