# mlink-backend/src/config/logging_config.py
import os
import logging
import logging.handlers
from datetime import datetime
from src.config.env_loader import env

class LoggingConfig:
    """로깅 설정 클래스"""
    
    @staticmethod
    def setup_logging():
        """로깅 설정 초기화"""
        
        # 로그 레벨 설정
        log_level = env.get('LOG_LEVEL', 'INFO').upper()
        numeric_level = getattr(logging, log_level, logging.INFO)
        
        # 로그 포맷 설정
        formatter = logging.Formatter(
            fmt='%(asctime)s [%(levelname)s] %(name)s:%(lineno)d - %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S'
        )
        
        # 루트 로거 설정
        root_logger = logging.getLogger()
        root_logger.setLevel(numeric_level)
        
        # 기존 핸들러 제거
        for handler in root_logger.handlers[:]:
            root_logger.removeHandler(handler)
        
        # 콘솔 핸들러
        console_handler = logging.StreamHandler()
        console_handler.setLevel(numeric_level)
        console_handler.setFormatter(formatter)
        root_logger.addHandler(console_handler)
        
        # 파일 핸들러 (로그 디렉토리 생성)
        log_dir = 'logs'
        os.makedirs(log_dir, exist_ok=True)
        
        file_handler = logging.handlers.RotatingFileHandler(
            filename=os.path.join(log_dir, 'mlink.log'),
            maxBytes=10 * 1024 * 1024,  # 10MB
            backupCount=5,
            encoding='utf-8'
        )
        file_handler.setLevel(numeric_level)
        file_handler.setFormatter(formatter)
        root_logger.addHandler(file_handler)
        
        # 에러 전용 파일 핸들러
        error_handler = logging.handlers.RotatingFileHandler(
            filename=os.path.join(log_dir, 'error.log'),
            maxBytes=10 * 1024 * 1024,  # 10MB
            backupCount=5,
            encoding='utf-8'
        )
        error_handler.setLevel(logging.ERROR)
        error_handler.setFormatter(formatter)
        root_logger.addHandler(error_handler)
        
        # 외부 라이브러리 로그 레벨 조정
        logging.getLogger('urllib3').setLevel(logging.WARNING)
        logging.getLogger('requests').setLevel(logging.WARNING)
        logging.getLogger('chromadb').setLevel(logging.WARNING)
        
        return root_logger

# 구조화된 로깅을 위한 헬퍼 클래스
class StructuredLogger:
    """구조화된 로깅을 위한 헬퍼 클래스"""
    
    def __init__(self, name: str):
        self.logger = logging.getLogger(name)
    
    def info(self, message: str, **kwargs):
        """정보 로그"""
        self.logger.info(message, extra=kwargs)
    
    def warning(self, message: str, **kwargs):
        """경고 로그"""
        self.logger.warning(message, extra=kwargs)
    
    def error(self, message: str, **kwargs):
        """에러 로그"""
        self.logger.error(message, extra=kwargs)
    
    def debug(self, message: str, **kwargs):
        """디버그 로그"""
        self.logger.debug(message, extra=kwargs)
    
    def log_api_request(self, method: str, endpoint: str, user_id: str = None, **kwargs):
        """API 요청 로그"""
        self.info(
            f"API 요청: {method} {endpoint}",
            event_type='api_request',
            method=method,
            endpoint=endpoint,
            user_id=user_id,
            **kwargs
        )
    
    def log_api_response(self, method: str, endpoint: str, status_code: int, response_time: float, **kwargs):
        """API 응답 로그"""
        self.info(
            f"API 응답: {method} {endpoint} - {status_code} ({response_time:.3f}s)",
            event_type='api_response',
            method=method,
            endpoint=endpoint,
            status_code=status_code,
            response_time=response_time,
            **kwargs
        )
    
    def log_chatbot_interaction(self, user_message: str, ai_response: str, session_id: str, **kwargs):
        """챗봇 상호작용 로그"""
        self.info(
            "챗봇 상호작용",
            event_type='chatbot_interaction',
            session_id=session_id,
            user_message_length=len(user_message),
            ai_response_length=len(ai_response),
            **kwargs
        )
    
    def log_external_api_call(self, service: str, endpoint: str, status_code: int, response_time: float, **kwargs):
        """외부 API 호출 로그"""
        self.info(
            f"외부 API 호출: {service} {endpoint} - {status_code} ({response_time:.3f}s)",
            event_type='external_api_call',
            service=service,
            endpoint=endpoint,
            status_code=status_code,
            response_time=response_time,
            **kwargs
        )