# 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

def parse(str_):

    parser = Parser(str_)

    def _path():

        tree = []

        trailing_slash = False

        while True:

            # Split path

            if parser.str_('{'):

                paths = []

                while True:

                    paths.append(tree + _path())

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

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

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

                break # nothing allowed after split path

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

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

            # Attrs

            if parser.str_('['):

                elem.attrs = []

                while True:

                    path = _path()

                    if parser.str_('='):

                        set_value(path, parser.re(r'[\w.|]*'))

                    elem.attrs.append(path)

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

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

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

            tree.append(elem)

            # Lookahead assertion

            if parser.str_('('):

                parser.str_('/', required=True) # next / is inside ()

                path = _path()

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

                elem.attrs.append(path)

                tree += path

            if not parser.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

    parser.str_('/') # optional leading /

    path = _path()

    parser.end()

    return path

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