#

# 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 unittest

import sys, os

import __init__

import tokenize

import StringIO

from cone.public import api,exceptions, utils

from cone.public.rules import ASTInterpreter, RelationContainerImpl

from cone.public.rules import ParseException, DefaultContext, BaseRelation

from cone.public import rules

#### TEST RELATIONS ####

AA_BA = 'a.a == "foo" requires b.b != 0'

AB_BB = 'a.b configures b.b = a.b+":"+ "test"'

BA_CA = 'b.a requires c.a and c.b and a.b'

CB_DA = 'c.b requires d.a'

DA_DB = 'd.a requires d.b'

AC_AB_BA = 'a.c and a.a requires b.a'

EA_FSTAR = 'e.a requires f.*'

TEST_RELATIONS = {

    'a.a' : [AA_BA, 'a.a == "test" requires b.a'],

    'a.b' : [AB_BB],

    'a.c' : [AC_AB_BA],

    'b.a' : [BA_CA],

    'c.b' : [CB_DA],

    'd.a' : [DA_DB],

    'e.a' : [EA_FSTAR]

}

def get_test_configuration():

    config = api.Configuration()

    config.add_feature(api.Feature('a'))

    config.add_feature(api.Feature('a'),'a')

    config.add_feature(api.Feature('b'),'a')

    config.add_feature(api.Feature('c'),'a')

    config.add_feature(api.Feature('b'))

    config.add_feature(api.Feature('a'),'b')

    config.add_feature(api.Feature('b'),'b')

    config.add_feature(api.Feature('c'))

    config.add_feature(api.Feature('a'),'c')

    config.add_feature(api.Feature('b'),'c')

    config.add_feature(api.Feature('d'))

    config.add_feature(api.Feature('a'),'d')

    config.add_feature(api.Feature('b'),'d')

    config.add_feature(api.Feature('e'))

    config.add_feature(api.Feature('a'),'e')

    dview = config.get_default_view()

    dview.get_feature('a.a').set_value('test')

    dview.get_feature('a.b').set_value('hey')

    dview.get_feature('a.c').set_value(False)

    dview.get_feature('b.a').set_value(True)

    dview.get_feature('b.b').set_value(True)

    dview.get_feature('c.a').set_value(True)

    dview.get_feature('c.b').set_value(True)

    dview.get_feature('d.a').set_value(False)

    dview.get_feature('d.b').set_value(False)

    return config

class TestFactory():

    def get_relations_for(self, configuration, ref):

        rels = TEST_RELATIONS.get(ref)

        if rels:

            relation_container = RelationContainerImpl()

            for rel in rels:

                (left_expression,relation_name,right_expression) = parse_rule(rel)

                relation = rules.RELATIONS.get(relation_name)(configuration, left_expression, right_expression)

                relation_container.add_relation(relation)

                propagated_relations = self.get_relations_for(configuration, right_expression)

                if propagated_relations:

                    for relation in propagated_relations:

                        relation_container.add_relation(relation)

            return relation_container

        return None

def parse_rule(rulestring):

    """

    Divide the given rule string into (left side, relation, right side) components. 

    @return: Triple (left side, relation, right side)

    """

    left_expression = ''

    relation_name = None

    right_expression = ''

    for token in rules.get_tokens(rulestring):

        if relation_name == None:

            if token in rules.RELATIONS.keys():

                relation_name = token

            else:

                left_expression += ' ' + token

        else:

            right_expression += ' ' + token

    if relation_name == None:

        raise exceptions.ParseError('invalid rule definition %s' % rulestring)

    return (left_expression,relation_name,right_expression)

class ConfigurationContext(DefaultContext):

    def handle_terminal(self, expression):

        try:

            value = self.data.get_feature(expression).get_value()

            if value != None:

                #print "handle_terminal %s = %s" % (expression,value)

                return value

            else:

                raise exceptions.NotBound('Feature %s has no value' % expression)

        except exceptions.NotFound,e:

            """ return the expression itself if it is not a fearef """

            #print "handle_terminal constant %s" % (expression)

            try:

                return eval(expression)

            except (NameError,SyntaxError), e:

                return expression

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

        #print "expression %s = %s" % (expression,value)

        pass

class ConfigurationBaseRelation(BaseRelation):

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

        self.context = ConfigurationContext(data)

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

class RequireRelation(ConfigurationBaseRelation):

    KEY = 'requires'

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

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

        self.context = ConfigurationContext(data)

class ConfigureRelation(ConfigurationBaseRelation):

    KEY = 'configures'

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

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

        self.context = ConfigurationContext(data)

def handle_configure(self, left, right):

    if left and right:

        return True

    elif not left:

        return True

    return False

def handle_set(self, left, right):

    left.set_value(right)

class ConfigureExpression(rules.TwoOperatorExpression):

    PRECEDENCE = rules.PRECEDENCES['RELATION_OPERATORS']

    KEY = 'configures'

    OP = handle_configure

    def eval(self, context):

        super(ConfigureExpression, self).eval(context)

        if not self.value:

            left_keys = []

            for ref in self.ast.extract_refs(str(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' : 'CONFIGURES right side value is "False"',

                                          'left_key' : key,

                                          'rule' : self.ast.expression

                                          })

        return self.value

def handle_plus(self, a,b):

    #print "%s adding a: %s to b: %s" % (self, a,b)

    return a + b

class ConcatExpression(rules.TwoOperatorExpression):

    PRECEDENCE = rules.PRECEDENCES['ADDSUB_OPERATORS']

    KEY= '+'

    OP = handle_plus

class SetExpression(rules.TwoOperatorExpression):

    PRECEDENCE = rules.PRECEDENCES['SET_OPERATORS']

    KEY= '='

    OP = handle_set

    def eval(self, context):

        try:

            variable = context.data.get_feature(self.left.expression)

            variable.set_value(self.right.eval(context))

            return True

        except exceptions.NotFound:

            return False

class TestRelations(unittest.TestCase):

    def setUp(self):

        self.configuration = get_test_configuration()

        self.RELATIONS_BACKUP = rules.RELATIONS

        self.OPERATORS_BACKUP = rules.OPERATORS

        rules.RELATIONS = rules.RELATIONS.copy()

        rules.OPERATORS = rules.OPERATORS.copy()

        self.assertTrue(self.RELATIONS_BACKUP is not rules.RELATIONS)

        self.assertTrue(self.OPERATORS_BACKUP is not rules.OPERATORS)

        rules.RELATIONS[RequireRelation.KEY] = RequireRelation

        rules.RELATIONS[ConfigureRelation.KEY] = ConfigureRelation

        rules.OPERATORS[ConfigureExpression.KEY] = ConfigureExpression

        rules.OPERATORS[ConcatExpression.KEY] = ConcatExpression

        rules.OPERATORS[SetExpression.KEY] = SetExpression

    def tearDown(self):

        rules.RELATIONS = self.RELATIONS_BACKUP

        rules.OPERATORS = self.OPERATORS_BACKUP

    def test_has_ref(self):

        """

        Tests the relation and relation container

        """

        factory = TestFactory()

        rels = factory.get_relations_for(self.configuration, 'a.a')

        ret= rels.execute()

        self.assertTrue(ret)

    def test_has_ref(self):

        """

        Tests the relation and relation container

        """

        factory = TestFactory()

        rels = factory.get_relations_for(self.configuration, 'a.a')

        ret= rels.execute()

        self.assertTrue(ret)

    def test_not_has_ref(self):

        factory = TestFactory()

        # depends on c.a which has no value in conf

        rels = factory.get_relations_for(self.configuration, 'b.a')

        ret = rels.execute()

        self.assertTrue(ret)

    def test_not_has_ref_in_container(self):

        factory = TestFactory()

        rels = factory.get_relations_for(self.configuration, 'c.b')

        ret = rels.execute()

        self.assertFalse(ret)

    def test_two_on_the_left(self):

        factory = TestFactory()

        rels = factory.get_relations_for(self.configuration, 'a.c')

        ret = rels.execute()

        self.assertTrue(ret)

    def test_configure_right_side(self):

        factory = TestFactory()

        rels = factory.get_relations_for(self.configuration, 'a.b')

        ret = rels.execute()

        self.assertTrue(ret)

        self.assertEquals(self.configuration.get_default_view().get_feature('b.b').get_value(),'hey:test')

if __name__ == '__main__':

    unittest.main()