wme-cli 0.1.3

//! Configuration management for the Wikimedia Enterprise CLI.
//!
//! This module handles loading, saving, and managing CLI configuration,
//! including authentication tokens. Configuration is stored in JSON format
//! at `~/.wme/config.json` by default.
//!
//! # Example
//!
//! ```rust
//! use wme_cli::config::Config;
//! use std::path::Path;
//!
//! # fn example() -> anyhow::Result<()> {
//! // Load config from default location
//! let config = Config::load(None)?;
//!
//! // Check if token is expired
//! if config.is_token_expired() {
//!     println!("Token expired, please login again");
//! }
//!
//! // Get access token if available
//! if let Some(token) = config.get_access_token() {
//!     println!("Using token: {}", token);
//! }
//! # Ok(())
//! # }
//! ```

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::Path;
use std::path::PathBuf;

/// Default config directory name
const CONFIG_DIR: &str = "wme";
/// Default config file name
const CONFIG_FILE: &str = "config.json";

/// CLI configuration stored in ~/.wme/config.json
///
/// Stores user authentication tokens and metadata. The configuration
/// file is created automatically on first login and updated when
/// tokens are refreshed or revoked.
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct Config {
    /// Username associated with the stored tokens
    pub username: Option<String>,
    /// Access token for API authentication
    pub access_token: Option<String>,
    /// Refresh token for obtaining new access tokens
    pub refresh_token: Option<String>,
    /// Access token expiration time in RFC3339 format
    pub token_expires_at: Option<String>,
    /// Refresh token expiration time in RFC3339 format (90 days from issue)
    pub refresh_token_expires_at: Option<String>,
    /// Additional settings (for forward compatibility)
    #[serde(flatten)]
    pub extra: HashMap<String, serde_json::Value>,
}

impl Config {
    /// Load configuration from a file path.
    ///
    /// If no path is provided, loads from the default location (`~/.wme/config.json`).
    /// If the file does not exist, returns a default empty configuration.
    ///
    /// # Arguments
    ///
    /// * `path` - Optional path to the config file. If `None`, uses default location.
    ///
    /// # Errors
    ///
    /// Returns an error if the file exists but cannot be read or parsed.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wme_cli::config::Config;
    ///
    /// # fn example() -> anyhow::Result<()> {
    /// // Load from default location
    /// let config = Config::load(None)?;
    ///
    /// // Load from specific path
    /// let config = Config::load(Some(std::path::Path::new("/path/to/config.json")))?;
    /// # Ok(())
    /// # }
    /// ```
    pub fn load(path: Option<&Path>) -> Result<Self> {
        let config_path = match path {
            Some(p) => p.to_path_buf(),
            None => default_config_path()?,
        };

        if config_path.exists() {
            let content = fs::read_to_string(&config_path)
                .with_context(|| format!("Failed to read config from {}", config_path.display()))?;
            let config: Config = serde_json::from_str(&content).with_context(|| {
                format!("Failed to parse config from {}", config_path.display())
            })?;
            Ok(config)
        } else {
            Ok(Config::default())
        }
    }

    /// Save configuration to a file.
    ///
    /// If no path is provided, saves to the default location (`~/.wme/config.json`).
    /// Creates parent directories if they don't exist.
    ///
    /// # Arguments
    ///
    /// * `path` - Optional path to save the config file. If `None`, uses default location.
    ///
    /// # Errors
    ///
    /// Returns an error if the file cannot be written or directories cannot be created.
    pub fn save(&self, path: Option<&Path>) -> Result<()> {
        let config_path = match path {
            Some(p) => p.to_path_buf(),
            None => default_config_path()?,
        };

        // Ensure parent directory exists
        if let Some(parent) = config_path.parent() {
            fs::create_dir_all(parent).with_context(|| {
                format!("Failed to create config directory {}", parent.display())
            })?;
        }

        let content = serde_json::to_string_pretty(self).context("Failed to serialize config")?;
        fs::write(&config_path, content)
            .with_context(|| format!("Failed to write config to {}", config_path.display()))?;

        Ok(())
    }

    /// Returns the default configuration file path.
    ///
    /// The default path is `~/.wme/config.json` on Unix systems.
    ///
    /// # Errors
    ///
    /// Returns an error if the home directory cannot be determined.
    pub fn default_path() -> Result<PathBuf> {
        default_config_path()
    }

    /// Check if the stored access token is expired.
    ///
    /// Parses the `token_expires_at` field and compares it to the current time.
    /// Returns `true` if the token is expired or if no expiration time is set.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wme_cli::config::Config;
    ///
    /// # fn example() {
    /// let config = Config::default();
    /// assert!(config.is_token_expired()); // No token = expired
    /// # }
    /// ```
    pub fn is_token_expired(&self) -> bool {
        match &self.token_expires_at {
            Some(expires_at) => {
                match chrono::DateTime::parse_from_rfc3339(expires_at) {
                    Ok(expiry) => chrono::Utc::now() > expiry.with_timezone(&chrono::Utc),
                    Err(_) => true, // If we can't parse, consider it expired
                }
            }
            None => true, // No expiry means expired
        }
    }

    /// Get the access token if it's available and not expired.
    ///
    /// Returns `Some(token)` if a valid (non-expired) access token exists,
    /// otherwise returns `None`.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wme_cli::config::Config;
    ///
    /// # fn example() {
    /// let config = Config::default();
    /// assert_eq!(config.get_access_token(), None); // No token
    /// # }
    /// ```
    pub fn get_access_token(&self) -> Option<String> {
        if self.is_token_expired() {
            None
        } else {
            self.access_token.clone()
        }
    }

    /// Store authentication tokens after a successful login.
    ///
    /// Updates the username, access token, refresh token, and calculates
    /// the expiration time based on the provided `expires_in` seconds.
    ///
    /// # Arguments
    ///
    /// * `username` - The username for the authenticated session
    /// * `access_token` - The access token from the authentication response
    /// * `refresh_token` - The refresh token from the authentication response
    /// * `expires_in` - Token lifetime in seconds
    pub fn set_tokens(
        &mut self,
        username: &str,
        access_token: &str,
        refresh_token: &str,
        expires_in: u64,
    ) {
        self.username = Some(username.to_string());
        self.access_token = Some(access_token.to_string());
        self.refresh_token = Some(refresh_token.to_string());

        let expires_at = chrono::Utc::now() + chrono::Duration::seconds(expires_in as i64);
        self.token_expires_at = Some(expires_at.to_rfc3339());

        // Refresh tokens expire after 90 days
        let refresh_expires_at = chrono::Utc::now() + chrono::Duration::days(90);
        self.refresh_token_expires_at = Some(refresh_expires_at.to_rfc3339());
    }

    /// Clear all authentication tokens.
    ///
    /// Removes the username, access token, refresh token, and expiration time.
    /// This effectively logs out the user.
    pub fn clear_tokens(&mut self) {
        self.username = None;
        self.access_token = None;
        self.refresh_token = None;
        self.token_expires_at = None;
        self.refresh_token_expires_at = None;
    }
}

/// Get the default config path (~/.wme/config.json)
fn default_config_path() -> Result<PathBuf> {
    let dirs = directories::BaseDirs::new().context("Failed to get home directory")?;
    Ok(dirs
        .home_dir()
        .join(format!(".{}", CONFIG_DIR))
        .join(CONFIG_FILE))
}

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

    #[test]
    fn test_config_default() {
        let config = Config::default();
        assert!(config.username.is_none());
        assert!(config.access_token.is_none());
        assert!(config.refresh_token.is_none());
        assert!(config.token_expires_at.is_none());
        assert!(config.extra.is_empty());
    }

    #[test]
    fn test_config_load_nonexistent() {
        // Load from a non-existent path should return default config
        let result = Config::load(Some(Path::new("/nonexistent/path/config.json")));
        assert!(result.is_ok());
        let config = result.unwrap();
        assert!(config.username.is_none());
    }

    #[test]
    fn test_config_load_and_save() {
        let temp_file = NamedTempFile::new().unwrap();

        // Create a config and save it
        let config = Config {
            username: Some("testuser".to_string()),
            access_token: Some("test_token".to_string()),
            refresh_token: Some("refresh_token".to_string()),
            token_expires_at: Some("2099-12-31T23:59:59Z".to_string()),
            refresh_token_expires_at: Some("2099-12-31T23:59:59Z".to_string()),
            extra: std::collections::HashMap::default(),
        };

        config.save(Some(temp_file.path())).unwrap();

        // Load it back
        let loaded = Config::load(Some(temp_file.path())).unwrap();
        assert_eq!(loaded.username, Some("testuser".to_string()));
        assert_eq!(loaded.access_token, Some("test_token".to_string()));
        assert_eq!(loaded.refresh_token, Some("refresh_token".to_string()));
        assert_eq!(
            loaded.token_expires_at,
            Some("2099-12-31T23:59:59Z".to_string())
        );
    }

    #[test]
    fn test_is_token_expired_no_expiry() {
        let config = Config::default();
        assert!(config.is_token_expired());
    }

    #[test]
    fn test_is_token_expired_past() {
        // Set expiry to the past
        let config = Config {
            token_expires_at: Some("2000-01-01T00:00:00Z".to_string()),
            ..Default::default()
        };
        assert!(config.is_token_expired());
    }

    #[test]
    fn test_is_token_expired_future() {
        // Set expiry to far future
        let config = Config {
            token_expires_at: Some("2099-12-31T23:59:59Z".to_string()),
            ..Default::default()
        };
        assert!(!config.is_token_expired());
    }

    #[test]
    fn test_is_token_expired_invalid_format() {
        // Invalid format should be treated as expired
        let config = Config {
            token_expires_at: Some("not-a-date".to_string()),
            ..Default::default()
        };
        assert!(config.is_token_expired());
    }

    #[test]
    fn test_get_access_token_expired() {
        let config = Config {
            access_token: Some("token".to_string()),
            token_expires_at: Some("2000-01-01T00:00:00Z".to_string()),
            ..Default::default()
        };
        assert_eq!(config.get_access_token(), None);
    }

    #[test]
    fn test_get_access_token_valid() {
        let config = Config {
            access_token: Some("valid_token".to_string()),
            token_expires_at: Some("2099-12-31T23:59:59Z".to_string()),
            ..Default::default()
        };
        assert_eq!(config.get_access_token(), Some("valid_token".to_string()));
    }

    #[test]
    fn test_set_tokens() {
        let mut config = Config::default();
        config.set_tokens("myuser", "access123", "refresh456", 3600);

        assert_eq!(config.username, Some("myuser".to_string()));
        assert_eq!(config.access_token, Some("access123".to_string()));
        assert_eq!(config.refresh_token, Some("refresh456".to_string()));
        assert!(config.token_expires_at.is_some());
        // Should not be expired immediately after setting
        assert!(!config.is_token_expired());
    }

    #[test]
    fn test_clear_tokens() {
        let mut config = Config::default();
        config.set_tokens("user", "access", "refresh", 3600);
        config.clear_tokens();

        assert!(config.username.is_none());
        assert!(config.access_token.is_none());
        assert!(config.refresh_token.is_none());
        assert!(config.token_expires_at.is_none());
        assert!(config.refresh_token_expires_at.is_none());
    }

    #[test]
    fn test_config_serialization() {
        let config = Config {
            username: Some("test".to_string()),
            access_token: Some("token".to_string()),
            refresh_token: Some("refresh".to_string()),
            token_expires_at: Some("2099-01-01T00:00:00Z".to_string()),
            refresh_token_expires_at: Some("2099-04-01T00:00:00Z".to_string()),
            extra: {
                let mut map = HashMap::new();
                map.insert("custom_key".to_string(), serde_json::json!("custom_value"));
                map
            },
        };

        let json = serde_json::to_string(&config).unwrap();
        assert!(json.contains("test"));
        assert!(json.contains("custom_key"));

        let deserialized: Config = serde_json::from_str(&json).unwrap();
        assert_eq!(deserialized.username, config.username);
        assert_eq!(
            deserialized.extra.get("custom_key").unwrap(),
            "custom_value"
        );
    }
}