Maintain/Run/

CLI.rs

//=============================================================================//
// File Path: Element/Maintain/Source/Run/CLI.rs
//=============================================================================//
// Module: CLI - Command Line Interface for Development Run
//
// This module provides the cargo-first CLI interface that enables triggering
// development runs directly with the Cargo utility instead of shell scripts.
//
// RESPONSIBILITIES:
// ================
//
// Primary:
// - Parse command-line arguments for profile-based runs
// - Load and validate configuration from land-config.json
// - Resolve environment variables from configuration
// - Execute development runs with resolved configuration
//
// Secondary:
// - Provide utility commands (--list-profiles, --show-profile)
// - Support dry-run mode for configuration preview
// - Enable profile aliases for quick access
//
// USAGE:
// ======
//
// Basic usage:
// ```bash
// cargo run --bin Maintain -- --run --profile debug-mountain
// ```
//
// List profiles:
// ```bash
// cargo run --bin Maintain -- --run --list-profiles
// ```
//
// Dry run:
// ```bash
// cargo run --bin Maintain -- --run --profile debug --dry-run
// ```
//
//===================================================================================

use clap::{Parser, Subcommand, ValueEnum};
use colored::Colorize;
use std::collections::HashMap;
use std::path::PathBuf;

use crate::Build::Rhai::{load_config, LandConfig, Profile as ConfigProfile};

//=============================================================================
// CLI Argument Definitions
//=============================================================================

/// Land Run System - Configuration-based development runs via Cargo
#[derive(Parser, Debug, Clone)]
#[clap(
    name = "maintain-run",
    author,
    version,
    about = "Land Run System - Configuration-based development runs",
    long_about = "A configuration-driven run system that enables triggering development \
    runs directly with Cargo instead of shell scripts. Reads configuration \
    from .vscode/land-config.json and supports multiple run profiles with \
    hot-reload support."
)]
pub struct Cli {
    #[clap(subcommand)]
    pub command: Option<Commands>,

    /// Run profile to use (shortcut for 'run' subcommand)
    #[clap(long, short = 'p', value_parser = parse_profile_name)]
    pub profile: Option<String>,

    /// Configuration file path (default: .vscode/land-config.json)
    #[clap(long, short = 'c', global = true)]
    pub config: Option<PathBuf>,

    /// Override workbench type
    #[clap(long, short = 'w', global = true)]
    pub workbench: Option<String>,

    /// Override Node.js version
    #[clap(long, short = 'n', global = true)]
    pub node_version: Option<String>,

    /// Override Node.js environment
    #[clap(long, short = 'e', global = true)]
    pub environment: Option<String>,

    /// Override dependency source
    #[clap(long, short = 'd', global = true)]
    pub dependency: Option<String>,

    /// Override environment variables (key=value pairs)
    #[clap(long = "env", value_parser = parse_key_val::<String, String>, global = true, action = clap::ArgAction::Append)]
    pub env_override: Vec<(String, String)>,

    /// Enable hot-reload (default: true for dev runs)
    #[clap(long, global = true, default_value = "true")]
    pub hot_reload: bool,

    /// Enable watch mode (default: true for dev runs)
    #[clap(long, global = true, default_value = "true")]
    pub watch: bool,

    /// Live-reload port
    #[clap(long, global = true, default_value = "3001")]
    pub live_reload_port: u16,

    /// Enable dry-run mode (show config without running)
    #[clap(long, global = true)]
    pub dry_run: bool,

    /// Enable verbose output
    #[clap(long, short = 'v', global = true)]
    pub verbose: bool,

    /// Merge with shell environment (default: true)
    #[clap(long, default_value = "true", global = true)]
    pub merge_env: bool,

    /// Additional run arguments (passed through to run command)
    #[clap(last = true)]
    pub run_args: Vec<String>,
}

/// Available subcommands
#[derive(Subcommand, Debug, Clone)]
pub enum Commands {
    /// Execute a development run with the specified profile
    Run {
        /// Run profile to use
        #[clap(long, short = 'p', value_parser = parse_profile_name)]
        profile: String,

        /// Enable hot-reload
        #[clap(long, default_value = "true")]
        hot_reload: bool,

        /// Enable dry-run mode
        #[clap(long)]
        dry_run: bool,
    },

    /// List all available run profiles
    ListProfiles {
        /// Show detailed information for each profile
        #[clap(long, short = 'v')]
        verbose: bool,
    },

    /// Show details for a specific profile
    ShowProfile {
        /// Profile name to show
        profile: String,
    },

    /// Validate a run profile
    ValidateProfile {
        /// Profile name to validate
        profile: String,
    },

    /// Show current environment variable resolution
    Resolve {
        /// Profile name to resolve
        #[clap(long, short = 'p')]
        profile: String,

        /// Output format
        #[clap(long, short = 'f', default_value = "table")]
        format: OutputFormat,
    },
}

/// Output format options
#[derive(Debug, Clone, ValueEnum)]
pub enum OutputFormat {
    Table,
    Json,
    Env,
}

impl std::fmt::Display for OutputFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            OutputFormat::Table => write!(f, "table"),
            OutputFormat::Json => write!(f, "json"),
            OutputFormat::Env => write!(f, "env"),
        }
    }
}

//=============================================================================
// CLI Implementation
//=============================================================================

impl Cli {
    /// Execute the CLI command
    pub fn execute(&self) -> Result<(), String> {
        let config_path = self.config.clone().unwrap_or_else(|| {
            PathBuf::from(".vscode/land-config.json")
        });

        // Load configuration
        let config = load_config(&config_path)
            .map_err(|e| format!("Failed to load configuration: {}", e))?;

        // Handle subcommands
        if let Some(command) = &self.command {
            return self.execute_command(command, &config);
        }

        // Handle direct profile argument
        if let Some(profile_name) = &self.profile {
            return self.execute_run(profile_name, &config, self.dry_run);
        }

        // Default: show help
        Err("No command specified. Use --profile <name> to run or --help for usage.".to_string())
    }

    /// Execute a subcommand
    fn execute_command(&self, command: &Commands, config: &LandConfig) -> Result<(), String> {
        match command {
            Commands::Run { profile, hot_reload, dry_run } => {
                let _ = hot_reload; // Use hot_reload for run-specific logic
                self.execute_run(profile, config, *dry_run)
            }
            Commands::ListProfiles { verbose } => {
                self.execute_list_profiles(config, *verbose)
            }
            Commands::ShowProfile { profile } => {
                self.execute_show_profile(profile, config)
            }
            Commands::ValidateProfile { profile } => {
                self.execute_validate_profile(profile, config)
            }
            Commands::Resolve { profile, format } => {
                self.execute_resolve(profile, config, Some(format.to_string()))
            }
        }
    }

    /// Execute a run with the specified profile
    fn execute_run(
        &self,
        profile_name: &str,
        config: &LandConfig,
        dry_run: bool,
    ) -> Result<(), String> {
        // Resolve profile name (handle aliases)
        let resolved_profile = resolve_profile_name(profile_name, config);

        // Get profile from config
        let profile = config.profiles.get(&resolved_profile).ok_or_else(|| {
            format!(
                "Profile '{}' not found. Available profiles: {}",
                resolved_profile,
                config.profiles.keys().cloned().collect::<Vec<_>>().join(", ")
            )
        })?;

        // Print run header
        print_run_header(&resolved_profile, profile);

        // Resolve environment variables with dual-path merge
        let env_vars = resolve_environment_dual_path(
            profile,
            config,
            self.merge_env,
            &self.env_override,
        );

        // Apply CLI overrides for explicit flags
        let env_vars = apply_overrides(
            env_vars,
            &self.workbench,
            &self.node_version,
            &self.environment,
            &self.dependency,
        );

        // Print resolved configuration
        if self.verbose || dry_run {
            print_resolved_environment(&env_vars);
        }

        // Dry run: stop here
        if dry_run {
            println!("\n{}", "Dry run complete. No changes made.");
            return Ok(());
        }

        // Execute run
        execute_run_command(&resolved_profile, config, &env_vars, &self.run_args)
    }

    /// List all available profiles
    fn execute_list_profiles(&self, config: &LandConfig, verbose: bool) -> Result<(), String> {
        println!("\n{}", "Land Run System - Available Profiles");
        println!("{}\n", "=".repeat(50));

        // Group profiles by type
        let mut debug_profiles: Vec<_> = config
            .profiles
            .iter()
            .filter(|(k, _)| k.starts_with("debug"))
            .collect();
        let mut release_profiles: Vec<_> = config
            .profiles
            .iter()
            .filter(|(k, _)| {
                k.starts_with("production") || k.starts_with("release") || k.starts_with("web")
            })
            .collect();

        // Sort profiles
        debug_profiles.sort_by_key(|(k, _)| k.as_str());
        release_profiles.sort_by_key(|(k, _)| k.as_str());

        // Print debug profiles
        println!("{}:", "Debug Profiles".yellow());
        println!();
        for (name, profile) in &debug_profiles {
            let default_profile = config.cli.as_ref()
                .and_then(|cli| cli.default_profile.as_ref())
                .map(|s| s.as_str())
                .unwrap_or("");
            let recommended = default_profile == name.as_str();
            let marker = if recommended { " [RECOMMENDED]" } else { "" };
            println!(
                " {:<20} - {}{}",
                name.green(),
                profile.description.as_ref().map(|d| d.as_str()).unwrap_or("No description"),
                marker.bright_magenta()
            );
            if verbose {
                if let Some(workbench) = &profile.workbench {
                    println!(" Workbench: {}", workbench);
                }
                if let Some(features) = &profile.features {
                    for (feature, enabled) in features {
                        let status = if *enabled { "[X]" } else { "[ ]" };
                        println!(" {:>20} {} = {}", feature.cyan(), status, enabled);
                    }
                }
            }
        }

        // Print release profiles
        println!("\n{}:", "Release Profiles".yellow());
        for (name, profile) in &release_profiles {
            println!(
                " {:<20} - {}",
                name.green(),
                profile.description.as_ref().map(|d| d.as_str()).unwrap_or("No description")
            );
            if verbose {
                if let Some(workbench) = &profile.workbench {
                    println!(" Workbench: {}", workbench);
                }
            }
        }

        // Print CLI aliases if available
        if let Some(cli_config) = &config.cli {
            if !cli_config.profile_aliases.is_empty() {
                println!("\n{}:", "Profile Aliases");
                for (alias, target) in &cli_config.profile_aliases {
                    println!(" {:<10} -> {}", alias.cyan(), target);
                }
            }
        }

        println!();
        Ok(())
    }

    /// Show details for a specific profile
    fn execute_show_profile(&self, profile_name: &str, config: &LandConfig) -> Result<(), String> {
        let resolved_profile = resolve_profile_name(profile_name, config);

        let profile = config.profiles.get(&resolved_profile).ok_or_else(|| {
            format!("Profile '{}' not found.", resolved_profile)
        })?;

        println!("\n{}: {}", "Profile:", resolved_profile.green());
        println!("{}\n", "=".repeat(50));

        // Description
        if let Some(desc) = &profile.description {
            println!("Description: {}", desc);
        }

        // Workbench
        if let Some(workbench) = &profile.workbench {
            println!("\nWorkbench:");
            println!(" Type: {}", workbench);
        }

        // Environment Variables
        println!("\nEnvironment Variables:");
        if let Some(env) = &profile.env {
            let mut sorted_env: Vec<_> = env.iter().collect();
            sorted_env.sort_by_key(|(k, _)| k.as_str());
            for (key, value) in sorted_env {
                println!(" {:<25} = {}", key, value);
            }
        }

        // Features
        if let Some(features) = &profile.features {
            println!("\nFeatures:");
            println!("\n Enabled:");
            let mut sorted_features: Vec<_> = features.iter()
                .filter(|(_, enabled)| **enabled)
                .collect();
            sorted_features.sort_by_key(|(k, _)| k.as_str());
            for (feature, _) in &sorted_features {
                println!(" {:<30}", feature.green());
            }
        }

        // Rhai Script
        if let Some(script) = &profile.rhai_script {
            println!("\nRhai Script: {}", script);
        }

        println!();
        Ok(())
    }

    /// Validate a profile's configuration
    fn execute_validate_profile(&self, profile_name: &str, config: &LandConfig) -> Result<(), String> {
        let resolved_profile = resolve_profile_name(profile_name, config);

        let profile = config.profiles.get(&resolved_profile).ok_or_else(|| {
            format!("Profile '{}' not found.", resolved_profile)
        })?;

        println!("\n{}: {}", "Validating Profile:", resolved_profile.green());
        println!("{}\n", "=".repeat(50));

        let mut issues = Vec::new();
        let mut warnings = Vec::new();

        // Check description
        if profile.description.is_none() {
            warnings.push("Profile has no description".to_string());
        }

        // Check workbench
        if profile.workbench.is_none() {
            issues.push("Profile has no workbench type specified".to_string());
        }

        // Check environment variables
        if profile.env.is_none() || profile.env.as_ref().unwrap().is_empty() {
            warnings.push("Profile has no environment variables defined".to_string());
        }

        // Display results
        if issues.is_empty() && warnings.is_empty() {
            println!("{}", "Profile is valid!".green());
        } else {
            if !warnings.is_empty() {
                println!("\n{} Warnings:", warnings.len().to_string().yellow());
                for warning in &warnings {
                    println!(" - {}", warning.yellow());
                }
            }
            if !issues.is_empty() {
                println!("\n{} Issues:", issues.len().to_string().red());
                for issue in &issues {
                    println!(" - {}", issue.red());
                }
            }
        }

        println!();
        Ok(())
    }

    /// Resolve a profile to its resolved configuration
    fn execute_resolve(&self, profile_name: &str, config: &LandConfig, _format: Option<String>) -> Result<(), String> {
        let resolved_profile = resolve_profile_name(profile_name, config);

        let profile = config.profiles.get(&resolved_profile).ok_or_else(|| {
            format!("Profile '{}' not found.", resolved_profile)
        })?;

        println!("\n{}: {}", "Resolved Profile:", resolved_profile.green());
        println!("{}\n", "=".repeat(50));

        // Profile information
        if let Some(desc) = &profile.description {
            println!("Description: {}", desc);
        }

        if let Some(workbench) = &profile.workbench {
            println!("Workbench: {}", workbench);
        }

        // Environment Variables
        if let Some(env) = &profile.env {
            println!("\nEnvironment Variables ({}):", env.len());
            for (key, value) in env {
                println!(" {} = {}", key.green(), value);
            }
        }

        // Features
        if let Some(features) = &profile.features {
            println!("\nFeatures ({}):", features.len());
            for (feature, enabled) in features {
                let status = if *enabled { "[X]" } else { "[ ]" };
                println!(" {} {}", status, feature);
            }
        }

        println!();
        Ok(())
    }
}

//=============================================================================
// Helper Functions (standalone functions, not methods)
//=============================================================================

/// Print run header
fn print_run_header(profile_name: &str, profile: &ConfigProfile) {
    println!("\n{}", "========================================");
    println!("Land Run: {}", profile_name);
    println!("========================================");

    if let Some(desc) = &profile.description {
        println!("Description: {}", desc);
    }

    if let Some(workbench) = &profile.workbench {
        println!("Workbench: {}", workbench);
    }
}

/// Print resolved environment variables
fn print_resolved_environment(env: &HashMap<String, String>) {
    println!("\nResolved Environment:");
    let mut sorted_env: Vec<_> = env.iter().collect();
    sorted_env.sort_by_key(|(k, _)| k.as_str());

    for (key, value) in sorted_env {
        let display_value = if value.is_empty() {
            "(empty)"
        } else {
            value
        };
        println!(" {:<25} = {}", key, display_value);
    }
}

/// Parse and validate profile name
fn parse_profile_name(s: &str) -> Result<String, String> {
    let name = s.trim().to_lowercase();

    if name.is_empty() {
        return Err("Profile name cannot be empty".to_string());
    }

    if name.contains(' ') {
        return Err("Profile name cannot contain spaces".to_string());
    }

    Ok(name)
}

/// Resolve profile name (handle aliases)
fn resolve_profile_name(name: &str, config: &LandConfig) -> String {
    if let Some(cli_config) = &config.cli {
        if let Some(resolved) = cli_config.profile_aliases.get(name) {
            return resolved.clone();
        }
    }
    name.to_string()
}

/// Resolve environment variables with dual-path merging.
///
/// This function implements the dual-path environment resolution:
/// - Path A: Shell environment variables (from process)
/// - Path B: CLI profile configuration (from land-config.json)
///
/// Merge priority (lowest to highest):
/// 1. Template defaults
/// 2. Shell environment variables (if merge_env is true)
/// 3. Profile environment variables
/// 4. CLI --env overrides
///
/// # Arguments
///
/// * `profile` - The profile configuration
/// * `config` - The land configuration
/// * `merge_env` - Whether to merge with shell environment
/// * `cli_overrides` - CLI --env override pairs
///
/// # Returns
///
/// Merged HashMap of environment variables
fn resolve_environment_dual_path(
    profile: &ConfigProfile,
    config: &LandConfig,
    merge_env: bool,
    cli_overrides: &[(String, String)],
) -> HashMap<String, String> {
    let mut env = HashMap::new();

    // Layer 1: Start with template defaults (lowest priority)
    if let Some(templates) = &config.templates {
        for (key, value) in &templates.env {
            env.insert(key.clone(), value.clone());
        }
    }

    // Layer 2: Merge shell environment variables (if enabled)
    if merge_env {
        for (key, value) in std::env::vars() {
            // Only merge relevant environment variables
            // that are part of our build system
            if is_run_env_var(&key) {
                env.insert(key, value);
            }
        }
    }

    // Layer 3: Apply profile environment (overrides shell)
    if let Some(profile_env) = &profile.env {
        for (key, value) in profile_env {
            env.insert(key.clone(), value.clone());
        }
    }

    // Layer 4: Apply CLI --env overrides (highest priority)
    for (key, value) in cli_overrides {
        env.insert(key.clone(), value.clone());
    }

    env
}

/// Check if an environment variable is a run system variable.
fn is_run_env_var(key: &str) -> bool {
    matches!(
        key,
        "Browser"
        | "Bundle"
        | "Clean"
        | "Compile"
        | "Debug"
        | "Dependency"
        | "Mountain"
        | "Wind"
        | "Electron"
        | "BrowserProxy"
        | "NODE_ENV"
        | "NODE_VERSION"
        | "NODE_OPTIONS"
        | "RUST_LOG"
        | "AIR_LOG_JSON"
        | "AIR_LOG_FILE"
        | "Level"
        | "Name"
        | "Prefix"
        | "HOT_RELOAD"
        | "WATCH"
    )
}

/// Parse a key=value pair from command line.
fn parse_key_val<K, V>(s: &str) -> Result<(K, V), String>
where
    K: std::str::FromStr,
    V: std::str::FromStr,
    K::Err: std::fmt::Display,
    V::Err: std::fmt::Display,
{
    let pos = s
        .find('=')
        .ok_or_else(|| format!("invalid KEY=value: no `=` found in `{s}`"))?;
    Ok((
        s[..pos].parse().map_err(|e| format!("key parse error: {e}"))?,
        s[pos + 1..].parse().map_err(|e| format!("value parse error: {e}"))?,
    ))
}

/// Apply CLI overrides to environment
fn apply_overrides(
    mut env: HashMap<String, String>,
    workbench: &Option<String>,
    node_version: &Option<String>,
    environment: &Option<String>,
    dependency: &Option<String>,
) -> HashMap<String, String> {
    if let Some(workbench) = workbench {
        // Clear all workbench flags
        env.remove("Browser");
        env.remove("Wind");
        env.remove("Mountain");
        env.remove("Electron");
        env.remove("BrowserProxy");

        // Set the selected workbench
        env.insert(workbench.clone(), "true".to_string());
    }

    if let Some(version) = node_version {
        env.insert("NODE_VERSION".to_string(), version.clone());
    }

    if let Some(environment) = environment {
        env.insert("NODE_ENV".to_string(), environment.clone());
    }

    if let Some(dependency) = dependency {
        env.insert("Dependency".to_string(), dependency.clone());
    }

    env
}

/// Execute the run command with dual-path environment injection.
///
/// This function:
/// 1. Calls the Maintain binary in run mode with merged environment variables
/// 2. Starts the development server with hot-reload
/// 3. Watches for file changes
///
/// # Arguments
///
/// * `profile_name` - The resolved profile name
/// * `config` - Land configuration
/// * `env_vars` - Merged environment variables from all sources
/// * `run_args` - Additional run arguments
///
/// # Returns
///
/// Result indicating success or failure
fn execute_run_command(
    profile_name: &str,
    config: &LandConfig,
    env_vars: &HashMap<String, String>,
    run_args: &[String],
) -> Result<(), String> {
    use std::process::Command as StdCommand;

    // Determine if this is a debug run
    let is_debug = profile_name.starts_with("debug");

    // Build the run command
    // For development runs, we typically use: pnpm dev or pnpm tauri dev
    let run_command = if is_debug {
        "pnpm tauri dev"
    } else {
        "pnpm dev"
    };

    // Build the command arguments
    let mut cmd_args: Vec<String> = run_command.split_whitespace().map(|s| s.to_string()).collect();
    cmd_args.extend(run_args.iter().cloned());

    println!("Executing: {}", cmd_args.join(" "));
    println!("With environment variables:");
    for (key, value) in env_vars.iter().take(10) {
        println!(" {}={}", key, value);
    }
    if env_vars.len() > 10 {
        println!(" ... and {} more", env_vars.len() - 10);
    }

    // Parse command into shell command and arguments
    let (shell_cmd, args) = cmd_args.split_first()
        .ok_or("Empty command")?;

    // Execute the command with merged environment variables
    let mut cmd = StdCommand::new(shell_cmd);
    cmd.args(args);
    cmd.envs(env_vars.iter());

    // Set the run mode indicator
    cmd.env("MAINTAIN_RUN_MODE", "true");

    cmd.stderr(std::process::Stdio::inherit())
        .stdout(std::process::Stdio::inherit());

    let status = cmd.status()
        .map_err(|e| format!("Failed to execute run command ({}): {}", shell_cmd, e))?;

    if status.success() {
        println!("\n{}", "Run completed successfully!".green());
        Ok(())
    } else {
        Err(format!("Run failed with exit code: {:?}", status.code()))
    }
}