mecha10-cli 0.6.3

//! Config command handlers
//!
//! Handles pushing, pulling, and listing robot configurations.
//! Uses shared sync logic from mecha10-robot-config crate.

use crate::commands::config::{ConfigListArgs, ConfigPullArgs, ConfigPushArgs, ConfigValidateArgs};
use crate::context::CliContext;
use crate::services::credentials::CredentialsService;
use anyhow::{Context, Result};
use mecha10_core::config::config_key_to_path;
use mecha10_robot_config::{
    collect_configs_from_dir, write_configs_to_dir, CollectOptions, RobotConfigClient, WriteOptions,
};

/// Robot config API path (appended to control plane URL)
const ROBOT_CONFIG_PATH: &str = "/api/robot-config";

/// Handle the config push command
///
/// Pushes local config files to the robot-config service.
pub async fn handle_config_push(ctx: &mut CliContext, args: &ConfigPushArgs) -> Result<()> {
    println!();
    println!("Pushing configurations...");
    println!();

    // Regenerate `websocket-bridge`'s relay topic allowlist from other nodes' own configs
    // (LAB relay-topics-core-deriver) before local config files get gathered below, so what
    // gets pushed to the control plane already reflects the current derived allowlist.
    mecha10_core::relay_topics::regenerate_websocket_bridge_relay_config(&ctx.working_dir)
        .context("Failed to regenerate websocket-bridge relay topics")?;

    // Get robot ID from args or project config
    let robot_id = get_robot_id(ctx, args.robot_id.as_deref()).await?;

    // Find configs directory
    let configs_dir = match &args.path {
        Some(path) => path.clone(),
        None => ctx.working_dir.join("configs"),
    };

    // Collect configs using shared function
    let options = CollectOptions {
        include_mecha10_json: true,
        project_root: Some(ctx.working_dir.clone()),
    };

    let configs = collect_configs_from_dir(&configs_dir, &options)
        .await
        .map_err(|e| anyhow::anyhow!("Failed to collect configs: {}", e))?;

    if configs.is_empty() {
        println!("No config files found");
        println!();
        println!("Expected:");
        println!("  - configs/ directory with node configs");
        println!("  - mecha10.json at project root");
        return Ok(());
    }

    println!("Robot ID:     {}", robot_id);
    if configs_dir.exists() {
        println!("Configs dir:  {}", configs_dir.display());
    }
    println!();
    println!("Found {} config(s):", configs.len());
    for (key, _) in &configs {
        println!("  - {}", key);
    }
    println!();

    if args.dry_run {
        println!("DRY RUN - No changes will be made");
        return Ok(());
    }

    // Create client and push configs
    let client = create_config_client(ctx).await?;

    match client.bulk_upsert_configs(&robot_id, configs).await {
        Ok(result) => {
            println!(
                "Pushed {} config(s) ({} created, {} updated)",
                result.configs.len(),
                result.created,
                result.updated
            );
        }
        Err(e) => {
            return Err(anyhow::anyhow!("Failed to push configs: {}", e));
        }
    }

    println!();
    Ok(())
}

/// Handle the config pull command
///
/// Pulls configs from the robot-config service to local files.
pub async fn handle_config_pull(ctx: &mut CliContext, args: &ConfigPullArgs) -> Result<()> {
    println!();
    println!("Pulling configurations...");
    println!();

    // Get robot ID from args or project config
    let robot_id = get_robot_id(ctx, args.robot_id.as_deref()).await?;

    // Output directory
    let output_dir = args.output.clone().unwrap_or_else(|| ctx.working_dir.join("configs"));

    println!("Robot ID:    {}", robot_id);
    println!("Output dir:  {}", output_dir.display());
    println!();

    // Create client and fetch configs
    let client = create_config_client(ctx).await?;

    let configs = match client.get_configs(&robot_id).await {
        Ok(configs) => configs,
        Err(e) => {
            return Err(anyhow::anyhow!("Failed to fetch configs: {}", e));
        }
    };

    // Simulation assets (LAB-1984) live in the same robot-config store under a
    // `simulation-assets/` key prefix but use a different on-disk layout (`simulation/`, decoded
    // from base64) than node configs / mecha10.json — `mecha10 sim pull` handles those, so they
    // must not fall through to `write_configs_to_dir` here (it would mangle them into flat,
    // still-base64-encoded files under `configs/`).
    let configs = exclude_sim_assets(configs);

    if configs.is_empty() {
        println!("No configs found for robot {}", robot_id);
        return Ok(());
    }

    println!("Found {} config(s):", configs.len());
    for config in &configs {
        println!("  - {}", config.config_key);
    }
    println!();

    // Write configs using shared function
    let write_options = WriteOptions {
        force: args.force,
        project_root: Some(ctx.working_dir.clone()),
    };

    let result = write_configs_to_dir(&configs, &output_dir, &write_options)
        .await
        .map_err(|e| anyhow::anyhow!("Failed to write configs: {}", e))?;

    // Print what was written/skipped
    for key in &result.written_keys {
        let display_name = config_key_to_path(key);
        println!("  Wrote {}", display_name);
    }
    for key in &result.skipped_keys {
        let display_name = config_key_to_path(key);
        println!("  Skipped {} (exists, use --force to overwrite)", display_name);
    }

    println!();
    println!("Pulled {} config(s), skipped {}", result.written, result.skipped);
    println!();

    Ok(())
}

/// Handle the config list command
///
/// Lists all configs for a robot.
pub async fn handle_config_list(ctx: &mut CliContext, args: &ConfigListArgs) -> Result<()> {
    println!();

    // Get robot ID from args or project config
    let robot_id = get_robot_id(ctx, args.robot_id.as_deref()).await?;

    println!("Configs for robot: {}", robot_id);
    println!();

    // Create client and fetch configs
    let client = create_config_client(ctx).await?;

    let configs = match client.get_configs(&robot_id).await {
        Ok(configs) => configs,
        Err(e) => {
            return Err(anyhow::anyhow!("Failed to fetch configs: {}", e));
        }
    };

    // Simulation assets (LAB-1984) live in the same store under a `simulation-assets/` key
    // prefix and would otherwise show up here as noisy, unreadable base64 blobs — filter them
    // out, same as `handle_config_pull`. `mecha10 sim push`/`sim pull` report their own asset
    // list directly.
    let configs = exclude_sim_assets(configs);

    if configs.is_empty() {
        println!("No configs found");
        println!();
        return Ok(());
    }

    for config in configs {
        println!("{}:", config.config_key);
        println!("  Updated: {}", config.updated_at.format("%Y-%m-%d %H:%M:%S UTC"));
        if let Some(ref user) = config.updated_by {
            println!("  By: {}", user);
        }

        if args.verbose {
            let value_str = serde_json::to_string_pretty(&config.config_value).unwrap_or_else(|_| "{}".to_string());
            // Indent the JSON
            for line in value_str.lines() {
                println!("    {}", line);
            }
        }
        println!();
    }

    Ok(())
}

/// Push configs from the project's configs/ directory that have changed since last push.
///
/// Fetches current remote configs, compares by value, and only pushes new or modified entries.
/// Used by build and upload handlers to auto-push configs after a successful operation.
pub async fn push_configs(ctx: &mut CliContext) -> Result<()> {
    // Regenerate `websocket-bridge`'s relay topic allowlist from other nodes' own configs
    // (LAB relay-topics-core-deriver) before local config files get gathered below - this is
    // also reached from `mecha10 build`'s auto-push step, not only the direct `config push`
    // command, so the call lives here too rather than only in `handle_config_push`.
    mecha10_core::relay_topics::regenerate_websocket_bridge_relay_config(&ctx.working_dir)
        .context("Failed to regenerate websocket-bridge relay topics")?;

    let configs_dir = ctx.working_dir.join("configs");

    if !configs_dir.exists() {
        println!("  No configs/ directory found, skipping config push");
        return Ok(());
    }

    let robot_id = get_robot_id(ctx, None).await?;

    let options = CollectOptions {
        include_mecha10_json: true,
        project_root: Some(ctx.working_dir.clone()),
    };

    let local_configs = collect_configs_from_dir(&configs_dir, &options)
        .await
        .map_err(|e| anyhow::anyhow!("Failed to collect configs: {}", e))?;

    if local_configs.is_empty() {
        println!("  No configs found in configs/ directory");
        return Ok(());
    }

    let client = create_config_client(ctx).await?;

    // Fetch current remote configs to diff against
    let remote_configs = client.get_configs(&robot_id).await.unwrap_or_default();

    let remote_map: std::collections::HashMap<&str, &mecha10_robot_config::ConfigValue> = remote_configs
        .iter()
        .map(|c| (c.config_key.as_str(), &c.config_value))
        .collect();

    // Only push configs that are new or have changed
    let changed: Vec<(String, mecha10_robot_config::ConfigValue)> = local_configs
        .into_iter()
        .filter(|(key, value)| {
            remote_map
                .get(key.as_str())
                .map_or(true, |remote_value| *remote_value != value)
        })
        .collect();

    if changed.is_empty() {
        println!("  No config changes detected");
        return Ok(());
    }

    println!(
        "  Pushing {} changed config(s) for robot {}...",
        changed.len(),
        robot_id
    );

    match client.bulk_upsert_configs(&robot_id, changed).await {
        Ok(result) => {
            println!(
                "  ✅ Pushed {} config(s) ({} created, {} updated)",
                result.configs.len(),
                result.created,
                result.updated
            );
        }
        Err(e) => {
            return Err(anyhow::anyhow!("Failed to push configs: {}", e));
        }
    }

    Ok(())
}

/// Handle the config show command
///
/// Prints the resolved project identity (name, robot ID, control plane URL for the
/// active environment, login status, and local configs/ directory path). These
/// `name`/`robot.id` values must match `robot_project.name`/`robot_id` in the
/// robot's `~/.mecha10/launcher/config.json` — verify with `mecha10-launcher config show`
/// on the robot.
pub async fn handle_config_show(ctx: &mut CliContext) -> Result<()> {
    println!();

    if !ctx.is_project_initialized() {
        println!("Not inside a mecha10 project (no mecha10.json found).");
        println!();
        println!("Run `mecha10 init` to create a new project.");
        println!();
        return Ok(());
    }

    let project_config = ctx.load_project_config().await?;
    let env_name = project_config.environments.current_env_name();
    let control_plane_url = project_config.environments.control_plane_url();
    let auth_status = mecha10_auth::commands::auth_status_line()?;
    let configs_dir = ctx.working_dir.join("configs");

    println!("Project name:      {}", project_config.name);
    println!("Robot ID:          {}", project_config.robot.id);
    println!("Environment:       {}", env_name);
    println!("Control plane URL: {}", control_plane_url);
    println!("Auth status:       {}", auth_status);
    println!("Configs dir:       {}", configs_dir.display());
    println!();
    println!("Note: `Project name` and `Robot ID` above must match `robot_project.name` and");
    println!("`robot_id` in the robot's ~/.mecha10/launcher/config.json — the launcher's binary");
    println!("registry looks up binaries by project name, and config/relay routing is scoped");
    println!("by robot ID. Run `mecha10-launcher config show` on the robot to verify.");
    println!();

    Ok(())
}

/// Handle the config validate command
///
/// Validates `mecha10.json` plus every node config it references, or --
/// with `--path` -- a single arbitrary config file (project, node, or
/// `model_catalog.toml`). This is the single command hooks/CI/build and
/// `mecha10 lint` all shell out to or call into for config validation (see
/// `docs/validate-configs.md`); it re-implements no validation logic of its
/// own, delegating entirely to [`crate::config_validation::validate_config`].
pub async fn handle_config_validate(ctx: &mut CliContext, args: &ConfigValidateArgs) -> Result<()> {
    println!();
    println!("🔎 Config Validation");
    println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    println!();

    // `--path` validates an arbitrary file standalone, no project needed.
    // Otherwise, resolve the project's mecha10.json the same way every other
    // config-aware command does.
    if args.path.is_none() && !ctx.is_project_initialized() {
        println!("❌ Not in a Mecha10 project directory (no mecha10.json found).");
        println!();
        println!("Run `mecha10 init` to create a new project, or pass --path to validate a single file.");
        println!();
        return Err(anyhow::anyhow!("Not in a Mecha10 project directory"));
    }

    match crate::config_validation::validate_config(args.path.as_deref()) {
        Ok(target) => {
            println!("✅ {} is valid", target.display());
            println!();
            Ok(())
        }
        Err(e) => {
            println!("❌ Config validation failed:");
            println!();
            println!("{:#}", e);
            println!();
            Err(e)
        }
    }
}

/// Drop simulation-asset entries (LAB-1984, `simulation-assets/` key prefix) from a batch of
/// configs fetched from the robot-config service, leaving only node configs and `mecha10.json`.
///
/// Shared by `handle_config_pull` (would otherwise mangle asset bytes into flat, still-base64
/// files under `configs/`) and `handle_config_list` (would otherwise print unreadable base64
/// blobs). `mecha10 sim push`/`sim pull` handle simulation assets separately.
fn exclude_sim_assets(configs: Vec<mecha10_robot_config::ConfigResponse>) -> Vec<mecha10_robot_config::ConfigResponse> {
    configs
        .into_iter()
        .filter(|c| !mecha10_robot_config::is_sim_asset_key(&c.config_key))
        .collect()
}

/// Get robot ID from args or project config
///
/// `pub(crate)` so `handlers::sim`'s `sim push`/`sim pull` (LAB-1984) can reuse the exact same
/// resolution order instead of duplicating it.
pub(crate) async fn get_robot_id(ctx: &mut CliContext, arg_robot_id: Option<&str>) -> Result<String> {
    if let Some(id) = arg_robot_id {
        return Ok(id.to_string());
    }

    // Try to get from project config
    if ctx.is_project_initialized() {
        let project_config = ctx.load_project_config().await?;
        return Ok(project_config.robot.id);
    }

    Err(anyhow::anyhow!(
        "No robot ID specified. Use --robot-id or run from a mecha10 project directory."
    ))
}

/// Create a RobotConfigClient with credentials
///
/// `pub(crate)` so `handlers::sim`'s `sim push`/`sim pull` (LAB-1984) can reuse the same
/// authenticated client the config commands use — simulation assets are synced through the same
/// robot-config service, just under a distinct config-key namespace (see
/// `mecha10_robot_config::sim_assets`).
pub(crate) async fn create_config_client(ctx: &mut CliContext) -> Result<RobotConfigClient> {
    // Load credentials
    let credentials_service = CredentialsService::new();
    let credentials = credentials_service
        .load()?
        .ok_or_else(|| anyhow::anyhow!("Not logged in. Run `mecha10 auth login` first."))?;

    // Get control plane URL from project config
    let project_config = ctx.load_project_config().await?;
    let control_plane_url = project_config.environments.control_plane_url();
    let config_url = format!("{}{}", control_plane_url, ROBOT_CONFIG_PATH);

    Ok(RobotConfigClient::with_user_id(
        config_url,
        credentials.api_key,
        Some(credentials.user_id),
    ))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::context::CliContextBuilder;
    use tempfile::tempdir;

    fn write_project_config(dir: &std::path::Path, robot_id: &str) -> std::path::PathBuf {
        let config_path = dir.join("mecha10.json");
        std::fs::write(
            &config_path,
            serde_json::json!({
                "name": "proj",
                "version": "0.1.0",
                "robot": {"id": robot_id},
            })
            .to_string(),
        )
        .unwrap();
        config_path
    }

    fn make_config_response(config_key: &str) -> mecha10_robot_config::ConfigResponse {
        mecha10_robot_config::ConfigResponse {
            id: "id".to_string(),
            robot_id: "robot".to_string(),
            config_key: config_key.to_string(),
            config_value: mecha10_robot_config::ConfigValue::new(),
            updated_by: None,
            updated_at: chrono::Utc::now(),
            created_at: chrono::Utc::now(),
        }
    }

    #[test]
    fn exclude_sim_assets_drops_simulation_asset_keys_only() {
        let configs = vec![
            make_config_response("@mecha10/motor"),
            make_config_response("mecha10.json"),
            make_config_response("simulation-assets/models/rover/model.json"),
            make_config_response("simulation-assets/environments/basic_arena/environment.json"),
        ];

        let filtered = exclude_sim_assets(configs);

        let keys: Vec<&str> = filtered.iter().map(|c| c.config_key.as_str()).collect();
        assert_eq!(keys, vec!["@mecha10/motor", "mecha10.json"]);
    }

    #[test]
    fn exclude_sim_assets_is_a_noop_when_nothing_matches() {
        let configs = vec![
            make_config_response("@mecha10/motor"),
            make_config_response("mecha10.json"),
        ];

        let filtered = exclude_sim_assets(configs);

        assert_eq!(filtered.len(), 2);
    }

    #[tokio::test]
    async fn get_robot_id_prefers_explicit_arg_over_project_config() {
        let dir = tempdir().unwrap();
        let config_path = write_project_config(dir.path(), "from-config");

        let mut ctx = CliContextBuilder::new()
            .working_dir(dir.path().to_path_buf())
            .config_path(Some(config_path))
            .build()
            .unwrap();

        let robot_id = get_robot_id(&mut ctx, Some("from-arg")).await.unwrap();
        assert_eq!(robot_id, "from-arg");
    }

    #[tokio::test]
    async fn get_robot_id_falls_back_to_project_config() {
        let dir = tempdir().unwrap();
        let config_path = write_project_config(dir.path(), "from-config");

        let mut ctx = CliContextBuilder::new()
            .working_dir(dir.path().to_path_buf())
            .config_path(Some(config_path))
            .build()
            .unwrap();

        let robot_id = get_robot_id(&mut ctx, None).await.unwrap();
        assert_eq!(robot_id, "from-config");
    }

    #[tokio::test]
    async fn get_robot_id_errors_when_no_arg_and_no_project() {
        let dir = tempdir().unwrap();
        // No mecha10.json written, so the project is not initialized.
        let config_path = dir.path().join("mecha10.json");

        let mut ctx = CliContextBuilder::new()
            .working_dir(dir.path().to_path_buf())
            .config_path(Some(config_path))
            .build()
            .unwrap();

        let err = get_robot_id(&mut ctx, None).await.unwrap_err();
        assert!(err.to_string().contains("No robot ID specified"));
    }
}