//! This crate provides a unified config file for all tools that are part of the [Vomit project](https://sr.ht/~bitfehler/vomit).
//!
//! It aims to provide configuration options for various aspects of email accounts. Most tools will only need a subset of the
//! available options, but once an account is fully configured, all tools will be able to work with it.
//!
//! While written for the Vomit project, this is essentially a generic email account configuration library. If you think it
//! might be useful for you feel free to use outside of Vomit.
//!
//! The standard location is `$XDG_CONFIG_DIR`/vomit/config.toml, which usually means `~/.config/vomit/config.toml`.
//!
//! Projects using this will have their own documentation about which values they require. Here is a sample with
//! all available options (though some commented out), including comments on their usage:
//!
//! ```toml
//! ## This section defines one account named "example". Most tools
//! ## support multiple accounts. If not specified, tools should default
//! ## to the first account in the config file.
//! [example]
//! ## `local` defaults to "~/.maildir", but can be set explicitly:
//! local = '/home/test/.maildir'
//! ## The mail server. Must support IMAPS
//! remote = 'imap.example.com'
//! ## Login name for the mail server
//! user = 'johndoe'
//! ## Password for the mail server. Can be set explicitly:
//! #password = 'hunter1'
//! ## but that's not great for security. Instead use a command,
//! ## e.g. to interact with your password manager
//! pass-cmd = 'pass show mail/example.com'
//! ## If sending mail is handled by a different server (i.e. a dedicated
//! ## SMTP server), override it like this:
//! send.remote = 'smtp.example.com'
//! ## Some mail setups even have different credentials for sending mail,
//! ## So those can be overridden, too:
//! send.user = 'johndoe@example.com'
//! ## See password and pass-cmd above:
//! #send.password = 's3cr3t'
//! send.pass-cmd = 'pass show mail/smtp.example.com'
//! ```

use std::fs;
use std::io;
use std::path::{Path, PathBuf};
use std::process::Command;

use dirs::{config_dir, home_dir};
use shellexpand::tilde;
use thiserror::Error;

const DEFAULT_MAILDIR: &str = "~/.maildir";

#[derive(Error, Debug)]
pub enum ConfigError {
    #[error("error getting default config file location")]
    DirError,
    #[error("error reading config file: {0}")]
    IOError(#[from] io::Error),
    #[error("error executing pass-cmd: {0}")]
    PassExecError(String),
    #[error("UTF-8 error: {0}")]
    UTF8Error(#[from] std::string::FromUtf8Error),
    #[error("error parsing config file: {0}")]
    TOMLError(#[from] toml::de::Error),
    #[error("config error: {0}")]
    Error(&'static str),
}

/// Represents the configuration of a specific account
pub struct Account<'a> {
    name: String,
    settings: &'a toml::value::Table,
    // Keep a copy of this, as it is potentially computed (tilde expansion)
    maildir_: String,
}

/// Represents a complete config file, which can hold multiple [Accounts](Account)
pub struct Config {
    cfg: toml::value::Table,
}

impl Config {
    /// Returns a specific account's configuration
    ///
    /// # Arguments
    ///
    /// * `name` - The name of the account. If `None`, returns the configuration of the first account in the config file.
    pub fn for_account(&self, name: Option<String>) -> Option<Account> {
        let name = match &name {
            Some(n) => n,
            // Leaving this a .expect() as load() already checks that there is an account
            None => self.cfg.keys().next().expect("no account found"),
        };

        if let Some(a) = self.cfg.get(name) {
            if let Some(t) = a.as_table() {
                // Compute the local maildir
                let mut path = DEFAULT_MAILDIR;
                if let Some(l) = t.get("local") {
                    if let Some(p) = l.as_str() {
                        path = p
                    }
                };

                return Some(Account {
                    name: String::from(name),
                    settings: t,
                    maildir_: tilde(path).into_owned(),
                });
            }
        }
        None
    }
}

impl Account<'_> {
    /// The name of the account
    pub fn name(&self) -> &String {
        &self.name
    }

    /// The directory where mail is stored locally in maildir format
    pub fn maildir(&self) -> &str {
        &self.maildir_
    }

    /// The remote IMAP server
    pub fn remote(&self) -> Option<&str> {
        return self.settings.get("remote").and_then(|v| v.as_str());
    }

    /// The user name to log in to the remote server
    pub fn user(&self) -> Option<&str> {
        return self.settings.get("user").and_then(|v| v.as_str());
    }

    /// The user name to log in when sending mail
    ///
    /// If not explicitly configured, this returns the value of [user()](Account::user).
    pub fn send_user(&self) -> Option<&str> {
        let v = self
            .settings
            .get("send")
            .and_then(|v| v.as_table())
            .and_then(|v| v.get("user"))
            .and_then(|v| v.as_str());
        v.or_else(|| self.user())
    }

    /// The remote SMTP server
    ///
    /// If not explicitly configured, this returns the value of [remote()](Account::remote).
    pub fn send_remote(&self) -> Option<&str> {
        let v = self
            .settings
            .get("send")
            .and_then(|v| v.as_table())
            .and_then(|v| v.get("remote"))
            .and_then(|v| v.as_str());
        v.or_else(|| self.remote())
    }

    fn pass_cmd(cmd: &str) -> Result<Option<String>, ConfigError> {
        let out = Command::new("sh").arg("-c").arg(cmd).output();
        match out {
            Ok(mut output) => {
                let newline: u8 = 10;
                if Some(&newline) == output.stdout.last() {
                    _ = output.stdout.pop(); // remove trailing newline
                }
                Ok(Some(String::from_utf8(output.stdout)?))
            }
            Err(e) => Err(ConfigError::PassExecError(e.to_string())),
        }
    }

    /// The password to log in to the remote server
    ///
    /// Potentially executes a configured command to retrieve the password.
    /// Returns an error if the password command has to be executed and fails. Can return `Ok(None)` if neither
    /// a password nor a password command are configured. Otherwise, returns the password.
    pub fn password(&self) -> Result<Option<String>, ConfigError> {
        if let Some(p) = self.settings.get("password").and_then(|v| v.as_str()) {
            return Ok(Some(String::from(p)));
        } else if let Some(cmd) = self.settings.get("pass-cmd").and_then(|v| v.as_str()) {
            return Account::pass_cmd(cmd);
        }
        Ok(None)
    }

    /// The password to log in to the remote server for sending mail
    ///
    /// Potentially executes a configured command to retrieve the password.
    /// Returns an error if the password command has to be executed and fails. Can return `Ok(None)` if neither
    /// a password nor a password command are configured. Otherwise, returns the password.
    ///
    /// Unless explicitly configured by the user, this returns the value of [password()](Account::password).
    pub fn send_password(&self) -> Result<Option<String>, ConfigError> {
        let pass = self
            .settings
            .get("send")
            .and_then(|v| v.as_table())
            .and_then(|v| v.get("password"))
            .and_then(|v| v.as_str());
        if let Some(p) = pass {
            return Ok(Some(String::from(p)));
        }

        let pcmd = self
            .settings
            .get("send")
            .and_then(|v| v.as_table())
            .and_then(|v| v.get("pass-cmd"))
            .and_then(|v| v.as_str());
        if let Some(cmd) = pcmd {
            return Account::pass_cmd(cmd);
        }
        self.password()
    }
}

/// Returns the (system dependent) default path to the configuration file
///
/// Can fail if the user's home directory cannot be determined.
pub fn default_path() -> Result<PathBuf, ConfigError> {
    if let Some(mut path) = config_dir() {
        // let mut cfg = PathBuf::from(path);
        path.push("vomit");
        path.push("config.toml");
        return Ok(path);
    };
    if let Some(mut path) = home_dir() {
        path.push(".vomitrc");
        return Ok(path);
    }
    Err(ConfigError::DirError)
}

/// Load a configuration file
///
/// # Arguments
///
/// * `path` - the path to load the file from. If `None`, load it from the default location.
///
/// See [default_path] for the default location.
pub fn load<P: AsRef<Path>>(path: Option<P>) -> Result<Config, ConfigError> {
    let contents = match path {
        Some(p) => fs::read_to_string(p)?,
        None => fs::read_to_string(default_path()?)?,
    };

    let value = contents.parse::<toml::Value>()?;
    let table: toml::value::Table = value.try_into()?;

    if table.is_empty() {
        Err(ConfigError::Error("no accounts found"))
    } else {
        Ok(Config { cfg: table })
    }
}

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

    #[test]
    fn test_simple() {
        let table: toml::value::Table = toml::from_str(
            r#"
            [example]
            local = '/home/test/.maildir'
            remote = 'mx.example.com'
            user = 'johndoe'
            password = 'hunter1'
        "#,
        )
        .unwrap();

        let config = Config { cfg: table };

        let acc = config.for_account(None).expect("no account found");

        assert_eq!(acc.user(), Some("johndoe"));
        assert_eq!(acc.remote(), Some("mx.example.com"));
        assert_eq!(
            acc.password().expect("failed to get password"),
            Some(String::from("hunter1"))
        );
        assert_eq!(acc.send_user(), Some("johndoe"));
        assert_eq!(acc.send_remote(), Some("mx.example.com"));
        assert_eq!(
            acc.send_password().expect("failed to get password"),
            Some(String::from("hunter1"))
        );
    }

    #[test]
    fn test_send() {
        let table: toml::value::Table = toml::from_str(
            r#"
            [example]
            local = '/home/test/.maildir'
            remote = 'imap.example.com'
            user = 'johndoe'
            password = 'hunter1'
            send.remote = 'smtp.example.com'
            send.user = 'johndoe@example.com'
            send.password = 's3cr3t'
        "#,
        )
        .unwrap();

        let config = Config { cfg: table };

        let acc = config.for_account(None).expect("no account found");

        assert_eq!(acc.user(), Some("johndoe"));
        assert_eq!(acc.remote(), Some("imap.example.com"));
        assert_eq!(
            acc.password().expect("failed to get password"),
            Some(String::from("hunter1"))
        );
        assert_eq!(acc.send_user(), Some("johndoe@example.com"));
        assert_eq!(acc.send_remote(), Some("smtp.example.com"));
        assert_eq!(
            acc.send_password().expect("failed to get password"),
            Some(String::from("s3cr3t"))
        );
    }

    #[test]
    fn test_simple_cmd() {
        let table: toml::value::Table = toml::from_str(
            r#"
            [example]
            local = '/home/test/.maildir'
            remote = 'mx.example.com'
            user = 'johndoe'
            pass-cmd = 'echo hunter1'
        "#,
        )
        .unwrap();

        let config = Config { cfg: table };

        let acc = config.for_account(None).expect("no account found");

        assert_eq!(acc.user(), Some("johndoe"));
        assert_eq!(acc.remote(), Some("mx.example.com"));
        assert_eq!(
            acc.password().expect("failed to get password"),
            Some(String::from("hunter1"))
        );
        assert_eq!(acc.send_user(), Some("johndoe"));
        assert_eq!(acc.send_remote(), Some("mx.example.com"));
        assert_eq!(
            acc.send_password().expect("failed to get password"),
            Some(String::from("hunter1"))
        );
    }

    #[test]
    fn test_send_cmd() {
        let table: toml::value::Table = toml::from_str(
            r#"
            [example]
            local = '/home/test/.maildir'
            remote = 'imap.example.com'
            user = 'johndoe'
            pass-cmd = 'echo hunter1'
            send.remote = 'smtp.example.com'
            send.user = 'johndoe@example.com'
            send.pass-cmd = 'echo s3cr3t'
        "#,
        )
        .unwrap();

        let config = Config { cfg: table };

        let acc = config.for_account(None).expect("no account found");

        assert_eq!(acc.user(), Some("johndoe"));
        assert_eq!(acc.remote(), Some("imap.example.com"));
        assert_eq!(
            acc.password().expect("failed to get password"),
            Some(String::from("hunter1"))
        );
        assert_eq!(acc.send_user(), Some("johndoe@example.com"));
        assert_eq!(acc.send_remote(), Some("smtp.example.com"));
        assert_eq!(
            acc.send_password().expect("failed to get password"),
            Some(String::from("s3cr3t"))
        );
    }
}