# XPath-based XML tree manipulation

from copy import deepcopy

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

        if self.attrs != []: str_ += repr(self.attrs)

        if self.value != None: str_ += '='+repr(self.value)

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

        return str_

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

def value(path): return path[-1].value

def set_value(path, value): path[-1].value = value

class XpathParser(Parser):

    def _main(self):

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

        return self._path()

    def _path(self):

        tree = []

        fork_idx = None

        elem_idx = 0

        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('->')

            if not elem.is_ptr and self._match_str('!'): fork_idx = elem_idx

            tree.append(elem)

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

            elem_idx += 1

        # Add lookahead assertion for rest of path

        if fork_idx != None: tree[fork_idx].attrs.append(tree[fork_idx+1:])

        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()

            if self._match_str('='): set_value(path, 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)

instance_level = 1

def obj(path):

    obj_path = deepcopy(path[:instance_level+1])

    obj_path[-1].is_ptr = False # prevent pointer w/o target

    return obj_path

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

    if has_types: id_level = instance_level

    else: id_level = 0

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

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

    # Warning: The last_only optimization may split data between multiple nodes

    if parent == None: parent = doc.documentElement

    if last_only == None: last_only = create

    elem_idx = 0

    for elem in path:

        # Find possible matches

        children = []

        if elem.is_attr:

            child = parent.getAttributeNode(elem.name)

            if child != None: children = [child]

        elif elem.name == '.': children = [parent]

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

        # Check each match

        node = None

        for child in children:

            is_match = elem.value == None or xml_util.value(child) == elem.value

            for attr in elem.attrs:

                if not is_match: break

                is_match = get(doc, attr, False, last_only, child) != None

            if is_match: node = child; break

        # Create node

        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: xml_util.set_value(doc, node, elem.value)

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

        # Follow pointer

        if elem.is_ptr:

            path = deepcopy(path[elem_idx+1:]) # rest of path

            attrs = path[instance_level].attrs

            if len(attrs) >= 1 and value(attrs[0]) == None:

                # backward (child-to-parent) pointer with target ID attr

                set_value(attrs[0], xml_util.get_id(node))

            else: # forward (parent-to-child) pointer

                id_ = xml_util.value(node)

                obj_path = obj(path) # target object

                if id_ == None or get(doc, obj_path, False, True) == None:

                    # no target or target attrs don't match

                    if not create: return None

                    # Use last target object's ID + 1

                    obj_path[-1].attrs = [] # just get by tag name

                    last = get(doc, obj_path, False, True)

                    if last != None: id_ = str(int(xml_util.get_id(last)) + 1)

                    else: id_ = '0'

                    # Will append if target attrs didn't match. Place ! in XPath

                    # after element to fork at to avoid this.

                    xml_util.set_value(doc, node, id_)

                else: last_only = False

                set_id(path, id_)

            return get(doc, path, create, last_only)

        parent = node

        elem_idx += 1

    return parent