# XPath parsing

import copy

from Parser import Parser

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

def backward_id(elem):

    if len(elem.attrs) >= 1 and value(elem.attrs[0]) == None and\

    len(elem.attrs[0]) == 1: return elem.attrs[0]

    else: return None

class XpathParser(Parser):

    def _main(self):

        self._match_str('/') # optional leading /

        return self._path()

    def _path(self):

        tree = []

        trailing_slash = False

        while True:

            # Split path

            if self._match_str('{'):

                paths = []

                while True:

                    paths.append(tree + self._path())

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

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

                tree = paths[0] # just use first subpath for now

                break # nothing allowed after split path

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

                name=self._match_re(r'[\w.*]+', required=True))

            # Attrs

            if self._match_str('['):

                elem.attrs = []

                while True:

                    path = self._path()

                    if self._match_str('='):

                        set_value(path, self._match_re(r'[\w.|]*'))

                    elem.attrs.append(path)

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

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

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

            tree.append(elem)

            # Lookahead assertion

            if self._match_str('('):

                self._match_str('/', required=True) # next / is inside ()

                path = self._path()

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

                elem.attrs.append(path)

                tree += path

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

        # Expand * abbrs

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

            elem = tree[i]

            id_ = backward_id(elem)

            if id_ != None: elem = id_[0]; offset = -2

            elif elem.is_ptr: offset = 2

            else: offset = 1

            before, abbr, after = elem.name.partition('*')

            if abbr != '':

                try: elem.name = before+tree[i+offset].name+after

                except IndexError: pass # no replacement elem

        return tree

def parse(string): return XpathParser(string).parse()

instance_level = 1

def obj(path):

    obj_path = copy.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 is_id(path): return path[0].is_attr and path[0].name == 'id'

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