import logging
import logging.config
import re
from dataclasses import asdict, dataclass

from appdaemon.logging import AppNameFormatter
from rich.console import Console
from rich.highlighter import RegexHighlighter
from rich.theme import Theme


class RCHighlighter(RegexHighlighter):
    highlights = [
        r'(?P<light>(light|switch)\.\w+)',
        r'(?P<time>\d+:\d+:\d+)',
        r'(?P<z2m>zigbee2mqtt/)',
        r'(?P<sensor>binary_sensor\.\w+)',
        # r"'state': '(?P<on>on)|(?P<off>off)'"
        r'(?P<true>True)|(?P<false>False)',
    ]


console = Console(
    width=100,
    theme=Theme(
        {
            'log.time': 'none',
            'logging.level.info': 'none',
            'room': 'italic bright_cyan',
            'component': 'dark_violet',
            'friendly_name': 'yellow',
            'light': 'light_slate_blue',
            'sensor': 'green',
            'time': 'yellow',
            'z2m': 'bright_black',
            'topic': 'chartreuse2',
            'true': 'green',
            'false': 'red',
        }
    ),
    log_time_format='%Y-%m-%d %I:%M:%S %p',
    highlighter=RCHighlighter(),
)


class ContextSettingFilter(logging.Filter):
    def filter(self, record: logging.LogRecord):
        for name, val in asdict(self).items():
            setattr(record, name, val)
        return record


@dataclass
class RoomControllerFilter(ContextSettingFilter):
    room: str
    component: str


class UnMarkupFormatter(AppNameFormatter):
    md_regex = re.compile(r'(?P<open>\[.*?\])(?P<text>.*?)(?P<close>\[\/\])')

    def format(self, record: logging.LogRecord):
        result = super().format(record)
        return self.md_regex.sub(r'\g<text>', result)


def create_rich_logging_dict(parent_room: str, typ: str = None):
    logger_name = f'room_control.{parent_room}'
    if typ is not None:
        logger_name += f'.{typ}'
        fmt = '[room]{room:>12}[/] [component]{component:<9}[/]{message}'
    else:
        fmt = '[room]{room:>12}[/] {message}'

    LOG_CFG = {
        'version': 1,
        'disable_existing_loggers': False,
        'filters': {
            logger_name: {
                '()': 'console.RoomControllerFilter',
                # '.': {'room': parent_room, 'component': typ},
                'room': parent_room,
                'component': typ,
            }
        },
        'formatters': {
            logger_name: {
                'style': '{',
                'format': fmt,
                # 'datefmt': '%Y-%m-%d %I:%M:%S %p',
            }
        },
        'handlers': {
            logger_name: {
                'filters': [logger_name],
                'formatter': logger_name,
                '()': 'rich.logging.RichHandler',
                'markup': True,
                'log_time_format': '%Y-%m-%d %I:%M:%S %p',
                'show_path': False,
                'omit_repeated_times': False,
                'highlighter': RCHighlighter(),
                'console': console,
            },
        },
        'loggers': {
            logger_name: {
                'level': 'INFO',
                'propagate': False,
                'handlers': [logger_name],
            }
        },
    }
    return LOG_CFG


def setup_component_logging(self):
    cfg_dict = create_rich_logging_dict(parent_room=self.args['app'], typ=type(self).__name__)
    logger_name = next(iter(cfg_dict['loggers']))

    try:
        logging.config.dictConfig(cfg_dict)
    except Exception:
        console.print_exception()
    else:
        self.logger = logging.getLogger(logger_name)