// Copyright (c) 2018 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
use jid::Jid;

use crate::core::{error::Error, FromXml, IntoXml};
use crate::data_forms::DataForm;
use crate::iq::{IqGetPayload, IqResultPayload, IqSetPayload};
use crate::ns::PUBSUB;
use crate::pubsub::{
    AffiliationAttribute, ItemId, NodeName, PubSubPayload, Subscription, SubscriptionId,
};
use crate::Element;

// TODO: a better solution would be to split this into a query and a result elements, like for
// XEP-0030.
/// A list of affiliations you have on a service, or on a node.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "affiliations")]
pub struct Affiliations {
    /// The optional node name this request pertains to.
    #[xml(attribute)]
    pub node: Option<NodeName>,

    /// The actual list of affiliation elements.
    #[xml(children)]
    pub affiliations: Vec<Affiliation>,
}

/// An affiliation element.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "affiliation")]
pub struct Affiliation {
    /// The node this affiliation pertains to.
    #[xml(attribute)]
    pub node: NodeName,

    /// The affiliation you currently have on this node.
    #[xml(attribute)]
    pub affiliation: AffiliationAttribute,
}

/// Request to configure a new node.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "configure")]
pub struct Configure {
    /// The form to configure it.
    #[xml(child(default))]
    pub form: Option<DataForm>,
}

/// Request to create a new node.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "create")]
pub struct Create {
    /// The node name to create, if `None` the service will generate one.
    #[xml(attribute)]
    pub node: Option<NodeName>,
}

/// Request for a default node configuration.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "default")]
pub struct Default {
    /// The node targeted by this request, otherwise the entire service.
    #[xml(attribute)]
    pub node: Option<NodeName>,
    // TODO: do we really want to support collection nodes?
    // type: Option<String> = "type",
}

/// A request for a list of items.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "items")]
pub struct Items {
    // TODO: should be an xs:positiveInteger, that is, an unbounded int ≥ 1.
    /// Maximum number of items returned.
    #[xml(attribute)]
    pub max_items: Option<u32>,

    /// The node queried by this request.
    #[xml(attribute)]
    pub node: NodeName,

    /// The subscription identifier related to this request.
    #[xml(attribute)]
    pub subid: Option<SubscriptionId>,

    #[xml(children)]
    /// The actual list of items returned.
    pub items: Vec<Item>,
}

impl Items {
    /// Create a new items request.
    pub fn new(node: &str) -> Items {
        Items {
            node: NodeName(String::from(node)),
            max_items: None,
            subid: None,
            items: Vec::new(),
        }
    }
}

/// An item from a PubSub node.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "item")]
pub struct Item {
    /// The identifier for this item, unique per node.
    #[xml(attribute)]
    pub id: Option<ItemId>,

    /// The JID of the entity who published this item.
    #[xml(attribute)]
    pub publisher: Option<Jid>,

    /// The payload of this item, in an arbitrary namespace.
    #[xml(element)]
    pub payload: Option<Element>,
}

impl Item {
    /// Create a new item, accepting only payloads implementing `PubSubPayload`.
    pub fn new<P: PubSubPayload>(
        id: Option<ItemId>,
        publisher: Option<Jid>,
        payload: Option<P>,
    ) -> Item {
        Item {
            id,
            publisher,
            payload: payload.map(Into::into),
        }
    }
}

impl From<super::event::Item> for Item {
    fn from(other: super::event::Item) -> Self {
        Self {
            id: other.id,
            publisher: other.publisher,
            payload: other.payload,
        }
    }
}

/// The options associated to a subscription request.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "options")]
pub struct Options {
    /// The JID affected by this request.
    #[xml(attribute)]
    pub jid: Jid,

    /// The node affected by this request.
    #[xml(attribute)]
    pub node: Option<NodeName>,

    /// The subscription identifier affected by this request.
    #[xml(attribute)]
    pub subid: Option<SubscriptionId>,

    /// The form describing the subscription.
    #[xml(child)]
    pub form: Option<DataForm>,
}

/// Request to publish items to a node.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "publish")]
pub struct Publish {
    /// The target node for this operation.
    #[xml(attribute)]
    pub node: NodeName,

    /// The items you want to publish.
    #[xml(children)]
    pub items: Vec<Item>,
}

/// The options associated to a publish request.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "publish-options")]
pub struct PublishOptions {
    /// The form describing these options.
    #[xml(child)]
    pub form: Option<DataForm>,
}

generate_attribute!(
    /// Whether a retract request should notify subscribers or not.
    Notify,
    "notify",
    bool
);

/// A request to retract some items from a node.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "retract")]
pub struct Retract {
    /// The node affected by this request.
    #[xml(attribute)]
    pub node: NodeName,

    /// Whether a retract request should notify subscribers or not.
    #[xml(attribute(default))]
    pub notify: Notify,

    /// The items affected by this request.
    #[xml(children)]
    pub items: Vec<Item>,
}

/// Indicate that the subscription can be configured.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "subscribe-options")]
pub struct SubscribeOptions {
    /// If `true`, the configuration is actually required.
    #[xml(flag(namespace = PUBSUB, name = "required"))]
    pub required: bool,
}

/// A request to subscribe a JID to a node.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "subscribe")]
pub struct Subscribe {
    /// The JID being subscribed.
    #[xml(attribute)]
    pub jid: Jid,

    /// The node to subscribe to.
    #[xml(attribute)]
    pub node: Option<NodeName>,
}

/// A request for current subscriptions.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "subscriptions")]
pub struct Subscriptions {
    /// The node to query.
    #[xml(attribute)]
    pub node: Option<NodeName>,

    /// The list of subscription elements returned.
    #[xml(children)]
    subscription: Vec<SubscriptionElem>,
}

/// A subscription element, describing the state of a subscription.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "subscription")]
pub struct SubscriptionElem {
    /// The JID affected by this subscription.
    #[xml(attribute)]
    jid: Jid,

    /// The node affected by this subscription.
    #[xml(attribute)]
    node: Option<NodeName>,

    /// The subscription identifier for this subscription.
    #[xml(attribute)]
    subid: Option<SubscriptionId>,

    /// The state of the subscription.
    #[xml(attribute)]
    subscription: Option<Subscription>,

    /// The options related to this subscription.
    #[xml(child)]
    subscribe_options: Option<SubscribeOptions>,
}

/// An unsubscribe request.
#[derive(FromXml, IntoXml, Debug, PartialEq, Clone)]
#[xml(namespace = PUBSUB, name = "unsubscribe")]
pub struct Unsubscribe {
    /// The JID affected by this request.
    #[xml(attribute)]
    jid: Jid,

    /// The node affected by this request.
    #[xml(attribute)]
    node: Option<NodeName>,

    /// The subscription identifier for this subscription.
    #[xml(attribute)]
    subid: Option<SubscriptionId>,
}

#[derive(FromXml, IntoXml)]
enum PubSubRawPayload {
    #[xml(transparent)]
    Create(Create),
    #[xml(transparent)]
    Subscribe(Subscribe),
    #[xml(transparent)]
    Publish(Publish),
    #[xml(transparent)]
    Affiliations(Affiliations),
    #[xml(transparent)]
    Default(Default),
    #[xml(transparent)]
    Items(Items),
    #[xml(transparent)]
    Retract(Retract),
    #[xml(transparent)]
    Subscription(SubscriptionElem),
    #[xml(transparent)]
    Subscriptions(Subscriptions),
    #[xml(transparent)]
    Unsubscribe(Unsubscribe),
}

#[derive(FromXml, IntoXml)]
#[xml(namespace = PUBSUB, name = "pubsub")]
struct PubSubRaw {
    #[xml(child)]
    payload: Option<PubSubRawPayload>,
    #[xml(child)]
    publish_options: Option<PublishOptions>,
    #[xml(child)]
    subscribe_options: Option<Options>,
    #[xml(child)]
    configure: Option<Configure>,
}

impl PubSubRaw {
    fn require_no_publish_options(opt: &Option<PublishOptions>) -> Result<(), Error> {
        if opt.is_some() {
            Err(Error::ParseError(
                "Unexpected publish-options in PubSub element.",
            ))
        } else {
            Ok(())
        }
    }

    fn require_no_subscribe_options(opt: &Option<Options>) -> Result<(), Error> {
        if opt.is_some() {
            Err(Error::ParseError(
                "Unexpected subscribe-options in PubSub element.",
            ))
        } else {
            Ok(())
        }
    }

    fn require_no_configure(opt: &Option<Configure>) -> Result<(), Error> {
        if opt.is_some() {
            Err(Error::ParseError("Unexpected configure in PubSub element."))
        } else {
            Ok(())
        }
    }
}

/// Main payload used to communicate with a PubSub service.
///
/// `<pubsub xmlns="http://jabber.org/protocol/pubsub"/>`
#[derive(Debug, Clone, PartialEq)]
pub enum PubSub {
    /// Request to create a new node, with optional suggested name and suggested configuration.
    Create {
        /// The create request.
        create: Create,

        /// The configure request for the new node.
        configure: Option<Configure>,
    },

    /// A subcribe request.
    Subscribe {
        /// The subscribe request.
        subscribe: Option<Subscribe>,

        /// The options related to this subscribe request.
        options: Option<Options>,
    },

    /// Request to publish items to a node, with optional options.
    Publish {
        /// The publish request.
        publish: Publish,

        /// The options related to this publish request.
        publish_options: Option<PublishOptions>,
    },

    /// A list of affiliations you have on a service, or on a node.
    Affiliations(Affiliations),

    /// Request for a default node configuration.
    Default(Default),

    /// A request for a list of items.
    Items(Items),

    /// A request to retract some items from a node.
    Retract(Retract),

    /// A request about a subscription.
    Subscription(SubscriptionElem),

    /// A request for current subscriptions.
    Subscriptions(Subscriptions),

    /// An unsubscribe request.
    Unsubscribe(Unsubscribe),
}

impl TryFrom<Element> for PubSub {
    type Error = Error;

    fn try_from(elem: Element) -> Result<PubSub, Error> {
        let inner: PubSubRaw = elem.try_into()?;

        match inner.payload {
            None => match inner.subscribe_options {
                Some(options) => Ok(PubSub::Subscribe {
                    subscribe: None,
                    options: Some(options),
                }),
                None => {
                    PubSubRaw::require_no_configure(&inner.configure)?;
                    PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                    Err(Error::ParseError("No payload in pubsub element."))
                }
            },
            Some(PubSubRawPayload::Create(create)) => {
                PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                PubSubRaw::require_no_subscribe_options(&inner.subscribe_options)?;
                Ok(PubSub::Create {
                    create,
                    configure: inner.configure,
                })
            }
            Some(PubSubRawPayload::Subscribe(subscribe)) => {
                PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                PubSubRaw::require_no_configure(&inner.configure)?;
                Ok(PubSub::Subscribe {
                    subscribe: Some(subscribe),
                    options: inner.subscribe_options,
                })
            }
            Some(PubSubRawPayload::Publish(publish)) => {
                PubSubRaw::require_no_subscribe_options(&inner.subscribe_options)?;
                PubSubRaw::require_no_configure(&inner.configure)?;
                Ok(PubSub::Publish {
                    publish,
                    publish_options: inner.publish_options,
                })
            }
            Some(PubSubRawPayload::Affiliations(affiliations)) => {
                PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                PubSubRaw::require_no_subscribe_options(&inner.subscribe_options)?;
                PubSubRaw::require_no_configure(&inner.configure)?;
                Ok(PubSub::Affiliations(affiliations))
            }
            Some(PubSubRawPayload::Default(default)) => {
                PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                PubSubRaw::require_no_subscribe_options(&inner.subscribe_options)?;
                PubSubRaw::require_no_configure(&inner.configure)?;
                Ok(PubSub::Default(default))
            }
            Some(PubSubRawPayload::Items(items)) => {
                PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                PubSubRaw::require_no_subscribe_options(&inner.subscribe_options)?;
                PubSubRaw::require_no_configure(&inner.configure)?;
                Ok(PubSub::Items(items))
            }
            Some(PubSubRawPayload::Retract(retract)) => {
                PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                PubSubRaw::require_no_subscribe_options(&inner.subscribe_options)?;
                PubSubRaw::require_no_configure(&inner.configure)?;
                Ok(PubSub::Retract(retract))
            }
            Some(PubSubRawPayload::Subscription(subscription)) => {
                PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                PubSubRaw::require_no_subscribe_options(&inner.subscribe_options)?;
                PubSubRaw::require_no_configure(&inner.configure)?;
                Ok(PubSub::Subscription(subscription))
            }
            Some(PubSubRawPayload::Subscriptions(subscriptions)) => {
                PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                PubSubRaw::require_no_subscribe_options(&inner.subscribe_options)?;
                PubSubRaw::require_no_configure(&inner.configure)?;
                Ok(PubSub::Subscriptions(subscriptions))
            }
            Some(PubSubRawPayload::Unsubscribe(unsubscribe)) => {
                PubSubRaw::require_no_publish_options(&inner.publish_options)?;
                PubSubRaw::require_no_subscribe_options(&inner.subscribe_options)?;
                PubSubRaw::require_no_configure(&inner.configure)?;
                Ok(PubSub::Unsubscribe(unsubscribe))
            }
        }
    }
}

impl From<PubSub> for Element {
    fn from(other: PubSub) -> Self {
        let transformed = match other {
            PubSub::Create { create, configure } => PubSubRaw {
                payload: Some(PubSubRawPayload::Create(create)),
                configure: configure,
                publish_options: None,
                subscribe_options: None,
            },
            PubSub::Subscribe { subscribe, options } => {
                if subscribe.is_none() && options.is_none() {
                    panic!("PubSub::Subscribe {{ .. }} must have at least one None member");
                }
                PubSubRaw {
                    payload: subscribe.map(PubSubRawPayload::Subscribe),
                    subscribe_options: options,
                    configure: None,
                    publish_options: None,
                }
            }
            PubSub::Publish {
                publish,
                publish_options,
            } => PubSubRaw {
                payload: Some(PubSubRawPayload::Publish(publish)),
                publish_options,
                configure: None,
                subscribe_options: None,
            },
            PubSub::Affiliations(affiliations) => PubSubRaw {
                payload: Some(PubSubRawPayload::Affiliations(affiliations)),
                configure: None,
                publish_options: None,
                subscribe_options: None,
            },
            PubSub::Default(default) => PubSubRaw {
                payload: Some(PubSubRawPayload::Default(default)),
                configure: None,
                publish_options: None,
                subscribe_options: None,
            },
            PubSub::Items(items) => PubSubRaw {
                payload: Some(PubSubRawPayload::Items(items)),
                configure: None,
                publish_options: None,
                subscribe_options: None,
            },
            PubSub::Retract(retract) => PubSubRaw {
                payload: Some(PubSubRawPayload::Retract(retract)),
                configure: None,
                publish_options: None,
                subscribe_options: None,
            },
            PubSub::Subscription(subscription) => PubSubRaw {
                payload: Some(PubSubRawPayload::Subscription(subscription)),
                configure: None,
                publish_options: None,
                subscribe_options: None,
            },
            PubSub::Subscriptions(subscriptions) => PubSubRaw {
                payload: Some(PubSubRawPayload::Subscriptions(subscriptions)),
                configure: None,
                publish_options: None,
                subscribe_options: None,
            },
            PubSub::Unsubscribe(unsubscribe) => PubSubRaw {
                payload: Some(PubSubRawPayload::Unsubscribe(unsubscribe)),
                configure: None,
                publish_options: None,
                subscribe_options: None,
            },
        };

        transformed.into()
    }
}

impl IqGetPayload for PubSub {}
impl IqSetPayload for PubSub {}
impl IqResultPayload for PubSub {}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::data_forms::{DataFormType, Field, FieldType};
    use crate::ns;

    #[test]
    fn create() {
        let elem: Element = "<pubsub xmlns='http://jabber.org/protocol/pubsub'><create/></pubsub>"
            .parse()
            .unwrap();
        let elem1 = elem.clone();
        let pubsub = PubSub::try_from(elem).unwrap();
        match pubsub.clone() {
            PubSub::Create { create, configure } => {
                assert!(create.node.is_none());
                assert!(configure.is_none());
            }
            _ => panic!(),
        }

        let elem2 = Element::from(pubsub);
        assert_eq!(elem1, elem2);

        let elem: Element =
            "<pubsub xmlns='http://jabber.org/protocol/pubsub'><create node='coucou'/></pubsub>"
                .parse()
                .unwrap();
        let elem1 = elem.clone();
        let pubsub = PubSub::try_from(elem).unwrap();
        match pubsub.clone() {
            PubSub::Create { create, configure } => {
                assert_eq!(&create.node.unwrap().0, "coucou");
                assert!(configure.is_none());
            }
            _ => panic!(),
        }

        let elem2 = Element::from(pubsub);
        assert_eq!(elem1, elem2);
    }

    #[test]
    fn create_and_configure_empty() {
        let elem: Element =
            "<pubsub xmlns='http://jabber.org/protocol/pubsub'><create/><configure/></pubsub>"
                .parse()
                .unwrap();
        let elem1 = elem.clone();
        let pubsub = PubSub::try_from(elem).unwrap();
        match pubsub.clone() {
            PubSub::Create { create, configure } => {
                assert!(create.node.is_none());
                assert!(configure.unwrap().form.is_none());
            }
            _ => panic!(),
        }

        let elem2 = Element::from(pubsub);
        assert_eq!(elem1, elem2);
    }

    #[test]
    fn create_and_configure_simple() {
        // XXX: Do we want xmpp-parsers to always specify the field type in the output Element?
        let elem: Element = "<pubsub xmlns='http://jabber.org/protocol/pubsub'><create node='foo'/><configure><x xmlns='jabber:x:data' type='submit'><field var='FORM_TYPE' type='hidden'><value>http://jabber.org/protocol/pubsub#node_config</value></field><field var='pubsub#access_model' type='list-single'><value>whitelist</value></field></x></configure></pubsub>"
        .parse()
        .unwrap();
        let elem1 = elem.clone();

        let pubsub = PubSub::Create {
            create: Create {
                node: Some(NodeName(String::from("foo"))),
            },
            configure: Some(Configure {
                form: Some(DataForm {
                    type_: DataFormType::Submit,
                    form_type: Some(String::from(ns::PUBSUB_CONFIGURE)),
                    title: None,
                    instructions: None,
                    fields: vec![Field {
                        var: String::from("pubsub#access_model"),
                        type_: FieldType::ListSingle,
                        label: None,
                        required: false,
                        options: vec![],
                        values: vec![String::from("whitelist")],
                        media: vec![],
                    }],
                }),
            }),
        };

        let elem2 = Element::from(pubsub);
        assert_eq!(elem1, elem2);
    }

    #[test]
    fn publish() {
        let elem: Element =
            "<pubsub xmlns='http://jabber.org/protocol/pubsub'><publish node='coucou'/></pubsub>"
                .parse()
                .unwrap();
        let elem1 = elem.clone();
        let pubsub = PubSub::try_from(elem).unwrap();
        match pubsub.clone() {
            PubSub::Publish {
                publish,
                publish_options,
            } => {
                assert_eq!(&publish.node.0, "coucou");
                assert!(publish_options.is_none());
            }
            _ => panic!(),
        }

        let elem2 = Element::from(pubsub);
        assert_eq!(elem1, elem2);
    }

    #[test]
    fn publish_with_publish_options() {
        let elem: Element = "<pubsub xmlns='http://jabber.org/protocol/pubsub'><publish node='coucou'/><publish-options/></pubsub>".parse().unwrap();
        let elem1 = elem.clone();
        let pubsub = PubSub::try_from(elem).unwrap();
        match pubsub.clone() {
            PubSub::Publish {
                publish,
                publish_options,
            } => {
                assert_eq!(&publish.node.0, "coucou");
                assert!(publish_options.unwrap().form.is_none());
            }
            _ => panic!(),
        }

        let elem2 = Element::from(pubsub);
        assert_eq!(elem1, elem2);
    }

    #[test]
    fn invalid_empty_pubsub() {
        let elem: Element = "<pubsub xmlns='http://jabber.org/protocol/pubsub'/>"
            .parse()
            .unwrap();
        let error = PubSub::try_from(elem).unwrap_err();
        let message = match error {
            Error::ParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message, "No payload in pubsub element.");
    }

    #[test]
    fn publish_option() {
        let elem: Element = "<publish-options xmlns='http://jabber.org/protocol/pubsub'><x xmlns='jabber:x:data' type='submit'><field var='FORM_TYPE' type='hidden'><value>http://jabber.org/protocol/pubsub#publish-options</value></field></x></publish-options>".parse().unwrap();
        let publish_options = PublishOptions::try_from(elem).unwrap();
        assert_eq!(
            &publish_options.form.unwrap().form_type.unwrap(),
            "http://jabber.org/protocol/pubsub#publish-options"
        );
    }

    #[test]
    fn subscribe_options() {
        let elem1: Element = "<subscribe-options xmlns='http://jabber.org/protocol/pubsub'/>"
            .parse()
            .unwrap();
        let subscribe_options1 = SubscribeOptions::try_from(elem1).unwrap();
        assert_eq!(subscribe_options1.required, false);

        let elem2: Element = "<subscribe-options xmlns='http://jabber.org/protocol/pubsub'><required/></subscribe-options>".parse().unwrap();
        let subscribe_options2 = SubscribeOptions::try_from(elem2).unwrap();
        assert_eq!(subscribe_options2.required, true);
    }

    #[test]
    fn test_options_without_subscribe() {
        let elem: Element = "<pubsub xmlns='http://jabber.org/protocol/pubsub'><options xmlns='http://jabber.org/protocol/pubsub' jid='juliet@capulet.lit/balcony'><x xmlns='jabber:x:data' type='submit'/></options></pubsub>".parse().unwrap();
        let elem1 = elem.clone();
        let pubsub = PubSub::try_from(elem).unwrap();
        match pubsub.clone() {
            PubSub::Subscribe { subscribe, options } => {
                assert!(subscribe.is_none());
                assert!(options.is_some());
            }
            _ => panic!(),
        }

        let elem2 = Element::from(pubsub);
        assert_eq!(elem1, elem2);
    }

    #[test]
    fn test_serialize_options() {
        let reference: Element = "<options xmlns='http://jabber.org/protocol/pubsub' jid='juliet@capulet.lit/balcony'><x xmlns='jabber:x:data' type='submit'/></options>"
        .parse()
        .unwrap();

        let elem: Element = "<x xmlns='jabber:x:data' type='submit'/>".parse().unwrap();

        let form = DataForm::try_from(elem).unwrap();

        let options = Options {
            jid: Jid::new("juliet@capulet.lit/balcony").unwrap(),
            node: None,
            subid: None,
            form: Some(form),
        };
        let serialized: Element = options.into();
        assert_eq!(serialized, reference);
    }

    #[test]
    fn test_serialize_publish_options() {
        let reference: Element = "<publish-options xmlns='http://jabber.org/protocol/pubsub'><x xmlns='jabber:x:data' type='submit'/></publish-options>"
        .parse()
        .unwrap();

        let elem: Element = "<x xmlns='jabber:x:data' type='submit'/>".parse().unwrap();

        let form = DataForm::try_from(elem).unwrap();

        let options = PublishOptions { form: Some(form) };
        let serialized: Element = options.into();
        assert_eq!(serialized, reference);
    }
}