#

# Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# under the terms of "Eclipse Public License v1.0"

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description: 

#

import operator as ops

import logging

import tokenize

import StringIO

RELATIONS = {}

def abstract():

    import inspect

    caller = inspect.getouterframes(inspect.currentframe())[1][3]

    raise NotImplementedError(caller + ' needs to be implemented')

def get_tokens(tokenstr):

    result = []

    tokens = []

    tokenstr = tokenstr.replace('\r', '')

    name_buffer = [] # Temp buffer for reading name tokens

    last_epos = None

    for toknum, tokval, spos, epos, _  in tokenize.generate_tokens(StringIO.StringIO(unicode(tokenstr)).readline):

        val = tokval.strip('\r\n\t ')

        if toknum == ENDMARKER and name_buffer:

            tokens.append(''.join(name_buffer))

        # Ignore whitespace (this ignores also the end marker,

        # since its value is empty)

        if val == '': continue

        # Put NAME, and ERRORTOKEN tokens through the temp

        # buffer

            # If this and the previous token in the temp buffer are not adjacent,

            # they belong to separate tokens

            if name_buffer and spos[1] != last_epos[1]:

                tokens.append(''.join(name_buffer))

                name_buffer = []

            name_buffer.append(val)

            last_epos = epos

        # Other tokens can just go directly to the token list

        else:

            if name_buffer:

                tokens.append(''.join(name_buffer))

                name_buffer = []

            tokens.append(val)

    while len(tokens) > 0:

        val = tokens.pop(0)

        # Join the refs with dot in between them to make them dotted refs

        if val == '.':

            newval = ".".join([result.pop(),tokens.pop(0)])

            result.append( newval )

        else:

            result.append( val )

    return result

class RelationException(Exception):

    pass

#### The containers are here ####

class RelationBase(object):

    """

    RelationBase defines a base class for all named relations that can be applied between objects. 

    e.g. Relation depends, that can be applied in Rule

    """

    relation_name = "RelationBase"

    def __init__(self, data, left, right):

        self.description = ""

        self.data = data or container.DataContainer()

        self.left = left

        self.right = right

    def __str__(self):

        """

        @return: A string presentation of the relation object

        """

        return "%s %s %s" % (self.left,self.relation_name,self.right)

    def get_name(self):

        """

        @return: The relation name.

        """

        return self.relation_name

    def get_description(self):

        """

        @return: a possible description of the relation.

        """

        return self.description

        """

        Execute the relation object.

        """

        pass

class RelationContainer(RelationBase, list):

    """

    This class provides the RelationContainer interface for collecting

    relation sets into one place which can be executed through the container.

    """

    def __init__(self, data=None):

        super(RelationContainer, self).__init__(data, 'LContainer', 'RContainer')

        self.value_list = list()

    def append(self, value):

        self.value_list.append(value)

    def __iter__(self):

        return self.value_list.__iter__()

    def __len__(self):

        return len(self.value_list)

    def __or__(self, other):

        """

        This function adds two RelationContainers to each other and removes

        duplicates from the result.

        The modification is inplace and the returned value is called object.

        """

        self.value_list = set(self.value_list) | set(other.value_list)

        return self

    def __unicode__(self):

        if self:

            ret = ''

            for value in self:

                ret += unicode(value)

        else:

            ret = 'No relations'

        return ret

    def find_relations(self, refs): abstract()

    def add_relation(self, relation): abstract()

    def has_errors(self): abstract()

class RelationContainerImpl(RelationContainer):

    """ Base implementation for RelationContainer to use in ConE rules

    """

        ret = True

        i = 0

        for relation in self:

            i += 1

            ret = ret and r

        return ret

    def find_relations(self, refs):

        relations = []

        for ref in refs:

            for relation in self:

                if relation.has_ref(ref):

                    relations.append(relation)

        return relations

    def add_relation(self, relation):

        self.append(relation)

    def has_ref(self, refs):

        for ref in refs:

            for relation in self:

                if relation.has_ref(ref):

                    return True

        return False

    def has_errors(self):

        for relation in self:

            if relation.has_errors():

                return True

        return False

    def get_errors(self):

        errors = []

        for relation in self:

            errors += relation.get_errors()

        return errors

#### The relations are here ####

class BaseRelation(RelationBase):

    """ BaseRelation implements the basic evaluation logic for relations

    This class abstract and should be extended for concrete implementation of

    relation type.

    Subclasses need to set their own context in their constructor before this

    class's constructor is called if custom context is needed. If context not

    set then DefaultContext is used.

    """

    KEY = 'base_relation'

    def __init__(self, data, left, right):

        # Context needs to be overridden for special purposes

        try:

            self.__getattribute__('context')

        except AttributeError:

            self.context = DefaultContext(data)

        left = self.expand_rule_elements(left)

        right = self.expand_rule_elements(right)

        super(BaseRelation, self).__init__(data, left, right)

        self.interpreter = ASTInterpreter(context=self.context)

        """

        @return Returns error dictionary

        In the client code proper way to check if the rule applies:

        info = relation.execute()

        if not info.has_errors():

        else: HANDLE ERRORS

        """

        # logger.debug("Interpreter context %s" % self.interpreter.context)

        self.interpreter.create_ast('%s %s %s' % (self.left, self.KEY, self.right))

        return ret

    def get_keys(self):

        """ Returns the references from this relation.

        """

        refs = ASTInterpreter.extract_refs(self.left)

        refs += ASTInterpreter.extract_refs(self.right)

        return refs

    def has_ref(self, ref):

        """ Returns if the 'ref' is included in this relation

        """

        return ref in self.get_keys()

    def has_errors(self):

        return bool(self.interpreter.errors)

    def get_refs(self):

    def _eval_rside_value(self, value): abstract()

    def _compare_value(self, value): abstract()

    def extract_erroneus_features_with_values(self):

        """

        Extract references who have errors.

        Returns dictionary { 'reference' : 'value' }

        """

        data_dict = {}

        for ref in ASTInterpreter.extract_refs(self.right):

            value = self.data.get_feature(ref)

            if self._compare_value(value):

                data_dict[ref] = value

            elif value == None:

                data_dict[ref] = None

        return data_dict

    def get_errors(self):

        return self.interpreter.errors

    def expand_rule_elements(self, rule):

        Context is used for fetching the child elements for parent references

        which uses asterisk identifier for selecting all child features: 

        'parent_feature.*' -> 'child_fea_1 and child_fea_2'.

        """

        tokens = get_tokens(rule) # [token for token in rule.split()]

        expanded_rule = ""

        for token in tokens:

            if token.endswith('.*'):

                index = token.index('.*')

                parent_ref = token[:index]

                children = self.context.get_children_for_reference(parent_ref)

                expanded_element = ' and '.join([child.reference for child in children])

                if expanded_rule:

                    expanded_rule = '%s and %s' % (expanded_rule, expanded_element.rstrip())

                else:

                    expanded_rule = expanded_element.rstrip()

            elif token.lower() in OPERATORS:

            else:

                if expanded_rule:

                    expanded_rule += '%s'% token

                else:

                    expanded_rule = token

        return expanded_rule.strip()

class RequireRelation(BaseRelation):

    KEY = 'requires'

RELATIONS[RequireRelation.KEY] = RequireRelation

class ExcludesRelation(BaseRelation):

    KEY = 'excludes'

RELATIONS['excludes'] = ExcludesRelation

################################

# Abstract syntax tree builder #

################################

def nor(expression, a, b):

    return not ops.or_(a, b)

def nand(expression, a, b):

    return not ops.and_(a, b)

def truth_and(expression, a, b):

    return ops.truth(a) and ops.truth(b)

class DefaultContext(object):

    """ DefaultContext implements ConE specific context for handling rules

    """

    def __init__(self, data):

        self.data = data

    def eval(self, ast, expression, value):

        pass

    def get_children_for_reference(self, reference):

        # implement ConE specific children expansion

        pass

    def handle_terminal(self, expression):

        try:

            return int(expression)

        except:

            return expression

PRECEDENCES = {

    'PREFIX_OPERATORS' : 10,

    'MULDIV_OPERATORS' : 8,

    'ADDSUB_OPERATORS' : 7,

    'SHIFT_OPERATORS' : 6,

    'BITWISE_OPERATORS' : 5,

    'COMPARISON_OPERATORS' : 4,

    'SET_OPERATORS' : 3,

    'BOOLEAN_OPERATORS' : 2, 

    'RELATION_OPERATORS' : 1,

    'NOT_DEFINED' : 0

}

class Expression(object):

    PRECEDENCE = PRECEDENCES['NOT_DEFINED']

    KEY = 'base_expression'

    def __init__(self, ast):

        self.ast = ast

        self.value = None

    def get_title(self):

        return self.KEY

class OneParamExpression(Expression):

    PARAM_COUNT = 1

    def __init__(self, ast, expression):

        super(OneParamExpression, self).__init__(ast)

        self.expression = expression

    def __unicode__(self):

        return u'%s %s' % (self.KEY, self.expression)

        context.eval(self.ast, self, self.value)

        return self.value

class TwoOperatorExpression(Expression):

    PARAM_COUNT = 2

    OP = None

    EVAL_AS_BOOLS = True

    def __init__(self, ast, left, right):

        super(TwoOperatorExpression, self).__init__(ast)

        self.left = left

        self.right = right

    def __unicode__(self):

        return u'%s %s %s' % (self.left, self.KEY, self.right)

        self.value = self.OP(self.left.eval(context), self.right.eval(context))

        context.eval(self.ast, self, self.value)

        return self.value

class TwoOperatorBooleanExpression(TwoOperatorExpression):

        context.eval(self.ast, self, self.value)

        return self.value