import libxml2mod

import types

import sys

# The root of all libxml2 errors.

class libxmlError(Exception): pass

# Type of the wrapper class for the C objects wrappers

def checkWrapper(obj):

    try:

        n = type(_obj).__name__

        if n != 'PyCObject' and n != 'PyCapsule':

            return 1

    except:

        return 0

    return 0

#

# id() is sometimes negative ...

#

def pos_id(o):

    i = id(o)

    if (i < 0):

        return (sys.maxsize - i)

    return i

#

# Errors raised by the wrappers when some tree handling failed.

#

class treeError(libxmlError):

    def __init__(self, msg):

        self.msg = msg

    def __str__(self):

        return self.msg

class parserError(libxmlError):

    def __init__(self, msg):

        self.msg = msg

    def __str__(self):

        return self.msg

class uriError(libxmlError):

    def __init__(self, msg):

        self.msg = msg

    def __str__(self):

        return self.msg

class xpathError(libxmlError):

    def __init__(self, msg):

        self.msg = msg

    def __str__(self):

        return self.msg

class ioWrapper:

    def __init__(self, _obj):

        self.__io = _obj

        self._o = None

    def io_close(self):

        if self.__io == None:

            return(-1)

        self.__io.close()

        self.__io = None

        return(0)

    def io_flush(self):

        if self.__io == None:

            return(-1)

        self.__io.flush()

        return(0)

    def io_read(self, len = -1):

        if self.__io == None:

            return(-1)

        try:

            if len < 0:

                ret = self.__io.read()

            else:

                ret = self.__io.read(len)

        except Exception:

            import sys

            e = sys.exc_info()[1]

            print("failed to read from Python:", type(e))

            print("on IO:", self.__io)

            self.__io == None

            return(-1)

        return(ret)

    def io_write(self, str, len = -1):

        if self.__io == None:

            return(-1)

        if len < 0:

            return(self.__io.write(str))

        return(self.__io.write(str, len))

class ioReadWrapper(ioWrapper):

    def __init__(self, _obj, enc = ""):

        ioWrapper.__init__(self, _obj)

        self._o = libxml2mod.xmlCreateInputBuffer(self, enc)

    def __del__(self):

        print("__del__")

        self.io_close()

        if self._o != None:

            libxml2mod.xmlFreeParserInputBuffer(self._o)

        self._o = None

    def close(self):

        self.io_close()

        if self._o != None:

            libxml2mod.xmlFreeParserInputBuffer(self._o)

        self._o = None

class ioWriteWrapper(ioWrapper):

    def __init__(self, _obj, enc = ""):

#        print "ioWriteWrapper.__init__", _obj

        if type(_obj) == type(''):

            print("write io from a string")

            self.o = None

        elif type(_obj).__name__ == 'PyCapsule':

            file = libxml2mod.outputBufferGetPythonFile(_obj)

            if file != None:

                ioWrapper.__init__(self, file)

            else:

                ioWrapper.__init__(self, _obj)

            self._o = _obj

#        elif type(_obj) == types.InstanceType:

#            print(("write io from instance of %s" % (_obj.__class__)))

#            ioWrapper.__init__(self, _obj)

#            self._o = libxml2mod.xmlCreateOutputBuffer(self, enc)

        else:

            file = libxml2mod.outputBufferGetPythonFile(_obj)

            if file != None:

                ioWrapper.__init__(self, file)

            else:

                ioWrapper.__init__(self, _obj)

            self._o = _obj

    def __del__(self):

#        print "__del__"

        self.io_close()

        if self._o != None:

            libxml2mod.xmlOutputBufferClose(self._o)

        self._o = None

    def flush(self):

        self.io_flush()

        if self._o != None:

            libxml2mod.xmlOutputBufferClose(self._o)

        self._o = None

    def close(self):

        self.io_flush()

        if self._o != None:

            libxml2mod.xmlOutputBufferClose(self._o)

        self._o = None

#

# Example of a class to handle SAX events

#

class SAXCallback:

    """Base class for SAX handlers"""

    def startDocument(self):

        """called at the start of the document"""

        pass

    def endDocument(self):

        """called at the end of the document"""

        pass

    def startElement(self, tag, attrs):

        """called at the start of every element, tag is the name of

           the element, attrs is a dictionary of the element's attributes"""

        pass

    def endElement(self, tag):

        """called at the start of every element, tag is the name of

           the element"""

        pass

    def characters(self, data):

        """called when character data have been read, data is the string

           containing the data, multiple consecutive characters() callback

           are possible."""

        pass

    def cdataBlock(self, data):

        """called when CDATA section have been read, data is the string

           containing the data, multiple consecutive cdataBlock() callback

           are possible."""

        pass

    def reference(self, name):

        """called when an entity reference has been found"""

        pass

    def ignorableWhitespace(self, data):

        """called when potentially ignorable white spaces have been found"""

        pass

    def processingInstruction(self, target, data):

        """called when a PI has been found, target contains the PI name and

           data is the associated data in the PI"""

        pass

    def comment(self, content):

        """called when a comment has been found, content contains the comment"""

        pass

    def externalSubset(self, name, externalID, systemID):

        """called when a DOCTYPE declaration has been found, name is the

           DTD name and externalID, systemID are the DTD public and system

           identifier for that DTd if available"""

        pass

    def internalSubset(self, name, externalID, systemID):

        """called when a DOCTYPE declaration has been found, name is the

           DTD name and externalID, systemID are the DTD public and system

           identifier for that DTD if available"""

        pass

    def entityDecl(self, name, type, externalID, systemID, content):

        """called when an ENTITY declaration has been found, name is the

           entity name and externalID, systemID are the entity public and

           system identifier for that entity if available, type indicates

           the entity type, and content reports it's string content"""

        pass

    def notationDecl(self, name, externalID, systemID):

        """called when an NOTATION declaration has been found, name is the

           notation name and externalID, systemID are the notation public and

           system identifier for that notation if available"""

        pass

    def attributeDecl(self, elem, name, type, defi, defaultValue, nameList):

        """called when an ATTRIBUTE definition has been found"""

        pass

    def elementDecl(self, name, type, content):

        """called when an ELEMENT definition has been found"""

        pass

    def entityDecl(self, name, publicId, systemID, notationName):

        """called when an unparsed ENTITY declaration has been found,

           name is the entity name and publicId,, systemID are the entity

           public and system identifier for that entity if available,

           and notationName indicate the associated NOTATION"""

        pass

    def warning(self, msg):

        #print msg

        pass

    def error(self, msg):

        raise parserError(msg)

    def fatalError(self, msg):

        raise parserError(msg)

#

# This class is the ancestor of all the Node classes. It provides

# the basic functionalities shared by all nodes (and handle

# gracefylly the exception), like name, navigation in the tree,

# doc reference, content access and serializing to a string or URI

#

class xmlCore:

    def __init__(self, _obj=None):

        if _obj != None: 

            self._o = _obj;

            return

        self._o = None

    def __eq__(self, other):

        if other == None:

            return False

        ret = libxml2mod.compareNodesEqual(self._o, other._o)

        if ret == None:

            return False

        return ret == True

    def __ne__(self, other):

        if other == None:

            return True

        ret = libxml2mod.compareNodesEqual(self._o, other._o)

        return not ret

    def __hash__(self):

        ret = libxml2mod.nodeHash(self._o)

        return ret

    def __str__(self):

        return self.serialize()

    def get_parent(self):

        ret = libxml2mod.parent(self._o)

        if ret == None:

            return None

        return nodeWrap(ret)

    def get_children(self):

        ret = libxml2mod.children(self._o)

        if ret == None:

            return None

        return nodeWrap(ret)

    def get_last(self):

        ret = libxml2mod.last(self._o)

        if ret == None:

            return None

        return nodeWrap(ret)

    def get_next(self):

        ret = libxml2mod.next(self._o)

        if ret == None:

            return None

        return nodeWrap(ret)

    def get_properties(self):

        ret = libxml2mod.properties(self._o)

        if ret == None:

            return None

        return xmlAttr(_obj=ret)

    def get_prev(self):

        ret = libxml2mod.prev(self._o)

        if ret == None:

            return None

        return nodeWrap(ret)

    def get_content(self):

        return libxml2mod.xmlNodeGetContent(self._o)

    getContent = get_content  # why is this duplicate naming needed ?

    def get_name(self):

        return libxml2mod.name(self._o)

    def get_type(self):

        return libxml2mod.type(self._o)

    def get_doc(self):

        ret = libxml2mod.doc(self._o)

        if ret == None:

            if self.type in ["document_xml", "document_html"]:

                return xmlDoc(_obj=self._o)

            else:

                return None

        return xmlDoc(_obj=ret)

    #

    # Those are common attributes to nearly all type of nodes

    # defined as python2 properties

    # 

    import sys

    if float(sys.version[0:3]) < 2.2:

        def __getattr__(self, attr):

            if attr == "parent":

                ret = libxml2mod.parent(self._o)

                if ret == None:

                    return None

                return nodeWrap(ret)

            elif attr == "properties":

                ret = libxml2mod.properties(self._o)

                if ret == None:

                    return None

                return xmlAttr(_obj=ret)

            elif attr == "children":

                ret = libxml2mod.children(self._o)

                if ret == None:

                    return None

                return nodeWrap(ret)

            elif attr == "last":

                ret = libxml2mod.last(self._o)

                if ret == None:

                    return None

                return nodeWrap(ret)

            elif attr == "next":

                ret = libxml2mod.next(self._o)

                if ret == None:

                    return None

                return nodeWrap(ret)

            elif attr == "prev":

                ret = libxml2mod.prev(self._o)

                if ret == None:

                    return None

                return nodeWrap(ret)

            elif attr == "content":

                return libxml2mod.xmlNodeGetContent(self._o)

            elif attr == "name":

                return libxml2mod.name(self._o)

            elif attr == "type":

                return libxml2mod.type(self._o)

            elif attr == "doc":

                ret = libxml2mod.doc(self._o)

                if ret == None:

                    if self.type == "document_xml" or self.type == "document_html":

                        return xmlDoc(_obj=self._o)

                    else:

                        return None

                return xmlDoc(_obj=ret)

            raise AttributeError(attr)

    else:

        parent = property(get_parent, None, None, "Parent node")

        children = property(get_children, None, None, "First child node")

        last = property(get_last, None, None, "Last sibling node")

        next = property(get_next, None, None, "Next sibling node")

        prev = property(get_prev, None, None, "Previous sibling node")

        properties = property(get_properties, None, None, "List of properies")

        content = property(get_content, None, None, "Content of this node")

        name = property(get_name, None, None, "Node name")

        type = property(get_type, None, None, "Node type")

        doc = property(get_doc, None, None, "The document this node belongs to")

    #

    # Serialization routines, the optional arguments have the following

    # meaning:

    #     encoding: string to ask saving in a specific encoding

    #     indent: if 1 the serializer is asked to indent the output

    #

    def serialize(self, encoding = None, format = 0):

        return libxml2mod.serializeNode(self._o, encoding, format)

    def saveTo(self, file, encoding = None, format = 0):

        return libxml2mod.saveNodeTo(self._o, file, encoding, format)

    #

    # Canonicalization routines:

    #

    #   nodes: the node set (tuple or list) to be included in the

    #     canonized image or None if all document nodes should be

    #     included.

    #   exclusive: the exclusive flag (0 - non-exclusive

    #     canonicalization; otherwise - exclusive canonicalization)

    #   prefixes: the list of inclusive namespace prefixes (strings),

    #     or None if there is no inclusive namespaces (only for

    #     exclusive canonicalization, ignored otherwise)

    #   with_comments: include comments in the result (!=0) or not

    #     (==0)

    def c14nMemory(self,

                   nodes=None,

                   exclusive=0,

                   prefixes=None,

                   with_comments=0):

        if nodes:

            nodes = [n._o for n in nodes]

        return libxml2mod.xmlC14NDocDumpMemory(

            self.get_doc()._o,

            nodes,

            exclusive != 0,

            prefixes,

            with_comments != 0)

    def c14nSaveTo(self,

                   file,

                   nodes=None,

                   exclusive=0,

                   prefixes=None,

                   with_comments=0):

        if nodes:

            nodes = [n._o for n in nodes]

        return libxml2mod.xmlC14NDocSaveTo(

            self.get_doc()._o,

            nodes,

            exclusive != 0,

            prefixes,

            with_comments != 0,

            file)

    #

    # Selecting nodes using XPath, a bit slow because the context

    # is allocated/freed every time but convenient.

    #

    def xpathEval(self, expr):

        doc = self.doc

        if doc == None:

            return None

        ctxt = doc.xpathNewContext()

        ctxt.setContextNode(self)

        res = ctxt.xpathEval(expr)

        ctxt.xpathFreeContext()

        return res

#    #

#    # Selecting nodes using XPath, faster because the context

#    # is allocated just once per xmlDoc.

#    #

#    # Removed: DV memleaks c.f. #126735

#    #

#    def xpathEval2(self, expr):

#        doc = self.doc

#        if doc == None:

#            return None

#        try:

#            doc._ctxt.setContextNode(self)

#        except:

#            doc._ctxt = doc.xpathNewContext()

#            doc._ctxt.setContextNode(self)

#        res = doc._ctxt.xpathEval(expr)

#        return res

    def xpathEval2(self, expr):

        return self.xpathEval(expr)

    # Remove namespaces

    def removeNsDef(self, href):

        """

        Remove a namespace definition from a node.  If href is None,

        remove all of the ns definitions on that node.  The removed

        namespaces are returned as a linked list.

        Note: If any child nodes referred to the removed namespaces,

        they will be left with dangling links.  You should call

        renconciliateNs() to fix those pointers.

        Note: This method does not free memory taken by the ns

        definitions.  You will need to free it manually with the

        freeNsList() method on the returns xmlNs object.

        """

        ret = libxml2mod.xmlNodeRemoveNsDef(self._o, href)

        if ret is None:return None

        __tmp = xmlNs(_obj=ret)

        return __tmp

    # support for python2 iterators

    def walk_depth_first(self):

        return xmlCoreDepthFirstItertor(self)

    def walk_breadth_first(self):

        return xmlCoreBreadthFirstItertor(self)

    __iter__ = walk_depth_first

    def free(self):

        try:

            self.doc._ctxt.xpathFreeContext()

        except:

            pass

        libxml2mod.xmlFreeDoc(self._o)

#

# implements the depth-first iterator for libxml2 DOM tree

#

class xmlCoreDepthFirstItertor:

    def __init__(self, node):

        self.node = node

        self.parents = []

    def __iter__(self):

        return self

    def __next__(self):

        while 1:

            if self.node:

                ret = self.node

                self.parents.append(self.node)

                self.node = self.node.children

                return ret

            try:

                parent = self.parents.pop()

            except IndexError:

                raise StopIteration

            self.node = parent.next

    next = __next__

#

# implements the breadth-first iterator for libxml2 DOM tree

#

class xmlCoreBreadthFirstItertor:

    def __init__(self, node):

        self.node = node

        self.parents = []

    def __iter__(self):

        return self

    def __next__(self):

        while 1:

            if self.node:

                ret = self.node

                self.parents.append(self.node)

                self.node = self.node.next

                return ret

            try:

                parent = self.parents.pop()

            except IndexError:

                raise StopIteration

            self.node = parent.children

    next = __next__

#

# converters to present a nicer view of the XPath returns

#

def nodeWrap(o):

    # TODO try to cast to the most appropriate node class

    name = libxml2mod.type(o)

    if name == "element" or name == "text":

        return xmlNode(_obj=o)

    if name == "attribute":

        return xmlAttr(_obj=o)

    if name[0:8] == "document":

        return xmlDoc(_obj=o)

    if name == "namespace":

        return xmlNs(_obj=o)

    if name == "elem_decl":

        return xmlElement(_obj=o)

    if name == "attribute_decl":

        return xmlAttribute(_obj=o)

    if name == "entity_decl":

        return xmlEntity(_obj=o)

    if name == "dtd":

        return xmlDtd(_obj=o)

    return xmlNode(_obj=o)

def xpathObjectRet(o):

    otype = type(o)

    if otype == type([]):

        ret = list(map(xpathObjectRet, o))

        return ret

    elif otype == type(()):

        ret = list(map(xpathObjectRet, o))

        return tuple(ret)

    elif otype == type('') or otype == type(0) or otype == type(0.0):

        return o

    else:

        return nodeWrap(o)

#

# register an XPath function

#

def registerXPathFunction(ctxt, name, ns_uri, f):

    ret = libxml2mod.xmlRegisterXPathFunction(ctxt, name, ns_uri, f)

#

# For the xmlTextReader parser configuration

#

PARSER_LOADDTD=1

PARSER_DEFAULTATTRS=2

PARSER_VALIDATE=3

PARSER_SUBST_ENTITIES=4

#

# For the error callback severities

#

PARSER_SEVERITY_VALIDITY_WARNING=1

PARSER_SEVERITY_VALIDITY_ERROR=2

PARSER_SEVERITY_WARNING=3

PARSER_SEVERITY_ERROR=4

#

# register the libxml2 error handler

#

def registerErrorHandler(f, ctx):

    """Register a Python written function to for error reporting.

       The function is called back as f(ctx, error). """

    import sys

    if 'libxslt' not in sys.modules:

        # normal behaviour when libxslt is not imported

        ret = libxml2mod.xmlRegisterErrorHandler(f,ctx)

    else:

        # when libxslt is already imported, one must

        # use libxst's error handler instead

        import libxslt

        ret = libxslt.registerErrorHandler(f,ctx)

    return ret

class parserCtxtCore:

    def __init__(self, _obj=None):

        if _obj != None: 

            self._o = _obj;

            return

        self._o = None

    def __del__(self):

        if self._o != None:

            libxml2mod.xmlFreeParserCtxt(self._o)

        self._o = None

    def setErrorHandler(self,f,arg):

        """Register an error handler that will be called back as

           f(arg,msg,severity,reserved).

           @reserved is currently always None."""

        libxml2mod.xmlParserCtxtSetErrorHandler(self._o,f,arg)

    def getErrorHandler(self):

        """Return (f,arg) as previously registered with setErrorHandler

           or (None,None)."""

        return libxml2mod.xmlParserCtxtGetErrorHandler(self._o)

    def addLocalCatalog(self, uri):

        """Register a local catalog with the parser"""

        return libxml2mod.addLocalCatalog(self._o, uri)

class ValidCtxtCore:

    def __init__(self, *args, **kw):

        pass

    def setValidityErrorHandler(self, err_func, warn_func, arg=None):

        """

        Register error and warning handlers for DTD validation.

        These will be called back as f(msg,arg)

        """

        libxml2mod.xmlSetValidErrors(self._o, err_func, warn_func, arg)

class SchemaValidCtxtCore:

    def __init__(self, *args, **kw):

        pass

    def setValidityErrorHandler(self, err_func, warn_func, arg=None):

        """

        Register error and warning handlers for Schema validation.

        These will be called back as f(msg,arg)

        """

        libxml2mod.xmlSchemaSetValidErrors(self._o, err_func, warn_func, arg)

class relaxNgValidCtxtCore:

    def __init__(self, *args, **kw):

        pass

    def setValidityErrorHandler(self, err_func, warn_func, arg=None):

        """

        Register error and warning handlers for RelaxNG validation.

        These will be called back as f(msg,arg)

        """

        libxml2mod.xmlRelaxNGSetValidErrors(self._o, err_func, warn_func, arg)

def _xmlTextReaderErrorFunc(xxx_todo_changeme,msg,severity,locator):

    """Intermediate callback to wrap the locator"""

    (f,arg) = xxx_todo_changeme

    return f(arg,msg,severity,xmlTextReaderLocator(locator))

class xmlTextReaderCore:

    def __init__(self, _obj=None):

        self.input = None

        if _obj != None:self._o = _obj;return

        self._o = None

    def __del__(self):

        if self._o != None:

            libxml2mod.xmlFreeTextReader(self._o)

        self._o = None

    def SetErrorHandler(self,f,arg):

        """Register an error handler that will be called back as

           f(arg,msg,severity,locator)."""

        if f is None:

            libxml2mod.xmlTextReaderSetErrorHandler(\

                self._o,None,None)

        else:

            libxml2mod.xmlTextReaderSetErrorHandler(\

                self._o,_xmlTextReaderErrorFunc,(f,arg))

    def GetErrorHandler(self):

        """Return (f,arg) as previously registered with setErrorHandler

           or (None,None)."""

        f,arg = libxml2mod.xmlTextReaderGetErrorHandler(self._o)

        if f is None:

            return None,None

        else:

            # assert f is _xmlTextReaderErrorFunc

            return arg

#

# The cleanup now goes though a wrapper in libxml.c

#

def cleanupParser():

    libxml2mod.xmlPythonCleanupParser()

#

# The interface to xmlRegisterInputCallbacks.

# Since this API does not allow to pass a data object along with

# match/open callbacks, it is necessary to maintain a list of all

# Python callbacks.

#

__input_callbacks = []

def registerInputCallback(func):

    def findOpenCallback(URI):

        for cb in reversed(__input_callbacks):

            o = cb(URI)

            if o is not None:

                return o

    libxml2mod.xmlRegisterInputCallback(findOpenCallback)

    __input_callbacks.append(func)

def popInputCallbacks():

    # First pop python-level callbacks, when no more available - start

    # popping built-in ones.

    if len(__input_callbacks) > 0:

        __input_callbacks.pop()

    if len(__input_callbacks) == 0:

        libxml2mod.xmlUnregisterInputCallback()

# WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING

#

# Everything before this line comes from libxml.py 

# Everything after this line is automatically generated

#

# WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING