"""cssutils ErrorHandler

ErrorHandler
    used as log with usual levels (debug, info, warn, error)

    if instanciated with ``raiseExceptions=True`` raises exeptions instead
    of logging

log
    defaults to instance of ErrorHandler for any kind of log message from
    lexerm, parser etc.

    - raiseExceptions = [False, True]
    - setloglevel(loglevel)
"""

__all__ = ['ErrorHandler']

import logging
import urllib.error
import urllib.parse
import urllib.request
import xml.dom


class _ErrorHandler:
    """
    handles all errors and log messages
    """

    def __init__(self, log, defaultloglevel=logging.INFO, raiseExceptions=True):
        """
        inits log if none given

        log
            for parse messages, default logs to sys.stderr
        defaultloglevel
            if none give this is logging.DEBUG
        raiseExceptions
            - True: Errors will be raised e.g. during building
            - False: Errors will be written to the log, this is the
              default behaviour when parsing
        """
        # may be disabled during setting of known valid items
        self.enabled = True

        if log:
            self._log = log
        else:
            import sys

            self._log = logging.getLogger('CSSUTILS')
            hdlr = logging.StreamHandler(sys.stderr)
            formatter = logging.Formatter('%(levelname)s\t%(message)s')
            hdlr.setFormatter(formatter)
            self._log.addHandler(hdlr)
            self._log.setLevel(defaultloglevel)

        self.raiseExceptions = raiseExceptions

    def __getattr__(self, name):
        "use self._log items"
        calls = ('debug', 'info', 'warn', 'error', 'critical', 'fatal')
        other = ('setLevel', 'getEffectiveLevel', 'addHandler', 'removeHandler')

        if name in calls:
            if name == 'warn':
                name = 'warning'
            self._logcall = getattr(self._log, name)
            return self.__handle
        elif name in other:
            return getattr(self._log, name)
        else:
            raise AttributeError('(errorhandler) No Attribute %r found' % name)

    def __handle(
        self, msg='', token=None, error=xml.dom.SyntaxErr, neverraise=False, args=None
    ):
        """
        handles all calls
        logs or raises exception
        """
        if self.enabled:
            if error is None:
                error = xml.dom.SyntaxErr

            line, col = None, None
            if token:
                if isinstance(token, tuple):
                    value, line, col = token[1], token[2], token[3]
                else:
                    value, line, col = token.value, token.line, token.col
                msg = f'{msg} [{line}:{col}: {value}]'

            if error and self.raiseExceptions and not neverraise:
                if isinstance(error, urllib.error.HTTPError) or isinstance(
                    error, urllib.error.URLError
                ):
                    raise
                elif issubclass(error, xml.dom.DOMException):
                    error.line = line
                    error.col = col
                raise error(msg)
            else:
                self._logcall(msg)

    def setLog(self, log):
        """set log of errorhandler's log"""
        self._log = log


class ErrorHandler(_ErrorHandler):
    "Singleton, see _ErrorHandler"

    instance = None

    def __init__(self, log=None, defaultloglevel=logging.INFO, raiseExceptions=True):
        if ErrorHandler.instance is None:
            ErrorHandler.instance = _ErrorHandler(
                log=log,
                defaultloglevel=defaultloglevel,
                raiseExceptions=raiseExceptions,
            )
        self.__dict__ = ErrorHandler.instance.__dict__