mecha10_cli/services/

simulation_assets.rs

//! Simulation assets service for downloading and caching simulation files from GitHub releases
//!
//! This service provides:
//! - Downloading simulation assets (Godot project, models, environments) from GitHub releases
//! - Caching assets to `~/.mecha10/simulation/`
//! - Version management and updates
//!
//! # Design
//!
//! - Assets are downloaded from GitHub releases as a tarball
//! - Assets are extracted to `~/.mecha10/simulation/{version}/`
//! - A symlink `~/.mecha10/simulation/current` points to the active version
//!
//! # Usage
//!
//! ```no_run
//! use mecha10_cli::services::SimulationAssetsService;
//!
//! let service = SimulationAssetsService::new();
//!
//! // Ensure assets are available (downloads if needed)
//! let path = service.ensure_assets().await?;
//!
//! // Get Godot project path
//! let godot_path = service.godot_project_path()?;
//! ```

use anyhow::{Context, Result};
use indicatif::{ProgressBar, ProgressStyle};
use std::path::PathBuf;

/// GitHub repository for simulation assets
const GITHUB_REPO: &str = "mecha-industries/mecha10";
/// Asset name pattern in GitHub releases
const ASSET_NAME: &str = "mecha10-simulation.tar.gz";

/// Service for managing simulation assets
pub struct SimulationAssetsService {
    /// Base directory for cached assets (~/.mecha10)
    cache_dir: PathBuf,
}

#[allow(dead_code)]
impl SimulationAssetsService {
    /// Create a new simulation assets service
    pub fn new() -> Self {
        let cache_dir = dirs::home_dir().unwrap_or_else(|| PathBuf::from(".")).join(".mecha10");
        Self { cache_dir }
    }

    /// Get the simulation cache directory
    pub fn cache_dir(&self) -> &PathBuf {
        &self.cache_dir
    }

    /// Get the path to the current simulation assets
    ///
    /// Returns the path to `~/.mecha10/simulation/current` if it exists
    pub fn current_assets_path(&self) -> Option<PathBuf> {
        let current = self.cache_dir.join("simulation").join("current");
        if current.exists() {
            // Resolve symlink to actual path
            std::fs::canonicalize(&current).ok()
        } else {
            None
        }
    }

    /// Get the Godot project path from cached assets
    pub fn godot_project_path(&self) -> Option<PathBuf> {
        self.current_assets_path()
            .map(|p| p.join("godot-project"))
            .filter(|p| p.exists())
    }

    /// Get the models directory from cached assets
    pub fn models_path(&self) -> Option<PathBuf> {
        self.current_assets_path()
            .map(|p| p.join("models"))
            .filter(|p| p.exists())
    }

    /// Get the environments directory from cached assets
    pub fn environments_path(&self) -> Option<PathBuf> {
        self.current_assets_path()
            .map(|p| p.join("environments"))
            .filter(|p| p.exists())
    }

    /// Check if simulation assets are installed
    pub fn is_installed(&self) -> bool {
        self.godot_project_path().is_some()
    }

    /// Get the installed version (if any)
    pub fn installed_version(&self) -> Option<String> {
        let version_file = self.cache_dir.join("simulation").join("version");
        std::fs::read_to_string(version_file).ok()
    }

    /// Ensure simulation assets are available, downloading if needed
    ///
    /// Returns the path to the simulation assets directory
    pub async fn ensure_assets(&self) -> Result<PathBuf> {
        if let Some(path) = self.current_assets_path() {
            tracing::debug!("Simulation assets already installed at {:?}", path);
            return Ok(path);
        }

        // Need to download
        println!("📦 Simulation assets not found locally");
        println!("   Downloading from GitHub releases...");

        self.download_latest().await
    }

    /// Download the latest simulation assets from GitHub releases
    pub async fn download_latest(&self) -> Result<PathBuf> {
        // Get latest release info from GitHub API
        let client = reqwest::Client::builder().user_agent("mecha10-cli").build()?;

        let release_url = format!("https://api.github.com/repos/{}/releases/latest", GITHUB_REPO);

        println!("   Checking latest release...");

        let response = client
            .get(&release_url)
            .send()
            .await
            .context("Failed to fetch release info from GitHub")?;

        if !response.status().is_success() {
            return Err(anyhow::anyhow!(
                "Failed to get release info: HTTP {}. \n\
                 The simulation assets may not be published yet.\n\n\
                 Alternative: Set MECHA10_FRAMEWORK_PATH to your local mecha10 clone:\n\
                   export MECHA10_FRAMEWORK_PATH=/path/to/mecha10",
                response.status()
            ));
        }

        let release: serde_json::Value = response.json().await?;

        let tag_name = release["tag_name"].as_str().unwrap_or("unknown").to_string();

        // Find the simulation asset
        let assets = release["assets"]
            .as_array()
            .ok_or_else(|| anyhow::anyhow!("No assets in release"))?;

        let asset = assets
            .iter()
            .find(|a| a["name"].as_str().map(|n| n == ASSET_NAME).unwrap_or(false))
            .ok_or_else(|| {
                anyhow::anyhow!(
                    "Simulation asset '{}' not found in release {}.\n\n\
                     The release may not include simulation assets yet.\n\
                     Alternative: Set MECHA10_FRAMEWORK_PATH to your local mecha10 clone.",
                    ASSET_NAME,
                    tag_name
                )
            })?;

        let download_url = asset["browser_download_url"]
            .as_str()
            .ok_or_else(|| anyhow::anyhow!("No download URL for asset"))?;

        let size = asset["size"].as_u64().unwrap_or(0);

        println!("   Release: {}", tag_name);
        println!("   Size: {:.1} MB", size as f64 / 1024.0 / 1024.0);

        // Download the asset
        self.download_and_extract(download_url, &tag_name, size).await
    }

    /// Download and extract simulation assets
    async fn download_and_extract(&self, url: &str, version: &str, size: u64) -> Result<PathBuf> {
        let client = reqwest::Client::builder().user_agent("mecha10-cli").build()?;

        // Create progress bar
        let pb = ProgressBar::new(size);
        pb.set_style(
            ProgressStyle::default_bar()
                .template("{spinner:.green} [{bar:40.cyan/blue}] {bytes}/{total_bytes} ({eta})")
                .unwrap()
                .progress_chars("#>-"),
        );

        println!("   Downloading...");

        let response = client
            .get(url)
            .send()
            .await
            .context("Failed to download simulation assets")?;

        if !response.status().is_success() {
            return Err(anyhow::anyhow!("Download failed: HTTP {}", response.status()));
        }

        // Download to temp file
        let temp_dir = tempfile::tempdir()?;
        let temp_file = temp_dir.path().join("simulation.tar.gz");

        let mut file = tokio::fs::File::create(&temp_file).await?;
        let mut stream = response.bytes_stream();

        use futures_util::StreamExt;
        use tokio::io::AsyncWriteExt;

        while let Some(chunk) = stream.next().await {
            let chunk = chunk.context("Error downloading chunk")?;
            file.write_all(&chunk).await?;
            pb.inc(chunk.len() as u64);
        }

        file.flush().await?;
        pb.finish_with_message("Download complete");

        // Extract
        println!("   Extracting...");

        let simulation_dir = self.cache_dir.join("simulation");
        let version_dir = simulation_dir.join(version);

        // Create directories
        tokio::fs::create_dir_all(&version_dir).await?;

        // Extract tarball
        let tar_gz = std::fs::File::open(&temp_file)?;
        let tar = flate2::read::GzDecoder::new(tar_gz);
        let mut archive = tar::Archive::new(tar);
        archive.unpack(&version_dir)?;

        // Create/update symlink to current version
        let current_link = simulation_dir.join("current");
        if current_link.exists() {
            tokio::fs::remove_file(&current_link).await.ok();
        }

        #[cfg(unix)]
        {
            std::os::unix::fs::symlink(&version_dir, &current_link)?;
        }

        #[cfg(windows)]
        {
            // On Windows, use directory junction or just copy
            std::os::windows::fs::symlink_dir(&version_dir, &current_link)?;
        }

        // Write version file
        let version_file = simulation_dir.join("version");
        tokio::fs::write(&version_file, version).await?;

        println!("✅ Simulation assets installed to {:?}", version_dir);

        Ok(version_dir)
    }

    /// Remove cached simulation assets
    pub async fn remove(&self) -> Result<()> {
        let simulation_dir = self.cache_dir.join("simulation");
        if simulation_dir.exists() {
            tokio::fs::remove_dir_all(&simulation_dir).await?;
            println!("✅ Simulation assets removed");
        } else {
            println!("No simulation assets installed");
        }
        Ok(())
    }

    /// Update to latest version
    pub async fn update(&self) -> Result<PathBuf> {
        // Remove current and download fresh
        self.remove().await.ok();
        self.download_latest().await
    }
}

impl Default for SimulationAssetsService {
    fn default() -> Self {
        Self::new()
    }
}