"""Logging Utility"""

import sys
import logging
from pathlib import Path
from typing import Optional
from datetime import datetime
from enum import Enum


class LogLevel(Enum):
    """Log level enumeration"""

    DEBUG = logging.DEBUG
    INFO = logging.INFO
    WARNING = logging.WARNING
    ERROR = logging.ERROR
    CRITICAL = logging.CRITICAL


class Logger:
    """Simple logging utility for Burme-Coder-Max"""

    def __init__(
        self,
        name: str = "burme_coder",
        level: int = logging.INFO,
        log_file: Optional[str] = None,
        format_string: Optional[str] = None,
    ):
        self.logger = logging.getLogger(name)
        self.logger.setLevel(level)
        self.logger.handlers = []

        if format_string is None:
            format_string = "%(asctime)s | %(levelname)-8s | %(message)s"

        formatter = logging.Formatter(format_string)

        console_handler = logging.StreamHandler(sys.stdout)
        console_handler.setFormatter(formatter)
        self.logger.addHandler(console_handler)

        if log_file:
            log_path = Path(log_file)
            log_path.parent.mkdir(parents=True, exist_ok=True)

            file_handler = logging.FileHandler(log_file, encoding="utf-8")
            file_handler.setFormatter(formatter)
            self.logger.addHandler(file_handler)

    def debug(self, message: str):
        """Log debug message"""
        self.logger.debug(message)

    def info(self, message: str):
        """Log info message"""
        self.logger.info(message)

    def warning(self, message: str):
        """Log warning message"""
        self.logger.warning(message)

    def error(self, message: str):
        """Log error message"""
        self.logger.error(message)

    def critical(self, message: str):
        """Log critical message"""
        self.logger.critical(message)

    def log(self, level: int, message: str):
        """Log with custom level"""
        self.logger.log(level, message)


_default_logger: Optional[Logger] = None


def get_logger(
    name: str = "burme_coder",
    level: int = logging.INFO,
    log_file: Optional[str] = None,
) -> Logger:
    """Get or create a logger instance"""
    global _default_logger

    if _default_logger is None or name != "burme_coder":
        return Logger(name=name, level=level, log_file=log_file)

    return _default_logger


def setup_default_logger(level: int = logging.INFO, log_file: Optional[str] = None):
    """Setup the default logger"""
    global _default_logger
    _default_logger = Logger(level=level, log_file=log_file)
    return _default_logger


class LogContext:
    """Context manager for logging operations"""

    def __init__(self, logger: Logger, operation: str):
        self.logger = logger
        self.operation = operation
        self.start_time = None

    def __enter__(self):
        self.start_time = datetime.now()
        self.logger.info(f"Starting: {self.operation}")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        duration = (datetime.now() - self.start_time).total_seconds()
        if exc_type is None:
            self.logger.info(f"Completed: {self.operation} ({duration:.2f}s)")
        else:
            self.logger.error(f"Failed: {self.operation} - {exc_val}")
        return False


def log_operation(operation: str, logger: Optional[Logger] = None):
    """Decorator for logging operations"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            log = logger or get_logger()
            with LogContext(log, operation):
                return func(*args, **kwargs)
        return wrapper
    return decorator