"""
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
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
        }
    )
    logn = Logger(log.get_logger_settings())

    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('stream_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.handlers['stream_handler'].se


if __name__ == "__main__":
    main()

# __END__