#

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

import cone.validation.common

class ValidationContext(object):

    def __init__(self, configuration):

        #: The configuration being validated

        self.configuration = configuration

        self._dview = None

        #: The list of validation problems

        self.problems = []

        #: The list of fixes executed in the context

        self.fixes = []

    @property

    def dview(self):

        """ 

        The configuration's default view 

        """

        if not self._dview:

            self._dview = self.configuration.get_default_view()

        return self._dview

    @property

    def feature_dict(self):

        """

        All the configuration's features as a ref -> feature dictionary. 

        """

        if not hasattr(self, '_feature_dict'):

            self._feature_dict = {}

            for fea in self.dview.get_features('**'):

                self._feature_dict[fea.fqr] = fea

        return self._feature_dict

class ValidatorBase(object):

    #: Types of the problems this validator produces

    PROBLEM_TYPES = None

    def __init__(self, context):

        self.context = context

    def validate(self):

        """

        Method called to validate a configuration.

        """

        raise NotImplementedError()

class FixerBase(object):

    def fix(self, context):

        """

        The fix functions takes ValidationContext that is expected to contain a 

        list of Problem objects that it will traverse through and it will try to 

        fix any problem that matches its category.

        @param context: The ValidationContext object from which problems should be fixed.  

        """

        raise NotImplementedError()

    def filter_problems(self, problems, problem_type):

        """

        A filtering function that returns a list of problems that match to the 

        given problem_type.

        @param problems: a list of api.Problem objects

        @param problem_type: a string that represents the problem name. e

        .g. 'model.confml.duplicate.setting'.

        """

        return [problem for problem in problems if problem.type == problem_type]

def get_validator_classes(problem_type_filter=None):

    """

    Return a list of all ConfML validator classes that match the given

    problem type filter (i.e. all validator classes that yield problems

    that will not be filtered out).

    @param problem_type_filter: The filter, if None, all validator

        classes will be returned.

    """

    classes = []

    # Validators from plug-in entry points

    classes.extend(cone.validation.common.load_plugin_classes(

        'cone.plugins.confmlvalidators',

        ValidatorBase))

    # Built-in validators

    from cone.validation.builtinvalidators.confml import VALIDATOR_CLASSES

    classes.extend(VALIDATOR_CLASSES)

    return cone.validation.common.filter_classes(classes, problem_type_filter)

def get_fixer_classes(problem_type_filter=None):

    """

    Return a list of all ConfML fixer classes that match the given

    problem type filter (i.e. all fixer classes that yield problems

    that will not be filtered out).

    @param problem_type_filter: The filter, if None, all fixer

        classes will be returned.

    """

    classes = []

    # Validators from plug-in entry points 

    classes.extend(cone.validation.common.load_plugin_classes(

        'cone.plugins.confmlfixers',

        FixerBase))

    # Built-in validators 

    from cone.validation.builtinvalidators.confml import FIXER_CLASSES

    classes.extend(FIXER_CLASSES)

    return cone.validation.common.filter_classes(classes, problem_type_filter)

def validate_configuration(configuration, validator_classes=None):

    """

    Validate the given configuration.

    @param configuration: The configuration to validate.

    @param validator_classes: The validator classes to use for the validation.

        If None, all validator classes will be used.

    @return: A ValidationContext objects, which contains a list of Problem objects in 

    member variable problems.

    """

    if validator_classes is None:

        validator_classes = get_validator_classes()

    context = ValidationContext(configuration)

    validators = [vc(context) for vc in validator_classes]

    for validator in validators:

        try:

            validator.validate()

        except Exception, e:

            from cone.public import utils

            utils.log_exception(logging.getLogger('cone'),

                                "Error validating configuration: %s: %s" \

                                % (e.__class__.__name__, e))

    return context

def fix_configuration(configuration, context=None, fixer_classes=None):

    """

    Validate the given configuration.

    @param configuration: The configuration to validate.

    @param context:  The ValidationContext if it has been alread created. With value None

        The ValidationContext will be created and validated fisrt

    @param fixer_classes: The fixer classes to use for the validation.

        If None, all fixer classes will be used.

    @return:  A ValidationContext objects, which contains a list of messaages of fixes that

    were executed.

    """

    try:

        conf = configuration.get_configuration('duplicate_settings1.confml')

        data1 = conf.data

    except Exception:

        pass

    if context is None:

        context = validate_configuration(configuration)

    if fixer_classes is None:

        fixer_classes = get_fixer_classes()

    try:

        conf = configuration.get_configuration('duplicate_settings1.confml')

        data2 = conf.data

    except Exception:

        pass

    for fixer in fixer_classes:

        try:

            fixer().fix(context)

        except Exception, e:

            from cone.public import utils

            utils.log_exception(logging.getLogger('cone'),

                                "Error fixing configuration: %s: %s" \

                                % (e.__class__.__name__, e))

    return context