#============================================================================ 

#Name        : configuration_model.py 

#Part of     : Helium 

#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 the License "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:

#===============================================================================

""" the model definition of property, group of property and configuration of property"""

import amara

import logging

import copy

_logger = logging.getLogger('configurationmodel')

#logging.basicConfig(level=logging.DEBUG)

_handler = logging.StreamHandler()

_handler.setFormatter(logging.Formatter('%(levelname)s: %(message)s'))

_logger.addHandler(_handler)

class PropertyDef(object):

    """ The model definition of a property. """

    def __init__(self, property_node):

        """ Initialization. """

        if not hasattr(property_node, 'name'):

            raise Exception("Name is not defined for '" + str(property_node) + "'")

        if not hasattr(property_node, 'type'):

            raise Exception("Type is not defined for '" + str(property_node.name) + "'")

        if not hasattr(property_node, 'description'):

            raise Exception("Description is not defined for '" + str(property_node.name) + "'")

        self.name = str(property_node.name)

        self.editStatus = str(property_node.editStatus)

        self.type = str(property_node.type)

        self.description = str(property_node.description).strip()

        if len(self.description) == 0:

            _logger.log(logging.ERROR, "Description has no content for '" + str(property_node.name) + "'")

        if hasattr(property_node, 'deprecated'):

            self.deprecated = str(property_node.deprecated)

    def __repr__(self):

        return self.name

    def __str__(self):

        return self.name

class GroupDef(object):

    """ The model definition of a group of properties. """

    def __init__(self, group_node):

        """ Initialization. """

        self.name = str(group_node.name)

        self.description = str(group_node.description)

        self.properties = {}

        self.propref = []

        for property_ in group_node.propertyRef:

            self.properties[str(property_)] = property_.usage

    def check_config(self, config, items):

        """ Checks that the set of properties in a group are properly defined. """

        defined_props = [p for p in self.properties.keys() if config.has_key(p)]

        if len(defined_props) > 0:

            required_props = [p for p in self.properties.keys() if self.properties[p] == 'required']

            required_not_defined_props = set(required_props).difference(set(defined_props))

            for undefined_property in required_not_defined_props:

                items.append(UndefinedRequiredInGroupItem((self.name, undefined_property)))

class DataModel(object):

    """ A model of the configuration properties. """

    def __init__(self, modelpath):

        """ Initialization. """

        doc = amara.parse(open(modelpath, 'r'))

        self.properties = {}

        self.required_props = []

        for property_ in doc.heliumDataModel.property:

            self.properties[str(property_.name)] = PropertyDef(property_)

        self.nongroupedproperties = copy.copy(self.properties)

        self.groups = {}

        for group in doc.heliumDataModel.group:

            groupobj = GroupDef(group)

            self.groups[str(group.name)] = groupobj

            for prop in groupobj.properties:

                groupobj.propref.append(self.properties[prop])

                if prop in self.nongroupedproperties:

                    del self.nongroupedproperties[prop]

            groupobj.propref.sort()

            required_props_in_group = [p for p in group.propertyRef if p.usage == 'required']

            for required_prop in required_props_in_group:

                self.required_props.append(required_prop)

                if not self.properties.has_key(str(required_prop)):

                    raise Exception("Required property " + str(required_prop) + " is not defined!")

    def validate_config(self, config):

        """ Validate the Ant configuration against the model. """

        items = []

        self._check_deprecated_properties(config, items)

        self._check_undefined_properties(config, items)

        self._check_undefined_properties_in_groups(config, items)

        self._check_type_validation(config, items)

        self._check_defined_properties_not_in_groups()

        return items

    def validate_config_at_startup(self, config):

        """ Validate the Ant configuration against the model at build startup. """

        items = []

        for p_props in self.required_props:

            if not config.has_key(str(p_props)):

                print "Required property " + str(p_props) + " is not defined!"

        return items

    def _check_deprecated_properties(self, config, items):

        """ Check that deprecated properties not being used. """

        deprecated_props = [p for p in self.properties.values() if hasattr(p, 'deprecated')]

        for deprecated_prop in deprecated_props:

            _logger.debug('Checking deprecated property: ' + str(deprecated_prop))

            if config.has_key(str(deprecated_prop)):

                items.append(UsingDeprecatedItem(deprecated_prop))

    def _check_undefined_properties(self, config, items):

        """ Check for any defined properties that are not in the model. """ 

        undefined_properties = [p_key for p_key in config.keys() if p_key not in self.properties]

        undefined_properties.sort()

        for undefined_property in undefined_properties:

            items.append(MissingFromDataModelItem(undefined_property))

    def _check_undefined_properties_in_groups(self, config, items):

        """ Check for any undefined properties that are in the group. """ 

        for group in self.groups.values():

            _logger.debug('Checking group: %s' % group.name)

            group.check_config(config, items)

    def _check_defined_properties_not_in_groups(self):

        """ Check for any defined properties that are not in the group. """ 

        g_props = []

        for group in self.groups.values():

            g_props = g_props + group.properties.keys()

        for p_props in self.properties.values():

            if not str(p_props) in g_props:

                raise Exception(str(p_props) + ' not in a group')

    def _check_type_validation(self, config, items):

        """ Check the type validation. """ 

        prop_string = [p_props for p_props in self.properties.values() if p_props.type == 'string']

        prop_integer = [p_props for p_props in self.properties.values() if p_props.type == 'integer']

        prop_boolean = [p_props for p_props in self.properties.values() if p_props.type == 'boolean']

        #prop_flag = [p_props for p_props in self.properties.values() if p_props.type == 'flag']

        for prop in prop_integer:

            if config.has_key(str(prop)):

                if not config[str(prop)].isdigit():

                    items.append(WrongTypeItem(("integer", prop)))

        for prop in prop_boolean:

            if config.has_key(str(prop)) :

                if not (config[str(prop)] == 'false' or 'true'):

                    items.append(WrongTypeItem(("boolean", prop)))

        for prop in prop_string:

            if config.has_key(str(prop)):

                if len(config[str(prop)]) == 0:

                    items.append(WrongTypeItem(("string", prop)))

class Item(object):

    """ Base class item """

    level = logging.INFO

    message = ''

    def __init__(self, values):

        """ Initialization. """

        self.values = values

    def log(self, logger):

        """log an error"""

        logger.log(self.level, str(self))

    def __str__(self):

        """string conversion"""

        return self.message % self.values

class MissingFromDataModelItem(Item):

    """ info message """

    level = logging.INFO

    message = 'Property not in data model: %s'

class UsingDeprecatedItem(Item):

    """ warning msg """

    level = logging.WARNING

    message = 'Deprecated property used: %s'

class UndefinedRequiredInGroupItem(Item):

    """ warning msg """

    level = logging.WARNING

    message = 'Required property in %s group is not defined: %s'

class WrongTypeItem(Item):

    """ warning msg """

    level = logging.WARNING

    message = 'Invalid %s value: %s'