import logging
from logging.handlers import RotatingFileHandler
from typing import Optional
from tools.globals import LOG_MAX_BYTES, LOG_BACKUP_COUNT


def config_logging(
    logger_name: str = "TPGGUI",
    log_file: str = "logfile.log",
    file_mode: str = "a",
    force_reset: bool = False,
) -> logging.Logger:
    """PYDM already has logging configured, but this prevents easy
    reconfiguration. This function reconfigures logging to output to a local
    file. After this function is called, logging can be done in the preferred
    configuration by recalling the logging instance:

    !!!Note: This should only be done when configuring a top-level logger (e.g. TPGGUI).
    For child loggers (e.g. TPGGUI.PB), using the normal logging.getLogger("TPGGUI.PB")
    will allow the correct handlers to propagate

        import logging
        class A():
            def __init__():
                self.logger = configLogging("CustomLogger")

            def foo(self):
                self.logger.info("Foo called")

    Args:
        logger_name (str, optional): Name of logger. Defaults to "TPGGUI".
        log_file (str, optional): File to write logs to. Defaults
        to "logfile.log".
        file_mode (str, optional): File writing mode. Defaults to "a".
        force_reset (bool, optional): Forces config to regenerate logger, even if
        it already exists. Defaults to False.

    Returns:
        logger (Logger): Configured Logger instance.
    """

    logger = logging.getLogger(logger_name)

    # Make custom logger
    # Remove any existing handlers
    for handler in logger.handlers[:]:
        is_fh = isinstance(handler, logging.FileHandler)
        is_sh = isinstance(handler, logging.StreamHandler)
        if is_fh or is_sh:
            logger.removeHandler(handler)

    # Make handlers
    f_handler = RotatingFileHandler(
        log_file, maxBytes=LOG_MAX_BYTES, backupCount=LOG_BACKUP_COUNT
    )
    s_handler = logging.StreamHandler()

    # Set handler levels
    f_handler.setLevel(logging.DEBUG)
    s_handler.setLevel(logging.DEBUG)

    # Set handler formatting
    formatter = AlignedLogFormatter()
    f_handler.setFormatter(formatter)
    s_handler.setFormatter(formatter)

    # Set logger level
    logger.setLevel(logging.DEBUG)

    # Add handlers to logger
    logger.addHandler(f_handler)
    logger.addHandler(s_handler)

    return logger


def logger_is_initialized(logger_name: str = "TPGGUI") -> bool:
    """Checks that the custom logger for TPGGUI has been initialized

    Args:
        logger_name (Optional[str], optional): logger name. Defaults to "TPGGUI".

    Returns:
        bool: if logger exists
    """
    return logger_name in logging.Logger.manager.loggerDict


class AlignedLogFormatter(logging.Formatter):
    def format(self, record):
        message = record.getMessage()
        levelname = record.levelname
        name = record.name

        # Column allocations for each section
        level_width = 8
        name_width = 10

        # Format message
        formatted_message = (
            f"{levelname:>{level_width}} | {name:<{name_width}} | {message}"
        )
        return formatted_message
