#

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

import logging

import plugin, exceptions, api, utils

import cone.confml.model

log = logging.getLogger('cone')

# The XML namespace for common ImplML definitions

COMMON_IMPLML_NAMESPACE = "http://www.symbianfoundation.org/xml/implml/1"

# Name of the marker variable used to mark a feature as a temporary

# feature

TEMP_FEATURE_MARKER_VARNAME = '__plugin_temp_feature_marker'

class TempVariableDefinition(object):

    """

    Class representing a temporary variable definition in an implementation file.

    """

    def __init__(self, ref, type, value):

        self.ref = ref

        self.type = type

        self.value = value

    def create_feature(self, config):

        """

        Add a feature based on this temp feature definition to the given configuration.

        """

        if '.' in self.ref:

            pos = self.ref.rfind('.')

            ref = self.ref[pos + 1:]

            namespace = self.ref[:pos]

        else:

            ref = self.ref

            namespace = ''

        mapping = {'string' : cone.confml.model.ConfmlStringSetting,

                   'int'    : cone.confml.model.ConfmlIntSetting,

                   'real'   : cone.confml.model.ConfmlRealSetting,

                   'boolean': cone.confml.model.ConfmlBooleanSetting}

        feature = mapping[self.type](ref)

        setattr(feature, TEMP_FEATURE_MARKER_VARNAME, True)

        config.add_feature(feature, namespace)

        value = utils.expand_refs_by_default_view(self.value, config.get_default_view())

        config.add_data(api.Data(fqr=self.ref, value=value))

    def __eq__(self, other):

        if type(self) is type(other):

            for varname in ('ref', 'type', 'value'):

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

                    return False

            return True

        else:

            return False

    def __ne__(self, other):

        return not (self == other)

    def __repr__(self):

        return "TempFeatureDefinition(ref=%r, type=%r, value=%r)" % (self.ref, self.type, self.value)

class TempVariableSequenceDefinition(object):

    """

    Class representing a temporary variable sequence definition in an implementation file.

    """

    def __init__(self, ref, sub_items):

        self.ref = ref

        self.sub_items = sub_items

    def create_feature(self, config):

        if '.' in self.ref:

            pos = self.ref.rfind('.')

            ref = self.ref[pos + 1:]

            namespace = self.ref[:pos]

        else:

            ref = self.ref

            namespace = ''

        # Creature the sequence feature

        seq_fea = api.FeatureSequence(ref)

        setattr(seq_fea, TEMP_FEATURE_MARKER_VARNAME, True)

        config.add_feature(seq_fea, namespace)

        # Create the sub-features

        mapping = {'string' : cone.confml.model.ConfmlStringSetting,

                   'int'    : cone.confml.model.ConfmlIntSetting,

                   'real'   : cone.confml.model.ConfmlRealSetting,

                   'boolean': cone.confml.model.ConfmlBooleanSetting}

        sub_features = []

        for sub_item in self.sub_items:

            sub_feature = mapping[sub_item[1]](sub_item[0])

            seq_fea.add_feature(sub_feature)

    def __eq__(self, other):

        if type(self) is type(other):

            return self.ref == other.ref and self.sub_items == other.sub_items

        else:

            return False

    def __ne__(self, other):

        return not (self == other)

    def __repr__(self):

        return "TempSeqFeatureDefinition(ref=%r, sub_items=%r)" % (self.ref, self.sub_items)

class SettingRefsOverride(object):

    """

    Class representing a setting reference override for an implementation.

    """

    def __init__(self, refs=None):

        """

        @param refs: The reference overrides, can be a list of references or None.

        """

        self.refs = refs

    def get_refs(self):

        return self.refs

    def __eq__(self, other):

        if type(self) is type(other):

            return self.refs == other.refs

        else:

            return False

    def __ne__(self, other):

        return not (self == other)

    def __repr__(self):

        return "SettingRefsOverride(refs=%r)" % self.refs

class CommonImplmlData(object):

    """

    Class representing the common ImplML namespace data read from

    an XML element.

    """

    def __init__(self):

        self.phase = None

        self.tags = None

        self.tempvar_defs = []

        self.setting_refs_override = None

        self.output_root_dir = None

        self.output_sub_dir = None

    def apply(self, impl):

        """

        Apply the data on the given implementation instance.

        """

        if self.phase:

            impl.set_invocation_phase(self.phase)

        if self.tags:

            impl.set_tags(self.tags)

        if self.setting_refs_override:

            # Override the get_refs() method of the implementation

            impl.get_refs = self.setting_refs_override.get_refs

            # Override also the has_ref() method in case it is overridden

            # in the implementation sub-class

            impl.has_ref = lambda refs: plugin.ImplBase.has_ref(impl, refs)

        if self.output_root_dir:

            impl.set_output_root_override(self.output_root_dir)

        if self.output_sub_dir:

            impl.output_subdir = self.output_sub_dir

    def extend(self, other):

        """

        Extend this object with the contents of another CommonImplmlData object.

        """

        if other.phase:

            self.phase = other.phase

        if other.tags:

            self.tags = other.tags

        self.tempvar_defs.extend(other.tempvar_defs)

        if other.setting_refs_override:

            self.setting_refs_override = other.setting_refs_override

        if other.output_root_dir:

            self.output_root_dir = other.output_root_dir

        if other.output_sub_dir:

            self.output_sub_dir = other.output_sub_dir

    def copy(self):

        result = CommonImplmlData()

        result.phase = self.phase

        if result.tags is not None:

            result.tags = self.tags.copy()

        result.tempvar_defs = list(self.tempvar_defs)

        result.setting_refs_override = copy.deepcopy(self.setting_refs_override)

        result.output_root_dir = self.output_root_dir

        result.output_sub_dir = self.output_sub_dir

        return result

    def __eq__(self, other):

        if type(self) is type(other):

            for varname in ('phase', 'tags', 'tempvar_defs', 'setting_refs_override', 'output_root_dir', 'output_sub_dir'):

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

                    return False

            return True

        else:

            return False

    def __ne__(self, other):

        return not (self == other)

    def __repr__(self):

        return "CommonImplmlData(phase=%r, tags=%r, tempvar_defs=%r, setting_refs_override=%r, output_root_dir=%r, output_sub_dir=%r)" \

            % (self.phase,

               self.tags,

               self.tempvar_defs,

               self.setting_refs_override,

               self.output_root_dir,

               self.output_sub_dir)

class ImplReader(object):

    """

    Internal reader class for reading implementations from a file in a configuration.

    """

    # The reader class list loaded using ImplFactory

    __loaded_reader_classes = None

    __reader_classes = None

    __supported_file_extensions = None

    __ignored_namespaces = None

    def __init__(self, resource_ref, configuration):

        self.resource_ref = resource_ref

        self.configuration = configuration

    @classmethod

    def _load_data_from_plugins(cls):

        """

        Load all data needed for implementation parsing from the plug-ins.

        The actual loading is only done the first time this method is called.

        """

        # Load the data only if the reader class list has not been loaded

        # yet or it has changed

        loaded_reader_classes = plugin.ImplFactory.get_reader_classes()

        if cls.__loaded_reader_classes is loaded_reader_classes:

            return

        reader_classes = [plugin.ReaderBase]

        reader_classes.extend(loaded_reader_classes)

        cls.__reader_classes = {}

        cls.__ignored_namespaces = []

        cls.__supported_file_extensions = []

        for rc in reader_classes:

            # Reader class

            ns = rc.NAMESPACE

            if ns is not None:

                if ns in cls.__reader_classes:

                    raise RuntimeError("Multiple reader classes registered for ImplML namespace '%s': at least %s and %s"\

                                       % (ns, rc, cls.__reader_classes[ns]))

                cls.__reader_classes[ns] = rc

            # Ignored namespaces

            for ns in rc.IGNORED_NAMESPACES:

                if ns not in cls.__ignored_namespaces:

                    cls.__ignored_namespaces.append(ns)

            # Supported file extensions

            for fe in rc.FILE_EXTENSIONS:

                fe = fe.lower()

                if fe not in cls.__supported_file_extensions:

                    cls.__supported_file_extensions.append(fe)

        cls.__loaded_reader_classes = loaded_reader_classes

    @classmethod

    def _get_namespaces(cls, etree):

        """

        Return a list of XML namespaces in the given element tree.

        """

        namespaces = []

        namespaces.append(utils.xml.split_tag_namespace(etree.tag)[0])

        for elem in etree:

            ns = utils.xml.split_tag_namespace(elem.tag)[0]

            if ns not in namespaces:

                namespaces.append(ns)

        return filter(lambda ns: ns is not None, namespaces)

    def _read_impls_from_file_root_element(self, root, namespaces):

        impls = []

        reader_classes = self.get_reader_classes()

        # Go through the list of XML namespaces encountered in the

        # file and read an implementation using the corresponding

        # reader for each namespace

        impl_count = 0

        common_data = CommonImplmlDataReader.read_data(root)

        for ns in namespaces:

            if ns not in reader_classes: continue

            rc = reader_classes[ns]

            impl = self._read_impl(rc, root)

            if impl:

                impl.index = impl_count

                impl_count += 1

                if common_data: common_data.apply(impl)

                impls.append(impl)

        # Add temp feature definitions to the first implementation

        if common_data and impls:

            impls[0]._tempvar_defs.extend(common_data.tempvar_defs)

        return impls

    def _read_impls_from_file_sub_elements(self, root):

        impls = []

        # Collect common ImplML namespace data

        common_data = CommonImplmlData()

        for elem in root:

            ns = utils.xml.split_tag_namespace(elem.tag)[0]

            if ns == COMMON_IMPLML_NAMESPACE:

                cd = CommonImplmlDataReader.read_data(elem)

                if cd: common_data.extend(cd)

        # Go through all sub-elements and read an implementation instance

        # from each if possible

        impl_count = 0

        reader_classes = self.get_reader_classes()

        for elem in root:

            ns = utils.xml.split_tag_namespace(elem.tag)[0]

            if ns != COMMON_IMPLML_NAMESPACE and ns in reader_classes:

                reader_class = reader_classes[ns]

                impl = self._read_impl(reader_class, elem)

                if impl:

                    cd = CommonImplmlDataReader.read_data(elem)

                    if cd is not None:

                        impl._tempvar_defs.extend(cd.tempvar_defs)

                        data = common_data.copy()

                        data.extend(cd)

                        data.apply(impl)

                    else:

                        common_data.apply(impl)

                    impl.index = impl_count

                    impl_count += 1

                    impls.append(impl)

        # Add temporary feature definitions to the first implementation instance

        if impls:

            impls[0]._tempvar_defs = common_data.tempvar_defs + impls[0]._tempvar_defs

        return impls

    def _read_impl(self, reader_class, elem):

        """

        Read an implementation with the given reader class from the given element.

        If an exception is raised during reading, the exception is logged

        and None returned. 

        @return: The read implementation or None.

        """

        try:

            return reader_class.read_impl(self.resource_ref, self.configuration, elem)

        except exceptions.ParseError, e:

            log.error("Error reading implementation '%s': %s", (self.resource_ref, e))

        except Exception, e:

            utils.log_exception(log, e)

        return None

    @classmethod

    def get_reader_classes(cls):

        """

        Return a dictionary of all possible implementation reader classes.

        Dictionary key is the XML namespace and the value is the corresponding

        reader class.

        """

        cls._load_data_from_plugins()

        return cls.__reader_classes

    @classmethod

    def get_supported_file_extensions(cls):

        """

        Return a list of all supported implementation file extensions.

        """

        cls._load_data_from_plugins()

        return cls.__supported_file_extensions

    @classmethod

    def get_ignored_namespaces(cls):

        """

        Return a list of all ignored XML namespaces.

        """

        cls._load_data_from_plugins()

        return cls.__ignored_namespaces

    def read_implementations(self):

        try:

            root = plugin.ReaderBase._read_xml_doc_from_resource(self.resource_ref, self.configuration)

            return self.read_implementation(root)

        except exceptions.ParseError, e:

            # Invalid XML data in the file

            log.error(e)

            return []

    def read_implementation(self, xmlroot):

        root = xmlroot

        # Check if the implementations should all be read from the

        # document root, or each from its own sub-element under the root

        read_from_root = False

        ns = utils.xml.split_tag_namespace(root.tag)[0]

        if ns: read_from_root = True

        # Collect namespaces from the file and check that all are supported or ignored

        namespaces = self._get_namespaces(root)

        for ns in namespaces:

            if ns != COMMON_IMPLML_NAMESPACE \

                and ns not in self.get_reader_classes() \

                and ns not in self.get_ignored_namespaces():

                log.error("Unsupported XML namespace '%s' in file '%s'" % (ns, self.resource_ref))

                return []

        if read_from_root:

            impls = self._read_impls_from_file_root_element(root, namespaces)

        else:

            impls = self._read_impls_from_file_sub_elements(root)

        return impls

class CommonImplmlDataReader(object):

    """

    Internal reader class for reading common ImplML namespace data from and element.

    """

    VALID_PHASES = ('pre', 'normal', 'post')

    VALID_TYPES = ('string', 'int', 'real', 'boolean')

    @classmethod

    def read_data(cls, etree):

        """

        Read common ImplML data from the given XML element.

        @return: A CommonImplmlData instance or None if no common namespace

            elements were found.

        """

        result = CommonImplmlData()

        reader_methods = {'phase'                   : cls._read_phase,

                          'tag'                     : cls._read_tag,

                          'tempVariable'            : cls._read_tempvar,

                          'tempVariableSequence'    : cls._read_tempvarseq,

                          'settingRefsOverride'     : cls._read_setting_refs_override,

                          'outputRootDir'           : cls._read_output_root_dir,

                          'outputSubDir'            : cls._read_output_sub_dir}

        found = False

        for elem in etree:

            ns, tag = utils.xml.split_tag_namespace(elem.tag)

            if ns != COMMON_IMPLML_NAMESPACE:   continue

            if tag not in reader_methods:       continue

            reader_methods[tag](elem, result)

            found = True

        if found:   return result

        else:       return None

    @classmethod

    def _read_phase(cls, elem, result):

        phase = elem.get('name')

        if phase is None:

            cls._raise_missing_attr(elem, 'name')

        if phase not in cls.VALID_PHASES:

            raise exceptions.ParseError("Invalid invocation phase '%s' defined." % phase)

        result.phase = phase

    @classmethod

    def _read_tag(cls, elem, result):

        name = elem.get('name')

        value = elem.get('value')

        if name is not None:

            if result.tags is None:     result.tags = {}

            if name not in result.tags: result.tags[name] = []

            result.tags[name].append(value)

    @classmethod

    def _read_tempvar(cls, elem, result):

        ref = elem.get('ref')

        type = elem.get('type', 'string')

        value = elem.get('value', '')

        if ref is None:

            cls._raise_missing_attr(elem, 'ref')

        if type not in cls.VALID_TYPES:

            cls._raise_invalid_type(ref, type)

        result.tempvar_defs.append(TempVariableDefinition(ref, type, value))

    @classmethod

    def _read_tempvarseq(cls, elem, result):

        ref = elem.get('ref')

        if ref is None:

            cls._raise_missing_attr(elem, 'ref')

        sub_items = []

        for sub_elem in elem.findall('{%s}tempVariable' % COMMON_IMPLML_NAMESPACE):

            sub_ref = sub_elem.get('ref')

            sub_type = sub_elem.get('type', 'string')

            if sub_ref is None:

                cls._raise_missing_attr(sub_elem, 'ref')

            if sub_type not in cls.VALID_TYPES:

                cls._raise_invalid_type(sub_ref, sub_type)