use AddressType;
use AutocryptHeader;
use AutocryptHeaderList;
use DecryptFlags;
use Error;
use InternetAddressList;
use Object;
use ffi;
use glib;
use glib::object::IsA;
use glib::translate::*;
use glib_ffi;
use gobject_ffi;
use std::mem;
use std::ptr;

glib_wrapper! {
    /// A MIME Message object.
    ///
    /// # Implements
    ///
    /// [`MessageExt`](trait.MessageExt.html), [`ObjectExt`](trait.ObjectExt.html)
    pub struct Message(Object<ffi::GMimeMessage, ffi::GMimeMessageClass>): Object;

    match fn {
        get_type => || ffi::g_mime_message_get_type(),
    }
}

impl Message {
    /// If `pretty_headers` is `true`, then the standard rfc822 headers are
    /// initialized so as to put headers in a nice friendly order. This is
    /// strictly a cosmetic thing, so if you are unsure, it is safe to say
    /// no (`false`).
    /// ## `pretty_headers`
    /// make pretty headers
    ///
    /// # Returns
    ///
    /// an empty `Message` object.
    pub fn new(pretty_headers: bool) -> Message {
        unsafe {
            from_glib_full(ffi::g_mime_message_new(pretty_headers.to_glib()))
        }
    }
}

/// Trait containing all `Message` methods.
///
/// # Implementors
///
/// [`Message`](struct.Message.html)
pub trait MessageExt {
    /// Add a mailbox of a chosen type to the MIME message.
    ///
    /// Note: The `name` (and `addr`) strings should be in UTF-8.
    /// ## `type_`
    /// A `AddressType`
    /// ## `name`
    /// The name of the mailbox (or `None`)
    /// ## `addr`
    /// The address of the mailbox
    fn add_mailbox(&self, type_: AddressType, name: &str, addr: &str);

    //fn foreach<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, callback: /*Unknown conversion*//*Unimplemented*/ObjectForeachFunc, user_data: P);

    /// Gets a list of addresses of the specified `type_` from the `self`.
    /// ## `type_`
    /// A `AddressType`
    ///
    /// # Returns
    ///
    /// a list of addresses of the specified
    /// `type_` from the `self`.
    fn get_addresses(&self, type_: AddressType) -> Option<InternetAddressList>;

    /// Gets the complete list of recipients for `self`.
    ///
    /// # Returns
    ///
    /// a newly allocated `InternetAddressList`
    /// containing all recipients of the message or `None` if no recipients
    /// are set.
    fn get_all_recipients(&self) -> Option<InternetAddressList>;

    /// Creates a new `AutocryptHeaderList` of relevant headers of the
    /// given type based on the recipient(s) of an e-mail message.
    ///
    /// Returns the same object as
    /// `g_mime_message_get_autocrypt_gossip_headers_with_inner_part` , but
    /// handles decryption and cleanup automatically.
    ///
    /// `flags` and `session_key` are passed through to
    /// `MultipartEncryptedExt::decrypt`, as needed.
    ///
    /// If the message is not actually an encrypted message, returns `None`:
    /// it should be ignored for purposes of evaluating gossip.
    ///
    /// If decryption fails, returns `None`. In this case, an exception
    /// will be set on `err` to provide information about the decryption
    /// failure.
    /// ## `now`
    /// a `glib::DateTime` object, or `None`
    /// ## `flags`
    /// a `DecryptFlags`, to be used during decryption
    /// ## `session_key`
    /// session key to use or `None`
    ///
    /// # Returns
    ///
    /// a new `AutocryptHeaderList` object,
    /// or `None` on error.
    fn get_autocrypt_gossip_headers(&self, now: &glib::DateTime, flags: DecryptFlags, session_key: &str) -> Result<AutocryptHeaderList, Error>;

    /// Creates a new `AutocryptHeaderList` of relevant headers of the
    /// given type based on the recipient(s) of an e-mail message.
    ///
    /// You must pass the decrypted inner part of the message to this
    /// function, since Autocrypt-Gossip headers are only stored within the
    /// encrypted layer.
    ///
    /// If you don't already have the decrypted inner part available to
    /// you, you probably want to use
    /// `MessageExt::get_autocrypt_gossip_headers` instead.
    ///
    /// Each header in the returned list will:
    ///
    ///  - have a valid address
    ///  - be of the type requested
    ///  - be complete
    ///
    /// If no Autocrypt header is found for a recipient, no
    /// `AutocryptHeader` will be in the list associated with that e-mail address.
    ///
    /// Note that the following types of Autocrypt headers will not be
    /// returned by this function:
    ///
    ///  - headers of an unrequested type
    ///  - headers that do not match an address in "From:"
    ///  - unparseable headers
    ///  - headers with unknown critical attributes
    ///  - duplicate valid headers for a given address
    ///
    /// On error (e.g. if this version of GMime cannot handle the requested
    /// Autocrypt type, or if a parameter is missing or malformed), returns
    /// `None`
    ///
    /// The returned Autocrypt headers will have their effective_date set
    /// to the earliest of either:
    ///
    /// - the Date: header of the message or
    /// - `now` (or the current time, if `now` is `None`)
    /// ## `now`
    /// a `glib::DateTime` object, or `None`
    /// ## `inner_part`
    /// a `Object` which is the cleartext part of the inner message
    ///
    /// # Returns
    ///
    /// a new `AutocryptHeaderList` object, or `None` on error.
    fn get_autocrypt_gossip_headers_from_inner_part<P: IsA<Object>>(&self, now: &glib::DateTime, inner_part: &P) -> Option<AutocryptHeaderList>;

    /// Creates a new `AutocryptHeader` base on the relevant Autocrypt
    /// header associated with the sender of an e-mail message.
    ///
    /// If the message has no sender in the From: field, or has more than
    /// one sender, then this function will return `None`. Autocrypt should
    /// ignore the message entirely.
    ///
    /// If there is one sender, but no single Autocrypt header is found
    /// that matches that e-mail address, a `AutocryptHeader` will be
    /// returned for the sender, but it will be incomplete (see
    /// `AutocryptHeaderExt::is_complete`).
    ///
    /// Note that the following types of Autocrypt headers will not be
    /// returned by this function:
    ///
    ///  - headers that do not match an address in "From:"
    ///  - unparseable headers
    ///  - headers with unknown critical attributes
    ///  - duplicate valid headers for the sender's address
    ///
    /// The returned Autocrypt headers will have their effective_date set
    /// to the earliest of either:
    ///
    /// - the Date: header of the message or
    /// - `now` (or the current time, if `now` is `None`)
    /// ## `now`
    /// a `glib::DateTime` object, or `None`
    ///
    /// # Returns
    ///
    /// a new `AutocryptHeaderList` object,
    /// or `None` if the message should be ignored for purposes of
    /// Autocrypt.
    fn get_autocrypt_header(&self, now: &glib::DateTime) -> Option<AutocryptHeader>;

    /// Gets combined list of parsed addresses in the Bcc header(s).
    ///
    /// # Returns
    ///
    /// the parsed list of addresses in the Bcc header(s).
    fn get_bcc(&self) -> Option<InternetAddressList>;

    /// Attempts to identify the MIME part containing the body of the
    /// message.
    ///
    /// # Returns
    ///
    /// a `Object` containing the textual
    /// content that appears to be the main body of the message.
    ///
    /// Note: This function is NOT guaranteed to always work as it
    /// makes some assumptions that are not necessarily true. It is
    /// recommended that you traverse the MIME structure yourself.
    fn get_body(&self) -> Option<Object>;

    /// Gets combined list of parsed addresses in the Cc header(s).
    ///
    /// # Returns
    ///
    /// the parsed list of addresses in the Cc header(s).
    fn get_cc(&self) -> Option<InternetAddressList>;

    /// Gets the parsed date and time value from the Date header.
    ///
    /// # Returns
    ///
    /// a `glib::DateTime` on success or `None` if the date could not be parsed.
    fn get_date(&self) -> Option<glib::DateTime>;

    /// Gets the parsed list of addresses in the From header.
    ///
    /// # Returns
    ///
    /// the parsed list of addresses in the From header.
    fn get_from(&self) -> Option<InternetAddressList>;

    /// Gets the Message-Id header of `self`.
    ///
    /// # Returns
    ///
    /// the Message-Id of a message.
    fn get_message_id(&self) -> Option<String>;

    /// Gets the toplevel MIME part contained within `self`.
    ///
    /// # Returns
    ///
    /// the toplevel MIME part of `self`.
    fn get_mime_part(&self) -> Option<Object>;

    /// Gets the parsed list of addresses in the Reply-To header.
    ///
    /// # Returns
    ///
    /// the parsed list of addresses in the Reply-To header.
    fn get_reply_to(&self) -> Option<InternetAddressList>;

    /// Gets the parsed list of addresses in the Sender header.
    ///
    /// # Returns
    ///
    /// the parsed list of addresses in the Sender header.
    fn get_sender(&self) -> Option<InternetAddressList>;

    /// Gets the subject of the `self`.
    ///
    /// # Returns
    ///
    /// the subject of the `self` in a form suitable for display
    /// or `None` if no subject is set. If not `None`, the returned string
    /// will be in UTF-8.
    fn get_subject(&self) -> Option<String>;

    /// Gets combined list of parsed addresses in the To header(s).
    ///
    /// # Returns
    ///
    /// the parsed list of addresses in the To header(s).
    fn get_to(&self) -> Option<InternetAddressList>;

    fn split(&self, max_size: usize) -> Vec<Message>;

    /// Sets the Date header on a MIME Message.
    /// ## `date`
    /// a date to be used in the Date header
    fn set_date(&self, date: &glib::DateTime);

    /// Set the Message-Id on a message.
    /// ## `message_id`
    /// message-id (addr-spec portion)
    fn set_message_id(&self, message_id: &str);

    /// Set the root-level MIME part of the message.
    /// ## `mime_part`
    /// The root-level MIME Part
    fn set_mime_part<P: IsA<Object>>(&self, mime_part: &P);

    /// Set the subject of a `self`.
    ///
    /// Note: The `subject` string should be in UTF-8.
    /// ## `subject`
    /// Subject string
    /// ## `charset`
    /// The charset to use for encoding the subject or `None` to use the default
    fn set_subject(&self, subject: &str, charset: &str);
}

impl<O: IsA<Message>> MessageExt for O {
    fn add_mailbox(&self, type_: AddressType, name: &str, addr: &str) {
        unsafe {
            ffi::g_mime_message_add_mailbox(self.to_glib_none().0, type_.to_glib(), name.to_glib_none().0, addr.to_glib_none().0);
        }
    }

    //fn foreach<P: Into<Option</*Unimplemented*/Fundamental: Pointer>>>(&self, callback: /*Unknown conversion*//*Unimplemented*/ObjectForeachFunc, user_data: P) {
    //    unsafe { TODO: call ffi::g_mime_message_foreach() }
    //}

    fn get_addresses(&self, type_: AddressType) -> Option<InternetAddressList> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_addresses(self.to_glib_none().0, type_.to_glib()))
        }
    }

    fn get_all_recipients(&self) -> Option<InternetAddressList> {
        unsafe {
            from_glib_full(ffi::g_mime_message_get_all_recipients(self.to_glib_none().0))
        }
    }

    fn get_autocrypt_gossip_headers(&self, now: &glib::DateTime, flags: DecryptFlags, session_key: &str) -> Result<AutocryptHeaderList, Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_mime_message_get_autocrypt_gossip_headers(self.to_glib_none().0, now.to_glib_none().0, flags.to_glib(), session_key.to_glib_none().0, &mut error);
            if error.is_null() { Ok(from_glib_full(ret)) } else { Err(from_glib_full(error)) }
        }
    }

    fn get_autocrypt_gossip_headers_from_inner_part<P: IsA<Object>>(&self, now: &glib::DateTime, inner_part: &P) -> Option<AutocryptHeaderList> {
        unsafe {
            from_glib_full(ffi::g_mime_message_get_autocrypt_gossip_headers_from_inner_part(self.to_glib_none().0, now.to_glib_none().0, inner_part.to_glib_none().0))
        }
    }

    fn get_autocrypt_header(&self, now: &glib::DateTime) -> Option<AutocryptHeader> {
        unsafe {
            from_glib_full(ffi::g_mime_message_get_autocrypt_header(self.to_glib_none().0, now.to_glib_none().0))
        }
    }

    fn get_bcc(&self) -> Option<InternetAddressList> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_bcc(self.to_glib_none().0))
        }
    }

    fn get_body(&self) -> Option<Object> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_body(self.to_glib_none().0))
        }
    }

    fn get_cc(&self) -> Option<InternetAddressList> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_cc(self.to_glib_none().0))
        }
    }

    fn get_date(&self) -> Option<glib::DateTime> {
        unsafe {
            from_glib_full(ffi::g_mime_message_get_date(self.to_glib_none().0))
        }
    }

    fn get_from(&self) -> Option<InternetAddressList> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_from(self.to_glib_none().0))
        }
    }

    fn get_message_id(&self) -> Option<String> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_message_id(self.to_glib_none().0))
        }
    }

    fn get_mime_part(&self) -> Option<Object> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_mime_part(self.to_glib_none().0))
        }
    }

    fn get_reply_to(&self) -> Option<InternetAddressList> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_reply_to(self.to_glib_none().0))
        }
    }

    fn get_sender(&self) -> Option<InternetAddressList> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_sender(self.to_glib_none().0))
        }
    }

    fn get_subject(&self) -> Option<String> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_subject(self.to_glib_none().0))
        }
    }

    fn get_to(&self) -> Option<InternetAddressList> {
        unsafe {
            from_glib_none(ffi::g_mime_message_get_to(self.to_glib_none().0))
        }
    }

    fn split(&self, max_size: usize) -> Vec<Message> {
        unsafe {
            let mut n_parts = mem::uninitialized();
            let parts = ffi::g_mime_message_partial_split_message(self.to_glib_none().0, max_size, &mut n_parts);
            FromGlibContainer::from_glib_full_num(parts, n_parts as usize)
        }
    }

    fn set_date(&self, date: &glib::DateTime) {
        unsafe {
            ffi::g_mime_message_set_date(self.to_glib_none().0, date.to_glib_none().0);
        }
    }

    fn set_message_id(&self, message_id: &str) {
        unsafe {
            ffi::g_mime_message_set_message_id(self.to_glib_none().0, message_id.to_glib_none().0);
        }
    }

    fn set_mime_part<P: IsA<Object>>(&self, mime_part: &P) {
        unsafe {
            ffi::g_mime_message_set_mime_part(self.to_glib_none().0, mime_part.to_glib_none().0);
        }
    }

    fn set_subject(&self, subject: &str, charset: &str) {
        unsafe {
            ffi::g_mime_message_set_subject(self.to_glib_none().0, subject.to_glib_none().0, charset.to_glib_none().0);
        }
    }
}