"""

XML serializer.

"""

from django.conf import settings

from django.core.serializers import base

from django.db import models

from django.utils.xmlutils import SimplerXMLGenerator

from django.utils.encoding import smart_unicode

from xml.dom import pulldom

class Serializer(base.Serializer):

    """

    Serializes a QuerySet to XML.

    """

    def indent(self, level):

        if self.options.get('indent', None) is not None:

            self.xml.ignorableWhitespace('\n' + ' ' * self.options.get('indent', None) * level)

    def start_serialization(self):

        """

        Start serialization -- open the XML document and the root element.

        """

        self.xml = SimplerXMLGenerator(self.stream, self.options.get("encoding", settings.DEFAULT_CHARSET))

        self.xml.startDocument()

        self.xml.startElement("django-objects", {"version" : "1.0"})

    def end_serialization(self):

        """

        End serialization -- end the document.

        """

        self.indent(0)

        self.xml.endElement("django-objects")

        self.xml.endDocument()

    def start_object(self, obj):

        """

        Called as each object is handled.

        """

        if not hasattr(obj, "_meta"):

            raise base.SerializationError("Non-model object (%s) encountered during serialization" % type(obj))

        self.indent(1)

        self.xml.startElement("object", {

            "pk"    : smart_unicode(obj._get_pk_val()),

            "model" : smart_unicode(obj._meta),

        })

    def end_object(self, obj):

        """

        Called after handling all fields for an object.

        """

        self.indent(1)

        self.xml.endElement("object")

    def handle_field(self, obj, field):

        """

        Called to handle each field on an object (except for ForeignKeys and

        ManyToManyFields)

        """

        self.indent(2)

        self.xml.startElement("field", {

            "name" : field.name,

            "type" : field.get_internal_type()

        })

        # Get a "string version" of the object's data.

        if getattr(obj, field.name) is not None:

            self.xml.characters(field.value_to_string(obj))

        else:

            self.xml.addQuickElement("None")

        self.xml.endElement("field")

    def handle_fk_field(self, obj, field):

        """

        Called to handle a ForeignKey (we need to treat them slightly

        differently from regular fields).

        """

        self._start_relational_field(field)

        related = getattr(obj, field.name)

        if related is not None:

            if field.rel.field_name == related._meta.pk.name:

                # Related to remote object via primary key

                related = related._get_pk_val()

            else:

                # Related to remote object via other field

                related = getattr(related, field.rel.field_name)

            self.xml.characters(smart_unicode(related))

        else:

            self.xml.addQuickElement("None")

        self.xml.endElement("field")

    def handle_m2m_field(self, obj, field):

        """

        Called to handle a ManyToManyField. Related objects are only

        serialized as references to the object's PK (i.e. the related *data*

        is not dumped, just the relation).

        """

        if field.creates_table:

            self._start_relational_field(field)

            for relobj in getattr(obj, field.name).iterator():

                self.xml.addQuickElement("object", attrs={"pk" : smart_unicode(relobj._get_pk_val())})

            self.xml.endElement("field")

    def _start_relational_field(self, field):

        """

        Helper to output the <field> element for relational fields

        """

        self.indent(2)

        self.xml.startElement("field", {

            "name" : field.name,

            "rel"  : field.rel.__class__.__name__,

            "to"   : smart_unicode(field.rel.to._meta),

        })

class Deserializer(base.Deserializer):

    """

    Deserialize XML.

    """

    def __init__(self, stream_or_string, **options):

        super(Deserializer, self).__init__(stream_or_string, **options)

        self.event_stream = pulldom.parse(self.stream)

    def next(self):

        for event, node in self.event_stream:

            if event == "START_ELEMENT" and node.nodeName == "object":

                self.event_stream.expandNode(node)

                return self._handle_object(node)

        raise StopIteration

    def _handle_object(self, node):

        """

        Convert an <object> node to a DeserializedObject.

        """

        # Look up the model using the model loading mechanism. If this fails,

        # bail.

        Model = self._get_model_from_node(node, "model")

        # Start building a data dictionary from the object.  If the node is

        # missing the pk attribute, bail.

        pk = node.getAttribute("pk")

        if not pk:

            raise base.DeserializationError("<object> node is missing the 'pk' attribute")

        data = {Model._meta.pk.attname : Model._meta.pk.to_python(pk)}

        # Also start building a dict of m2m data (this is saved as

        # {m2m_accessor_attribute : [list_of_related_objects]})

        m2m_data = {}

        # Deseralize each field.

        for field_node in node.getElementsByTagName("field"):

            # If the field is missing the name attribute, bail (are you

            # sensing a pattern here?)

            field_name = field_node.getAttribute("name")

            if not field_name:

                raise base.DeserializationError("<field> node is missing the 'name' attribute")

            # Get the field from the Model. This will raise a

            # FieldDoesNotExist if, well, the field doesn't exist, which will

            # be propagated correctly.

            field = Model._meta.get_field(field_name)

            # As is usually the case, relation fields get the special treatment.

            if field.rel and isinstance(field.rel, models.ManyToManyRel):

                m2m_data[field.name] = self._handle_m2m_field_node(field_node, field)

            elif field.rel and isinstance(field.rel, models.ManyToOneRel):

                data[field.attname] = self._handle_fk_field_node(field_node, field)

            else:

                if field_node.getElementsByTagName('None'):

                    value = None

                else:

                    value = field.to_python(getInnerText(field_node).strip())

                data[field.name] = value

        # Return a DeserializedObject so that the m2m data has a place to live.

        return base.DeserializedObject(Model(**data), m2m_data)

    def _handle_fk_field_node(self, node, field):

        """

        Handle a <field> node for a ForeignKey

        """

        # Check if there is a child node named 'None', returning None if so.

        if node.getElementsByTagName('None'):

            return None

        else:

            return field.rel.to._meta.get_field(field.rel.field_name).to_python(

                       getInnerText(node).strip())

    def _handle_m2m_field_node(self, node, field):

        """

        Handle a <field> node for a ManyToManyField.

        """

        return [field.rel.to._meta.pk.to_python(

                    c.getAttribute("pk"))

                    for c in node.getElementsByTagName("object")]

    def _get_model_from_node(self, node, attr):

        """

        Helper to look up a model from a <object model=...> or a <field

        rel=... to=...> node.

        """

        model_identifier = node.getAttribute(attr)

        if not model_identifier:

            raise base.DeserializationError(

                "<%s> node is missing the required '%s' attribute" \

                    % (node.nodeName, attr))

        try:

            Model = models.get_model(*model_identifier.split("."))

        except TypeError:

            Model = None

        if Model is None:

            raise base.DeserializationError(

                "<%s> node has invalid model identifier: '%s'" % \

                    (node.nodeName, model_identifier))

        return Model

def getInnerText(node):

    """

    Get all the inner text of a DOM node (recursively).

    """

    # inspired by http://mail.python.org/pipermail/xml-sig/2005-March/011022.html

    inner_text = []

    for child in node.childNodes:

        if child.nodeType == child.TEXT_NODE or child.nodeType == child.CDATA_SECTION_NODE:

            inner_text.append(child.data)

        elif child.nodeType == child.ELEMENT_NODE:

            inner_text.extend(getInnerText(child))

        else:

           pass

    return u"".join(inner_text)