import copy

import warnings

import util

import xml_dom

import xpath_func

##### Path elements

class XpathElem:

    def __init__(self, name='', value=None, is_attr=False):

        self.name = name

        self.is_positive = True

        self.is_lookup_only = False

        self.is_ptr = False

        self.other_branches = [] # temp implementation for split paths

        if not self.is_positive: str_ += '!'

        if self.is_attr: str_ += '@'

        if self.name == '': str_ += '""'

        if self.is_lookup_only: str_ += '?'

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

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

        return str_

empty_elem = XpathElem()

def is_self(elem): return elem.name == '' or elem.name == '.'

##### Paths

def is_positive(path): return path[0].is_positive

def is_rooted(path): return elem_is_empty(path[0])

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

def set_value(path, value):

def backward_id(elem):

    if len(elem.keys) >= 1 and value(elem.keys[0]) == None: return elem.keys[0]

    else: return None

instance_level = 1 # root's grandchildren

    '''Caller must make a shallow copy of the path to prevent modifications from

    if has_types: id_level = instance_level

    if is_self(path[0]): id_level += 1 # explicit root element

def is_instance(elem): return elem.keys != [] and is_id(elem.keys[0])

def expand_abbr(name, repl):

_cache = {}

def parse(str_):

    try: return _cache[str_]

    parser = Parser(str_)

    def _path():

        is_positive = not parser.str_('!')

        tree = []

            # Split path

            if parser.str_('{'):

                last = tree[-1]

                parser.str_('}', required=True)

                if parser.str_('/'): # common subpath after {}

            elem = XpathElem(is_attr=parser.str_('@'), name=_value())

            elem.is_lookup_only = parser.str_('?')

            # Keys used to match nodes

            if parser.str_('['):

                elem.keys = _paths()

                parser.str_(']', required=True)

            # Attrs created when no matching node exists

            elem.is_ptr = parser.str_('->')

            tree.append(elem)

            if parser.str_('('):

                elem.keys.append(path)

                tree += path

            if not parser.str_('/'): break

        tree[0].is_positive = is_positive

        if parser.str_('='):

            if parser.str_('$'): # reference (different from a pointer)

            set_value(tree, value)

        # Expand * abbrs

        for i in reversed(xrange(len(tree))):

            if elem.is_ptr: offset = 2

            else: offset = 1

            try: repl = tree[i+offset].name

            except IndexError: pass # no replacement elem

        return tree

    def _value():

    def _paths():

    path = _path()

    path = xpath_func.process(path)

    _cache[str_] = path

    return path

##### Querying/creating XML trees

def get(root, xpath, create=False, last_only=None, limit=1, allow_rooted=True):

    '''Warning: The last_only optimization may put data that should be together

    if last_only == None: last_only = create

    if limit == None or limit > 1: last_only = False

    if util.is_str(xpath): xpath = parse(xpath)

    # Handle edge cases

    if xpath == []: return [root]

    if create and not is_positive(xpath): return []

    doc = root.ownerDocument

    if allow_rooted and is_rooted(xpath): root = doc.documentElement

    elem = xpath[0]

        child = root.getAttributeNode(elem.name)

        if child != None: children = [child]

    elif is_self(elem): children = [root]

        parent = xml_dom.parent(root)

        if parent == None: return [] # don't try to create doc root's parent

    else:

        children = xml_dom.by_tag_name(root, elem.name,

            last_only and (elem.keys == [] or is_instance(elem)))

    # Retrieve elem value

    # Check each match

    nodes = []

    for child in children:

        is_match = value_ == None or xml_dom.value(child) == value_

        for attr in elem.keys:

            is_match = ((get(child, attr, False, last_only,

        if is_match:

    if nodes == []:

        if not create or elem.is_lookup_only: return []

        if elem.is_attr:

            root.setAttribute(elem.name, '')

        elif util.list_eq_is(children, [root]): node = root

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

        if value_ != None: xml_dom.set_value(node, value_)

        nodes.append(node)

    path_value = value(xpath)

    xpath = xpath[1:] # rest of XPath

    next = []

                get(node, attr, create, last_only, allow_rooted=False)

            root = doc.documentElement

            xpath = copy.deepcopy(xpath)

        next += get(root, xpath, create, last_only, limit, allow_rooted=False)

            branch = branch[:] # don't modify input!

            set_value(branch, path_value)

            next += get(node, branch, create, last_only, limit,

def get_1(*args, **kw_args):

def put_obj(root, xpath, id_, has_types, value=None):

    if util.is_str(xpath): xpath = parse(xpath)

    xpath = xpath[:] # don't modify input!

    set_id(xpath, id_, has_types)

    if value != None: set_value(xpath, value)

    get(root, xpath, True)

def path2xml(xpath, first_branch=True):

    get(root, xpath, True)

    return root

def xml_set_id(root, id_): xml_dom.set_id(root.firstChild, id_)