mecha10-cli 0.7.0

#![allow(dead_code)]

//! CLI execution context
//!
//! The CliContext is the single source of truth for runtime configuration,
//! combining CLI flags, environment variables, and config file settings.

use crate::paths;
use crate::services::{
    ComponentCatalogService, ConfigService, DeploymentService, DevService, DiscoveryService, DockerService,
    InitService, PackageService, ProcessService, ProjectService, ProjectTemplateService, RedisService,
    SimulationService, TemplateDownloadService, TopologyService,
};
use crate::types::ProjectConfig;
use std::path::PathBuf;
use tracing::Level;

pub struct CliContext {
    pub config_path: PathBuf,

    pub log_level: Level,

    pub working_dir: PathBuf,

    redis_url: String,

    postgres_url: Option<String>,

    verbose: bool,

    redis_service: Option<RedisService>,
    project_service: Option<ProjectService>,
    simulation_service: Option<SimulationService>,
    process_service: Option<ProcessService>,
    shared_process_service: Option<std::sync::Arc<std::sync::Mutex<ProcessService>>>,
    docker_service: Option<DockerService>,
    package_service: Option<PackageService>,
    deployment_service: Option<DeploymentService>,
    component_catalog_service: Option<ComponentCatalogService>,
    discovery_service: Option<DiscoveryService>,
    init_service: Option<InitService>,
    project_template_service: Option<ProjectTemplateService>,
    dev_service: Option<DevService>,
    topology_service: Option<TopologyService>,
    template_download_service: Option<TemplateDownloadService>,

    _phantom: std::marker::PhantomData<ProjectConfig>,
}

macro_rules! lazy_init_getter {
    ($(#[$meta:meta])* fn $name:ident() -> &$ty:ty, $field:ident, self |$self_:ident| $ctor:expr) => {
        $(#[$meta])*
        pub fn $name(&mut self) -> &$ty {
            if self.$field.is_none() {
                let value = {
                    let $self_ = &*self;
                    $ctor
                };
                self.$field = Some(value);
            }
            self.$field.as_ref().unwrap()
        }
    };
    ($(#[$meta:meta])* fn $name:ident() -> &$ty:ty, $field:ident, $ctor:expr) => {
        $(#[$meta])*
        pub fn $name(&mut self) -> &$ty {
            if self.$field.is_none() {
                self.$field = Some($ctor);
            }
            self.$field.as_ref().unwrap()
        }
    };
    ($(#[$meta:meta])* mut fn $name:ident() -> &mut $ty:ty, $field:ident, $ctor:expr) => {
        $(#[$meta])*
        pub fn $name(&mut self) -> &mut $ty {
            if self.$field.is_none() {
                self.$field = Some($ctor);
            }
            self.$field.as_mut().unwrap()
        }
    };
    ($(#[$meta:meta])* try fn $name:ident() -> &$ty:ty, $field:ident, |$self_:ident| $ctor:expr) => {
        $(#[$meta])*
        pub fn $name(&mut self) -> anyhow::Result<&$ty> {
            if self.$field.is_none() {
                let value = {
                    let $self_ = &*self;
                    $ctor
                };
                self.$field = Some(value);
            }
            Ok(self.$field.as_ref().unwrap())
        }
    };
}

impl CliContext {
    /// Load the project configuration
    ///
    /// This loads the configuration from disk each time it's called.
    /// For better performance in commands that access config multiple times,
    /// call this once and store the result.
    pub async fn load_project_config(&self) -> anyhow::Result<ProjectConfig> {
        ConfigService::load_from(&self.config_path).await
    }

    /// Check if a project is initialized (mecha10.json exists)
    pub fn is_project_initialized(&self) -> bool {
        ConfigService::is_initialized(&self.working_dir)
    }

    /// Get a path relative to the project root
    pub fn project_path(&self, path: &str) -> PathBuf {
        self.working_dir.join(path)
    }

    /// Check if verbose mode is enabled
    pub fn is_verbose(&self) -> bool {
        self.verbose
    }

    /// Get the Redis connection URL
    pub fn redis_url(&self) -> &str {
        &self.redis_url
    }

    /// Get the PostgreSQL connection URL if configured
    pub fn postgres_url(&self) -> Option<&str> {
        self.postgres_url.as_deref()
    }

    lazy_init_getter!(
        /// Get Redis service (creates on first access)
        try fn redis() -> &RedisService, redis_service, |s| RedisService::new(&s.redis_url)?
    );

    lazy_init_getter!(
        /// Get Project service (creates on first access)
        try fn project() -> &ProjectService, project_service, |s| ProjectService::detect(&s.working_dir)?
    );

    lazy_init_getter!(
        /// Get Simulation service (creates on first access)
        fn simulation() -> &SimulationService, simulation_service, SimulationService::new()
    );

    lazy_init_getter!(
        /// Get Process service (creates on first access)
        mut fn process() -> &mut ProcessService, process_service, ProcessService::new()
    );

    /// Get shared Process service for concurrent access
    ///
    /// This returns an Arc<Mutex<ProcessService>> that can be safely shared
    /// between tasks (e.g., DevSession and CommandListener).
    /// Uses std::sync::Mutex so it works in both sync and async contexts.
    pub fn shared_process(&mut self) -> std::sync::Arc<std::sync::Mutex<ProcessService>> {
        if self.shared_process_service.is_none() {
            self.shared_process_service = Some(std::sync::Arc::new(std::sync::Mutex::new(ProcessService::new())));
        }
        self.shared_process_service.as_ref().unwrap().clone()
    }

    lazy_init_getter!(
        /// Get Docker service (creates on first access)
        fn docker() -> &DockerService, docker_service, DockerService::new()
    );

    /// Get Package service (creates on first access)
    ///
    /// Note: This requires a valid project to be detected with name and version.
    pub fn package(&mut self) -> anyhow::Result<&PackageService> {
        if self.package_service.is_none() {
            let project = self.project()?;
            let name = project.name()?;
            let version = project.version()?;
            self.package_service = Some(PackageService::new(name, version, self.working_dir.clone())?);
        }
        Ok(self.package_service.as_ref().unwrap())
    }

    lazy_init_getter!(
        /// Get Deployment service (creates on first access)
        fn deployment() -> &DeploymentService, deployment_service, DeploymentService::new()
    );

    lazy_init_getter!(
        /// Get Component Catalog service (creates on first access)
        fn component_catalog() -> &ComponentCatalogService, component_catalog_service, ComponentCatalogService::new()
    );

    lazy_init_getter!(
        /// Get Discovery service (creates on first access)
        mut fn discovery() -> &mut DiscoveryService, discovery_service, DiscoveryService::new()
    );

    lazy_init_getter!(
        /// Get Init service (creates on first access)
        fn init_service() -> &InitService, init_service, InitService::new()
    );

    lazy_init_getter!(
        /// Get Project Template service (creates on first access)
        fn project_template_service() -> &ProjectTemplateService, project_template_service, ProjectTemplateService::new()
    );

    lazy_init_getter!(
        /// Get Dev service (creates on first access)
        fn dev() -> &DevService, dev_service, self |s| DevService::new(s.redis_url.clone())
    );

    lazy_init_getter!(
        /// Get Topology service (creates on first access)
        ///
        /// The topology service performs static analysis of project structure,
        /// extracting node definitions and pub/sub topic relationships from source code.
        fn topology() -> &TopologyService, topology_service, self |s| TopologyService::new(s.working_dir.clone())
    );

    lazy_init_getter!(
        /// Get Template Download service (creates on first access)
        ///
        /// Downloads project templates from GitHub releases on-demand.
        /// Templates are versioned and cached locally for offline use.
        fn template_download() -> &TemplateDownloadService, template_download_service, TemplateDownloadService::new()
    );

    /// Validate project structure
    ///
    /// Checks that the project has the expected directory structure
    /// and required files.
    pub fn validate_project_structure(&self) -> anyhow::Result<()> {
        if !self.is_project_initialized() {
            return Err(anyhow::anyhow!("Project not initialized. Run 'mecha10 init' first."));
        }

        let required_dirs = vec!["nodes", "drivers"];
        for dir in required_dirs {
            let path = self.project_path(dir);
            if !path.exists() {
                return Err(anyhow::anyhow!(
                    "Required directory missing: {}. Expected at: {}",
                    dir,
                    path.display()
                ));
            }
        }

        Ok(())
    }

    /// Check if running in CI environment
    pub fn is_ci(&self) -> bool {
        is_ci_environment()
    }

    /// Get logs directory path
    pub fn logs_dir(&self) -> PathBuf {
        self.project_path("logs")
    }

    /// Get data directory path
    pub fn data_dir(&self) -> PathBuf {
        self.project_path("data")
    }

    /// Get recordings directory path
    pub fn recordings_dir(&self) -> PathBuf {
        self.project_path("data/recordings")
    }

    /// Get maps directory path
    pub fn maps_dir(&self) -> PathBuf {
        self.project_path("data/maps")
    }

    /// Get telemetry directory path
    pub fn telemetry_dir(&self) -> PathBuf {
        self.project_path("data/telemetry")
    }

    /// Get simulation directory path
    pub fn simulation_dir(&self) -> PathBuf {
        self.project_path(paths::project::SIMULATION_DIR)
    }

    /// Get RL task-curriculum configs directory path (`configs/rl/tasks`, LAB-2429) - deliberately
    /// separate from `simulation_dir()` since tasks are project RL config, not a simulation/
    /// physics/rendering asset.
    pub fn rl_tasks_dir(&self) -> PathBuf {
        self.project_path(paths::project::RL_TASKS_DIR)
    }

    /// Get target/debug directory path
    pub fn target_debug_dir(&self) -> PathBuf {
        self.project_path("target/debug")
    }

    /// Get target/release directory path
    pub fn target_release_dir(&self) -> PathBuf {
        self.project_path("target/release")
    }

    /// Get packages output directory path
    pub fn packages_dir(&self) -> PathBuf {
        self.project_path("target/packages")
    }

    /// Ensure a directory exists, creating it if necessary
    pub fn ensure_dir(&self, path: &PathBuf) -> anyhow::Result<()> {
        if !path.exists() {
            std::fs::create_dir_all(path)?;
        }
        Ok(())
    }
}

impl Default for CliContext {
    fn default() -> Self {
        CliContextBuilder::new()
            .log_level(Level::INFO)
            .build()
            .expect("Failed to build default CliContext")
    }
}

pub struct CliContextBuilder {
    config_path: Option<PathBuf>,
    log_level: Option<Level>,
    working_dir: Option<PathBuf>,
    redis_url: Option<String>,
    postgres_url: Option<String>,
    verbose: Option<bool>,
}

impl CliContextBuilder {
    /// Create a new builder
    pub fn new() -> Self {
        Self {
            config_path: None,
            log_level: None,
            working_dir: None,
            redis_url: None,
            postgres_url: None,
            verbose: None,
        }
    }

    mecha10_core::builder_setter!(
        /// Set config file path
        assign, config_path, config_path, Option<PathBuf>
    );

    mecha10_core::builder_setter!(
        /// Set log level
        into_some, log_level, log_level, Level
    );

    mecha10_core::builder_setter!(
        /// Set working directory
        into_some, working_dir, working_dir, PathBuf
    );

    mecha10_core::builder_setter!(
        /// Set Redis URL
        into_some, redis_url, redis_url, String
    );

    mecha10_core::builder_setter!(
        /// Set PostgreSQL URL
        assign, postgres_url, postgres_url, Option<String>
    );

    mecha10_core::builder_setter!(
        /// Set verbose mode
        into_some, verbose, verbose, bool
    );

    /// Build the CliContext with proper precedence
    pub fn build(self) -> anyhow::Result<CliContext> {
        let working_dir = self
            .working_dir
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));

        let config_path = self
            .config_path
            .unwrap_or_else(|| working_dir.join(paths::PROJECT_CONFIG));

        let config_redis_url = if config_path.exists() {
            std::fs::read_to_string(&config_path)
                .ok()
                .and_then(|content| serde_json::from_str::<serde_json::Value>(&content).ok())
                .and_then(|json| json.get("redis")?.get("url")?.as_str().map(String::from))
        } else {
            None
        };

        let redis_url = self
            .redis_url
            .or_else(|| std::env::var("MECHA10_REDIS_URL").ok())
            .or_else(|| std::env::var("REDIS_URL").ok())
            .or(config_redis_url)
            .unwrap_or_else(|| "redis://localhost:6379".to_string());

        let postgres_url = self
            .postgres_url
            .or_else(|| std::env::var("DATABASE_URL").ok())
            .or_else(|| std::env::var("POSTGRES_URL").ok());

        let log_level = self.log_level.unwrap_or(Level::INFO);

        let verbose = self.verbose.unwrap_or(false);

        Ok(CliContext {
            config_path,
            log_level,
            working_dir,
            redis_url,
            postgres_url,
            verbose,
            redis_service: None,
            project_service: None,
            simulation_service: None,
            process_service: None,
            shared_process_service: None,
            docker_service: None,
            package_service: None,
            deployment_service: None,
            component_catalog_service: None,
            discovery_service: None,
            init_service: None,
            project_template_service: None,
            dev_service: None,
            topology_service: None,
            template_download_service: None,
            _phantom: std::marker::PhantomData,
        })
    }
}

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

/// Check if running in a CI environment.
///
/// Standalone free function (not just `CliContext::is_ci`) so call sites that don't have a
/// `CliContext` handy - e.g. deciding whether to gate a proactive `mecha10_auth::commands::
/// ensure_authenticated_interactive` call behind the old hard-error, so scripted/CI usage isn't
/// surprised by a device-code poll that blocks until it expires - can still check this.
pub fn is_ci_environment() -> bool {
    std::env::var("CI").is_ok()
        || std::env::var("GITHUB_ACTIONS").is_ok()
        || std::env::var("GITLAB_CI").is_ok()
        || std::env::var("CIRCLECI").is_ok()
        || std::env::var("JENKINS_HOME").is_ok()
}