#

# 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

from token import ENDMARKER, NAME, ERRORTOKEN

import StringIO

from cone.public import container

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

        #print "toknum: %r, tokval: %r, spos: %r, epos: %r" % (toknum, tokval, spos, epos)

        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 toknum in (NAME, ERRORTOKEN):

            # 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

    def execute(self):

        """

        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

    """

    def execute(self):

        ret = True

        i = 0

        for relation in self:

            i += 1

            r = relation.execute()

            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)

    def execute(self):

        """

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

        ret = self.interpreter.eval()

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

        return (ASTInterpreter.extract_refs(self.left), ASTInterpreter.extract_refs(self.right))

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

        """ Expans rule elements base on the reference.

        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:

                expanded_rule += ' %s ' % token

            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_keys(self, refs):

        return ASTInterpreter.extract_refs(refs)

    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

    def eval(self, context): pass

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)

    def eval(self, context):

        self.value = self.OP(self.expression.eval(context))

        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)

    def eval(self, context):

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

    def eval(self, context):

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

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

        return self.value         

class TerminalExpression(Expression):

    KEY = 'terminal'

    def __init__(self, ast, expression):

        super(TerminalExpression, self).__init__(ast)

        self.expression = expression

    def eval(self, context):

        """ Use context to eval the value

        Expression on TerminalExpression is feature reference or value

        context should handle the reference conversion to correct value

        """

        self.value = context.handle_terminal(self.expression)

        return self.value

    def __unicode__(self):

        return self.expression

    def __repr__(self):

        return self.expression

class NegExpression(OneParamExpression):

    PRECEDENCE = PRECEDENCES['PREFIX_OPERATORS']

    KEY= '-'

    OP = ops.neg

class AndExpression(TwoOperatorBooleanExpression):

    PRECEDENCE = PRECEDENCES['BOOLEAN_OPERATORS']

    KEY= 'and'

    OP = truth_and

class NandExpression(TwoOperatorBooleanExpression):

    PRECEDENCE = PRECEDENCES['BOOLEAN_OPERATORS']

    KEY = 'nand'

    OP = nand

class OrExpression(TwoOperatorBooleanExpression):

    PRECEDENCE = PRECEDENCES['BOOLEAN_OPERATORS']

    KEY = 'or'

    OP = ops.or_

class XorExpression(TwoOperatorBooleanExpression):

    PRECEDENCE = PRECEDENCES['BOOLEAN_OPERATORS']

    KEY = 'xor'

    OP = ops.xor

class NorExpression(TwoOperatorBooleanExpression):

    PRECEDENCE = PRECEDENCES['BOOLEAN_OPERATORS']

    KEY = 'nor'

    OP = nor

class EqualExpression(TwoOperatorExpression):

    PRECEDENCE = PRECEDENCES['COMPARISON_OPERATORS']

    KEY = '=='

    OP = ops.eq

class NotEqualExpression(TwoOperatorExpression):

    PRECEDENCE = PRECEDENCES['COMPARISON_OPERATORS']

    KEY = '!='

    OP = ops.ne

class LessThanExpression(TwoOperatorExpression):

    PRECEDENCE = PRECEDENCES['COMPARISON_OPERATORS']

    KEY = '<'

    OP = ops.lt

class GreaterThanExpression(TwoOperatorExpression):

    PRECEDENCE = PRECEDENCES['COMPARISON_OPERATORS']

    KEY = '>'

    OP = ops.gt

class LessThanEqualExpression(TwoOperatorExpression):

    PRECEDENCE = PRECEDENCES['COMPARISON_OPERATORS']

    KEY = '<='

    OP = ops.le

class GreaterThanEqualExpression(TwoOperatorExpression):

    PRECEDENCE = PRECEDENCES['COMPARISON_OPERATORS']

    KEY = '>='

    OP = ops.ge

def handle_require(expression, left, right):

    if left and right:

        return True

    elif not left:

        return True

    return False

class RequireExpression(TwoOperatorExpression):

    PRECEDENCE = PRECEDENCES['RELATION_OPERATORS']

    KEY = 'requires'

    OP = handle_require

    def eval(self, context):

        super(RequireExpression, self).eval(context)

        if not self.value:

            left_keys = []

            for ref in self.ast.extract_refs(unicode(self.left)):

                for key in context.get_keys(ref):

                    left_keys.append(key)

            for key in left_keys:

                self.ast.add_error(key, { 'error_string' : 'REQUIRES right side value is "False"',

                                          'left_key' : key,

                                          'rule' : self.ast.expression

                                          })

        return self.value

def handle_exclude(expression, left, right):

    if left and not right:

        return True