#!/usr/bin/env python
# -*- coding: utf-8 -*-
""" :mod:`java2python.lang.selector` -- Declarative AST node selection
=======================================================================

.. module:: java2python.lang.selector
    :synopsis: Declarative AST node selection.
.. moduleauthor:: Troy Melhase <troy@gci.net>

This module provides classes for simple AST node selection that can be
easily combined to form complex, declarative rules for retrieving AST
nodes.

The classes are similar to CSS selectors, with a nod to Python parsing
libraries like LEPL and PyParsing.  At the moment, only a few very
basic selector types are implemented, but those that are here already
provide all of the functionality necessary for use within the package.

Projects using java2python should regard this subpackage as
experimental.  While the interfaces are not expected to change, the
semantics may.  Use with caution.
"""
from java2python.lang import tokens


class Selector(object):
    """ Base class for concrete selectors; provides operator methods. """

    def __add__(self, other):
        """ E + F

        Like CSS "E + F": an F element immediately preceded by an E element
        """
        return AdjacentSibling(self, other)

    def __and__(self, other):
        """ E & F

        Like CSS "E F":  an F element descendant of an E element
        """
        return Descendant(self, other)

    def __call__(self, *args, **kwds):
        """ Subclasses must implement. """
        raise NotImplementedError('Selector class cannot be called.')

    def __getitem__(self, key):
        """ E[n]

        Like CSS "E:nth-child(n)": an E element, the n-th child of its parent
        """
        return Nth(self, key)

    def __gt__(self, other):
        """ E > F

        Like CSS: "E > F": an F element child of an E element
        """
        return Child(self, other)

    def __div__(self, other):
        """ E / F

        Produces a AnySibling.
        """
        return AnySibling(self, other)

    def walk(self, tree):
        """ Select items from the tree and from the tree children. """
        for item in self(tree):
            yield item
        for child in tree.children:
            for item in self.walk(child):
                yield item


class Token(Selector):
    """ Token(...) -> select tokens by matching attributes.

    Token is the most generic and flexible Selector; using it,
    arbitrary nodes of any type, line number, position, and/or text
    can be selected.

    Calling Token() without any keywords is equivalent to:

        Token(channel=None, index=None, input=None, line=None,
              start=None, stop=None, text=None, type=None)

    Note that the value of each keyword can be a constant or a
    callable.  When callables are specified, they are passed a the
    token and should return a bool.
    """

    def __init__(self, **attrs):
        self.attrs = attrs
        ## we support strings so that the client can refer to the
        ## token name that way instead of via lookup or worse, integer.
        if isinstance(attrs.get('type'), (basestring, )):
            self.attrs['type'] = getattr(tokens, attrs.get('type'))

    def __call__(self, tree):
        items = self.attrs.items()
        token = tree.token

        def match_or_call(k, v):
            if callable(v):
                return v(token)
            return getattr(token, k)==v

        if all(match_or_call(k, v) for k, v in items if v is not None):
            yield tree

    def __str__(self):
        items = self.attrs.items()
        keys = ('{}={}'.format(k, v) for k, v in items if v is not None)
        return 'Token({})'.format(', '.join(keys))


class Nth(Selector):
    """ E[n] ->  match any slice n of E

    Similar to the :nth-child pseudo selector in CSS, but without the
    support for keywords like 'odd', 'even', etc.
    """
    def __init__(self, e, key):
        self.e, self.key = e, key

    def __call__(self, tree):
        for etree in self.e(tree):
            try:
                matches = tree.children[self.key]
            except (IndexError, ):
                return
            if not isinstance(matches, (list, )):
                matches = [matches]
            for child in matches:
                yield child

    def __str__(self):
        return 'Nth({0})[{1}]'.format(self.e, self.key)


class Child(Selector):
    """ E > F    select any F that is a child of E

    """
    def __init__(self, e, f):
        self.e, self.f = e, f

    def __call__(self, tree):
        for ftree in self.f(tree):
            for etree in self.e(tree.parent):
                yield ftree

    def __str__(self):
        return 'Child({0} > {1})'.format(self.e, self.f)


class Type(Selector):
    """ Type(T)    select any token of type T

    Similar to the type selector in CSS.
    """
    def __init__(self, key, value=None):
        self.key = key if isinstance(key, int) else getattr(tokens, key)
        self.value = value

    def __call__(self, tree):
        if tree.token.type == self.key:
            if self.value is None or self.value == tree.token.text:
                yield tree

    def __str__(self):
        val = '' if self.value is None else '={0}'.format(self.value)
        return 'Type({0}{1}:{2})'.format(tokens.map[self.key], val, self.key)


class Star(Selector):
    """ *    select any

    Similar to the * selector in CSS.
    """
    def __call__(self, tree):
        yield tree

    def __str__(self):
        return 'Star(*)'


class Descendant(Selector):
    """ E & F    select any F that is a descendant of E

    """
    def __init__(self, e, f):
        self.e, self.f = e, f

    def __call__(self, tree):
        for ftree in self.f(tree):
            root, ftree = ftree, ftree.parent
            while ftree:
                for etree in self.e(ftree):
                    yield root
                ftree = ftree.parent

    def __str__(self):
        return 'Descendant({0} & {1})'.format(self.e, self.f)


class AdjacentSibling(Selector):
    """ E + F    select any F immediately preceded by a sibling E

    """
    def __init__(self, e, f):
        self.e, self.f = e, f

    def __call__(self, node):
        if not node.parent:
            return
        for ftree in self.f(node):
            index = node.parent.children.index(ftree)
            if not index:
                return
            previous = node.parent.children[index-1]
            for child in self.e(previous):
                yield ftree

    def __str__(self):
        return 'AdjacentSibling({} + {})'.format(self.e, self.f)


class AnySibling(Selector):
    """ E / F    select any F preceded by a sibling E

    """
    def __init__(self, e, f):
        self.e, self.f = e, f

    def __call__(self, node):
        if not node.parent:
            return
        for ftree in self.f(node):
            index = node.parent.children.index(ftree)
            if not index:
                return
            for prev in node.parent.children[:index]:
                for child in self.e(prev):
                    yield ftree

    def __str__(self):
        return 'AnySibling({} / {})'.format(self.e, self.f)