path: root/src/imap/command/authenticated.rs

use std::collections::BTreeMap;
use std::sync::Arc;
use thiserror::Error;

use anyhow::{anyhow, bail, Result};
use imap_codec::imap_types::command::{
    Command, CommandBody, ListReturnItem, SelectExamineModifier,
};
use imap_codec::imap_types::core::{Atom, Literal, QuotedChar, Vec1};
use imap_codec::imap_types::datetime::DateTime;
use imap_codec::imap_types::extensions::enable::CapabilityEnable;
use imap_codec::imap_types::flag::{Flag, FlagNameAttribute};
use imap_codec::imap_types::mailbox::{ListMailbox, Mailbox as MailboxCodec};
use imap_codec::imap_types::response::{Code, CodeOther, Data};
use imap_codec::imap_types::status::{StatusDataItem, StatusDataItemName};

use crate::imap::capability::{ClientCapability, ServerCapability};
use crate::imap::command::{anystate, MailboxName};
use crate::imap::flow;
use crate::imap::mailbox_view::{MailboxView, UpdateParameters};
use crate::imap::response::Response;
use crate::imap::Body;

use crate::mail::uidindex::*;
use crate::user::User;
use crate::mail::IMF;
use crate::mail::namespace::MAILBOX_HIERARCHY_DELIMITER as MBX_HIER_DELIM_RAW;

pub struct AuthenticatedContext<'a> {
    pub req: &'a Command<'static>,
    pub server_capabilities: &'a ServerCapability,
    pub client_capabilities: &'a mut ClientCapability,
    pub user: &'a Arc<User>,
}

pub async fn dispatch<'a>(
    mut ctx: AuthenticatedContext<'a>,
) -> Result<(Response<'static>, flow::Transition)> {
    match &ctx.req.body {
        // Any state
        CommandBody::Noop => anystate::noop_nothing(ctx.req.tag.clone()),
        CommandBody::Capability => {
            anystate::capability(ctx.req.tag.clone(), ctx.server_capabilities)
        }
        CommandBody::Logout => anystate::logout(),

        // Specific to this state (11 commands)
        CommandBody::Create { mailbox } => ctx.create(mailbox).await,
        CommandBody::Delete { mailbox } => ctx.delete(mailbox).await,
        CommandBody::Rename { from, to } => ctx.rename(from, to).await,
        CommandBody::Lsub {
            reference,
            mailbox_wildcard,
        } => ctx.list(reference, mailbox_wildcard, &[], true).await,
        CommandBody::List {
            reference,
            mailbox_wildcard,
            r#return,
        } => ctx.list(reference, mailbox_wildcard, r#return, false).await,
        CommandBody::Status {
            mailbox,
            item_names,
        } => ctx.status(mailbox, item_names).await,
        CommandBody::Subscribe { mailbox } => ctx.subscribe(mailbox).await,
        CommandBody::Unsubscribe { mailbox } => ctx.unsubscribe(mailbox).await,
        CommandBody::Select { mailbox, modifiers } => ctx.select(mailbox, modifiers).await,
        CommandBody::Examine { mailbox, modifiers } => ctx.examine(mailbox, modifiers).await,
        CommandBody::Append {
            mailbox,
            flags,
            date,
            message,
        } => ctx.append(mailbox, flags, date, message).await,

        // rfc5161 ENABLE
        CommandBody::Enable { capabilities } => ctx.enable(capabilities),

        // Collect other commands
        _ => anystate::wrong_state(ctx.req.tag.clone()),
    }
}

// --- PRIVATE ---
impl<'a> AuthenticatedContext<'a> {
    async fn create(
        self,
        mailbox: &MailboxCodec<'a>,
    ) -> Result<(Response<'static>, flow::Transition)> {
        let name = match mailbox {
            MailboxCodec::Inbox => {
                return Ok((
                    Response::build()
                        .to_req(self.req)
                        .message("Cannot create INBOX")
                        .bad()?,
                    flow::Transition::None,
                ));
            }
            MailboxCodec::Other(aname) => std::str::from_utf8(aname.as_ref())?,
        };

        match self.user.create_mailbox(&name).await {
            Ok(()) => Ok((
                Response::build()
                    .to_req(self.req)
                    .message("CREATE complete")
                    .ok()?,
                flow::Transition::None,
            )),
            Err(e) => Ok((
                Response::build()
                    .to_req(self.req)
                    .message(&e.to_string())
                    .no()?,
                flow::Transition::None,
            )),
        }
    }

    async fn delete(
        self,
        mailbox: &MailboxCodec<'a>,
    ) -> Result<(Response<'static>, flow::Transition)> {
        let name: &str = MailboxName(mailbox).try_into()?;

        match self.user.delete_mailbox(&name).await {
            Ok(()) => Ok((
                Response::build()
                    .to_req(self.req)
                    .message("DELETE complete")
                    .ok()?,
                flow::Transition::None,
            )),
            Err(e) => Ok((
                Response::build()
                    .to_req(self.req)
                    .message(e.to_string())
                    .no()?,
                flow::Transition::None,
            )),
        }
    }

    async fn rename(
        self,
        from: &MailboxCodec<'a>,
        to: &MailboxCodec<'a>,
    ) -> Result<(Response<'static>, flow::Transition)> {
        let name: &str = MailboxName(from).try_into()?;
        let new_name: &str = MailboxName(to).try_into()?;

        match self.user.rename_mailbox(&name, &new_name).await {
            Ok(()) => Ok((
                Response::build()
                    .to_req(self.req)
                    .message("RENAME complete")
                    .ok()?,
                flow::Transition::None,
            )),
            Err(e) => Ok((
                Response::build()
                    .to_req(self.req)
                    .message(e.to_string())
                    .no()?,
                flow::Transition::None,
            )),
        }
    }

    async fn list(
        &mut self,
        reference: &MailboxCodec<'a>,
        mailbox_wildcard: &ListMailbox<'a>,
        must_return: &[ListReturnItem],
        is_lsub: bool,
    ) -> Result<(Response<'static>, flow::Transition)> {
        let mbx_hier_delim: QuotedChar = QuotedChar::unvalidated(MBX_HIER_DELIM_RAW);

        let reference: &str = MailboxName(reference).try_into()?;
        if !reference.is_empty() {
            return Ok((
                Response::build()
                    .to_req(self.req)
                    .message("References not supported")
                    .bad()?,
                flow::Transition::None,
            ));
        }

        let status_item_names = must_return.iter().find_map(|m| match m {
            ListReturnItem::Status(v) => Some(v),
            _ => None,
        });

        // @FIXME would probably need a rewrite to better use the imap_codec library
        let wildcard = match mailbox_wildcard {
            ListMailbox::Token(v) => std::str::from_utf8(v.as_ref())?,
            ListMailbox::String(v) => std::str::from_utf8(v.as_ref())?,
        };
        if wildcard.is_empty() {
            if is_lsub {
                return Ok((
                    Response::build()
                        .to_req(self.req)
                        .message("LSUB complete")
                        .data(Data::Lsub {
                            items: vec![],
                            delimiter: Some(mbx_hier_delim),
                            mailbox: "".try_into().unwrap(),
                        })
                        .ok()?,
                    flow::Transition::None,
                ));
            } else {
                return Ok((
                    Response::build()
                        .to_req(self.req)
                        .message("LIST complete")
                        .data(Data::List {
                            items: vec![],
                            delimiter: Some(mbx_hier_delim),
                            mailbox: "".try_into().unwrap(),
                        })
                        .ok()?,
                    flow::Transition::None,
                ));
            }
        }

        let mailboxes = self.user.list_mailboxes().await?;
        let mut vmailboxes = BTreeMap::new();
        for mb in mailboxes.iter() {
            for (i, _) in mb.match_indices(MBX_HIER_DELIM_RAW) {
                if i > 0 {
                    let smb = &mb[..i];
                    vmailboxes.entry(smb).or_insert(false);
                }
            }
            vmailboxes.insert(mb, true);
        }

        let mut ret = vec![];
        for (mb, is_real) in vmailboxes.iter() {
            if matches_wildcard(&wildcard, mb) {
                let mailbox: MailboxCodec = mb
                    .to_string()
                    .try_into()
                    .map_err(|_| anyhow!("invalid mailbox name"))?;
                let mut items = vec![FlagNameAttribute::from(Atom::unvalidated("Subscribed"))];

                // Decoration
                if !*is_real {
                    items.push(FlagNameAttribute::Noselect);
                } else {
                    match *mb {
                        "Drafts" => items.push(Atom::unvalidated("Drafts").into()),
                        "Archive" => items.push(Atom::unvalidated("Archive").into()),
                        "Sent" => items.push(Atom::unvalidated("Sent").into()),
                        "Trash" => items.push(Atom::unvalidated("Trash").into()),
                        _ => (),
                    };
                }

                // Result type
                if is_lsub {
                    ret.push(Data::Lsub {
                        items,
                        delimiter: Some(mbx_hier_delim),
                        mailbox: mailbox.clone(),
                    });
                } else {
                    ret.push(Data::List {
                        items,
                        delimiter: Some(mbx_hier_delim),
                        mailbox: mailbox.clone(),
                    });
                }

                // Also collect status
                if let Some(sin) = status_item_names {
                    let ret_attrs = match self.status_items(mb, sin).await {
                        Ok(a) => a,
                        Err(e) => {
                            tracing::error!(err=?e, mailbox=%mb, "Unable to fetch status for mailbox");
                            continue;
                        }
                    };

                    let data = Data::Status {
                        mailbox,
                        items: ret_attrs.into(),
                    };

                    ret.push(data);
                }
            }
        }

        let msg = if is_lsub {
            "LSUB completed"
        } else {
            "LIST completed"
        };
        Ok((
            Response::build()
                .to_req(self.req)
                .message(msg)
                .many_data(ret)
                .ok()?,
            flow::Transition::None,
        ))
    }

    async fn status(
        &mut self,
        mailbox: &MailboxCodec<'static>,
        attributes: &[StatusDataItemName],
    ) -> Result<(Response<'static>, flow::Transition)> {
        let name: &str = MailboxName(mailbox).try_into()?;

        let ret_attrs = match self.status_items(name, attributes).await {
            Ok(v) => v,
            Err(e) => match e.downcast_ref::<CommandError>() {
                Some(CommandError::MailboxNotFound) => {
                    return Ok((
                        Response::build()
                            .to_req(self.req)
                            .message("Mailbox does not exist")
                            .no()?,
                        flow::Transition::None,
                    ))
                }
                _ => return Err(e.into()),
            },
        };

        let data = Data::Status {
            mailbox: mailbox.clone(),
            items: ret_attrs.into(),
        };

        Ok((
            Response::build()
                .to_req(self.req)
                .message("STATUS completed")
                .data(data)
                .ok()?,
            flow::Transition::None,
        ))
    }

    async fn status_items(
        &mut self,
        name: &str,
        attributes: &[StatusDataItemName],
    ) -> Result<Vec<StatusDataItem>> {
        let mb_opt = self.user.open_mailbox(name).await?;
        let mb = match mb_opt {
            Some(mb) => mb,
            None => return Err(CommandError::MailboxNotFound.into()),
        };

        let view = MailboxView::new(mb, self.client_capabilities.condstore.is_enabled()).await;

        let mut ret_attrs = vec![];
        for attr in attributes.iter() {
            ret_attrs.push(match attr {
                StatusDataItemName::Messages => StatusDataItem::Messages(view.exists()?),
                StatusDataItemName::Unseen => StatusDataItem::Unseen(view.unseen_count() as u32),
                StatusDataItemName::Recent => StatusDataItem::Recent(view.recent()?),
                StatusDataItemName::UidNext => StatusDataItem::UidNext(view.uidnext()),
                StatusDataItemName::UidValidity => {
                    StatusDataItem::UidValidity(view.uidvalidity())
                }
                StatusDataItemName::Deleted => {
                    bail!("quota not implemented, can't return deleted elements waiting for EXPUNGE");
                },
                StatusDataItemName::DeletedStorage => {
                    bail!("quota not implemented, can't return freed storage after EXPUNGE will be run");
                },
                StatusDataItemName::HighestModSeq => {
                    self.client_capabilities.enable_condstore();
                    StatusDataItem::HighestModSeq(view.highestmodseq().get())
                },
            });
        }
        Ok(ret_attrs)
    }

    async fn subscribe(
        self,
        mailbox: &MailboxCodec<'a>,
    ) -> Result<(Response<'static>, flow::Transition)> {
        let name: &str = MailboxName(mailbox).try_into()?;

        if self.user.has_mailbox(&name).await? {
            Ok((
                Response::build()
                    .to_req(self.req)
                    .message("SUBSCRIBE complete")
                    .ok()?,
                flow::Transition::None,
            ))
        } else {
            Ok((
                Response::build()
                    .to_req(self.req)
                    .message(format!("Mailbox {} does not exist", name))
                    .bad()?,
                flow::Transition::None,
            ))
        }
    }

    async fn unsubscribe(
        self,
        mailbox: &MailboxCodec<'a>,
    ) -> Result<(Response<'static>, flow::Transition)> {
        let name: &str = MailboxName(mailbox).try_into()?;

        if self.user.has_mailbox(&name).await? {
            Ok((
                Response::build()
                    .to_req(self.req)
                    .message(format!(
                        "Cannot unsubscribe from mailbox {}: not supported by Aerogramme",
                        name
                    ))
                    .bad()?,
                flow::Transition::None,
            ))
        } else {
            Ok((
                Response::build()
                    .to_req(self.req)
                    .message(format!("Mailbox {} does not exist", name))
                    .no()?,
                flow::Transition::None,
            ))
        }
    }

    /*
    * TRACE BEGIN ---


    Example:    C: A142 SELECT INBOX
    S: * 172 EXISTS
    S: * 1 RECENT
    S: * OK [UNSEEN 12] Message 12 is first unseen
    S: * OK [UIDVALIDITY 3857529045] UIDs valid
    S: * OK [UIDNEXT 4392] Predicted next UID
    S: * FLAGS (\Answered \Flagged \Deleted \Seen \Draft)
    S: * OK [PERMANENTFLAGS (\Deleted \Seen \*)] Limited
    S: A142 OK [READ-WRITE] SELECT completed

    --- a mailbox with no unseen message -> no unseen entry
    NOTES:
      RFC3501 (imap4rev1) says if there is no OK [UNSEEN] response, client must make no assumption,
                          it is therefore correct to not return it even if there are unseen messages
      RFC9051 (imap4rev2) says that OK [UNSEEN] responses are deprecated after SELECT and EXAMINE
      For Aerogramme, we just don't send the OK [UNSEEN], it's correct to do in both specifications.


    20 select "INBOX.achats"
    * FLAGS (\Answered \Flagged \Deleted \Seen \Draft $Forwarded JUNK $label1)
    * OK [PERMANENTFLAGS (\Answered \Flagged \Deleted \Seen \Draft $Forwarded JUNK $label1 \*)] Flags permitted.
    * 88 EXISTS
    * 0 RECENT
    * OK [UIDVALIDITY 1347986788] UIDs valid
    * OK [UIDNEXT 91] Predicted next UID
    * OK [HIGHESTMODSEQ 72] Highest
    20 OK [READ-WRITE] Select completed (0.001 + 0.000 secs).

    * TRACE END ---
    */
    async fn select(
        self,
        mailbox: &MailboxCodec<'a>,
        modifiers: &[SelectExamineModifier],
    ) -> Result<(Response<'static>, flow::Transition)> {
        self.client_capabilities.select_enable(modifiers);

        let name: &str = MailboxName(mailbox).try_into()?;

        let mb_opt = self.user.open_mailbox(&name).await?;
        let mb = match mb_opt {
            Some(mb) => mb,
            None => {
                return Ok((
                    Response::build()
                        .to_req(self.req)
                        .message("Mailbox does not exist")
                        .no()?,
                    flow::Transition::None,
                ))
            }
        };
        tracing::info!(username=%self.user.username, mailbox=%name, "mailbox.selected");

        let mb = MailboxView::new(mb, self.client_capabilities.condstore.is_enabled()).await;
        let data = mb.summary()?;

        Ok((
            Response::build()
                .message("Select completed")
                .to_req(self.req)
                .code(Code::ReadWrite)
                .set_body(data)
                .ok()?,
            flow::Transition::Select(mb, flow::MailboxPerm::ReadWrite),
        ))
    }

    async fn examine(
        self,
        mailbox: &MailboxCodec<'a>,
        modifiers: &[SelectExamineModifier],
    ) -> Result<(Response<'static>, flow::Transition)> {
        self.client_capabilities.select_enable(modifiers);

        let name: &str = MailboxName(mailbox).try_into()?;

        let mb_opt = self.user.open_mailbox(&name).await?;
        let mb = match mb_opt {
            Some(mb) => mb,
            None => {
                return Ok((
                    Response::build()
                        .to_req(self.req)
                        .message("Mailbox does not exist")
                        .no()?,
                    flow::Transition::None,
                ))
            }
        };
        tracing::info!(username=%self.user.username, mailbox=%name, "mailbox.examined");

        let mb = MailboxView::new(mb, self.client_capabilities.condstore.is_enabled()).await;
        let data = mb.summary()?;

        Ok((
            Response::build()
                .to_req(self.req)
                .message("Examine completed")
                .code(Code::ReadOnly)
                .set_body(data)
                .ok()?,
            flow::Transition::Select(mb, flow::MailboxPerm::ReadOnly),
        ))
    }

    //@FIXME we should write a specific version for the "selected" state
    //that returns some unsollicited responses
    async fn append(
        self,
        mailbox: &MailboxCodec<'a>,
        flags: &[Flag<'a>],
        date: &Option<DateTime>,
        message: &Literal<'a>,
    ) -> Result<(Response<'static>, flow::Transition)> {
        let append_tag = self.req.tag.clone();
        match self.append_internal(mailbox, flags, date, message).await {
            Ok((_mb_view, uidvalidity, uid, _modseq)) => Ok((
                Response::build()
                    .tag(append_tag)
                    .message("APPEND completed")
                    .code(Code::Other(CodeOther::unvalidated(
                        format!("APPENDUID {} {}", uidvalidity, uid).into_bytes(),
                    )))
                    .ok()?,
                flow::Transition::None,
            )),
            Err(e) => Ok((
                Response::build()
                    .tag(append_tag)
                    .message(e.to_string())
                    .no()?,
                flow::Transition::None,
            )),
        }
    }

    fn enable(
        self,
        cap_enable: &Vec1<CapabilityEnable<'static>>,
    ) -> Result<(Response<'static>, flow::Transition)> {
        let mut response_builder = Response::build().to_req(self.req);
        let capabilities = self.client_capabilities.try_enable(cap_enable.as_ref());
        if capabilities.len() > 0 {
            response_builder = response_builder.data(Data::Enabled { capabilities });
        }
        Ok((
            response_builder.message("ENABLE completed").ok()?,
            flow::Transition::None,
        ))
    }

    //@FIXME should be refactored and integrated to the mailbox view
    pub(crate) async fn append_internal(
        self,
        mailbox: &MailboxCodec<'a>,
        flags: &[Flag<'a>],
        date: &Option<DateTime>,
        message: &Literal<'a>,
    ) -> Result<(MailboxView, ImapUidvalidity, ImapUid, ModSeq)> {
        let name: &str = MailboxName(mailbox).try_into()?;

        let mb_opt = self.user.open_mailbox(&name).await?;
        let mb = match mb_opt {
            Some(mb) => mb,
            None => bail!("Mailbox does not exist"),
        };
        let mut view = MailboxView::new(mb, self.client_capabilities.condstore.is_enabled()).await;

        if date.is_some() {
            tracing::warn!("Cannot set date when appending message");
        }

        let msg =
            IMF::try_from(message.data()).map_err(|_| anyhow!("Could not parse e-mail message"))?;
        let flags = flags.iter().map(|x| x.to_string()).collect::<Vec<_>>();
        // TODO: filter allowed flags? ping @Quentin

        let (uidvalidity, uid, modseq) =
            view.internal.mailbox.append(msg, None, &flags[..]).await?;
        //let unsollicited = view.update(UpdateParameters::default()).await?;

        Ok((view, uidvalidity, uid, modseq))
    }
}

fn matches_wildcard(wildcard: &str, name: &str) -> bool {
    let wildcard = wildcard.chars().collect::<Vec<char>>();
    let name = name.chars().collect::<Vec<char>>();

    let mut matches = vec![vec![false; wildcard.len() + 1]; name.len() + 1];

    for i in 0..=name.len() {
        for j in 0..=wildcard.len() {
            matches[i][j] = (i == 0 && j == 0)
                || (j > 0
                    && matches[i][j - 1]
                    && (wildcard[j - 1] == '%' || wildcard[j - 1] == '*'))
                || (i > 0
                    && j > 0
                    && matches[i - 1][j - 1]
                    && wildcard[j - 1] == name[i - 1]
                    && wildcard[j - 1] != '%'
                    && wildcard[j - 1] != '*')
                || (i > 0
                    && j > 0
                    && matches[i - 1][j]
                    && (wildcard[j - 1] == '*'
                        || (wildcard[j - 1] == '%' && name[i - 1] != MBX_HIER_DELIM_RAW)));
        }
    }

    matches[name.len()][wildcard.len()]
}

#[derive(Error, Debug)]
pub enum CommandError {
    #[error("Mailbox not found")]
    MailboxNotFound,
}

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

    #[test]
    fn test_wildcard_matches() {
        assert!(matches_wildcard("INBOX", "INBOX"));
        assert!(matches_wildcard("*", "INBOX"));
        assert!(matches_wildcard("%", "INBOX"));
        assert!(!matches_wildcard("%", "Test.Azerty"));
        assert!(!matches_wildcard("INBOX.*", "INBOX"));
        assert!(matches_wildcard("Sent.*", "Sent.A"));
        assert!(matches_wildcard("Sent.*", "Sent.A.B"));
        assert!(!matches_wildcard("Sent.%", "Sent.A.B"));
    }
}