foxhunt/tli/src/dashboard/vault_integration_example.rs

//! Vault Dashboard Integration Example
//!
//! This module demonstrates how to integrate the VaultStatusWidget with
//! actual Vault service data in the TLI client application.

use anyhow::Result;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::mpsc;

use crate::dashboard::{DashboardManager, DashboardEvent};
// DEPRECATED: TLI should not access Vault directly
// Use config crate instead: use config::{ConfigManager, VaultSecrets};
// This example file should be removed - TLI is a pure client

/// Example of how to integrate Vault with the dashboard system
pub struct VaultDashboardIntegration {
    dashboard_manager: DashboardManager,
    vault_service: Arc<VaultService>,
    event_sender: mpsc::Sender<DashboardEvent>,
}

impl VaultDashboardIntegration {
    /// Initialize the integration with both dashboard and Vault service
    pub async fn new(vault_config: VaultConfig) -> Result<Self> {
        // Initialize dashboard manager
        let (mut dashboard_manager, event_sender) = DashboardManager::new();

        // Initialize Vault service
        let vault_service = Arc::new(VaultService::new(vault_config).await?);

        // Connect Vault service to dashboard
        dashboard_manager.set_vault_service(vault_service.clone());

        Ok(Self {
            dashboard_manager,
            vault_service,
            event_sender,
        })
    }

    /// Start the integration with background tasks
    pub async fn start(&mut self) -> Result<()> {
        // Start Vault service
        self.vault_service.start().await?;

        // Start background task to periodically update Vault dashboard
        let dashboard_manager_clone = &mut self.dashboard_manager;
        let update_interval = Duration::from_secs(5); // Update every 5 seconds

        tokio::spawn(async move {
            let mut interval = tokio::time::interval(update_interval);

            loop {
                interval.tick().await;

                // Update Vault dashboard with latest stats
                if let Err(e) = dashboard_manager_clone.update_vault_dashboard().await {
                    eprintln!("Failed to update Vault dashboard: {}", e);
                }
            }
        });

        Ok(())
    }

    /// Get the dashboard manager for UI rendering
    pub fn dashboard_manager(&mut self) -> &mut DashboardManager {
        &mut self.dashboard_manager
    }

    /// Get the Vault service for direct operations
    pub fn vault_service(&self) -> Arc<VaultService> {
        self.vault_service.clone()
    }

    /// Stop the integration and cleanup resources
    pub async fn stop(self) -> Result<()> {
        // Stop Vault service
        self.vault_service.stop().await?;

        Ok(())
    }
}

/// Example configuration for development/testing
pub fn create_example_vault_config() -> VaultConfig {
    VaultConfig {
        url: "http://127.0.0.1:8200".to_string(),
        auth_method: AuthMethod::Token {
            token: "dev-only-token".to_string(),
        },
        mount_path: "secret/".to_string(),
        service_mount_path: "services/".to_string(),
        timeout_seconds: 30,
        retry_attempts: 3,
        tls_verify: false, // Only for development
    }
}

/// Example usage in main application
pub async fn example_usage() -> Result<()> {
    // Create Vault configuration
    let vault_config = create_example_vault_config();

    // Initialize integration
    let mut integration = VaultDashboardIntegration::new(vault_config).await?;

    // Start background services
    integration.start().await?;

    // Get dashboard manager for UI
    let dashboard_manager = integration.dashboard_manager();

    // Example: Manually trigger Vault status update
    dashboard_manager.update_vault_dashboard().await?;

    // In a real application, this would be integrated with the terminal UI loop
    println!("Vault dashboard integration initialized successfully!");
    println!("Use 'v' key to switch to Vault Status dashboard");

    // Cleanup
    integration.stop().await?;

    Ok(())
}

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

    #[tokio::test]
    async fn test_vault_dashboard_integration() {
        let vault_config = create_example_vault_config();

        // This test would require a running Vault instance
        // For now, just verify the configuration is valid
        assert_eq!(vault_config.url, "http://127.0.0.1:8200");
        assert_eq!(vault_config.mount_path, "secret/");
    }
}