#

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

import re

import logging

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, parsecontext

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)

    result = ElementTree.tostring(etree)

    # To make the output the same in linux and windows

    # (needed to make testing easier)

    if os.linesep != '\r\n':

        result = result.replace(os.linesep, '\r\n')

    return result

def loads(xml):

    return ConfmlReader().loads(xml)

def add_parse_warning(msg, line, type='model.confml'):

    parsecontext.get_confml_context().handle_problem(

        api.Problem(msg,

                    severity = api.Problem.SEVERITY_WARNING,

                    type     = type,

                    line     = line))

def add_unknown_element_warning(elem):

    add_parse_warning("Unknown element '%s'" % elem.tag,

                      utils.etree.get_lineno(elem),

                      type='model.confml.unknown_element')

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")

        try:

            etree = utils.etree.fromstring(xmlstr)

        except exceptions.XmlParseError, e:

            e.problem_type = 'xml.confml'

            raise e

        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)

        if obj.get_name():

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

        if obj.version != None:

            elem.set("version", obj.version) 

        if obj.get_id():

            elem.set('id', obj.get_id())

        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(name=etree.get("name"),

                                                  id=etree.get("id"),

                                                  version=etree.get("version"))

        configuration.lineno = utils.etree.get_lineno(etree)

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

                add_unknown_element_warning(elem)

                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()

        metaelem.lineno = utils.etree.get_lineno(etree)

        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)

        desc.lineno = utils.etree.get_lineno(elem)

        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

        """

        proxy = api.ConfigurationProxy(self.parse_include(elem))

        # proxy.lineno = utils.etree.get_lineno(elem)

        return proxy

    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()})

        if obj.get_name():

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

        if obj.get_type():

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

        if obj.get_id() != None:

            elem.set('id', obj.get_id())

        if obj.get_relevant() != None:

            elem.set('relevant', obj.get_relevant())

        if obj.get_constraint() != None:

            elem.set('constraint', obj.get_constraint())

        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'))

        if elem.get('id') != None:

            feature.set_id(elem.get('id'))

        if elem.get('relevant') != None:

            feature.set_relevant(elem.get('relevant'))

        if elem.get('constraint') != None:

            feature.set_constraint(elem.get('constraint'))

        feature.set_type(type)

        feature.lineno = utils.etree.get_lineno(elem)

        for elem in elem.getchildren():

            # At the moment we ignore the namespace of elements

            try:

                reader = get_reader_for_elem(elemname)

                obj = reader.loads(elem)

                feature.add(obj)

                add_unknown_element_warning(elem)

                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

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

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

        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'),

                                map_value=elem.get('mapValue'), 

                                display_name=elem.get('displayName'))

            option.lineno = utils.etree.get_lineno(elem) 

        return option

class IconWriter(ConfmlWriter):