from __future__ import with_statement

#

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

import sys

import logging

import mimetypes

from cone.public import exceptions, utils, container, mapping

def get_file_logger():

    return logger

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)

        try:

            for arg in kwargs.keys():

                if kwargs.get(arg) != None:

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

        except AttributeError,e:

            raise e

    def __repr__(self):

        dict = self._dict()

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

#    def __reduce_ex__(self, protocol_version):

#        tpl = super(Base, self).__reduce_ex__(protocol_version)

#        return tpl

#    def __getstate__(self):

#        state = self._dict(internals=True, ignore_empty=True)

#        # pop out the _name so that it wont appear as redundant data (ref is the same)

#        state.pop('_name', None)

#        state.pop('_parent', None)

#        return state

#

#    def __setstate__(self, state):

#        super(Base, self).__setstate__(state)

#        self.ref = state.get('ref','')

#        for arg in state.keys():

#            self.__dict__.setdefault(arg, state.get(arg))

    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, **kwargs):

        """

        Return the public variables in a dictionary

        """

        dict = {}

        # loop through the items in this object internal __dict__

        # and add all except internal variables and function overrides  

        for (key,value) in self.__dict__.items():

            if not kwargs.get('internals', False) and key.startswith('_'):

                continue

            elif not kwargs.get('callables', False) and callable(value):

                continue

            elif kwargs.get('ignore_empty') and not value:

                # ignore empty values

                pass

            else:

                dict[key] = value

        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 path(self, toparent=None):

        """

        Get the path to this Base object..

        @param toparent: the _parent object up to which the path is relative. Default value is None.,

        which gives the fully qualified path in the topology.

        @return: The path to this Base object from toparent

        """

        return self._path(toparent)

    def parent_path(self, toparent=None):

        """

        Get the path to the parent of this Base object..

        @param toparent: the _parent object up to which the path is relative. Default value is None.,

        which gives the fully qualified path in the topology.

        @return: The path to this Base object from toparent

        """

        if self._parent != None:

            return self._parent.path(toparent)

        else:

            return ''

    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_configuration(self):

        """

        Return the containing configuration of this object.

        """

        parent = self._find_parent_or_default(type=Configuration)

        return parent

    def get_configuration_path(self):

        """

        Return the path of containing configuration of this object.

        """

        parent = self._find_parent_or_default(type=Configuration)

        try:

            return parent.get_full_path()

        except AttributeError:

            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

    def get_store_interface(self):

        # if the project cannot be retrieved return None

        try:

            return self.get_project()

        except exceptions.NotFound:

            return None

    def get_id(self): 

        try:

            return self._id

        except AttributeError:

            return None

    def set_id(self,value): 

        self._id = value

    def del_id(self): 

        delattr(self,'_id')

    """ The id as a property """

    id = property(get_id,set_id, del_id)

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.loaded = {}

        self.set_storage(storage)

        self.update()

    def __getstate__(self):

        state = {}

        state['storage'] = self.storage

        return state

    def __setstate__(self, state):

        self.__init__(state['storage'])

    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 False in case the object is loaded at all in this project 

            # increases performance as unloading is not done on unchanged objects

            return False

    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 storage != None and not isinstance(storage, Storage):

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

        self.storage = 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

        """

        # TODO

        # huge performance problem