memvid_cli/

org_ticket_cache.rs

//! Organisation-level ticket caching
//!
//! Caches org-level tickets locally to avoid repeated API calls.
//! Tickets are automatically refreshed when expired.

use std::fs;
use std::path::PathBuf;

use anyhow::{Context, Result};

use crate::api::{fetch_org_ticket, OrgTicket, OrgTicketResponse};
use crate::config::CliConfig;

const ORG_TICKET_FILE: &str = "org_ticket.json";

/// Cached org ticket with metadata
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct CachedOrgTicket {
    pub ticket: OrgTicket,
    pub plan_id: String,
    pub plan_name: String,
    pub org_id: String,
    pub org_name: String,
    pub total_storage_bytes: u64,
    pub subscription_status: String,
}

impl CachedOrgTicket {
    /// Check if the cached ticket has expired
    pub fn is_expired(&self) -> bool {
        self.ticket.is_expired()
    }

    /// Get capacity in bytes from the ticket
    pub fn capacity_bytes(&self) -> u64 {
        self.ticket.capacity_bytes
    }

    /// Check if the plan is a paid plan
    pub fn is_paid(&self) -> bool {
        self.ticket.is_paid()
    }
}

/// Get the path to the org ticket cache file
fn cache_path(config: &CliConfig) -> PathBuf {
    config.cache_dir.join(ORG_TICKET_FILE)
}

/// Load a cached org ticket from disk
pub fn load(config: &CliConfig) -> Result<CachedOrgTicket> {
    let path = cache_path(config);
    let data = fs::read(&path)
        .with_context(|| "no cached org ticket available")?;
    let cached: CachedOrgTicket = serde_json::from_slice(&data)
        .with_context(|| format!("failed to parse cached org ticket: {}", path.display()))?;
    Ok(cached)
}

/// Store an org ticket response to disk
pub fn store(config: &CliConfig, response: &OrgTicketResponse) -> Result<()> {
    let path = cache_path(config);
    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent).with_context(|| {
            format!(
                "failed to create org ticket cache directory: {}",
                parent.display()
            )
        })?;
    }

    let cached = CachedOrgTicket {
        ticket: response.ticket.clone(),
        plan_id: response.plan.id.clone(),
        plan_name: response.plan.name.clone(),
        org_id: response.organisation.id.clone(),
        org_name: response.organisation.name.clone(),
        total_storage_bytes: response.organisation.total_storage_bytes,
        subscription_status: response.subscription.status.clone(),
    };

    let tmp = path.with_extension("json.tmp");
    let data = serde_json::to_vec_pretty(&cached)?;
    fs::write(&tmp, data)
        .with_context(|| format!("failed to write org ticket cache file: {}", tmp.display()))?;
    fs::rename(&tmp, &path).with_context(|| {
        format!(
            "failed to atomically persist org ticket cache file: {}",
            path.display()
        )
    })?;
    Ok(())
}

/// Clear the cached org ticket
pub fn clear(config: &CliConfig) -> Result<()> {
    let path = cache_path(config);
    if path.exists() {
        fs::remove_file(&path).with_context(|| {
            format!("failed to remove org ticket cache file: {}", path.display())
        })?;
    }
    Ok(())
}

/// Get a valid org ticket, fetching from API if needed
///
/// This function:
/// 1. Tries to load a cached ticket
/// 2. If cached ticket is valid (not expired), returns it
/// 3. If no cache or expired, fetches a new ticket from the API
/// 4. Caches the new ticket and returns it
pub fn get_or_refresh(config: &CliConfig) -> Result<CachedOrgTicket> {
    // Try cached ticket first
    if let Ok(cached) = load(config) {
        if !cached.is_expired() {
            return Ok(cached);
        }
        log::debug!("Cached org ticket expired, refreshing...");
    }

    // Fetch new ticket
    refresh(config)
}

/// Force refresh the org ticket from the API
pub fn refresh(config: &CliConfig) -> Result<CachedOrgTicket> {
    log::debug!("Fetching org ticket from API...");
    let response = fetch_org_ticket(config)?;
    store(config, &response)?;
    load(config)
}

/// Get org ticket if API key is configured, otherwise return None
///
/// This is useful for optional ticket validation - if no API key is set,
/// we fall back to free tier limits without requiring authentication.
///
/// When API key is set, this automatically syncs the plan ticket from the
/// dashboard if needed (first use or expired). This enables seamless
/// capacity validation without explicit `memvid plan sync`.
pub fn get_optional(config: &CliConfig) -> Option<CachedOrgTicket> {
    // No API key = free tier, silent fallback
    if config.api_key.is_none() {
        log::debug!("No API key set, using free tier limits");
        return None;
    }

    // Check if we need to fetch (no cache or expired)
    let needs_fetch = match load(config) {
        Ok(cached) => cached.is_expired(),
        Err(_) => true,
    };

    if needs_fetch {
        // Silent auto-sync on first use or when expired
        log::debug!("Auto-syncing plan ticket from dashboard...");
        match refresh(config) {
            Ok(ticket) => {
                log::info!(
                    "Plan synced: {} ({})",
                    ticket.plan_name,
                    format_capacity(ticket.capacity_bytes())
                );
                return Some(ticket);
            }
            Err(err) => {
                // Check if it's an auth error - silently fall back to free tier
                let err_str = err.to_string();
                if err_str.contains("Invalid API key") || err_str.contains("401") {
                    log::debug!("API key invalid, using free tier limits");
                } else {
                    // Only warn for non-auth errors (network issues, etc.)
                    log::warn!("Failed to sync plan (using free tier limits): {}", err);
                }
                return None;
            }
        }
    }

    // Use cached ticket
    match load(config) {
        Ok(ticket) => Some(ticket),
        Err(_) => None,
    }
}

/// Format capacity bytes for display
fn format_capacity(bytes: u64) -> String {
    if bytes >= 1024 * 1024 * 1024 * 1024 {
        format!("{:.1} TB", bytes as f64 / (1024.0 * 1024.0 * 1024.0 * 1024.0))
    } else if bytes >= 1024 * 1024 * 1024 {
        format!("{:.1} GB", bytes as f64 / (1024.0 * 1024.0 * 1024.0))
    } else if bytes >= 1024 * 1024 {
        format!("{:.1} MB", bytes as f64 / (1024.0 * 1024.0))
    } else if bytes >= 1024 {
        format!("{:.1} KB", bytes as f64 / 1024.0)
    } else {
        format!("{} B", bytes)
    }
}