#!/usr/bin/env python3
# pylint: disable=too-many-instance-attributes, too-many-arguments, too-many-positional-arguments, logging-fstring-interpolation
"""
All of the Zabbix Usermacro related configuration
"""
from re import match
from logging import getLogger
from modules.tools import field_mapper

class ZabbixUsermacros():
    """Class that represents a Zabbix interface."""

    def __init__(self, nb, usermacro_map, usermacro_sync, logger=None, host=None):
        self.nb = nb
        self.name = host if host else nb.name
        self.usermacro_map = usermacro_map
        self.logger = logger if logger else getLogger(__name__)
        self.usermacros = {}
        self.usermacro_sync = usermacro_sync
        self.sync = False
        self.force_sync = False
        self._set_config()

    def __repr__(self):
        return self.name

    def __str__(self):
        return self.__repr__()

    def _set_config(self):
        """
        Setup class
        """
        if str(self.usermacro_sync).lower() == "full":
            self.sync = True
            self.force_sync = True
        elif self.usermacro_sync:
            self.sync = True
        return True

    def validate_macro(self, macro_name):
        """
        Validates usermacro name
        """
        pattern = r'\{\$[A-Z0-9\._]*(\:.*)?\}'
        return match(pattern, macro_name)

    def render_macro(self, macro_name, macro_properties):
        """
        Renders a full usermacro from partial input
        """
        macro={}
        macrotypes={'text': 0, 'secret': 1, 'vault': 2}
        if self.validate_macro(macro_name):
            macro['macro'] = str(macro_name)
            if isinstance(macro_properties, dict):
                if not 'value' in macro_properties:
                    self.logger.error(f'Usermacro {macro_name} has no value, skipping.')
                    return False
                macro['value'] = macro_properties['value']

                if 'type' in macro_properties and macro_properties['type'].lower() in macrotypes:
                    macro['type'] = str(macrotypes[macro_properties['type']])
                else:
                    macro['type'] = str(0)

                if ('description' in macro_properties and
                     isinstance(macro_properties['description'], str)):
                    macro['description'] = macro_properties['description']
                else:
                    macro['description'] = ""

            elif isinstance(macro_properties, str):
                macro['value'] = macro_properties
                macro['type'] = str(0)
                macro['description'] = ""
        else:
            self.logger.error(f'Usermacro {macro_name} is not a valid usermacro name, skipping.')
            return False
        return macro

    def generate(self):
        """
        Generate full set of Usermacros
        """
        macros=[]
        # Parse the field mapper for usermacros
        if self.usermacro_map:
            self.logger.debug(f"Host {self.nb.name}: Starting usermacro mapper")
            field_macros = field_mapper(self.nb.name, self.usermacro_map, self.nb, self.logger)
            for macro, value in field_macros.items():
                m = self.render_macro(macro, value)
                if m:
                    macros.append(m)
        # Parse NetBox config context for usermacros
        if "zabbix" in self.nb.config_context and "usermacros" in self.nb.config_context['zabbix']:
            for macro, properties in self.nb.config_context['zabbix']['usermacros'].items():
                m = self.render_macro(macro, properties)
                if m:
                    macros.append(m)
        return macros