import logging as _logging
import os as _os
import sys as _sys
import _thread
import time as _time
import traceback as _traceback
import warnings
from logging import DEBUG
from logging import ERROR
from logging import CRITICAL
from logging import INFO
from logging import WARN
import threading

# Don't use this directly. Use get_logger() instead.
_logger = None
_logger_lock = threading.Lock()

_file_handler = None


def set_enabled(value: bool):
    get_logger().disabled = not value


def is_enabled():
    return not get_logger().disabled


def error_log(error_msg, level=ERROR):
    """Empty helper method."""
    del error_msg, level


def _get_formatter():
    return _logging.Formatter(
        fmt='%(asctime)s.%(msecs)03d %(name)-12s %(levelname)-8s %(thread)-6d %(message)s',
        datefmt='%H:%M:%S')


def _get_caller(offset=3):
    """Returns a code and frame object for the lowest non-logging stack frame."""
    # Use sys._getframe().  This avoids creating a traceback object.
    f = _sys._getframe(offset)
    our_file = f.f_code.co_filename
    f = f.f_back
    while f:
        code = f.f_code
        if code.co_filename != our_file:
            return code, f
        f = f.f_back
    return None, None


def _logger_find_caller(stack_info=False, stacklevel=1):
    code, frame = _get_caller(4)
    sinfo = None
    if stack_info:
        sinfo = '\n'.join(_traceback.format_stack())
    if code:
        return (code.co_filename, frame.f_lineno, code.co_name, sinfo)
    else:
        return '(unknown file)', 0, '(unknown function)', sinfo


def get_logger():
    global _logger

    # Use double-checked locking to avoid taking lock unnecessarily.
    if _logger:
        return _logger

    _logger_lock.acquire()

    try:
        if _logger:
            return _logger

        logger = _logging.getLogger('unitap')

        # Override findCaller on the logger to skip internal helper functions
        logger.findCaller = _logger_find_caller

        if not _logging.getLogger().handlers:
            # Determine whether we are in an interactive environment
            _interactive = False
            try:
                # This is only defined in interactive shells.
                if _sys.ps1:
                    _interactive = True
            except AttributeError:
                # Even now, we may be in an interactive shell with `python -i`.
                _interactive = _sys.flags.interactive

            # If we are in an interactive environment (like Jupyter), set loglevel
            # to INFO and pipe the output to stdout.
            if _interactive:
                logger.setLevel(INFO)
                _logging_target = _sys.stdout
            else:
                _logging_target = _sys.stderr

            # Add the output handler.
            _handler = _logging.StreamHandler(_logging_target)
            _handler.setFormatter(_get_formatter())
            logger.addHandler(_handler)
            logger.propagate = False

        _logger = logger
        return _logger

    finally:
        _logger_lock.release()


def log(level, msg, *args, **kwargs):
    get_logger().log(level, msg, *args, **kwargs)


def debug(msg, *args, **kwargs):
    get_logger().debug(msg, *args, **kwargs)


def error(msg, *args, **kwargs):
    get_logger().error(msg, *args, **kwargs)


def fatal(msg, *args, **kwargs):
    get_logger().fatal(msg, *args, **kwargs)


def info(msg, *args, **kwargs):
    get_logger().info(msg, *args, **kwargs)


def warn(msg, *args, **kwargs):
    get_logger().warning(msg, *args, **kwargs)


def warning(msg, *args, **kwargs):
    get_logger().warning(msg, *args, **kwargs)


_level_names = {
    CRITICAL: 'CRITICAL',
    ERROR: 'ERROR',
    WARN: 'WARN',
    INFO: 'INFO',
    DEBUG: 'DEBUG',
}

# Mask to convert integer thread ids to unsigned quantities for logging
# purposes
_THREAD_ID_MASK = 2 * _sys.maxsize + 1

_log_prefix = None  # later set to google2_log_prefix

# Counter to keep track of number of log entries per token.
_log_counter_per_token = {}


def TaskLevelStatusMessage(msg):
    error(msg)


def flush():
    raise NotImplementedError()


# Code below is taken from pyglib/logging
def vlog(level, msg, *args, **kwargs):
    get_logger().log(level, msg, *args, **kwargs)


def _GetNextLogCountPerToken(token):
    global _log_counter_per_token
    _log_counter_per_token[token] = 1 + _log_counter_per_token.get(token, -1)
    return _log_counter_per_token[token]


def log_every_n(level, msg, n, *args):
    """Log 'msg % args' at level 'level' once per 'n' times.
  Logs the 1st call, (N+1)st call, (2N+1)st call,  etc.
  Not threadsafe.
  Args:
    level: The level at which to log.
    msg: The message to be logged.
    n: The number of times this should be called before it is logged.
    *args: The args to be substituted into the msg.
  """
    count = _GetNextLogCountPerToken(_GetFileAndLine())
    log_if(level, msg, not (count % n), *args)


def log_first_n(level, msg, n, *args):
    """Log 'msg % args' at level 'level' only first 'n' times.
  Not threadsafe.
  Args:
    level: The level at which to log.
    msg: The message to be logged.
    n: The number of times this should be called before it is logged.
    *args: The args to be substituted into the msg.
  """
    count = _GetNextLogCountPerToken(_GetFileAndLine())
    log_if(level, msg, count < n, *args)


def log_if(level, msg, condition, *args):
    """Log 'msg % args' at level 'level' only if condition is fulfilled."""
    if condition:
        vlog(level, msg, *args)


def _GetFileAndLine():
    """Returns (filename, linenumber) for the stack frame."""
    code, f = _get_caller()
    if not code:
        return '<unknown>', 0
    return code.co_filename, f.f_lineno


def google2_log_prefix(level, timestamp=None, file_and_line=None):
    """Assemble a logline prefix using the google2 format."""
    global _level_names

    # Record current time
    now = timestamp or _time.time()
    now_tuple = _time.localtime(now)
    now_microsecond = int(1e6 * (now % 1.0))

    (filename, line) = file_and_line or _GetFileAndLine()
    basename = _os.path.basename(filename)

    # Severity string
    severity = 'I'
    if level in _level_names:
        severity = _level_names[level][0]

    s = '%c%02d%02d %02d:%02d:%02d.%06d %5d %s:%d] ' % (
        severity,
        now_tuple[1],  # month
        now_tuple[2],  # day
        now_tuple[3],  # hour
        now_tuple[4],  # min
        now_tuple[5],  # sec
        now_microsecond,
        _get_thread_id(),
        basename,
        line)

    return s


def get_verbosity():
    """Return how much logging output will be produced."""
    return get_logger().getEffectiveLevel()


def set_verbosity(v):
    """Sets the threshold for what messages will be logged."""
    get_logger().setLevel(v)


def set_file_output(filename, file_mode="w"):
    """Set file handler"""
    warnings.warn("This function is deprecated. Use `enable_file_logging` and `disable_file_logging` instead.",
                  DeprecationWarning)
    enable_file_logging(filename, file_mode)


def enable_file_logging(filename, file_mode="w"):
    global _file_handler

    if _file_handler is None:
        _file_handler = _logging.FileHandler(filename, mode=file_mode)
        _file_handler.setFormatter(_get_formatter())
        get_logger().addHandler(_file_handler)
    else:
        _file_handler.stream.close()
        filename = _os.fspath(filename)
        _file_handler.baseFilename = _os.path.abspath(filename)
        _file_handler.stream = open(_file_handler.baseFilename, file_mode)


def disable_file_logging():
    global _file_handler

    if _file_handler is not None:
        _file_handler.stream.close()
        get_logger().removeHandler(_file_handler)
        _file_handler = None
    else:
        warnings.warn("Cannot disable file logging because file logger is not defined")


def _get_thread_id():
    """Get id of current thread, suitable for logging as an unsigned quantity."""
    thread_id = _thread.get_ident()
    return thread_id & _THREAD_ID_MASK


_log_prefix = google2_log_prefix