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

from cone.public import persistence, exceptions, api, utils

def dumps(obj):
    return DictWriter().dumps(obj)

def loads(dictstr):
    # convert the dict string with eval to actual dict
    return DictReader().loads(eval(dictstr))

class DictWriter(persistence.ConeWriter):
    """
    """ 

    def dumps(self, obj):
        """
        @param obj: The object 
        """
        writer = get_writer_for_class(obj.__class__.__name__)
        return {obj.__class__.__name__: writer.dumps(obj)}


class DictReader(persistence.ConeReader):
    """
    """ 
    class_type = "Dict"

    def loads(self, dict):
        """
        @param dict: The dictianary which to read. reads only the first object. 
        """
        classname = dict.keys()[0]
        reader = get_reader_for_elem(classname)
        return reader.loads(dict)


class GenericWriter(DictWriter):
    """
    """ 

    def dumps(self, obj):
        """
        @param obj: The Configuration object 
        """
        dict = {'dict': todict(obj)}
        for child in obj._objects():
            writer = get_writer_for_class(child.__class__.__name__)
            chd = writer.dumps(child)
            if not dict.has_key('children'):
                 dict['children'] = []
            dict['children'].append({child.__class__.__name__: chd})
        return dict

    @classmethod
    def supported_class(cls, classname):
        """
        Class method to determine if this DictWriter supports writing
        of the given class name
        """
        try:
            cls = get_class(classname)
            return True
        except exceptions.IncorrectClassError:
            return False


class GenericReader(DictReader):
    """
    """ 
    
    @classmethod
    def supported_elem(cls, elemname, parent=None):
        """
        Class method to determine if this DictWriter supports reading
        of the given elem name
        """
        try:
            cls = get_class(elemname)
            return True
        except exceptions.IncorrectClassError:
            return False

    def __init__(self):
        pass

    def loads(self, dict):
        """
        @param obj: The Configuration object 
        """
        
        (classname,objdata) = dict.popitem()
        obj = get_class(classname)()
        objdict = objdata.get('dict',{})
        for membername in objdict.keys():
            try:
                setattr(obj, membername, objdict[membername])
            except AttributeError:
                # read only attributes cannot be set
                pass
        obj._name = utils.resourceref.to_objref(obj.ref)

        #container.ObjectContainer.__init__(obj,utils.resourceref.to_dottedref(obj.ref))
        for child in objdata.get('children',[]):
            classname = child.keys()[0]
            reader = get_reader_for_elem(classname)
            childobj = reader.loads(child)
            obj.add(childobj)
        return obj


class ConfigurationProxyWriter(DictWriter):
    """
    """ 
    def dumps(self, obj):
        """
        @param obj: The Configuration object 
        """
        dict = {'dict': todict(obj)}
        return dict

    @classmethod
    def supported_class(cls, classname):
        """
        Class method to determine if this DictWriter supports writing
        of the given class name
        """
        if classname=="ConfigurationProxy":
            return True
        else:
            return False


class ConfigurationProxyReader(DictReader):
    """
    """ 
    def loads(self, dict):
        """
        @param obj: The Configuration object 
        """
        (classname,objdata) = dict.popitem()
        obj = api.ConfigurationProxy("")
        obj.__dict__.update(objdata.get('dict',{}))
        obj.set('_name',utils.resourceref.to_objref(obj.path))
        return obj
        
    @classmethod
    def supported_elem(cls, elemname, parent=None):
        """
        Class method to determine if this DictWriter supports reading
        of the given elem name
        """
        if elemname=="ConfigurationProxy":
            return True
        else:
            return False


def get_class(elemname):
    """
    Get a correct class from a element name.
    """
    if elemname=="Configuration":
        return api.Configuration
    elif elemname=="CompositeConfiguration":
        return api.CompositeConfiguration
    elif elemname=="Feature":
        return api.Feature
    elif elemname=="Data":
        return api.Data
    elif elemname=="DataContainer":
        return api.DataContainer
    elif elemname=="Base":
        return api.Base
    else:
        raise exceptions.IncorrectClassError("Could not find a class for name %s!" % elemname)

def get_reader_for_elem(classname):
    for reader in DictReader.__subclasses__():
        if reader.supported_elem(classname):
            return reader()
    raise exceptions.ConePersistenceError("No reader for given class found!")

def get_writer_for_class(classname):
    for writer in DictWriter.__subclasses__():
        if writer.supported_class(classname):
            return writer ()
    raise exceptions.ConePersistenceError("No writer for given class found! %s" % classname)

def todict(obj):
    """
    Helper function to push all non internal data to a dictionary
    """
    dict = {}
    fromdict = obj._dict()
    for member in fromdict:
        if member.startswith("_"):
            # skip internals
            continue
        value = getattr(obj,member)
        if isinstance(value,str):
            dict[member] = value
            continue
        if isinstance(value,int):
            dict[member] = value
            continue
    return dict