#

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

#

"""

Container classes.

Mainly internal classed that the public data model uses internally.

"""

import re

import pickle

import logging

import utils, exceptions

def object_container_filter(obj,**kwargs):

    """ Create a list of filter functions for each argument """ 

    filters=[]

    if kwargs.has_key('name'):

        filters.append(lambda x: re.match(kwargs.get('name'), x._name))

    if kwargs.has_key('path'):

        filters.append(lambda x: re.match(kwargs.get('path'), x._path()))

    if kwargs.has_key('type'):

        filters.append(lambda x: isinstance(x, kwargs.get('type')))

    if kwargs.has_key('filters'):

        filters += kwargs.get('filters')

    ret = []

    for sobj in utils.get_list(obj):

        if utils.filter(obj,filters):

            ret.append(sobj)

    return ret

def _apply_filter(obj,filters):

    """ Create a list of filter functions for each argument """ 

    if utils.filter(obj,filters):

        return [obj]

    else:

        return []

""" object container adding policies """

REPLACE = 0

APPEND = 1

PREPEND = 2

ERROR = 3

class DataContainer(object):

    """

    Class for data containers. 

    Container is a data storage that can hold several keys, where each key is unique. Each key however 

    can hold several values, where the active value is the last one added. 

    Example:

    data = {'key1' :[1,2,3,4], 

            'key2' :['foo','bar],

            'key3' :['testing'],

            'path/to/key' :['some','value','in','here','too']}

    The active values for keys are the last ones in the array. E.g. key1 = 4.

    """

    def __init__(self):

        self.data = {}

    def list_keys(self):

        """

        List all keys of the DataStorage.

        """

        return self.data.keys()

    def add_value(self,key,value):

        """

        Add the value as a topmost item for the given key.

        @param key: name for the key to store the data.

        @param value: the value to store.  

        """

        if self.data.has_key(key):

            self.data[key].append(value)

        else:

            self.data[key] = [value]

        return

    def remove_value(self,key,value):

        """

        remove individual value of the key value array

        """

        self.data[key].remove(value)

        return 

    def remove_key(self,key):

        del self.data[key]

        return

    def get_value(self,key):

        """

        self.data = {'key1' :[1,2,3,4], 

                    'key2' :['foo','bar],

                    'key3' :['testing'],

                    'path/to/key' :['some','value','in','here','too']}

        self.get_value('key1')

        4

        """

        return self.data[key][-1]

    def get_values(self,key):

        """

        return a copy of data values inside the container

        """

        values = []

        values.extend(self.data[key])

        return values

    def flatten(self):

        """

        return a new dictionary of the DataContainer data with only single values for each key, 

        instead of the array of values.

        """

        rest = {}

        for key in self.data.keys():

            rest[key] = self.get_value(key)

        return rest

    def clear(self):

        """

        Remove all data from the container.

        """

        return self.data.clear()

class ContainerBase(object):

    def _set_parent(self, newparent):

        """

        @param newparent:  The new parent object

        @return: None

        """

        self._parent = newparent

    def _get_parent(self):

        """

        @return: existing parent object

        """

        return self._parent

    def _del_parent(self):

        """

        Set the current parent to None

        """

        self._parent = None

    parent = property(_get_parent, _set_parent,_del_parent)

class ObjectProxy(ContainerBase):

    """

    An object proxy class. The ObjectProxy overrides the python builtin methdo __getattr__

    to redirect any function/member access to the subobject.  

    """

    def __init__(self,obj=None):

        """

        """

        self._obj  = obj

        self._parent = None

    def __getattr__(self,name):

        """

        direct all not found attribute calls to the sub object getattr

        """

        return getattr(self._obj,name)

#    def _set_parent(self, newparent):

#        """

#        @param newparent:  The new parent object

#        @return: None

#        """

#        self._parent = newparent

#        if isinstance(self._obj, ContainerBase):

#            self._obj._set_parent(newparent)

class LoadInterface(ContainerBase):

    def load(self,ref):

        file = open(ref,"r")

        self._parent = None

        return pickle.load(file)

    def unload(self,ref, obj):

        """

        unload or release

        """

        file = open(ref,"w")

        pickle.dump(obj,file)

        file.close()

    def get_path(self):

        """

        Return the path of the configuration resource

        """

        return ""

class LoadProxy(ContainerBase):

    """

    This class is meant for loading & unloading an object, when it need.

    """

    def __init__(self, path, store_interface=None):

        """

        @param path: the path which is used in loadin

        @param store_interface: the loading interface object, which is used. 

        Expects load(path) and dump(obj) functions  

        """

        self.set('_obj', None)

        self.set('_parent', None)

        self.set('path', path)

        self.set('_storeint', store_interface)

    def __getattr__(self,name):

        """

        direct all not found attribute calls to the sub object getattr

        """

        if not self._obj: 

            self._load()

        return getattr(self._obj,name)

    def __setattr__(self, name, value):

        """

        direct attribute setting calls to the sub object setattr

        """

        if not self._obj: 

            self._load()

        setattr(self._obj,name,value)

    def __delattr__(self, name):

        """

        direct attribute setting calls to the sub object setattr

        """

        if not self._obj: 

            self._load()

        delattr(self._obj,name)

    def _set_parent(self, newparent):

        """

        @param newparent:  The new parent object

        @return: None

        """

        self.set('_parent',newparent)

        if self._obj:

            self._obj._parent = self._parent

    def _set_obj(self, obj):

        self.set('_obj',obj)

        # set the same _parent for the actual object as is stored for the proxy

        self._obj._parent = self._parent

        self._obj.set_path(self.path)

    def _get_obj(self):

        if not self._obj: 

            self._load()

        return self._obj

    def _load(self):

        # Should the loading of layer external resources be supported?

        # E.g. resources with absolute path relative to the storage (starts with slash)

        """ If the loading of the object fails => Raise an InvalidObject exception """ 

        try:

            obj = self._store_interface().load(self.fullpath)

            self._set_obj(obj)

            obj.set_ref(utils.resourceref.to_objref(self.path))

        except exceptions.NotResource,e:

            logging.getLogger('cone').warning("Loading %s from parent %s failed! %s" % (self.path,self.get_parent_path(), e))

            raise exceptions.InvalidObject("Invalid configuration object %s" % self.path)

    def _unload(self):

        if self._obj:

            self._store_interface().unload(self.fullpath, self._obj)

            self.set('_obj',None)

    def _store_interface(self):

        if not self._storeint:

            self.set('_storeint',self._parent.get_project())

        return self._storeint

    def set(self,name,value):

        """

        Proxy has a specific attribute setting function, because by default all attributes are 

        stored to the actual proxy object  

        """

        self.__dict__[name] = value

    def get(self,name):

        """

        Proxy has also a specific attribute getting function, because by default all attributes are 

        stored to the actual proxy object  

        """

        return self.__dict__[name]

    def save(self):

        if hasattr(self._obj,'save'):

            self._obj.save()

        self._unload()

    def close(self):

        if hasattr(self._obj,'close'):

            self._obj.close()

    def get_parent_path(self):

        """

        Return the path of the configuration resource

        """

        if self._parent:

            return utils.resourceref.get_path(self._parent.get_path())

        else:

            return ""

    def get_path(self):

        """

        Return the path of the configuration resource

        """

        if self._obj:

            return self._obj.get_path()

        else:

            return self.path

    @property

    def fullpath(self):

        """

        Return the path of the configuration resource

        """

        try:

            return self._obj.get_full_path() 

        except AttributeError:

            parent_path = self.get_parent_path() 

            return utils.resourceref.join_refs([parent_path,self.path])

class ObjectContainer(ContainerBase):

    """

    An object container class. The ObjectContainer is actually a Tree data structure. Any ObjectContainer 

    instance can include any number of children, that must be instances of ObjectContainer.  

    """

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

        """

        """

        if len(name.split(".")) > 1 or len(name.split("/")) > 1:

            raise exceptions.InvalidRef("Illegal name for ObjectContainer %s" % name)

        self._name = name

        self._parent = None

        self._order = []

        self._children = {}

        for arg in kwargs.keys():

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

    def __getattr__(self,name):

        """

        direct all not found attribute calls to the sub object getattr

        """

        try:

            return self.__dict__['_children'][name]

        except KeyError:

            return getattr(super(ObjectContainer),name)

    def _path(self, toparent=None):

        """

        Get the path to this ObjectContainer.

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

        which gives the fully qualified path

        @return: The path to the ObjectContainer from toparent

        """

        if self == toparent:

            return ""

        elif self._parent and self._parent != toparent:

            # return the path with list index if the given element is in a list

            if utils.is_list(self.parent._get(self._name)):

                return self._parent._path(toparent)+"."+"%s[%s]" % (self._name,self.get_index())

            else:

                return self._parent._path(toparent)+"."+self._name

        else:

            return self._name

    def _add(self, child, policy=REPLACE):

        """

        Add a child object. 

        @param child: The child object to add. The child needs to be an instance of ObjectContainer. 

        @param policy: The policy which is used when an object with same name exists already  

        """

        # check that the child is a supported type

        if not self._supported_type(child):

            raise exceptions.IncorrectClassError("Cannot add instance of %s to %s." % (child.__class__,self.__class__))

        if policy == REPLACE:

            self._replace(child)

        elif policy == ERROR:

            self._error(child)

        elif policy == APPEND:

            self._append(child)

        elif policy == PREPEND:

            self._prepend(child)

    def _append(self, child):

        """

        Add the given child to the proper key. Create a list entry if necessary

        """

        child._set_parent(self)

        if not self._children.has_key(child._name):

            # skip all internal objects (that start with _)

            if not child._name.startswith('?'):

                self._order.append(child._name)

            self._children[child._name] = child

        else:

            """ Create a list under the child name """

            self._children[child._name] = utils.add_list(self._children[child._name], child)

        return

    def _prepend(self, child):

        """

        Add the given child to the proper key. Create a list entry if necessary

        """

        child._set_parent(self)

        if not self._children.has_key(child._name):

            # skip all internal objects (that start with _)

            if not child._name.startswith('?'):

                self._order.insert(0,child._name)

            self._children[child._name] = child

        else:

            """ Create a list under the child name """

            self._children[child._name] = utils.prepend_list(self._children[child._name], child)

        return

    def _replace(self, child):

        """

        If the given child already exists => Replace the child, 

        but maintain the current children of that child 

        """

        child._set_parent(self)

        # skip all internal objects (that start with _)

        if not self._children.has_key(child._name):

            if not child._name.startswith('?'):

                self._order.append(child._name)

        else:

            """ if the existing child is a instance of ObjectContainer, 

                add all children of the existing contianer to this new object """

            existingchild = self._children[child._name]

            if isinstance(existingchild, ObjectContainer):

                for subchild in existingchild._objects():

                     child._add(subchild)

        self._children[child._name] = child

        return

    def _error(self, child):

        """

        If the given child already exists => raise an exception.

        @raise exceptions.AlreadyExists: 

        """

        child._set_parent(self)

        if not self._children.has_key(child._name):

            # skip all internal objects (that start with _)

            if not child._name.startswith('?'):

                self._order.insert(0,child._name)

            self._children[child._name] = child

        else:

            raise exceptions.AlreadyExists('Child %s already exists' % child._name)

        return

    def _add_to_path(self, path, child, policy=REPLACE):

        """

        Add a child object.

        @param path: the path for the object

        @param child: The child object to add 

        @param namespace: The namespace of the object, which defines where the object is created  

        """

        # check that the child is a supported type

        if not self._supported_type(child):

            raise exceptions.IncorrectClassError("Cannot add instance of %s to %s Container" % (child.__class__,self.__class__))

        # ensure that the elements to the namespace exist  

        curelem = self

        for ppath in utils.dottedref.split_ref(path):

            if not curelem._children.has_key(ppath):

                # Create missing elem

                curelem._add(self._default_object(ppath))

            curelem = curelem._get(ppath)

        curelem._add(child,policy)

    def _get(self, path):

        """

        Get a child object by it path.

        @return: The child object if it is found. 

        @raise NotFound: when object is not found from the children.  

        """

        try:

            # traverse to the actual child element 

            curelem = self

            for pathelem in utils.dottedref.split_ref(path):

                if utils.dottedref.get_index(pathelem) == None:

                    curelem = curelem._children[pathelem]

                else:

                    # If the given pathelem is referring to a list 

                    name = utils.dottedref.get_name(pathelem)

                    index = utils.dottedref.get_index(pathelem)

                    curelem = utils.get_list(curelem._children[name])[index]

            return curelem

        # Catch the KeyError exception from dict and IndexError from list

        except (KeyError,IndexError): 

            raise exceptions.NotFound("Child %s not found!" % path)

    def _has(self, path):

        """

        Returns True if an element under the path is found.

        @return: Boolean value. 

        """

        try:

            # traverse to the actual child element 

            curelem = self

            for pathelem in utils.dottedref.split_ref(path):

                curelem = curelem._children[pathelem]

            return True

        except KeyError: 

            return False