# coding: utf-8

#------------------------------------------------------------------------------
# Copyright (c) 2008 Sébastien Boisgérault
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
# -----------------------------------------------------------------------------

__all__ = ["ExpatError", "ParserCreate", "XMLParserType", "error", "errors"]

# Jython check
import sys
if not sys.platform.startswith('java'):
    raise ImportError("this version of expat requires the jython interpreter")

# Standard Python Library
import re
import types

# Jython
from org.python.core import Py
from org.python.core.util import StringUtil
from jarray import array

# Java Standard Edition
from java.io import ByteArrayInputStream
from java.lang import String, StringBuilder
from org.xml.sax import InputSource
from org.xml.sax import SAXNotRecognizedException, SAXParseException
from org.xml.sax.helpers import XMLReaderFactory
from org.xml.sax.ext import DefaultHandler2

# Xerces
try:
    # Name mangled by jarjar?
    import org.python.apache.xerces.parsers.SAXParser
    _xerces_parser = "org.python.apache.xerces.parsers.SAXParser"
except ImportError:
    _xerces_parser = "org.apache.xerces.parsers.SAXParser"


# @expat args registry
_register = {}


def ParserCreate(encoding=None, namespace_separator=None):
    return XMLParser(encoding, namespace_separator)


class XMLParser(object):

    def __init__(self, encoding, namespace_separator):
        self.encoding = encoding
        self.CurrentLineNumber = 1
        self.CurrentColumnNumber = 0
        self._NextLineNumber = 1
        self._NextColumnNumber = 0
        self.ErrorLineNumber = -1
        self.ErrorColumnNumber = -1
        self.ErrorCode = None

        if namespace_separator is None:
            self.namespace_separator = namespace_separator
        elif isinstance(namespace_separator, basestring):
            self.namespace_separator = str(namespace_separator)
            if len(self.namespace_separator) > 1:
                error = ("namespace_separator must be at most one character, "
                         "omitted, or None")
                raise ValueError(error)
        else:
            error = ("ParserCreate() argument 2 must be string or None, "
                     "not %s" % type(namespace_separator).__name__)
            raise TypeError(error)

        self._reader = XMLReaderFactory.createXMLReader(_xerces_parser)

        if self.namespace_separator is None:
            try:
                feature = "http://xml.org/sax/features/namespaces"
                self._reader.setFeature(feature, False)
            except SAXNotRecognizedException:
                error = ("namespace support cannot be disabled; "
                         "set namespace_separator to a string of length 1.")
                raise ValueError(error)

        self._base = None
        self._buffer_text = True
        self._returns_unicode = True

        self._data = StringBuilder()

        self._handler = XMLEventHandler(self)
        self._reader.setContentHandler(self._handler)
        self._reader.setErrorHandler(self._handler)
        self._reader.setDTDHandler(self._handler)
        self._reader.setEntityResolver(self._handler)

        sax_properties = ("lexical-handler", "declaration-handler")
        for name in sax_properties:
            try:
                name = "http://xml.org/sax/properties/" + name
                self._reader.setProperty(name, self._handler)
            except SAXNotRecognizedException:
                error = "can't set property %r" % name
                raise NotImplementedError(error)

        apache_features = (("nonvalidating/load-external-dtd", False),)
        for name, value in apache_features:
            try:
                name = "http://apache.org/xml/features/" + name
                self._reader.setFeature(name, value)
            except SAXNotRecognizedException:
                error = "can't set feature %r" % name
                raise NotImplementedError(error)

        # experimental
        #f = "http://xml.org/sax/features/external-general-entities"
        f = "http://xml.org/sax/features/external-parameter-entities"
        #self._reader.setFeature(f, False)

        # check
        f = "http://xml.org/sax/features/use-entity-resolver2"
        assert self._reader.getFeature(f)

    def GetBase(self):
        return self._base

    def SetBase(self, base):
        self._base = base

    def _error(self, value=None):
        raise AttributeError("'XMLParser' has no such attribute")

    def _get_buffer_text(self):
        return self._buffer_text

    def _set_buffer_text(self, value):
        self._buffer_text = bool(value)

    def _get_returns_unicode(self):
        return bool(self._returns_unicode)

    def _set_returns_unicode(self, value):
        self._returns_unicode = value

    # 'ordered' and 'specified' attributes are not supported
    ordered_attributes = property(_error, _error)
    specified_attributes = property(_error, _error)
    # any setting is allowed, but it won't make a difference
    buffer_text = property(_get_buffer_text, _set_buffer_text)
    # non-significant read-only values
    buffer_used = property(lambda self: None)
    buffer_size = property(lambda self: None)
    # 'returns_unicode' attribute is properly supported
    returns_unicode = property(_get_returns_unicode, _set_returns_unicode)

    def _expat_error(self, sax_error):
        sax_message = sax_error.getMessage()
        pattern = 'The entity ".*" was referenced, but not declared\.'
        if re.match(pattern, sax_message):
            expat_message = "undefined entity: line %s, column %s" % \
                            (self.ErrorLineNumber, self.ErrorColumnNumber)
        else:
            expat_message = sax_message
        error = ExpatError(expat_message)
        error.lineno = self.ErrorLineNumber
        error.offset = self.ErrorColumnNumber
        error.code = self.ErrorCode
        return error

    def Parse(self, data, isfinal=False):
        # The 'data' argument should be an encoded text: a str instance that
        # represents an array of bytes. If instead it is a unicode string,
        # only the us-ascii range is considered safe enough to be silently
        # converted.
        if isinstance(data, unicode):
            data = data.encode(sys.getdefaultencoding())

        self._data.append(data)

        if isfinal:
            bytes = StringUtil.toBytes(self._data.toString())
            byte_stream = ByteArrayInputStream(bytes)
            source = InputSource(byte_stream)
            if self.encoding is not None:
                source.setEncoding(self.encoding)
            try:
                self._reader.parse(source)
            except SAXParseException, sax_error:
                # Experiments tend to show that the '_Next*' parser locations
                # match more closely expat behavior than the 'Current*' or sax
                # error locations.
                self.ErrorLineNumber = self._NextLineNumber
                self.ErrorColumnNumber = self._NextColumnNumber
                self.ErrorCode = None
                raise self._expat_error(sax_error)
            return 1

    def ParseFile(self, file):
        # TODO: pseudo-buffering if a read without argument is not supported.
        #       document parse / parsefile usage.
        return self.Parse(file.read(), isfinal=True)


XMLParserType = XMLParser


def _encode(arg, encoding):
    if isinstance(arg, unicode):
        return arg.encode(encoding)
    else:
        if isinstance(arg, dict):
            iterator = arg.iteritems()
        else:
            iterator = iter(arg)
        return type(arg)(_encode(_arg, encoding) for _arg in iterator)


def expat(callback=None, guard=True, force=False, returns=None):
    def _expat(method):
        name = method.__name__
        context = id(sys._getframe(1))
        key = name, context
        append = _register.setdefault(key, []).append
        append((method, callback, guard, force, returns))

        def new_method(*args):
            self = args[0]
            parser = self.parser
            self._update_location(event=name) # bug if multiple method def
            for (method, callback, guard, force, returns) in _register[key]:
                if guard not in (True, False):
                    guard = getattr(self, guard)
                _callback = callback and guard and \
                            getattr(parser, callback, None)
                if _callback or force:
                    results = method(*args)
                    if _callback:
                        if not isinstance(results, tuple):
                            results = (results,)
                        if not parser.returns_unicode:
                            results = _encode(results, "utf-8")
                        _callback(*results)
                    return returns

        new_method.__name__ = name
        #new_method.__doc__ = method.__doc__ # what to do with multiple docs ?
        return new_method
    return _expat


class XMLEventHandler(DefaultHandler2):

    def __init__(self, parser):
        self.parser = parser
        self._tags = {}
        self.not_in_dtd = True
        self._entity = {}
        self._previous_event = None

    # --- Helpers -------------------------------------------------------------

    def _intern(self, tag):
        return self._tags.setdefault(tag, tag)

    def _qualify(self, local_name, qname, namespace=None):
        namespace_separator = self.parser.namespace_separator
        if namespace_separator is None:
            return qname
        if not namespace:
            return local_name
        else:
            return namespace + namespace_separator + local_name

    def _char_slice_to_unicode(self, characters, start, length):
        """Convert a char[] slice to a PyUnicode instance"""
        text = Py.newUnicode(String(characters[start:start + length]))
        return text

    def _expat_content_model(self, name, model_):
        # TODO : implement a model parser
        return (name, model_) # does not fit expat conventions

    def _update_location(self, event=None):
        parser = self.parser
        locator = self._locator

        # ugly hack that takes care of a xerces-specific (?) locator issue:
        # locate start and end elements at the '<' instead of the first tag
        # type character.
        if event == "startElement" and self._previous_event == "characters":
            parser._NextColumnNumber = max(parser._NextColumnNumber - 1, 0)
        if event == "endElement" and self._previous_event == "characters":
            parser._NextColumnNumber = max(parser._NextColumnNumber - 2, 0)
        # TODO: use the same trick to report accurate error locations ?

        parser.CurrentLineNumber = parser._NextLineNumber
        parser.CurrentColumnNumber = parser._NextColumnNumber
        parser._NextLineNumber = locator.getLineNumber()
        parser._NextColumnNumber = locator.getColumnNumber() - 1

        self._previous_event = event

    # --- ContentHandler Interface --------------------------------------------

    @expat("ProcessingInstructionHandler")
    def processingInstruction(self, target, data):
        return target, data

    @expat("StartElementHandler")
    def startElement(self, namespace, local_name, qname, attributes):
        tag = self._qualify(local_name, qname, namespace)
        attribs = {}
        length = attributes.getLength()
        for index in range(length):
            local_name = attributes.getLocalName(index)
            qname = attributes.getQName(index)
            namespace = attributes.getURI(index)
            name = self._qualify(local_name, qname, namespace)
            value = attributes.getValue(index)
            attribs[name] = value
        return self._intern(tag), attribs

    @expat("EndElementHandler")
    def endElement(self, namespace, local_name, qname):
        return self._intern(self._qualify(local_name, qname, namespace))

    @expat("CharacterDataHandler")
    def characters(self, characters, start, length):
        return self._char_slice_to_unicode(characters, start, length)

    @expat("DefaultHandlerExpand")
    def characters(self, characters, start, length):
        return self._char_slice_to_unicode(characters, start, length)

    @expat("DefaultHandler")
    def characters(self, characters, start, length):
        # TODO: make a helper function here
        if self._entity["location"] == (self.parser.CurrentLineNumber,
                                        self.parser.CurrentColumnNumber):
            return "&%s;" % self._entity["name"]
        else:
            return self._char_slice_to_unicode(characters, start, length)

    @expat("StartNamespaceDeclHandler")
    def startPrefixMapping(self, prefix, uri):
        return prefix, uri

    @expat("EndNamespaceDeclHandler")
    def endPrefixMapping(self, prefix):
        return prefix

    empty_source = InputSource(ByteArrayInputStream(array([], "b")))

    @expat("ExternalEntityRefHandler", guard="not_in_dtd",
                                       returns=empty_source)
    def resolveEntity(self, name, publicId, baseURI, systemId):
        context = name # wrong. see expat headers documentation.
        base = self.parser.GetBase()
        return context, base, systemId, publicId

    @expat("DefaultHandlerExpand", guard="not_in_dtd",
                                   returns=empty_source)
    def resolveEntity(self, name, publicId, baseURI, systemId):
        return "&%s;" % name

    @expat("DefaultHandler", guard="not_in_dtd",
                             returns=empty_source)
    def resolveEntity(self, name, publicId, baseURI, systemId):
        return "&%s;" % name

    @expat(force=True, returns=empty_source)
    def resolveEntity(self, name, publicId, baseURI, systemId):
        pass

    def setDocumentLocator(self, locator):
        self._locator = locator

    def skippedEntity(self, name):
        error = ExpatError()
        error.lineno = self.ErrorLineNumber = self.parser._NextLineNumber
        error.offset = self.ErrorColumnNumber = self.parser._NextColumnNumber
        error.code = self.ErrorCode = None
        message = "undefined entity &%s;: line %s, column %s"
        message = message % (name, error.lineno, error.offset)
        error.__init__(message)
        raise error

    # --- LexicalHandler Interface --------------------------------------------

    @expat("CommentHandler")
    def comment(self, characters, start, length):
        return self._char_slice_to_unicode(characters, start, length)

    @expat("StartCdataSectionHandler")
    def startCDATA(self):
        return ()

    @expat("EndCdataSectionHandler")
    def endCDATA(self):
        return ()

    @expat("StartDoctypeDeclHandler", force=True)
    def startDTD(self, name, publicId, systemId):
        self.not_in_dtd = False
        has_internal_subset = 0 # don't know this ...
        return name, systemId, publicId, has_internal_subset

    @expat("EndDoctypeDeclHandler", force=True)
    def endDTD(self):
        self.not_in_dtd = True

    def startEntity(self, name):
        self._entity = {}
        self._entity["location"] = (self.parser._NextLineNumber,
                                    self.parser._NextColumnNumber)
        self._entity["name"] = name

    def endEntity(self, name):
        pass

    # --- DTDHandler Interface ------------------------------------------------

    @expat("NotationDeclHandler")
    def notationDecl(self, name, publicId, systemId):
        base = self.parser.GetBase()
        return name, base, systemId, publicId

    @expat("UnparsedEntityDeclHandler") # deprecated
    def unparsedEntityDecl(self, name, publicId, systemId, notationName):
        base = self.parser.GetBase()
        return name, base, systemId, publicId, notationName

    # --- DeclHandler Interface -----------------------------------------------

    @expat("AttlistDeclHandler")
    def attributeDecl(self, eName, aName, type, mode, value):
        # TODO: adapt mode, required, etc.
        required = False
        return eName, aName, type, value, required

    @expat("ElementDeclHandler")
    def elementDecl(self, name, model):
        return self._expat_content_model(name, model)

    @expat("EntityDeclHandler")
    def externalEntityDecl(self, name, publicId, systemId):
        base = self.parser.GetBase()
        value = None
        is_parameter_entity = None
        notation_name = None
        return (name, is_parameter_entity, value, base, systemId, publicId,
                notation_name)

    @expat("EntityDeclHandler")
    def internalEntityDecl(self, name, value):
        base = self.parser.GetBase()
        is_parameter_entity = None
        notation_name = None
        systemId, publicId = None, None
        return (name, is_parameter_entity, value, base, systemId, publicId,
                notation_name)


def _init_model():
    global model
    model = types.ModuleType("pyexpat.model")
    model.__doc__ = "Constants used to interpret content model information."
    quantifiers = "NONE, OPT, REP, PLUS"
    for i, quantifier in enumerate(quantifiers.split(", ")):
        setattr(model, "XML_CQUANT_" + quantifier, i)
    types_ = "EMPTY, ANY, MIXED, NAME, CHOICE, SEQ"
    for i, type_ in enumerate(types_.split(", ")):
        setattr(model, "XML_CTYPE_" + type_, i+1)

_init_model()
del _init_model


class ExpatError(Exception):
    pass


error = ExpatError


def _init_error_strings():
    global ErrorString
    error_strings = (
        None,
        "out of memory",
        "syntax error",
        "no element found",
        "not well-formed (invalid token)",
        "unclosed token",
        "partial character",
        "mismatched tag",
        "duplicate attribute",
        "junk after document element",
        "illegal parameter entity reference",
        "undefined entity",
        "recursive entity reference",
        "asynchronous entity",
        "reference to invalid character number",
        "reference to binary entity",
        "reference to external entity in attribute",
        "XML or text declaration not at start of entity",
        "unknown encoding",
        "encoding specified in XML declaration is incorrect",
        "unclosed CDATA section",
        "error in processing external entity reference",
        "document is not standalone",
        "unexpected parser state - please send a bug report",
        "entity declared in parameter entity",
        "requested feature requires XML_DTD support in Expat",
        "cannot change setting once parsing has begun",
        "unbound prefix",
        "must not undeclare prefix",
        "incomplete markup in parameter entity",
        "XML declaration not well-formed",
        "text declaration not well-formed",
        "illegal character(s) in public id",
        "parser suspended",
        "parser not suspended",
        "parsing aborted",
        "parsing finished",
        "cannot suspend in external parameter entity")
    def ErrorString(code):
        try:
            return error_strings[code]
        except IndexError:
            return None

_init_error_strings()
del _init_error_strings


def _init_errors():
    global errors

    errors = types.ModuleType("pyexpat.errors")
    errors.__doc__ = "Constants used to describe error conditions."

    error_names = """
    XML_ERROR_NONE
    XML_ERROR_NONE,
    XML_ERROR_NO_MEMORY,
    XML_ERROR_SYNTAX,
    XML_ERROR_NO_ELEMENTS,
    XML_ERROR_INVALID_TOKEN,
    XML_ERROR_UNCLOSED_TOKEN,
    XML_ERROR_PARTIAL_CHAR,
    XML_ERROR_TAG_MISMATCH,
    XML_ERROR_DUPLICATE_ATTRIBUTE,
    XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
    XML_ERROR_PARAM_ENTITY_REF,
    XML_ERROR_UNDEFINED_ENTITY,
    XML_ERROR_RECURSIVE_ENTITY_REF,
    XML_ERROR_ASYNC_ENTITY,
    XML_ERROR_BAD_CHAR_REF,
    XML_ERROR_BINARY_ENTITY_REF,
    XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
    XML_ERROR_MISPLACED_XML_PI,
    XML_ERROR_UNKNOWN_ENCODING,
    XML_ERROR_INCORRECT_ENCODING,
    XML_ERROR_UNCLOSED_CDATA_SECTION,
    XML_ERROR_EXTERNAL_ENTITY_HANDLING,
    XML_ERROR_NOT_STANDALONE,
    XML_ERROR_UNEXPECTED_STATE,
    XML_ERROR_ENTITY_DECLARED_IN_PE,
    XML_ERROR_FEATURE_REQUIRES_XML_DTD,
    XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
    XML_ERROR_UNBOUND_PREFIX,
    XML_ERROR_UNDECLARING_PREFIX,
    XML_ERROR_INCOMPLETE_PE,
    XML_ERROR_XML_DECL,
    XML_ERROR_TEXT_DECL,
    XML_ERROR_PUBLICID,
    XML_ERROR_SUSPENDED,
    XML_ERROR_NOT_SUSPENDED,
    XML_ERROR_ABORTED,
    XML_ERROR_FINISHED,
    XML_ERROR_SUSPEND_PE
    """
    error_names = [name.strip() for name in error_names.split(',')]
    for i, name in enumerate(error_names[1:]):
        setattr(errors, name, ErrorString(i+1))

_init_errors()
del _init_errors