// 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::{error::Error, FromXml, IntoXml};
use crate::media_element::MediaElement;
use crate::ns::DATA_FORMS;

/// Represents one of the possible values for a list- field.
#[derive(FromXml, IntoXml, Debug, Clone, PartialEq)]
#[xml(namespace = DATA_FORMS, name = "option")]
pub struct Option_ {
    /// The optional label to be displayed to the user for this option.
    #[xml(attribute)]
    pub label: Option<String>,

    /// The value returned to the server when selecting this option.
    #[xml(child(namespace = DATA_FORMS, name = "value", extract(text)))]
    pub value: String,
}

generate_attribute!(
    /// The type of a [field](struct.Field.html) element.
    FieldType, "type", {
        /// This field can only take the values "0" or "false" for a false
        /// value, and "1" or "true" for a true value.
        Boolean => "boolean",

        /// This field describes data, it must not be sent back to the
        /// requester.
        Fixed => "fixed",

        /// This field is hidden, it should not be displayed to the user but
        /// should be sent back to the requester.
        Hidden => "hidden",

        /// This field accepts one or more [JIDs](../../jid/struct.Jid.html).
        /// A client may want to let the user autocomplete them based on their
        /// contacts list for instance.
        JidMulti => "jid-multi",

        /// This field accepts one [JID](../../jid/struct.Jid.html).  A client
        /// may want to let the user autocomplete it based on their contacts
        /// list for instance.
        JidSingle => "jid-single",

        /// This field accepts one or more values from the list provided as
        /// [options](struct.Option_.html).
        ListMulti => "list-multi",

        /// This field accepts one value from the list provided as
        /// [options](struct.Option_.html).
        ListSingle => "list-single",

        /// This field accepts one or more free form text lines.
        TextMulti => "text-multi",

        /// This field accepts one free form password, a client should hide it
        /// in its user interface.
        TextPrivate => "text-private",

        /// This field accepts one free form text line.
        TextSingle => "text-single",
    }, Default = TextSingle
);

fn validate_field(field: &mut Field) -> Result<(), Error> {
    if !field.is_list() && field.options.len() > 0 {
        return Err(Error::ParseError("Option element found in non-list field."));
    }
    Ok(())
}

/// Represents a field in a [data form](struct.DataForm.html).
#[derive(FromXml, IntoXml, Debug, Clone, PartialEq)]
#[xml(namespace = DATA_FORMS, name = "field", validate = validate_field)]
pub struct Field {
    /// The unique identifier for this field, in the form.
    #[xml(attribute)]
    pub var: String,

    /// The type of this field.
    #[xml(attribute(name = "type", default))]
    pub type_: FieldType,

    /// The label to be possibly displayed to the user for this field.
    #[xml(attribute)]
    pub label: Option<String>,

    /// The form will be rejected if this field isn’t present.
    #[xml(flag(namespace = DATA_FORMS, name = "required"))]
    pub required: bool,

    /// A list of allowed values.
    #[xml(children)]
    pub options: Vec<Option_>,

    /// The values provided for this field.
    #[xml(children(namespace = DATA_FORMS, name = "value", extract(text)))]
    pub values: Vec<String>,

    /// A list of media related to this field.
    #[xml(children)]
    pub media: Vec<MediaElement>,
}

impl Field {
    /// Create a new Field, of the given var and type.
    pub fn new(var: &str, type_: FieldType) -> Field {
        Field {
            var: String::from(var),
            type_,
            label: None,
            required: false,
            options: Vec::new(),
            media: Vec::new(),
            values: Vec::new(),
        }
    }

    /// Set only one value in this Field.
    pub fn with_value(mut self, value: &str) -> Field {
        self.values.push(String::from(value));
        self
    }

    /// Create a text-single Field with the given var and unique value.
    pub fn text_single(var: &str, value: &str) -> Field {
        Field::new(var, FieldType::TextSingle).with_value(value)
    }

    fn is_list(&self) -> bool {
        self.type_ == FieldType::ListSingle || self.type_ == FieldType::ListMulti
    }
}

generate_attribute!(
    /// Represents the type of a [data form](struct.DataForm.html).
    DataFormType, "type", {
        /// This is a cancel request for a prior type="form" data form.
        Cancel => "cancel",

        /// This is a request for the recipient to fill this form and send it
        /// back as type="submit".
        Form => "form",

        /// This is a result form, which contains what the requester asked for.
        Result_ => "result",

        /// This is a complete response to a form received before.
        Submit => "submit",
    }
);

/// Extract the FORM_TYPE, if any, and write it into the form_type field.
fn validate_form(form: &mut DataForm) -> Result<(), Error> {
    let mut error: Option<Error> = None;
    form.fields.retain_mut(|field| {
        if field.var == "FORM_TYPE" {
            if form.form_type.is_some() {
                error = Some(Error::ParseError("More than one FORM_TYPE in a data form."));
                return true; // does not matter because we error out
            }
            if field.type_ != FieldType::Hidden {
                error = Some(Error::ParseError("Invalid field type for FORM_TYPE."));
                return true; // does not matter because we error out
            }
            if field.values.len() != 1 {
                error = Some(Error::ParseError("Wrong number of values in FORM_TYPE."));
                return true; // does not matter because we error out
            }
            form.form_type = field.values.pop();
            false
        } else {
            true
        }
    });
    if let Some(error) = error {
        Err(error)
    } else {
        Ok(())
    }
}

/// Inject the form_type, if set, into the fields before emitting.
fn prepare_form(form: &mut DataForm) {
    if let Some(type_) = form.form_type.take() {
        form.fields.insert(
            0,
            Field {
                type_: FieldType::Hidden,
                var: "FORM_TYPE".to_string(),
                label: None,
                media: Vec::new(),
                options: Vec::new(),
                required: false,
                values: vec![type_],
            },
        );
    }
}

/// This is a form to be sent to another entity for filling.
#[derive(FromXml, IntoXml, Debug, Clone, PartialEq)]
#[xml(namespace = DATA_FORMS, name = "x", validate = validate_form, prepare = prepare_form)]
pub struct DataForm {
    /// The type of this form, telling the other party which action to execute.
    #[xml(attribute = "type")]
    pub type_: DataFormType,

    /// An easy accessor for the FORM_TYPE of this form, see
    /// [XEP-0068](https://xmpp.org/extensions/xep-0068.html) for more
    /// information.
    #[xml(ignore)]
    pub form_type: Option<String>,

    /// The title of this form.
    #[xml(child(namespace = DATA_FORMS, name = "title", extract(text), default))]
    pub title: Option<String>,

    /// The instructions given with this form.
    #[xml(child(namespace = DATA_FORMS, name = "instructions", extract(text), default))]
    pub instructions: Option<String>,

    /// A list of fields comprising this form.
    #[xml(children)]
    pub fields: Vec<Field>,
}

impl DataForm {
    /// Create a new DataForm.
    pub fn new(type_: DataFormType, form_type: &str, fields: Vec<Field>) -> DataForm {
        DataForm {
            type_,
            form_type: Some(String::from(form_type)),
            title: None,
            instructions: None,
            fields,
        }
    }
}

/* impl TryFrom<Element> for DataForm {
    type Error = Error;

    fn try_from(elem: Element) -> Result<DataForm, Error> {
        check_self!(elem, "x", DATA_FORMS);
        check_no_unknown_attributes!(elem, "x", ["type"]);
        let type_ = get_attr!(elem, "type", Required);
        let mut form = DataForm {
            type_,
            form_type: None,
            title: None,
            instructions: None,
            fields: vec![],
        };
        for child in elem.children() {
            if child.is("title", ns::DATA_FORMS) {
                if form.title.is_some() {
                    return Err(Error::ParseError("More than one title in form element."));
                }
                check_no_children!(child, "title");
                check_no_attributes!(child, "title");
                form.title = Some(child.text());
            } else if child.is("instructions", ns::DATA_FORMS) {
                if form.instructions.is_some() {
                    return Err(Error::ParseError(
                        "More than one instructions in form element.",
                    ));
                }
                check_no_children!(child, "instructions");
                check_no_attributes!(child, "instructions");
                form.instructions = Some(child.text());
            } else if child.is("field", ns::DATA_FORMS) {
                let field = Field::try_from(child.clone())?;
            } else {
                return Err(Error::ParseError("Unknown child in data form element."));
            }
        }
        Ok(form)
    }
}

impl From<DataForm> for Element {
    fn from(form: DataForm) -> Element {
        Element::builder("x", ns::DATA_FORMS)
            .attr("type", form.type_)
            .append_all(
                form.title
                    .map(|title| Element::builder("title", ns::DATA_FORMS).append(title)),
            )
            .append_all(
                form.instructions
                    .map(|text| Element::builder("instructions", ns::DATA_FORMS).append(text)),
            )
            .append_all(form.form_type.map(|form_type| {
                Element::builder("field", ns::DATA_FORMS)
                    .attr("var", "FORM_TYPE")
                    .attr("type", "hidden")
                    .append(Element::builder("value", ns::DATA_FORMS).append(form_type))
            }))
            .append_all(form.fields.iter().cloned().map(Element::from))
            .build()
    }
} */

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

    use crate::Element;

    #[cfg(target_pointer_width = "32")]
    #[test]
    fn test_size() {
        assert_size!(Option_, 24);
        assert_size!(FieldType, 1);
        assert_size!(Field, 64);
        assert_size!(DataFormType, 1);
        assert_size!(DataForm, 52);
    }

    #[cfg(target_pointer_width = "64")]
    #[test]
    fn test_size() {
        assert_size!(Option_, 48);
        assert_size!(FieldType, 1);
        assert_size!(Field, 128);
        assert_size!(DataFormType, 1);
        assert_size!(DataForm, 104);
    }

    #[test]
    fn test_simple() {
        let elem: Element = "<x xmlns='jabber:x:data' type='result'/>".parse().unwrap();
        let form = DataForm::try_from(elem).unwrap();
        assert_eq!(form.type_, DataFormType::Result_);
        assert!(form.form_type.is_none());
        assert!(form.fields.is_empty());
    }

    #[test]
    fn test_invalid() {
        let elem: Element = "<x xmlns='jabber:x:data'/>".parse().unwrap();
        let error = DataForm::try_from(elem).unwrap_err();
        let message = match error {
            Error::ParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(
            message,
            "Required attribute field 'type_' on DataForm element missing."
        );

        let elem: Element = "<x xmlns='jabber:x:data' type='coucou'/>".parse().unwrap();
        let error = DataForm::try_from(elem).unwrap_err();
        let message = match error {
            Error::ParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message, "Unknown value for 'type' attribute.");
    }

    #[test]
    fn test_wrong_child() {
        let elem: Element = "<x xmlns='jabber:x:data' type='cancel'><coucou/></x>"
            .parse()
            .unwrap();
        let error = DataForm::try_from(elem).unwrap_err();
        let message = match error {
            Error::ParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message, "Unknown child in DataForm element.");
    }

    #[test]
    fn option() {
        let elem: Element =
            "<option xmlns='jabber:x:data' label='Coucou !'><value>coucou</value></option>"
                .parse()
                .unwrap();
        let option = Option_::try_from(elem).unwrap();
        assert_eq!(&option.label.unwrap(), "Coucou !");
        assert_eq!(&option.value, "coucou");

        let elem: Element = "<option xmlns='jabber:x:data' label='Coucou !'/>"
            .parse()
            .unwrap();
        let error = Option_::try_from(elem).unwrap_err();
        let message = match error {
            Error::ParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(message, "Missing child field 'value' in Option_ element.");

        let elem: Element = "<option xmlns='jabber:x:data' label='Coucou !'><value>coucou</value><value>error</value></option>".parse().unwrap();
        let error = Option_::try_from(elem).unwrap_err();
        let message = match error {
            Error::ParseError(string) => string,
            _ => panic!(),
        };
        assert_eq!(
            message,
            "Option_ element must not have more than one child in field 'value'."
        );
    }
}