import logging
import logging.handlers
import os
import sys


# Currently this method only handles not to create duplicate for
# StreamHandler (stdout or stdin) & SysLogHandler
def isHandlerTypePresent(logger, handler):
    isPresent = False
    handlerType = type(handler)
    for h in logger.handlers[:]:
        if handlerType == type(h):
            isPresent = True
            break

    return isPresent


def addHandlerIfNotPresent(logger, handler):
    # Add handler only if not present in logger and root logger
    if not isHandlerTypePresent(logger, handler) and \
            not isHandlerTypePresent(logging.getLogger(), handler):
        logger.addHandler(handler)


def getLogLevelFromVault(conf):
    try:
        if conf.vault_logging_level.lower() == 'debug':
            return logging.DEBUG
        elif conf.vault_logging_level.lower() == 'info':
            return logging.INFO
        elif conf.vault_logging_level.lower() == 'warn':
            return logging.WARN
        else:
            return logging.ERROR
    except BaseException:
        return logging.logging.ERROR


# oslo config has oslo style log params which need to be converted to python
# std logging style params
def oslo_interval_type_to_std(rotate_type):
    if rotate_type is not None:
        if rotate_type == "Hours":
            return 'H'
        elif rotate_type == "Minutes":
            return 'M'
        elif rotate_type == "Seconds":
            return 'S'
        elif rotate_type == "Days":
            return 'D'
    return None


# Currently s3 config only supports interval based rotations.
# returns the handler
def SetupLogFileRotation(logger, conf, log_file, format, datefmt):
    if log_file is None:
        return

    if conf.log_rotation_type == "interval":
        when = oslo_interval_type_to_std(conf.log_rotate_interval_type)
        interval = conf.log_rotate_interval
        backup_count = conf.max_logfile_count
        handler = logging.handlers.TimedRotatingFileHandler(
            log_file, when=when, interval=interval, backupCount=backup_count)
        formatter = logging.Formatter(format, datefmt)
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        return handler


def SetupS3FuseLogging(conf):
    # This log format is set similar to oslo.log default format used
    # in openstack with exception of %(instance)s which is only available
    # in openstack. openstack specific format is defined in openstack setups
    # vault.conf, for example see
    # <s3fuse src>/etc/tvault-object-store/tvault-object-store.conf
    default_log_format = '%(asctime)s.%(msecs)03d %(process)d ' + \
        '%(levelname)s %(name)s [-] %(message)s'

    log_args = {}

    log_to_file = False
    if conf.log_dir is not None and len(conf.log_dir) != 0:
        if conf.log_file is not None and len(conf.log_file) != 0:
            log_args['filename'] = os.path.join(conf.log_dir, conf.log_file)
            log_to_file = True
    else:
        if conf.log_file is not None and len(conf.log_file) != 0:
            log_args['filename'] = conf.log_file
            log_to_file = True

    if conf.log_format is not None and len(conf.log_format) != 0:
        log_args['format'] = conf.log_format
    else:
        log_args['format'] = default_log_format

    if conf.log_date_format is not None and len(conf.log_date_format) != 0:
        log_args['datefmt'] = conf.log_date_format

    if conf.log_config is not None and len(conf.log_config) != 0:
        logging.config.fileConfig(fname=conf.log_config)

    if conf.log_config_append is not None and len(conf.log_config_append) != 0:
        logging.config.fileConfig(fname=conf.log_config_append, disable_existing_loggers=False)

    # configure the logging module
    logging.basicConfig(**log_args)
    s3fuse_logger = logging.getLogger(conf.vault_storage_type.lower())
    botocore_logger = logging.getLogger("botocore")

    if log_to_file and conf.log_rotation_type is not None:
        handler = SetupLogFileRotation(s3fuse_logger, conf,
                                       log_args['filename'],
                                       log_args['format'], log_args['datefmt'])
        botocore_logger.addHandler(handler)

    if conf.use_syslog is not None and conf.use_syslog:
        handler = logging.handlers.SysLogHandler()
        formatter = logging.Formatter(log_args['format'], log_args['datefmt'])
        handler.setFormatter(formatter)
        addHandlerIfNotPresent(s3fuse_logger, handler)

    if conf.use_stderr is not None and conf.use_stderr:
        handler = logging.StreamHandler(sys.stderr)
        formatter = logging.Formatter(log_args['format'], log_args['datefmt'])
        handler.setFormatter(formatter)
        addHandlerIfNotPresent(s3fuse_logger, handler)

    # Setup logging level filters
    s3fuse_logger.setLevel(getLogLevelFromVault(conf))

    # For boto, set log level to warn
    botocore_logger.setLevel(getLogLevelFromVault(conf))

    # return module logger for s3fuse
    return s3fuse_logger