"""
Log logging_handling.log testing
"""

# import atexit
import sys
from pathlib import Path
# this is for testing only
from corelibs.logging_handling.log import Log, Logger, ConsoleFormat, ConsoleFormatSettings
from corelibs.debug_handling.debug_helpers import exception_stack, call_stack
from corelibs.logging_handling.logging_level_handling.logging_level import LoggingLevel


def main():
    """
    Log testing
    """
    script_path: Path = Path(__file__).resolve().parent
    log = Log(
        log_path=script_path.joinpath('log', 'test.log'),
        log_name="Test Log",
        log_settings={
            "log_level_console": 'DEBUG',
            # "log_level_console": None,
            "log_level_file": 'DEBUG',
            # "console_color_output_enabled": False,
            "per_run_log": True,
            # "console_format_type": ConsoleFormatSettings.NONE,
            # "console_format_type": ConsoleFormatSettings.MINIMAL,
            # "console_format_type": ConsoleFormat.TIME_MICROSECONDS | ConsoleFormat.NAME | ConsoleFormat.LEVEL,
            "console_format_type": None,
            # "console_format_type": ConsoleFormat.NAME,
            # "console_format_type": (
            #     ConsoleFormat.TIME | ConsoleFormat.TIMEZONE | ConsoleFormat.LINENO | ConsoleFormat.LEVEL
            # ),
        }
    )
    logn = Logger(log.get_logger_settings())

    log.info("ConsoleFormatType FILE is: %s", ConsoleFormat.FILE)
    log.info("ConsoleFormatSettings ALL is: %s", ConsoleFormatSettings.ALL)
    log.info("ConsoleFormatSettings lookup is: %s", ConsoleFormatSettings.from_string('ALL'))

    log.logger.debug('[NORMAL] Debug test: %s', log.logger.name)
    log.lg.debug('[NORMAL] Debug test: %s', log.logger.name)
    log.debug('[NORMAL-] Debug test: %s', log.logger.name)
    logn.lg.debug('[NORMAL N] Debug test: %s', log.logger.name)
    logn.debug('[NORMAL N-] Debug test: %s', log.logger.name)
    log.logger.info('[NORMAL] Info test: %s', log.logger.name)
    log.info('[NORMAL-] Info test: %s', log.logger.name)
    log.logger.warning('[NORMAL] Warning test: %s', log.logger.name)
    log.warning('[NORMAL-] Warning test: %s', log.logger.name)
    log.logger.error('[NORMAL] Error test: %s', log.logger.name)
    log.error('[NORMAL-] Error test: %s', log.logger.name)
    log.logger.critical('[NORMAL] Critical test: %s', log.logger.name)
    log.critical('[NORMAL-] Critical test: %s', log.logger.name)
    log.logger.log(LoggingLevel.ALERT.value, '[NORMAL] alert test: %s', log.logger.name)
    log.alert('[NORMAL-] alert test: %s', log.logger.name)
    log.emergency('[NORMAL-] emergency test: %s', log.logger.name)
    log.logger.log(LoggingLevel.EMERGENCY.value, '[NORMAL] emergency test: %s', log.logger.name)
    log.exception('[NORMAL] Exception test: %s', log.logger.name)
    log.logger.log(LoggingLevel.EXCEPTION.value, '[NORMAL] exception test: %s', log.logger.name, exc_info=True)

    bad_level = 'WRONG'
    if not Log.validate_log_level(bad_level):
        print(f"Invalid level: {bad_level}")
    good_level = 'WARNING'
    if Log.validate_log_level(good_level):
        print(f"Valid level: {good_level}")

    print(f"ERROR is to_logging_level(): {LoggingLevel.ERROR.to_logging_level()}")
    print(f"ERROR is to_lower_case(): {LoggingLevel.ERROR.to_lower_case()}")
    print(f"ERROR is: {LoggingLevel.ERROR}")
    print(f"ERROR is value: {LoggingLevel.ERROR.value}")
    print(f"ERROR is name: {LoggingLevel.ERROR.name}")
    print(f"ERROR is from_string(lower): {LoggingLevel.from_string('ERROR')}")
    print(f"ERROR is from_string(upper): {LoggingLevel.from_string('ERROR')}")
    print(f"ERROR is from_int: {LoggingLevel.from_int(40)}")
    print(f"ERROR is from_any(text lower): {LoggingLevel.from_any('ERROR')}")
    print(f"ERROR is from_any(text upper): {LoggingLevel.from_any('ERROR')}")
    print(f"ERROR is from_any(int): {LoggingLevel.from_any(40)}")
    print(f"INFO <= ERROR: {LoggingLevel.INFO.includes(LoggingLevel.ERROR)}")
    print(f"INFO > ERROR: {LoggingLevel.INFO.is_higher_than(LoggingLevel.ERROR)}")
    print(f"INFO < ERROR: {LoggingLevel.INFO.is_lower_than(LoggingLevel.ERROR)}")
    print(f"INFO < ERROR: {LoggingLevel.INFO.is_lower_than(LoggingLevel.ERROR)}")

    try:
        print(f"INVALID is A: {LoggingLevel.from_string('INVALID')}")
    except ValueError as e:
        print(f"* ERROR: {e}")

    try:
        __test = 5 / 0
        print(f"Divied: {__test}")
    except ZeroDivisionError as e:
        print(f"** sys.exec_info(): {sys.exc_info()}")
        print(f"** sys.exec_info(): [{exception_stack()}] | [{exception_stack(sys.exc_info())}] | [{call_stack()}]")
        log.logger.critical("Divison through zero: %s", e)
        log.exception("Divison through zero: %s", e)

    for handler in log.logger.handlers:
        print(
            f"** Handler (logger) {handler} [{handler.name}] -> "
            f"{handler.level} -> {LoggingLevel.from_any(handler.level)}"
        )

    for key, handler in log.handlers.items():
        print(f"Handler (handlers) [{key}] {handler} -> {handler.level} -> {LoggingLevel.from_any(handler.level)}")
    log.set_log_level(Log.CONSOLE_HANDLER, LoggingLevel.ERROR)
    log.logger.warning('[NORMAL] Invisible Warning test: %s', log.logger.name)
    log.logger.error('[NORMAL] Visible Error test: %s', log.logger.name)
    log.logger.debug('[NORMAL] Visible Debug test: %s', log.logger.name)
    print(f"*** Any handler is minimum level ERROR: {log.any_handler_is_minimum_level(LoggingLevel.ERROR)}")
    print(f"*** Any handler is minimum level DEBUG: {log.any_handler_is_minimum_level(LoggingLevel.DEBUG)}")
    for handler in log.handlers.values():
        print(
            f"*** Setting handler {handler} is level {LoggingLevel.from_any(handler.level).name} -> "
            f"*** INC {LoggingLevel.from_any(handler.level).includes(LoggingLevel.DEBUG)}")

    print(f"*** WARNING includes ERROR: {LoggingLevel.WARNING.includes(LoggingLevel.ERROR)}")
    print(f"*** ERROR includes WARNING: {LoggingLevel.ERROR.includes(LoggingLevel.WARNING)}")

    log.set_log_level(Log.CONSOLE_HANDLER, LoggingLevel.DEBUG)
    log.debug('Current logging format: %s', log.log_settings['console_format_type'])
    log.debug('Current console formatter: %s', log.get_console_formatter())
    log.update_console_formatter(ConsoleFormat.TIME | ConsoleFormat.LINENO)
    log.info('Does hit show less A')
    log.debug('Current console formatter after A: %s', log.get_console_formatter())
    log.update_console_formatter(ConsoleFormat.TIME | ConsoleFormat.LINENO)
    log.info('Does hit show less B')
    log.debug('Current console formatter after B: %s', log.get_console_formatter())
    log.update_console_formatter(ConsoleFormatSettings.ALL)
    log.info('Does hit show less C')
    log.debug('Current console formatter after C: %s', log.get_console_formatter())
    print(f"*** Any handler is minimum level ERROR: {log.any_handler_is_minimum_level(LoggingLevel.ERROR)}")
    print(f"*** Any handler is minimum level DEBUG: {log.any_handler_is_minimum_level(LoggingLevel.DEBUG)}")


if __name__ == "__main__":
    main()

# __END__