# XPath-based XML tree manipulation

from xml.dom import Node

from Parser import Parser

import xml_util

class XpathElem:

    def __init__(self, name, value=None, attrs=None, is_attr=False,

        is_ptr=False):

        if attrs == None: attrs = []

        self.name = name

        self.value = value

        self.attrs = attrs

        self.is_attr = is_attr

        self.is_ptr = is_ptr

    def __repr__(self):

        str_ = ''

        if self.is_attr: str_ += '@'

        str_ += self.name+repr(self.attrs)+'='+repr(self.value)

        if self.is_ptr: str_ += '->'

        return str_

    def __eq__(self, other): return self.__dict__ == other.__dict__

class XpathParser(Parser):

    def _main(self):

        self._match_str('/', required=True)

        return self._path()

    def _path(self):

        tree = []

        while True:

            elem = XpathElem(is_attr=self._match_str('@'), name=self._fields())

            if self._match_str('['):

                elem.attrs = self._attrs()

                self._match_str(']', required=True)

            elem.is_ptr = self._match_str('->')

            tree.append(elem)

            if not self._match_str('/'): break

        return tree

    def _fields(self):

        if self._match_str('{'):

            tree = []

            while True:

                tree.append(self._field())

                if not self._match_str(','): break

            self._match_str('}', required=True)

            tree = tuple(tree)

            tree = tree[0] # just use first field for now

        else: tree = self._field()

        return tree

    def _attrs(self):

        tree = []

        while True:

            path = self._path()

            self._match_str('=', required=True)

            path[-1].value = self._value()

            tree.append(path)

            if not self._match_str(','): break

        return tree

    def _field(self):

        return self._name()

    def _name(self): return self._match_re(r'[\w.]+', required=True)

    def _value(self): return self._match_re(r'[\w.|]+', required=True)

def set_id(path, id_, has_type_containers=True):

    if has_type_containers: id_level = 1

    else: id_level = 0

    path[id_level].attrs.append([XpathElem('id', id_, is_attr=True)])

def get(doc, path, create=False, parent=None):

    if parent == None: parent = doc.documentElement

    for elem in path:

        node = None

        if elem.is_attr: node = parent.getAttributeNode(elem.name)

        elif elem.name == '.': node = parent

        else: node = xml_util.by_tag_name(parent, elem.name)

        if node != None and elem.value != None\

        and xml_util.value(node) != elem.value: node = None

        for attr in elem.attrs:

            if get(doc, attr, parent=node) == None: node = None; break

        if node == None:

            if not create: return None

            if elem.is_attr:

                parent.setAttribute(elem.name, '')

                node = parent.getAttributeNode(elem.name)

            else: node = parent.appendChild(doc.createElement(elem.name))

            if elem.value != None:

                if node.nodeType == Node.ELEMENT_NODE:

                    node.appendChild(doc.createTextNode(elem.value))

                else: node.nodeValue = elem.value

            for attr in elem.attrs: get(doc, attr, create, node)

        if elem.is_ptr:

            pass

        parent = node

    return parent