"""A validating CSSParser"""

import codecs
import sys

from . import errorhandler, helper, tokenize2


class ErrorHandler:
    """Basic class for CSS error handlers.

    This class class provides a default implementation ignoring warnings and
    recoverable errors and throwing a SAXParseException for fatal errors.

    If a CSS application needs to implement customized error handling, it must
    extend this class and then register an instance with the CSS parser
    using the parser's setErrorHandler method. The parser will then report all
    errors and warnings through this interface.

    The parser shall use this class instead of throwing an exception: it is
    up to the application whether to throw an exception for different types of
    errors and warnings. Note, however, that there is no requirement that the
    parser continue to provide useful information after a call to fatalError
    (in other words, a CSS driver class could catch an exception and report a
    fatalError).
    """

    def __init__(self):
        self._log = errorhandler.ErrorHandler()

    def error(self, exception, token=None):
        self._log.error(exception, token, neverraise=True)

    def fatal(self, exception, token=None):
        self._log.fatal(exception, token)

    def warn(self, exception, token=None):
        self._log.warn(exception, token, neverraise=True)


class DocumentHandler:
    """
    void     endFontFace()
             Receive notification of the end of a font face statement.
    void     endMedia(SACMediaList media)
             Receive notification of the end of a media statement.
    void     endPage(java.lang.String name, java.lang.String pseudo_page)
             Receive notification of the end of a media statement.
    void     importStyle(java.lang.String uri, SACMediaList media,
             java.lang.String defaultNamespaceURI)
             Receive notification of a import statement in the style sheet.
    void     startFontFace()
             Receive notification of the beginning of a font face statement.
    void     startMedia(SACMediaList media)
             Receive notification of the beginning of a media statement.
    void     startPage(java.lang.String name, java.lang.String pseudo_page)
             Receive notification of the beginning of a page statement.
    """

    def __init__(self):
        def log(msg):
            sys.stderr.write('INFO\t%s\n' % msg)

        self._log = log

    def comment(self, text, line=None, col=None):
        "Receive notification of a comment."
        self._log(f"comment {text!r} at [{line}, {col}]")

    def startDocument(self, encoding):
        "Receive notification of the beginning of a style sheet."
        # source
        self._log("startDocument encoding=%s" % encoding)

    def endDocument(self, source=None, line=None, col=None):
        "Receive notification of the end of a document."
        self._log("endDocument EOF")

    def importStyle(self, uri, media, name, line=None, col=None):
        "Receive notification of a import statement in the style sheet."
        # defaultNamespaceURI???
        self._log(f"importStyle at [{line}, {col}]")

    def namespaceDeclaration(self, prefix, uri, line=None, col=None):
        "Receive notification of an unknown rule t-rule not supported by this parser."
        # prefix might be None!
        self._log(f"namespaceDeclaration at [{line}, {col}]")

    def startSelector(self, selectors=None, line=None, col=None):
        "Receive notification of the beginning of a rule statement."
        # TODO selectorList!
        self._log(f"startSelector at [{line}, {col}]")

    def endSelector(self, selectors=None, line=None, col=None):
        "Receive notification of the end of a rule statement."
        self._log(f"endSelector at [{line}, {col}]")

    def property(self, name, value='TODO', important=False, line=None, col=None):
        "Receive notification of a declaration."
        # TODO: value is LexicalValue?
        self._log(f"property {name!r} at [{line}, {col}]")

    def ignorableAtRule(self, atRule, line=None, col=None):
        "Receive notification of an unknown rule t-rule not supported by this parser."
        self._log(f"ignorableAtRule {atRule!r} at [{line}, {col}]")


class EchoHandler(DocumentHandler):
    "Echos all input to property `out`"

    def __init__(self):
        super().__init__()
        self._out = []

    out = property(lambda self: ''.join(self._out))

    def startDocument(self, encoding):
        super().startDocument(encoding)
        if 'utf-8' != encoding:
            self._out.append('@charset "%s";\n' % encoding)

    def importStyle(self, uri, media, name, line=None, col=None):
        "Receive notification of a import statement in the style sheet."
        # defaultNamespaceURI???
        super().importStyle(uri, media, name, line, col)
        self._out.append(
            '@import %s%s%s;\n'
            % (
                helper.string(uri),
                '%s ' % media if media else '',
                '%s ' % name if name else '',
            )
        )

    def namespaceDeclaration(self, prefix, uri, line=None, col=None):
        super().namespaceDeclaration(prefix, uri, line, col)
        self._out.append(
            '@namespace %s%s;\n'
            % ('%s ' % prefix if prefix else '', helper.string(uri))
        )

    def startSelector(self, selectors=None, line=None, col=None):
        super().startSelector(selectors, line, col)
        if selectors:
            self._out.append(', '.join(selectors))
        self._out.append(' {\n')

    def endSelector(self, selectors=None, line=None, col=None):
        self._out.append('    }')

    def property(self, name, value, important=False, line=None, col=None):
        super().property(name, value, line, col)
        self._out.append(
            '    {}: {}{};\n'.format(name, value, ' !important' if important else '')
        )


class Parser:
    """
    java.lang.String     getParserVersion()
        Returns a string about which CSS language is supported by this parser.
     boolean     parsePriority(InputSource source)
          Parse a CSS priority value (e.g.
     LexicalUnit     parsePropertyValue(InputSource source)
          Parse a CSS property value.
     void     parseRule(InputSource source)
          Parse a CSS rule.
     SelectorList     parseSelectors(InputSource source)
          Parse a comma separated list of selectors.
     void     parseStyleDeclaration(InputSource source)
          Parse a CSS style declaration (without '{' and '}').
     void     parseStyleSheet(InputSource source)
          Parse a CSS document.
     void     parseStyleSheet(java.lang.String uri)
          Parse a CSS document from a URI.
     void     setConditionFactory(ConditionFactory conditionFactory)

     void     setDocumentHandler(DocumentHandler handler)
          Allow an application to register a document event handler.
     void     setErrorHandler(ErrorHandler handler)
          Allow an application to register an error event handler.
     void     setLocale(java.util.Locale locale)
          Allow an application to request a locale for errors and warnings.
     void     setSelectorFactory(SelectorFactory selectorFactory)
    """

    def __init__(self, documentHandler=None, errorHandler=None):
        self._tokenizer = tokenize2.Tokenizer()
        if documentHandler:
            self.setDocumentHandler(documentHandler)
        else:
            self.setDocumentHandler(DocumentHandler())

        if errorHandler:
            self.setErrorHandler(errorHandler)
        else:
            self.setErrorHandler(ErrorHandler())

    def parseString(self, cssText, encoding=None):  # noqa: C901
        if isinstance(cssText, str):
            cssText = codecs.getdecoder('css')(cssText, encoding=encoding)[0]

        tokens = self._tokenizer.tokenize(cssText, fullsheet=True)

        def COMMENT(val, line, col):
            self._handler.comment(val[2:-2], line, col)

        def EOF(val, line, col):
            self._handler.endDocument(val, line, col)

        def simple(t):
            map = {'COMMENT': COMMENT, 'S': lambda val, line, col: None, 'EOF': EOF}
            type_, val, line, col = t
            if type_ in map:
                map[type_](val, line, col)
                return True
            else:
                return False

        # START PARSING
        t = next(tokens)
        type_, val, line, col = t

        encoding = 'utf-8'
        if 'CHARSET_SYM' == type_:
            # @charset "encoding";
            # S
            encodingtoken = next(tokens)
            semicolontoken = next(tokens)
            if 'STRING' == type_:
                encoding = helper.stringvalue(val)
            # ;
            if 'STRING' == encodingtoken[0] and semicolontoken:
                encoding = helper.stringvalue(encodingtoken[1])
            else:
                self._errorHandler.fatal('Invalid @charset')

            t = next(tokens)
            type_, val, line, col = t

        self._handler.startDocument(encoding)

        while True:
            start = (line, col)
            try:
                if simple(t):
                    pass

                elif 'ATKEYWORD' == type_ or type_ in (
                    'PAGE_SYM',
                    'MEDIA_SYM',
                    'FONT_FACE_SYM',
                ):
                    atRule = [val]
                    braces = 0
                    while True:
                        # read till end ;
                        # TODO: or {}
                        t = next(tokens)
                        type_, val, line, col = t
                        atRule.append(val)
                        if ';' == val and not braces:
                            break
                        elif '{' == val:
                            braces += 1
                        elif '}' == val:
                            braces -= 1
                            if braces == 0:
                                break

                    self._handler.ignorableAtRule(''.join(atRule), *start)

                elif 'IMPORT_SYM' == type_:
                    # import URI or STRING media? name?
                    uri, media, name = None, None, None
                    while True:
                        t = next(tokens)
                        type_, val, line, col = t
                        if 'STRING' == type_:
                            uri = helper.stringvalue(val)
                        elif 'URI' == type_:
                            uri = helper.urivalue(val)
                        elif ';' == val:
                            break

                    if uri:
                        self._handler.importStyle(uri, media, name)
                    else:
                        self._errorHandler.error(
                            'Invalid @import' ' declaration at %r' % (start,)
                        )

                elif 'NAMESPACE_SYM' == type_:
                    prefix, uri = None, None
                    while True:
                        t = next(tokens)
                        type_, val, line, col = t
                        if 'IDENT' == type_:
                            prefix = val
                        elif 'STRING' == type_:
                            uri = helper.stringvalue(val)
                        elif 'URI' == type_:
                            uri = helper.urivalue(val)
                        elif ';' == val:
                            break
                    if uri:
                        self._handler.namespaceDeclaration(prefix, uri, *start)
                    else:
                        self._errorHandler.error(
                            'Invalid @namespace' ' declaration at %r' % (start,)
                        )

                else:
                    # CSSSTYLERULE
                    selector = []
                    selectors = []
                    while True:
                        # selectors[, selector]* {
                        if 'S' == type_:
                            selector.append(' ')
                        elif simple(t):
                            pass
                        elif ',' == val:
                            selectors.append(''.join(selector).strip())
                            selector = []
                        elif '{' == val:
                            selectors.append(''.join(selector).strip())
                            self._handler.startSelector(selectors, *start)
                            break
                        else:
                            selector.append(val)

                        t = next(tokens)
                        type_, val, line, col = t

                    end = None
                    while True:
                        # name: value [!important][;name: value [!important]]*;?
                        name, value, important = None, [], False

                        while True:
                            # name:
                            t = next(tokens)
                            type_, val, line, col = t
                            if 'S' == type_:
                                pass
                            elif simple(t):
                                pass
                            elif 'IDENT' == type_:
                                if name:
                                    self._errorHandler.error(
                                        'more than one property name', t
                                    )
                                else:
                                    name = val
                            elif ':' == val:
                                if not name:
                                    self._errorHandler.error('no property name', t)
                                break
                            elif ';' == val:
                                self._errorHandler.error('premature end of property', t)
                                end = val
                                break
                            elif '}' == val:
                                if name:
                                    self._errorHandler.error(
                                        'premature end of property', t
                                    )
                                end = val
                                break
                            else:
                                self._errorHandler.error(
                                    'unexpected property name token %r' % val, t
                                )

                        while not ';' == end and not '}' == end:
                            # value !;}
                            t = next(tokens)
                            type_, val, line, col = t

                            if 'S' == type_:
                                value.append(' ')
                            elif simple(t):
                                pass
                            elif '!' == val or ';' == val or '}' == val:
                                value = ''.join(value).strip()
                                if not value:
                                    self._errorHandler.error(
                                        'premature end of property (no value)', t
                                    )
                                end = val
                                break
                            else:
                                value.append(val)

                        while '!' == end:
                            # !important
                            t = next(tokens)
                            type_, val, line, col = t

                            if simple(t):
                                pass
                            elif 'IDENT' == type_ and not important:
                                important = True
                            elif ';' == val or '}' == val:
                                end = val
                                break
                            else:
                                self._errorHandler.error(
                                    'unexpected priority token %r' % val
                                )

                        if name and value:
                            self._handler.property(name, value, important)

                        if '}' == end:
                            self._handler.endSelector(selectors, line=line, col=col)
                            break
                        else:
                            # reset
                            end = None

                    else:
                        self._handler.endSelector(selectors, line=line, col=col)

                t = next(tokens)
                type_, val, line, col = t

            except StopIteration:
                break

    def setDocumentHandler(self, handler):
        "Allow an application to register a document event `handler`."
        self._handler = handler

    def setErrorHandler(self, handler):
        "TODO"
        self._errorHandler = handler