#

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

#

"""

Cone public API.

The core interface to the ConE functionality.

"""

import os

import re

import sys

import logging

import copy

import sets

import exceptions, utils, container, mapping

class Base(container.ObjectContainer):

    """

    The Base class is intended for capturing same kind of naming scheme.

    """

    def __init__(self, ref="", **kwargs):

        if len(utils.dottedref.split_ref(ref)) > 1:

            raise exceptions.InvalidRef("Invalid reference for Base object %s!" % ref)

        self.ref = ref

        container.ObjectContainer.__init__(self, ref)

        for arg in kwargs.keys():

            if kwargs.get(arg) != None:

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

    def __repr__(self):

        dict = self._dict()

        return "%s(%s)" % (self.__class__.__name__, dict)

    def _get_mapper(self,modelname):

        """

        Return a instance of appropriate mapper for given model.

        """

        return mapping.BaseMapper()

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

        """ 

        Compare the attributes of elements 

        """

        if isinstance(other, Base):

            keys = dict_keys or self._dict().keys() 

            for key in keys:

                self_attr = None

                other_attr = None

                try:

                    self_attr = getattr(self, key)

                    other_attr = getattr(other, key)

                except AttributeError:

                    # If the attribute is not found from either elements

                    # ignore it entirely

                    if self_attr == None and other_attr == None: 

                        continue

                if  self_attr != other_attr:

                    return False

            # If all given keys match report this as as similar element

            return True

        else:

            return False

    def _clone(self, **kwargs):

        """

        A generic implementation for cloning the object.

        Copies all (public) members in dictionary.

        To clone objects recursively set the recursion level with recursion param.

        @param recursion: Boolean to define recursion on or off

        @param recursion_depth: positive integer to define recursion depth. default is -1 which will 

        perform recursion to all objects.

        """

        dict = self._dict()

        if kwargs.get('class_instance'):

            class_instance = kwargs.get('class_instance')

            del kwargs['class_instance']

        else:

            class_instance = self.__class__

        obj = class_instance(**dict)

        # Remove all children created at the construction phase 

        # This is needed when the recursion adds children to the object so that there are not duplicates

        obj._order = []

        obj._children = {}

        # handle the recursion argument

        recursion = kwargs.get('recursion', False)

        if recursion:

            recursion_depth = kwargs.get('recursion_depth', -1)

            if recursion_depth < 0 or recursion_depth > 0:

                # decrease the recursion

                kwargs['recursion_depth'] = recursion_depth - 1 

                for child in self._objects():

                    obj._add(child._clone(**kwargs), container.APPEND)

        return obj

    def _dict(self):

        """

        Return the public variables in a dictionary

        """

        dict = {}

        for key in self.__dict__.keys():

            if key.startswith('_'):

                continue

            else:

                dict[key] = self.__dict__[key]

        return dict

    def _default_object(self, name):

        return Base(name)

    @property

    def fqr(self):

        """

        Return a Fully Qualified Ref, which is the full name of the reference. 

        Joins the namespace and ref to one string.

        @return: A string 

        """

        return utils.dottedref.join_refs([self.namespace, self.get_ref()])

    @property

    def namespace(self):

        """

        @return: The namespace of the object.

        """

        containerpath = ""

        path = ""

        parentcontainer = self.find_parent(container=True)

        parent = self.find_parent(type=Base)

        paths = []

        while parent and parent != parentcontainer:

            """ Skip the element if it is supposed to be hidden. Begins with _. """

            if not parent.get_ref().startswith('_'):

                paths.append(parent.get_ref())

            parent = parent._get_parent()

        if parentcontainer:

            paths.append(parentcontainer.namespace)

        paths.reverse()

        return utils.dottedref.join_refs(paths)

    def get_fullref(self):

        """

        Return a full reference, reference including a 

        possible index of the object in list. 

        e.g. ref can be bar[1] or just the normal bar. 

        @return: The full reference of the object.

        """

        if self.parent and utils.is_list(self.parent._get(self.ref)):

            return "%s[%s]" % (self.ref, self.get_index())

        else:

            return self.ref

    def get_fullfqr(self):

        """

        Return a full reference, reference including a 

        possible index of the object in list. 

        ref and adds index.

        @return: A string 

        """

        return utils.dottedref.join_refs([self.get_fullnamespace(), self.get_fullref()])

    def get_fullnamespace(self):

        """

        @return: The full namespace of the object with possible indexes of the parent objects

        """

        containerpath = ""

        path = ""

        parentcontainer = self.find_parent(container=True)

        parent = self.find_parent(type=Base)

        paths = []

        while parent and parent != parentcontainer:

            paths.append(parent.get_fullref())

            parent = parent.parent

        if parentcontainer:

            paths.append(parentcontainer.namespace)

        paths.reverse()

        return utils.dottedref.join_refs(paths)

    def get_storage(self):

        """

        Get the root storage from the root object.

        """

        if self._find_parent():

            return self._find_parent().get_storage()

        else:

            raise exceptions.StorageException("Storage is not found from root!")

    def get_project(self):

        """

        Get the root project from the root object.

        """

        if isinstance(self, Project):

                return self

        elif self._find_parent():

            return self._find_parent().get_project()

        else:

            raise exceptions.NotFound("Project not found!!")

    def get_default_view(self):

        """

        Get the default view from the root object.

        """

        try:

            return self._find_parent().get_default_view()

        except exceptions.NotFound:

            raise exceptions.NotFound("Default View is not found! No root configuration?")

    def get_root(self):

        """

        Get the root object

        """

        try:

            return self._find_parent().get_root()

        except exceptions.NotFound:

            return self

    def get_root_configuration(self):

        """

        Get the root object

        """

        if self.find_parent(type=Configuration):

            return self.find_parent(type=Configuration).get_root_configuration()

        elif isinstance(self, Configuration):

            return self

        else:

            return None

    def get_index(self):

        """

        @return : the index of the data element for sequential data defined inside the same configuration.

        0 for normal data.

        """

        # Get the list of items from parent which contains this element and ask my own index

        # Make sure that the returned element is a list with get_list

        selflist = utils.get_list(self._get_parent()._get(self.get_ref()))

        return selflist.index(self)

    def find_parent(self, **kwargs):

        """

        find the closest parent object of given type.

        e.g. find_parent(type=Configuration) returns the closest parent 

        Configuration parent instance

        @param type: class definitiob

        """

        type = kwargs.get('type', None)

        container = kwargs.get('container', False)

        try:

            parent = self._find_parent()

            if type and isinstance(parent, type):

                    return parent

            elif container and hasattr(parent, 'container'):

                    return parent

            else:

                return parent.find_parent(**kwargs)

        except exceptions.NotFound:

            return None

    def add(self, child, policy=container.REPLACE):

        """

        A generic add function to add child objects. The function is intended to act as

        proxy function that call the correct add function based on the child objects class.

        Example: obj.add(Feature("test")), actually obj.add_feature(Feature("test"))

        @param child: the child object to add

        @raise IncorrectClassError: if the given class cannot be added to this object.  

        """

        raise exceptions.NotSupportedException("Cannot add %s object to %s" % (child, self))

    def get_elem(self, fqr):

        """

        A generic get function to get child objects and members. The function uses getattr

        to traverse downwards the the object tree. The returned object is the final object or attribute 

        if it is found. Raises AttributeError if the child is not found.

        Example: obj.get('test.bar'), returns child obj.test.bar

        @param fqr: the fully qualified ref to the object

        @raise AttributeError: if the given ref is not found.  

        """

        return None

class Project(Base):

    """

    A project is a container that can hold several Configuration objects.

    """

    def __init__(self, storage, **kwargs):

        """

        Project constructor

        """

        Base.__init__(self, "")

        """ Try to set the model and tet the actual configuration class """

        try:

            self._model = storage.persistentmodule.MODEL

        except AttributeError:

            self._model = None

        self.set_storage(storage)

        self.update()

        self.loaded = {}

    def __add_loaded__(self, ref, obj):

        """

        Add the object to loaded 

        """

        self.loaded[ref] = {'counter': 0, 'obj': obj}

    def __get_loaded__(self, ref):

        """

        Get a loaded object if it is existing and increase the reference counter

        @param ref: 

        @return: The loaded object if it exists. None if it does not. 

        """

        if self.loaded.has_key(ref):

            return self.loaded[ref]['obj']

        else:

            return None

    def __loaded__(self, ref):

        """

        Get a loaded object if it is existing and increase the reference counter

        @param ref: 

        @return: The loaded object if it exists. None if it does not. 

        """

        if self.loaded.has_key(ref):

            self.loaded[ref]['counter'] += 1

        else:

            raise exceptions.NotFound("ref %s is not found from loaded!" % ref)

    def __unloaded__(self, ref):

        """

        returns True when the reference count is zero and object can be released.

        """

        if self.loaded.has_key(ref):

            self.loaded[ref]['counter'] -= 1

            if self.loaded[ref]['counter'] == 0:

                del self.loaded[ref]

                return True

            else: 

                return False

        else: 

            return True

    def _supported_type(self, obj):

        if isinstance(obj, Configuration) \

        or isinstance(obj, ConfigurationProxy): 

            return True

        else:

            return False

    def update(self):

        """

        update the root confml files as configurations

        """

        root_confmls = self.get_storage().list_resources(".")

        root_confmls = utils.resourceref.filter_resources(root_confmls, "\.confml")

        for rootml in root_confmls:

            self._add(ConfigurationProxy(rootml))

    def get_storage(self):

        """

        Get the Storage instance of this Project.

        """

        return self.storage

    def set_storage(self, storage):

        """

        Set the Storage instance of this Project.

        """

        if isinstance(storage, Storage):

            self.storage = storage

        else:

            raise exceptions.StorageException("The given storage is not a instance of Storage!")

    def list_configurations(self, filter_or_filters=None):

        """

        List the direct child objects of the project (Root configurations)

        @param filter_or_filters: A regular expression or list of regular expressions

            used for filtering the configuration paths. If None, all configurations are

            returned.

        @return: a list for configuration file paths

        """

        filters = None

        if isinstance(filter_or_filters, basestring):   filters = [filter_or_filters]

        elif filter_or_filters is not None:             filters = filter_or_filters

        configs = [obj.get_path() for obj in self._objects()]

        if filters is not None:

            result = []

            for config in configs:

                for filter in filters:

                    if re.match(filter, config) is not None:

                        result.append(config)

                        break

            return result

        else:

            return configs

    def list_all_configurations(self):

        """

        List all configuration objects of the project (all configurations)

        @return: a list for configuration file paths

        """

        return [obj.get_path() for obj in self._traverse(type=(Configuration, ConfigurationProxy))]

    def get_configuration(self, path):

        """

        Get a configuration object from the given path

        @param path: path to configuration 

        @return: a instance of Configuration.

        """

        # Load the configuration object if it is not already loaded

        try:

            return self._get(utils.resourceref.to_objref(utils.resourceref.norm(path)))

        except exceptions.NotFound, e:

            if self.storage.is_resource(utils.resourceref.norm(path)):

                proxy = ConfigurationProxy(utils.resourceref.norm(path))

                proxy._set_parent(self)

                return proxy

            else:

                raise e

    def is_configuration(self, path):

        """

        Return true if the given path is a configuration object in this Project.

        @param path: path to configuration 

        @return: Boolean return value.

        """

        # Changed from list_all_configurations to list_configurations

        # (list_all_configurations causes a insane performance problem with _traverse)

        return path in self.list_configurations()

    def add_configuration(self, config):

        """

        Add a Configuration object to this project

        """

        if isinstance(config, Configuration):

            if self.is_configuration(config.get_path()):

                raise exceptions.AlreadyExists("%s" % config.get_path())

            self._add(config)

            self.__add_loaded__(config.get_path(), config)

            self.__loaded__(config.get_path())

        else:

            raise exceptions.IncorrectClassError("Only Configuration instance can be added to Project!")

    def create_configuration(self, path, namespace=""):

        """

        Create a Configuration object to this project

        """

        config = self.get_configuration_class()(utils.resourceref.norm(path), namespace=namespace)

        self.add_configuration(config)

        return config

    def remove_configuration(self, path):

        """

        Remove a Configuration by its reference

        """

        # remove configuration as an object and try to remove it from the storage

        self._remove(utils.resourceref.to_objref(path))

        try:

            self.storage.delete_resource(path)

        except exceptions.NotSupportedException:

            pass

        return

    def import_configuration(self, configuration):  

        """

        Import a configuration object from another storage

        """

        self.storage.import_resources(configuration.list_resources(), configuration.get_storage())

        return

    def export_configuration(self, configuration, export_storage, empty_folders=False):

        """

        Export a configuration object to another storage

        """

        # First clone the configuration and then import the rest of the configuration resources

        if isinstance(configuration, ConfigurationProxy):

            configuration = configuration._get_obj()

        export_storage.unload(configuration.get_full_path(),configuration)

        for child in configuration._traverse(type=Configuration):

            export_storage.unload(child.get_full_path(),child)

        #If the configuration is not in the root of the project adding the path 

        #to final exporting source path.

        #l = []

        cpath = utils.resourceref.get_path(configuration.get_path()) 

        resr = [utils.resourceref.join_refs([cpath,related]) \

                for related in configuration.get_layer().list_all_related(empty_folders)]        

        self.storage.export_resources(resr ,export_storage, empty_folders)

        return

    def get_configuration_class(self):

        """

        return the default configuration class that is used with the model. 

        """

        return utils.get_class(self._model, Configuration)

    def save(self):

        """

        Save the object to the permanent Storage object. Calls the save operation for 

        all the children and also for the Storage.

        """

        for child in self._objects():

            if isinstance(child, (Configuration, ConfigurationProxy)):

                child.save()

        self.storage.save()

    def close(self):

        """