#

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

#

## 

# @author Teemu Rytkonen

import sys

import os

import re

import logging

import sets

import inspect

import xml.parsers.expat

from cone.public import exceptions, utils, api, container, settings, rules

import _plugin_reader

debug = 0

"""

Implementation specific settings can be overriden in the global impl_settings variable

"""

AUTOCONFIG_CONFML = "autodata.confml"

def get_autoconfig(configuration):

    """

    Return the "automatic" configuration for storing temporary run-time ConfML

    features and values.

    """

    lastconfig = configuration.get_last_configuration()

    if lastconfig.get_path() != AUTOCONFIG_CONFML:

        logging.getLogger('cone').debug('Adding autodata configuration %s' % AUTOCONFIG_CONFML)

        configuration.create_configuration(AUTOCONFIG_CONFML)

    lastconfig = configuration.get_last_configuration()

    assert lastconfig.get_path() == AUTOCONFIG_CONFML

    return lastconfig

def get_supported_file_extensions():

    """

    Return a list of all supported ImplML file extension.

    Implementations are only attempted to be read from files with these

    extensions.

    """

    return ImplFactory.get_supported_file_extensions()

def get_supported_namespaces():

    """

    Returns a list of all supported ImplML namespaces.

    """

    return ImplFactory.get_reader_dict().keys()

def is_temp_feature(feature):

    """

    Return whether the given feature is a temporary feature.

    """

    return hasattr(feature, _plugin_reader.TEMP_FEATURE_MARKER_VARNAME)

class GenerationContext(object):

    """

    Context object that can be used for passing generation-scope

    data to implementation instances.

    """

    def __init__(self, tags={}):

        #: The tags used in this generation context

        #: (i.e. the tags passed from command line)

        self.tags = tags

        #: The tags policy used in this generation context

        self.tags_policy = "OR"

        #: A dictionary that implementation instances can use to

        #: pass any data between each other

        self.impl_data_dict = {}

        #: A string for the phase of the generation

        self.phase = ""

        #: a list of rule results

        self.results = []

        #: a pointer to the configuration 

        self.configuration = None

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

        """

        eval for rule evaluation against the context

        """

        pass

    def handle_terminal(self, expression):

        """

        Handle a terminal object 

        """

        try:

            if isinstance(expression, str): 

                m = re.match("\${(.*)}", expression)

                if m:

                    try:

                        dview = self.configuration.get_default_view()

                        return dview.get_feature(m.group(1)).value

                    except Exception, e:

                        logging.getLogger('cone').error("Could not dereference feature %s. Exception %s" % (expression, e))

                        raise e

                elif expression in ['true','1','True']:

                    return True

                elif expression in ['false','0','False']:

                    return False

                else:

                    try:

                        return eval(expression)

                    except NameError:

                        # If the expression is a string in it self it can be returned

                        return expression

            else:

                return expression

        except Exception,e:

            logging.getLogger('cone').error("Exception with expression %s: %s" % (expression, e))

            raise e

class FlatComparisonResultEntry(object):

    """

    Class representing a result entry for a flat implementation

    comparison.

    Contains the following members:

    Member        Description

    file          Implementation file

    impl_type     Implementation type (e.g. 'crml', 'gcfml')

    id            Entry ID (e.g. CRML repository UID)

    sub_id        Entry sub-ID if applicable (e.g. CRML key UID)

    value_id      Implementation-specific value identifier

    source_value  Value in the source implementation

    target_value  Value in the target implementation

    data          Any extra data (implementation-specific)

    """

    VARNAMES = ['file', 'impl_type', 'id', 'sub_id', 'value_id', 'source_value', 'target_value']

    def __init__(self, **kwargs):

        for varname in self.VARNAMES:

            setattr(self, varname, kwargs.get(varname))

        self.data = kwargs.get('data')

    def __repr__(self):

        var_entries = [] 

        for varname in self.VARNAMES:

            var_entries.append('%s=%r' % (varname, getattr(self, varname)))

        return "FlatComparisonResultEntry(%s)" % ', '.join(var_entries)

    def __eq__(self, other):

        if type(self) is not type(other):

            return False

        for varname in self.VARNAMES:

            if getattr(self, varname) != getattr(other, varname):

                return False

        return True

    def __ne__(self, other):

        return not (self == other)

    def __lt__(self, other):

        for varname in self.VARNAMES:

            self_val = getattr(self, varname)

            other_val = getattr(other, varname)

            if self_val < other_val:    return True

            elif self_val == other_val: pass

            else:                       return False

        return False

class DuplicateImplementationEntry(object):

    """

    Class representing an entry of duplicate implementation instances

    found in a comparison.

    """

    VARNAMES = ['impl_type', 'id', 'files_in_source', 'files_in_target']

    def __init__(self, **kwargs):

        self.impl_type       = kwargs.get('impl_type')

        self.id              = kwargs.get('id')

        self.files_in_source = kwargs.get('files_in_source', [])

        self.files_in_target = kwargs.get('files_in_target', [])

    def __repr__(self):

        var_entries = [] 

        for varname in self.VARNAMES:

            val = getattr(self, varname)

            if isinstance(val, list): val = sorted(val)

            var_entries.append('%s=%r' % (varname, val))

        return "DuplicateImplementationEntry(%s)" % ', '.join(var_entries)

    def __eq__(self, other):

        if type(self) is not type(other):

            return False

        return self.impl_type == other.impl_type \

            and self.impl_type == other.impl_type \

            and sorted(self.files_in_source) == sorted(other.files_in_source) \

            and sorted(self.files_in_target) == sorted(other.files_in_target)

    def __ne__(self, other):

        return not (self == other)

    def __lt__(self, other):

        for varname in self.VARNAMES:

            self_val = getattr(self, varname)

            other_val = getattr(other, varname)

            if isinstance(self_val, list):      self_val = sorted(self_val)

            if isinstance(other_val, list):     other_val = sorted(other_val)

            if self_val < other_val:    return True

            elif self_val == other_val: pass

            else:                       return False

        return False

class FlatComparisonResult(object):

    """

    Class representing a flat comparison result.

    Each member is a list of FlatComparisonResultEntry

    objects, except for 'duplicate', which contains

    DuplicateImplementationEntry objects.

    Note that the entry members 'value_id', 'source_value' and

    'target_value' are irrelevant in the 'only_in_source' and

    'only_in_target' lists, and will always be None.

    """

    def __init__(self, **kwargs):

        self.only_in_source = kwargs.get('only_in_source', [])

        self.only_in_target = kwargs.get('only_in_target', [])

        self.modified       = kwargs.get('modified', [])

        self.duplicate      = kwargs.get('duplicate', [])

    def extend(self, other):

        """

        Extend this comparison result with another one.

        """

        if not isinstance(other, FlatComparisonResult):

            raise ValueError("Expected instance of %s" % FlatComparisonResult.__name__)

        self.only_in_source.extend(other.only_in_source)

        self.only_in_target.extend(other.only_in_target)

        self.modified.extend(other.modified)

    def __repr__(self):

        data = ["FlatComparisonResult(\n"]

        def get_list_data(lst):

            if len(lst) == 0: return '[]'

            temp = ['[\n']

            for item in sorted(lst):

                temp.append("    %r\n" % item)

            temp.append('  ]')

            return ''.join(temp)

        entries = []

        for varname in ('only_in_source', 'only_in_target', 'modified', 'duplicate'):

            entry_text = '  %s = %s' % (varname, get_list_data(getattr(self, varname)))

            entries.append(entry_text)

        data.append(',\n'.join(entries))

        data.append('\n)')

        return ''.join(data)

    def __len__(self):

        return len(self.only_in_source) + len(self.only_in_target) + len(self.modified)

    def __eq__(self, other):

        if type(self) is not type(other):

            return False

        return sorted(self.only_in_source) == sorted(other.only_in_source) \

            and sorted(self.only_in_target) == sorted(other.only_in_target) \

            and sorted(self.modified) == sorted(other.modified) \

            and sorted(self.duplicate) == sorted(other.duplicate)

    def __ne__(self, other):

        return not (self == other)

class ImplBase(object):

    """

    Base class for any implementation class. 

    """

    #: Identifier for the implementation type, used e.g. in .cfg files.

    #: Should be a string like e.g. 'someml'.

    IMPL_TYPE_ID = None

    #: Defines the default invocation phase for the implementation.

    #: The default is used if the phase is not explicitly set in the

    #: ImplML file or manually overridden by calling set_invocation_phase()

    DEFAULT_INVOCATION_PHASE = None

    def __init__(self, ref, configuration):

        """

        Create a ImplBase object

        @param ref : the ref to the Implml file resource.

        @param configuration : the Configuration instance for the

        configuration data.

        """

        self._settings = None

        self.ref = ref

        self.index = None

        self.configuration = configuration

        self._output_root = self.settings.get('output_root','output')

        self.output_subdir = self.settings.get('output_subdir','')

        self.plugin_output = self.settings.get('plugin_output','')

        self.generation_context = None

        self._tags = None

        self._invocation_phase = None

        self._tempvar_defs = []

        self.condition = None

        self._output_root_override = None

    def _eval_context(self, context):

        """

        This is a internal function that returns True when the context matches to the 

        context of this implementation. For example phase, tags, etc are evaluated.

        """

        if context.tags and not self.has_tag(context.tags, context.tags_policy):

            return False

        if context.phase and not context.phase in self.invocation_phase():

            return False

        if self.condition and not self.condition.eval(context):

            return False 

        return True

    def _dereference(self, ref):

        """

        Function for dereferencing a configuration ref to a value in the Implementation configuration context. 

        """

        return configuration.get_default_view().get_feature(ref).value

    def _compare(self, other, dict_keys=None):

        """ 

        The plugin instance against another plugin instance

        """

        raise exceptions.NotSupportedException()

    def generate(self, context=None):

        """

        Generate the given implementation.

        @param context: The generation context can be given as a parameter. 

        The context can contain generation specific parameters for the 

        implementation object itself or the implementation can store data to it 

        which is visible to other implementations. 

        @return: 

        """

        raise exceptions.NotSupportedException()

    def post_generate(self, context=None):

        """

        Called when all normal generation has been done.

        @param context: The generation context can be given as a parameter. 

        The context can contain generation specific parameters for the 

        implementation object itself or the implementation can store data to it 

        which is visible to other implementations. 

        @attention: This is a temporary method used for implementing cenrep_rfs.txt generation.

        """

        pass

    def list_output_files(self):

        """

        Return a list of output files as an array. 

        """

        return []

    def get_refs(self):

        """

        Return a list of all ConfML setting references that affect this

        implementation. May also return None if references are not relevant

        for the implementation.

        """

        return None

    def has_ref(self, refs):

        """

        @param refs: a list of references to check against.

        @returns True if the implementation uses the given refs as input value, return False if the ref is not found.

        If refs are not relevant for the given plugin returns None. 

        """

        impl_refs = self.get_refs()

        if impl_refs is None:

            return None

        if isinstance(refs, basestring):

            refs = [refs]

        for ref in refs:

            for impl_ref in impl_refs:

                if ref.startswith(impl_ref):

                    if len(ref) == len(impl_ref):

                        return True

                    elif ref[len(impl_ref)] == '.':

                        return True

        return False

    def flat_compare(self, other):

        """

        Return a flat comparison result for two implementations.

        @param other: The target implementation to compare against.

        @return: A FlatComparisonResult object.

        @raise exceptions.NotSupportedException(): The implementation class does not support

            flat comparison.

        """

        raise exceptions.NotSupportedException()

    def get_flat_comparison_id(self):

        """

        Return the ID used to uniquely identify this implementation instance for flat comparison.

        @raise exceptions.NotSupportedException() if the implementation class does not support

            flat comparison.

        """

        raise exceptions.NotSupportedException()

    def get_flat_comparison_extra_data(self):

        """

        Return the extra data object for a flat comparison entry.

        This method is called when an implementation container comparison finds an

        implementation instance that is not in the other container.

        @raise exceptions.NotSupportedException() if the implementation class does not support

            flat comparison.

        """

        raise exceptions.NotSupportedException()

    @classmethod

    def get_flat_comparison_impl_type_id(cls):

        """

        Return the type ID used to uniquely identify the current implementation class in flat comparison.

        @raise exceptions.NotSupportedException() if the implementation class does not support

            flat comparison.

        """

        raise exceptions.NotSupportedException()

    @property

    def settings(self):

        if not self._settings:

            parser = settings.SettingsFactory.cone_parser()

            if self.IMPL_TYPE_ID is not None:

                section = self.IMPL_TYPE_ID.upper()

            else:

                section = settings.DEFAULT_SECTION

            self._settings = settings.ConeSettings(parser, section)

        return self._settings

    @property

    def output(self):

        vars = {'output_root': self.output_root,'output_subdir': self.output_subdir,'plugin_output': self.plugin_output}

        default_format = '%(output_root)s/%(output_subdir)s/%(plugin_output)s'

        return utils.resourceref.norm(self.settings.get('output',default_format,vars))

    def _get_output_root(self):

        if self._output_root_override is not None:

            return self._output_root_override

        else:

            return self._output_root

    def _set_output_root(self, value):

        self._output_root = value

    output_root = property(_get_output_root, _set_output_root, None,

       """

       The output root directory.

       Note that if set_output_root_override() has been called with a value

       other than None, reading this property will always return that value.

       Otherwise it works just like any other property.

       """)

    def get_tags(self):

        if self._tags is not None:

            tags = self._tags

        else:

            tags = eval(self.settings.get('plugin_tags','{}'))

        # If we have a configuration, expand setting references in the tags

        if self.configuration is not None:

            dview = self.configuration.get_default_view()

            expanded_tags = {}

            for name, values in tags.iteritems():

                exp_name = utils.expand_refs_by_default_view(name, dview)

                exp_values = []

                expanded_tags[exp_name] = exp_values

                for value in values:

                    exp_value = utils.expand_refs_by_default_view(value, dview)

                    exp_values.append(exp_value)

            return expanded_tags

        else:

            return tags.copy()

    def set_tags(self, tags):

        """

        Override the default implementation tags.

        @param phase: The tag dictionary to set. If None, the implementation's

            default tags will be used.

        """

        self._tags = tags

    def has_tag(self, tags, policy=None):

        """

        @param tags: a dictionary of context : tags to check agains

        @returns True if the implementation has a matching tag.

        Otherwise return False.

        """