1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! # Backend context
//!
//! The [`BackendContext`] is usually used for storing clients or
//! sessions (structures than cannot be cloned or sync). The
//! [`BackendContextBuilder`] gives instructions on how to build such
//! context. It is used by the backend builder.

use async_trait::async_trait;
use paste::paste;

use crate::{
    envelope::{get::GetEnvelope, list::ListEnvelopes, watch::WatchEnvelopes},
    flag::{add::AddFlags, remove::RemoveFlags, set::SetFlags},
    folder::{
        add::AddFolder, delete::DeleteFolder, expunge::ExpungeFolder, list::ListFolders,
        purge::PurgeFolder,
    },
    message::{
        add::AddMessage, copy::CopyMessages, delete::DeleteMessages, get::GetMessages,
        peek::PeekMessages, r#move::MoveMessages, remove::RemoveMessages, send::SendMessage,
    },
    AnyResult,
};

use super::feature::{BackendFeature, CheckUp};

/// The backend context.
///
/// This is just a marker for other backend traits. Every backend
/// context needs to implement this trait manually or to derive
/// [`crate::backend_v2::macros::BackendContextV2`].
pub trait BackendContext: Send + Sync {}

/// Macro for defining [`BackendContextBuilder`] features.
macro_rules! feature {
    ($feat:ty) => {
        paste! {
            /// Define the given backend feature.
            fn [<$feat:snake>](&self) -> Option<BackendFeature<Self::Context, dyn $feat>> {
                None
            }
        }
    };
}

/// The backend context builder.
///
/// This trait defines how a context should be built. It also defines
/// default backend features implemented by the context itself.
#[async_trait]
pub trait BackendContextBuilder: Clone + Send + Sync {
    /// The type of the context being built by this builder.
    type Context: BackendContext;

    feature!(CheckUp);

    feature!(AddFolder);
    feature!(ListFolders);
    feature!(ExpungeFolder);
    feature!(PurgeFolder);
    feature!(DeleteFolder);
    feature!(GetEnvelope);
    feature!(ListEnvelopes);
    feature!(WatchEnvelopes);
    feature!(AddFlags);
    feature!(SetFlags);
    feature!(RemoveFlags);
    feature!(AddMessage);
    feature!(SendMessage);
    feature!(PeekMessages);
    feature!(GetMessages);
    feature!(CopyMessages);
    feature!(MoveMessages);
    feature!(DeleteMessages);
    feature!(RemoveMessages);

    /// Build the final context used by the backend.
    async fn build(self) -> AnyResult<Self::Context>;

    #[cfg(feature = "account-sync")]
    fn try_to_sync_cache_builder(
        &self,
        account_config: &crate::account::config::AccountConfig,
    ) -> std::result::Result<crate::maildir::MaildirContextBuilder, crate::account::Error>
    where
        Self: crate::sync::hash::SyncHash,
    {
        use dirs::data_dir;
        use log::debug;
        use shellexpand_utils::try_shellexpand_path;
        use std::{
            hash::{DefaultHasher, Hasher},
            sync::Arc,
        };

        use crate::{
            account::{config::AccountConfig, Error},
            maildir::{config::MaildirConfig, MaildirContextBuilder},
        };

        let mut hasher = DefaultHasher::new();
        self.sync_hash(&mut hasher);
        let hash = format!("{:x}", hasher.finish());

        let account_config = Arc::new(AccountConfig {
            name: account_config.name.clone(),
            email: account_config.email.clone(),
            display_name: account_config.display_name.clone(),
            signature: account_config.signature.clone(),
            signature_delim: account_config.signature_delim.clone(),
            downloads_dir: account_config.downloads_dir.clone(),
            folder: account_config.folder.clone(),
            envelope: account_config.envelope.clone(),
            flag: account_config.flag.clone(),
            message: account_config.message.clone(),
            template: account_config.template.clone(),
            sync: None,
            #[cfg(feature = "pgp")]
            pgp: account_config.pgp.clone(),
        });

        let sync_dir = account_config.sync.as_ref().and_then(|c| c.dir.as_ref());
        let root_dir = match sync_dir {
            Some(dir) => {
                let sync_dir = try_shellexpand_path(dir)
                    .map_err(|err| Error::GetSyncDirInvalidError(err, dir.clone()))?;
                debug!("using custom sync dir {sync_dir:?}");
                sync_dir
            }
            None => {
                let sync_dir = data_dir()
                    .ok_or(Error::GetXdgDataDirSyncError)?
                    .join("pimalaya")
                    .join("email")
                    .join("sync")
                    .join(&hash);
                debug!("using default sync dir {sync_dir:?}");
                sync_dir
            }
        };
        let config = Arc::new(MaildirConfig { root_dir });
        let ctx = MaildirContextBuilder::new(account_config.clone(), config);

        Ok(ctx)
    }
}