# python3.7
"""Contains the base class for logging.

Basically, this is an interface bridging the program and the local file system.
A logger is able to log wrapped message onto the screen and a log file.
"""

import logging

__all__ = ['BaseLogger']


class BaseLogger(object):
    """Defines the base logger.

    A logger should have the following members:

    (1) logger: The logger to record message.
    (2) pbar: The progressive bar (shown on the screen only).
    (3) pbar_kwargs: The arguments for the progressive bar.
    (4) file_stream: The stream to log messages into if needed.

    A logger should have the following functions:

    (1) log(): The base function to log message.
    (2) debug(): The function to log message with `DEBUG` level.
    (3) info(): The function to log message with `INFO` level.
    (4) warning(): The function to log message with `WARNING` level.
    (5) warn(): Same as function `warning()`.
    (6) error(): The function to log message with `ERROR` level.
    (7) exception(): The function to log message with exception information.
    (8) critical(): The function to log message with `CRITICAL` level.
    (9) fatal(): Same as function `critical()`.
    (10) print(): The function to print the message without any decoration.
    (11) init_pbar(): The function to initialize the progressive bar.
    (12) add_pbar_task(): The function to add a task to the progressive bar.
    (13) update_pbar(): The function to update the progressive bar.
    (14) close_pbar(): The function to close the progressive bar.

    The logger will record log message both on screen and to file.

    Args:
        logger_name: Unique name for the logger. (default: `logger`)
        logfile: Path to the log file. If set as `None`, the file stream
            will be skipped. (default: `None`)
        screen_level: Minimum level of message to log onto screen.
            (default: `logging.INFO`)
        file_level: Minimum level of message to log into file.
            (default: `logging.DEBUG`)
        indent_space: Number of spaces between two adjacent indent levels.
            (default: 4)
        verbose_log: Whether to log verbose message. (default: False)
    """

    def __init__(self,
                 logger_name='logger',
                 logfile=None,
                 screen_level=logging.INFO,
                 file_level=logging.DEBUG,
                 indent_space=4,
                 verbose_log=False):
        self.logger_name = logger_name
        self.logfile = logfile
        self.screen_level = screen_level
        self.file_level = file_level
        self.indent_space = indent_space
        self.verbose_log = verbose_log

        self.logger = None
        self.pbar = None
        self.pbar_kwargs = None
        self.file_stream = None

        self.warn = self.warning
        self.fatal = self.critical

    def __del__(self):
        self.close()

    def close(self):
        """Closes the logger."""
        if self.file_stream is not None:
            self.file_stream.close()

    @property
    def name(self):
        """Returns the class name of the logger."""
        return self.__class__.__name__

    # Log message.
    def wrap_message(self, message, indent_level=0):
        """Wraps the message with indent."""
        if message is None:
            message = ''
        assert isinstance(message, str)
        assert isinstance(indent_level, int) and indent_level >= 0
        if message == '':
            return ''
        return ' ' * (indent_level * self.indent_space) + message

    def _log(self, message, **kwargs):
        """Logs wrapped message."""
        raise NotImplementedError('Should be implemented in derived class!')

    def _debug(self, message, **kwargs):
        """Logs wrapped message with `DEBUG` level."""
        raise NotImplementedError('Should be implemented in derived class!')

    def _info(self, message, **kwargs):
        """Logs wrapped message with `INFO` level."""
        raise NotImplementedError('Should be implemented in derived class!')

    def _warning(self, message, **kwargs):
        """Logs wrapped message with `WARNING` level."""
        raise NotImplementedError('Should be implemented in derived class!')

    def _error(self, message, **kwargs):
        """Logs wrapped message with `ERROR` level."""
        raise NotImplementedError('Should be implemented in derived class!')

    def _exception(self, message, **kwargs):
        """Logs wrapped message with exception information."""
        raise NotImplementedError('Should be implemented in derived class!')

    def _critical(self, message, **kwargs):
        """Logs wrapped message with `CRITICAL` level."""
        raise NotImplementedError('Should be implemented in derived class!')

    def _print(self, *messages, **kwargs):
        """Prints wrapped message without any decoration."""
        raise NotImplementedError('Should be implemented in derived class!')

    def log(self, message, indent_level=0, is_verbose=False, **kwargs):
        """Logs message.

        The message is wrapped with indent, and will be disabled if `is_verbose`
        is set as `True`.
        """
        if is_verbose and not self.verbose_log:
            return
        message = self.wrap_message(message, indent_level=indent_level)
        self._log(message, **kwargs)

    def debug(self, message, indent_level=0, is_verbose=False, **kwargs):
        """Logs message with `DEBUG` level.

        The message is wrapped with indent, and will be disabled if `is_verbose`
        is set as `True`.
        """
        if is_verbose and not self.verbose_log:
            return
        message = self.wrap_message(message, indent_level=indent_level)
        self._debug(message, **kwargs)

    def info(self, message, indent_level=0, is_verbose=False, **kwargs):
        """Logs message with `INFO` level.

        The message is wrapped with indent, and will be disabled if `is_verbose`
        is set as `True`.
        """
        if is_verbose and not self.verbose_log:
            return
        message = self.wrap_message(message, indent_level=indent_level)
        self._info(message, **kwargs)

    def warning(self, message, indent_level=0, is_verbose=False, **kwargs):
        """Logs message with `WARNING` level.

        The message is wrapped with indent, and will be disabled if `is_verbose`
        is set as `True`.
        """
        if is_verbose and not self.verbose_log:
            return
        message = self.wrap_message(message, indent_level=indent_level)
        self._warning(message, **kwargs)

    def error(self, message, indent_level=0, is_verbose=False, **kwargs):
        """Logs message with `ERROR` level.

        The message is wrapped with indent, and will be disabled if `is_verbose`
        is set as `True`.
        """
        if is_verbose and not self.verbose_log:
            return
        message = self.wrap_message(message, indent_level=indent_level)
        self._error(message, **kwargs)

    def exception(self, message, indent_level=0, is_verbose=False, **kwargs):
        """Logs message with exception information.

        The message is wrapped with indent, and will be disabled if `is_verbose`
        is set as `True`.
        """
        if is_verbose and not self.verbose_log:
            return
        message = self.wrap_message(message, indent_level=indent_level)
        self._exception(message, **kwargs)

    def critical(self, message, indent_level=0, is_verbose=False, **kwargs):
        """Logs message with `CRITICAL` level.

        The message is wrapped with indent, and will be disabled if `is_verbose`
        is set as `True`.
        """
        if is_verbose and not self.verbose_log:
            return
        message = self.wrap_message(message, indent_level=indent_level)
        self._critical(message, **kwargs)

    def print(self, *messages, indent_level=0, is_verbose=False, **kwargs):
        """Prints message without any decoration.

        The message is wrapped with indent, and will be disabled if `is_verbose`
        is set as `True`.
        """
        if is_verbose and not self.verbose_log:
            return
        new_messages = []
        for message in messages:
            new_messages.append(
                self.wrap_message(message, indent_level=indent_level))
        self._print(*new_messages, **kwargs)

    # Progressive bar.
    def init_pbar(self, leave=False):
        """Initializes the progressive bar.

        Args:
            leave: Whether to leave the trace of the progressive bar.
                (default: False)
        """
        raise NotImplementedError('Should be implemented in derived class!')

    def add_pbar_task(self, name, total, **kwargs):
        """Adds a task to the progressive bar.

        Args:
            name: Name of the added task.
            total: Total number of steps (samples) contained in the task.
            **kwargs: Additional arguments.

        Returns:
            Task ID.
        """
        raise NotImplementedError('Should be implemented in derived class!')

    def update_pbar(self, task_id, advance=1):
        """Updates the progressive bar.

        Args:
            task_id: ID of the task to update.
            advance: Number of steps advanced onto the target task. (default: 1)
        """
        raise NotImplementedError('Should be implemented in derived class!')

    def close_pbar(self):
        """Closes the progress bar."""
        raise NotImplementedError('Should be implemented in derived class!')