#

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

import logging

import xml.parsers.expat

try:

    from cElementTree import ElementTree

except ImportError:

    try:    

        from elementtree import ElementTree

    except ImportError:

        try:

            from xml.etree import cElementTree as ElementTree

        except ImportError:

            from xml.etree import ElementTree

""" cone specific imports """

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

from cone.confml import model

CONFIGURATION_NAMESPACES = ["http://www.s60.com/xml/confml/2","http://www.s60.com/xml/confml/1"]

INCLUDE_NAMESPACES       = ["http://www.w3.org/2001/XInclude","http://www.w3.org/2001/xinclude"]

XLINK_NAMESPACES         = ["http://www.w3.org/1999/xlink"]

SCHEMA_NAMESPACES        = ["http://www.w3.org/2001/XMLSchema"]

CV_NAMESPACE             = {"http://www.nokia.com/xml/cpf-id/1": "cv"}

MODEL                    = model

def dumps(obj, indent=True):

    etree = ConfmlWriter().dumps(obj)

    if indent:

        persistence.indent(etree)

    return ElementTree.tostring(etree)

def loads(xml):

    return ConfmlReader().loads(xml)

class ConfmlWriter(persistence.ConeWriter):

    """

    """ 

    def dumps(self, obj):

        """

        @param obj: The object 

        """

        """ Make sure that the object is mapped to an object in this model """

        mobj = obj._get_mapper('confml').map_object(obj)

        writer = get_writer_for_class(mobj.__class__.__name__)

        return writer.dumps(obj)

class ConfmlReader(persistence.ConeReader):

    """

    """ 

    def loads(self, xmlstr):

        """

        @param xml: The xml which to read. reads only the first object. 

        """

        reader = get_reader_for_elem("configuration")

        etree = utils.etree.fromstring(xmlstr)

        return reader.loads(etree)

class ConfigurationWriter(ConfmlWriter):

    """

    Writes a single Configuration project confml file.

    """ 

    @classmethod

    def supported_class(cls, classname):

        """

        Class method to determine if this ConfmlWriter supports writing

        of the given class name

        """

        if classname=="Configuration" or \

           classname=="ConfmlConfiguration" :

            return True

        else:

            return False

    def __init__(self):

        self.configuration_namespace = CONFIGURATION_NAMESPACES[0]

        self.include_namespace       = INCLUDE_NAMESPACES[0]

        self.xlink_namespace         = XLINK_NAMESPACES[0]

        self.schema_namespace        = SCHEMA_NAMESPACES[0]

    def dumps(self,obj,indent=True):

        elem = ElementTree.Element("configuration")

        if self.configuration_namespace:

            elem.set("xmlns",self.configuration_namespace)

        if self.include_namespace:

            elem.set("xmlns:xi",self.include_namespace)

        if self.include_namespace:

            elem.set("xmlns:xlink",self.xlink_namespace)

        if self.schema_namespace:

            elem.set("xmlns:xs",self.schema_namespace)

        elem.set("name",obj.get_name()) 

        for child in obj._objects():

            """ Make sure that the object is mapped to an object in this model """

            mobj = child._get_mapper('confml').map_object(child)

            writer = get_writer_for_class(mobj.__class__.__name__)

            childelem = writer.dumps(child)

            elem.append(childelem)

        return elem

class ConfigurationReader(ConfmlReader):

    """

    Parses a single CPF configuration project root confml file. Parses the XInclude statements to 

    find out the layers inside the project

    """ 

    @classmethod

    def supported_elem(cls, elemname, parent=None):

        """

        Class method to determine if this ConfmlWriter supports writing

        of the given elem name

        """

        if elemname=="configuration":

            return True

        else:

            return False

    def __init__(self):

        self.configuration_namespaces  = CONFIGURATION_NAMESPACES

        self.include_namespaces        = INCLUDE_NAMESPACES

        self.schema_namespaces         = SCHEMA_NAMESPACES

    def loads(self, etree):

        configuration = model.ConfmlConfiguration("")

        configuration.set_name(etree.get("name") or 'unknown') 

        configuration.set_ref(etree.get("name") or 'unknown')

        for elem in etree.getchildren():

            # At the moment we ignore the namespace of elements

            (namespace,elemname) = get_elemname(elem.tag)

            try:

                reader = get_reader_for_elem(elemname)

                obj = reader.loads(elem)

                if obj:

                    configuration.add(obj)

            except exceptions.ConePersistenceError,e:

                logging.getLogger('cone').warning("Could not parse element %s. Exception: %s" % (elem,e))

                continue

        return configuration

class MetaWriter(ConfmlWriter):

    @classmethod

    def supported_class(cls, classname):

        """

        Class method to determine if this ConfmlWriter supports writing

        of the given class name

        """

        if classname=="ConfmlMeta":

            return True

        else:

            return False

    def dumps(self, obj):

        """

        @param obj: The Configuration object 

        """

        elem = ElementTree.Element("meta")

        for metaproperty in obj:

            prefix = CV_NAMESPACE.get(metaproperty.ns, "")

            if prefix != "":

                #Including namespace to metadata element as well            

                elem.set(("xmlns:%s" % prefix), metaproperty.ns)

                childelem = ElementTree.Element(prefix + ":" + metaproperty.tag)

            else:

                childelem = ElementTree.Element(metaproperty.tag)

            if metaproperty.value != None:

                childelem.text = metaproperty.value

            for attr in metaproperty.attrs:

                childelem.set(attr, metaproperty.attrs[attr])

            elem.append(childelem)

        return elem

class MetaReader(ConfmlReader):

    @classmethod

    def supported_elem(cls, elemname, parent=None):

        """

        Class method to determine if this ConfmlWriter supports reading

        of the given elem name

        """

        if elemname=="meta":

            return True

        else:

            return False

    def loads(self,etree):

        metaelem = model.ConfmlMeta()

        for elem in etree.getchildren():            

            (namespace,elemname) = get_elemname(elem.tag)

            attributes = {}

            for key in elem.keys():

                attributes[key] = elem.get(key)

            metaprop = model.ConfmlMetaProperty(elemname, elem.text, namespace, attrs=attributes)

            metaelem.append(metaprop)

        return metaelem

class DescWriter(ConfmlWriter):

    """

    """ 

    @classmethod

    def supported_class(cls, classname):

        """

        Class method to determine if this ConfmlWriter supports writing

        of the given class name

        """

        if classname=="ConfmlDescription":

            return True

        else:

            return False

    def dumps(self, obj):

        """

        @param obj: The Configuration object 

        """

        elem = ElementTree.Element('desc')

        elem.text = obj.text

        return elem

class DescReader(ConfmlReader):

    @classmethod

    def supported_elem(cls, elemname, parent=None):

        """

        Class method to determine if this ConfmlReader supports reading

        of the given elem name

        """

        if elemname=="desc":

            return True

        else:

            return False

    def loads(self,elem):

        desc = model.ConfmlDescription(elem.text)

        return desc

class ConfigurationProxyWriter(ConfmlWriter):

    """

    """ 

    @classmethod

    def supported_class(cls, classname):

        """

        Class method to determine if this ConfmlWriter supports writing

        of the given class name

        """

        if classname=="ConfigurationProxy":

            return True

        else:

            return False

    def dumps(self, obj):

        """

        @param obj: The Configuration object 

        """

        elem = self.to_include(obj.path)

        return elem

    def to_include(self,include):

        elem = ElementTree.Element("xi:include",{"href":include})

        return elem 

class ConfigurationProxyReader(ConfmlReader):

    """

    """ 

    @classmethod

    def supported_elem(cls, elemname, parent=None):

        """

        Class method to determine if this ConfmlWriter supports reading

        of the given elem name

        """

        if elemname=="include":

            return True

        else:

            return False

    def loads(self, elem):

        """

        @param elem: The xml include elem

        """

        return api.ConfigurationProxy(self.parse_include(elem))

    def parse_include(self,include):

        #print "Found include %s" % include.get('href').replace('#/','')

        return include.get('href').replace('#/','')

class FeatureWriter(ConfmlWriter):

    @classmethod

    def supported_class(cls, classname):

        """

        Class method to determine if this ConfmlWriter supports writing

        of the given class name

        """

        if classname=="ConfmlFeature" or \

           classname=="Feature":

            return True

        else:

            return False

    def dumps(self, obj):

        """

        @param obj: The Configuration object 

        """

        elem = ElementTree.Element('feature', 

                                   {'ref' : obj.get_ref(),

                                    'name' : obj.get_name()})

        if obj.get_type():

            elem.set('type', obj.get_type())

        for child in obj._objects():

            """ Make sure that the object is mapped to an object in this model """

            mobj = child._get_mapper('confml').map_object(child)

            writer = get_writer_for_class(mobj.__class__.__name__)

            childelem = writer.dumps(child)

            if childelem != None:

                elem.append(childelem)

        return elem

class FeatureReader(ConfmlReader):

    """

    """ 

    @classmethod

    def supported_elem(cls, elemname, parent=None):

        """

        Class method to determine if this ConfmlWriter supports reading

        of the given elem name

        """

        if elemname=="feature":

            return True

        else:

            return False

    def loads(self, elem):

        """

        @param elem: The xml include elem

        """

        type = elem.get('type')

        if type == 'sequence':

            feature = api.FeatureSequence(elem.get('ref'))

        else:

            feature = model.ConfmlFeature(elem.get('ref'))

        if elem.get('name'):

            feature.set_name(elem.get('name'))

        feature.set_type(type)

        for elem in elem.getchildren():

            # At the moment we ignore the namespace of elements

            (namespace,elemname) = get_elemname(elem.tag)

            try:

                reader = get_reader_for_elem(elemname)

                obj = reader.loads(elem)

                feature.add(obj)

            except exceptions.ConePersistenceError,e:

                logging.getLogger('cone').warning("Could not parse element %s. Exception: %s" % (elem,e))

                continue

        return feature

class OptionWriter(ConfmlWriter):

    @classmethod

    def supported_class(cls, classname):

        """

        Class method to determine if this ConfmlWriter supports writing

        of the given class name

        """

        if classname=="Option":

            return True

        else:

            return False

    def dumps(self, obj):

        """

        @param obj: The Option object 

        """

        objdict = {}

        if obj.get_name() is not None: objdict['name'] = obj.get_name()

        if obj.get_value() is not None: objdict['value'] = obj.get_value()

        if obj.map is not None: objdict['map'] = obj.map

        if obj.relevant is not None: objdict['relevant'] = obj.relevant

        elem = ElementTree.Element('option', objdict)

        return elem

class OptionReader(ConfmlReader):

    """

    """ 

    @classmethod

    def supported_elem(cls, elemname, parent=None):

        """

        Class method to determine if this ConfmlWriter supports reading

        of the given elem name

        """

        if elemname=="option":

            return True

        else:

            return False

    def loads(self, elem):

        """

        @param elem: The xml include elem

        """

        name = elem.get('name')

        value = elem.get('value')

        optmap = elem.get('map')

        if value == None and optmap == None:

            logging.getLogger('cone').warning("Encountered option with no value")

            option = None

        else:

            option = api.Option(name, value, map=optmap, relevant=elem.get('relevant'))

        return option

class IconWriter(ConfmlWriter):

    @classmethod

    def supported_class(cls, classname):

        """

        Class method to determine if this ConfmlWriter supports writing

        of the given class name

        """

        if classname=="ConfmlIcon":

            return True

        else:

            return False

    def dumps(self, obj):

        """

        @param obj: The Option object 

        """

        elem = ElementTree.Element('icon', 

                                   {'xlink:href' : obj.href})

        return elem

class IconReader(ConfmlReader):

    """

    """ 

    @classmethod

    def supported_elem(cls, elemname, parent=None):

        """

        Class method to determine if this ConfmlWriter supports reading

        of the given elem name

        """

        if elemname=="icon":

            return True

        else:

            return False

    def loads(self, elem):

        """

        @param elem: The xml include elem

        """

        href = elem.get('{%s}href' % XLINK_NAMESPACES[0])

        obj = model.ConfmlIcon(href)

        return obj

class PropertyWriter(ConfmlWriter):

    @classmethod

    def supported_class(cls, classname):

        """

        Class method to determine if this ConfmlWriter supports writing

        of the given class name

        """

        if classname=="ConfmlProperty":

            return True

        else:

            return False

    def dumps(self, obj):

        """

        @param obj: The Option object 

        """

        elem = ElementTree.Element('property')

        if obj.name != None:

            elem.set('name', obj.name)

        if obj.value != None:

            elem.set('value', obj.value)

        if obj.unit != None:

            elem.set('unit', obj.unit)

        return elem

class PropertyReader(ConfmlReader):

    """

    """ 

    @classmethod

    def supported_elem(cls, elemname, parent=None):

        """

        Class method to determine if this ConfmlWriter supports reading

        of the given elem name

        """

        if elemname=="property":

            return True

        else:

            return False

    def loads(self, elem):

        """

        @param elem: The xml include elem

        """

        option = model.ConfmlProperty(name=elem.get('name'),value=elem.get('value'), unit=elem.get('unit'))

        return option

class XmlSchemaFacetWriter(ConfmlWriter):

    MAPPING = {'ConfmlLength'       : 'xs:length',

               'ConfmlMinLength'    : 'xs:minLength',

               'ConfmlMaxLength'    : 'xs:maxLength',