// Copyright (c) 2017 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 crate::core::{FromXml, IntoXml};
use crate::ns::RSM;

/// Information about the first item in an RSM paged result.
#[derive(FromXml, IntoXml, Debug, Clone, PartialEq)]
#[xml(namespace = RSM, name = "first")]
pub struct First {
    /// The UID of the first item of the page.
    #[xml(text)]
    pub uid: String,

    /// The position of the first item in the full set (which may be
    /// approximate).
    #[xml(attribute)]
    pub index: Option<usize>,
}

/// Requests paging through a potentially big set of items (represented by an
/// UID).
#[derive(FromXml, IntoXml, Debug, Clone, PartialEq)]
#[xml(namespace = RSM, name = "set")]
pub struct SetQuery {
    /// Limit the number of items, or use the recipient’s defaults if None.
    #[xml(child(namespace = RSM, name = "max", extract(text), default))]
    pub max: Option<usize>,

    /// The UID after which to give results, or if None it is the element
    /// “before” the first item, effectively an index of negative one.
    #[xml(child(namespace = RSM, name = "after", extract(text), default))]
    pub after: Option<String>,

    /// The UID before which to give results, or if None it starts with the
    /// last page of the full set.
    #[xml(child(namespace = RSM, name = "before", extract(text), default))]
    pub before: Option<String>,

    /// Numerical index of the page (deprecated).
    #[xml(child(namespace = RSM, name = "index", extract(text), default))]
    pub index: Option<usize>,
}

/// Describes the paging result of a [query](struct.SetQuery.html).
#[derive(FromXml, IntoXml, Debug, Clone, PartialEq)]
#[xml(namespace = RSM, name = "set")]
pub struct SetResult {
    /// UID and index of the first child.
    #[xml(child)]
    pub first: Option<First>,

    /// The UID of the last item of the page.
    #[xml(child(namespace = RSM, name = "last", extract(text), default))]
    pub last: Option<String>,

    /// How many items there are in the full set (which may be approximate).
    #[xml(child(namespace = RSM, name = "count", extract(text), default))]
    pub count: Option<usize>,
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::core::error::Error;
    use crate::Element;

    #[cfg(target_pointer_width = "32")]
    #[test]
    fn test_size() {
        assert_size!(SetQuery, 40);
        assert_size!(SetResult, 40);
    }

    #[cfg(target_pointer_width = "64")]
    #[test]
    fn test_size() {
        assert_size!(SetQuery, 80);
        assert_size!(SetResult, 80);
    }

    #[test]
    fn test_simple() {
        let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'/>"
            .parse()
            .unwrap();
        let set = SetQuery::try_from(elem).unwrap();
        assert_eq!(set.max, None);
        assert_eq!(set.after, None);
        assert_eq!(set.before, None);
        assert_eq!(set.index, None);

        let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'/>"
            .parse()
            .unwrap();
        let set = SetResult::try_from(elem).unwrap();
        match set.first {
            Some(_) => panic!(),
            None => (),
        }
        assert_eq!(set.last, None);
        assert_eq!(set.count, None);
    }

    #[test]
    fn test_unknown() {
        let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>"
            .parse()
            .unwrap();
        let error = SetQuery::try_from(elem.clone()).unwrap_err();
        let returned_elem = match error {
            Error::TypeMismatch(_, _, elem) => elem,
            _ => panic!(),
        };
        assert_eq!(elem, returned_elem);

        let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>"
            .parse()
            .unwrap();
        let error = SetResult::try_from(elem.clone()).unwrap_err();
        let returned_elem = match error {
            Error::TypeMismatch(_, _, elem) => elem,
            _ => panic!(),
        };
        assert_eq!(elem, returned_elem);
    }

    #[test]
    fn test_invalid_child() {
        let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'><coucou/></set>"
            .parse()
            .unwrap();
        let error = SetQuery::try_from(elem).unwrap_err();
        let message = match error {
            Error::ParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message, "Unknown child in SetQuery element.");

        let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'><coucou/></set>"
            .parse()
            .unwrap();
        let error = SetResult::try_from(elem).unwrap_err();
        let message = match error {
            Error::ParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message, "Unknown child in SetResult element.");
    }

    #[test]
    fn test_serialise() {
        let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'/>"
            .parse()
            .unwrap();
        let rsm = SetQuery {
            max: None,
            after: None,
            before: None,
            index: None,
        };
        let elem2 = rsm.into();
        assert_eq!(elem, elem2);

        let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'/>"
            .parse()
            .unwrap();
        let rsm = SetResult {
            first: None,
            last: None,
            count: None,
        };
        let elem2 = rsm.into();
        assert_eq!(elem, elem2);
    }

    #[test]
    fn test_serialise_empty_before() {
        let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'><before/></set>"
            .parse()
            .unwrap();
        let rsm = SetQuery {
            max: None,
            after: None,
            before: Some("".into()),
            index: None,
        };
        let elem2 = rsm.into();
        assert_eq!(elem, elem2);
    }

    #[test]
    fn test_first_index() {
        let elem: Element =
            "<set xmlns='http://jabber.org/protocol/rsm'><first index='4'>coucou</first></set>"
                .parse()
                .unwrap();
        let elem1 = elem.clone();
        let set = SetResult::try_from(elem).unwrap();
        assert_eq!(set.first.as_ref().map(|x| x.uid.as_str()), Some("coucou"));
        assert_eq!(set.first.as_ref().and_then(|x| x.index), Some(4));

        let set2 = SetResult {
            first: Some(First {
                uid: String::from("coucou"),
                index: Some(4),
            }),
            last: None,
            count: None,
        };
        let elem2 = set2.into();
        assert_eq!(elem1, elem2);
    }
}