git_claw/workflow/

init.rs

//! Project initialization workflow (`git claw init`).
//!
//! Scans repository for environment files, compose files, and port variables,
//! and generates a tailored `.git-claw.toml`.

use crate::cli::output::print_success;
use crate::core::config::{DockerConfig, EnvironmentConfig};
use crate::infra::docker::parse_compose_services;
use crate::infra::git::resolve_toplevel;
use crate::workflow::error::WorkflowError;
use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};

/// Options for repository initialization.
pub struct InitOptions<'a> {
    pub yes: bool,
    pub repo_root: Option<&'a Path>,
}

/// Recursively scans directory up to depth 3 for `.env` files.
fn scan_env_files(root: &Path) -> Vec<String> {
    let mut results = Vec::new();

    fn visit_dirs(root: &Path, dir: &Path, depth: usize, results: &mut Vec<String>) {
        if depth > 3 {
            return;
        }
        let entries = match fs::read_dir(dir) {
            Ok(e) => e,
            Err(_) => return,
        };

        for entry in entries.flatten() {
            let path = entry.path();
            let file_name = entry.file_name();
            let name_str = file_name.to_string_lossy();

            if name_str.starts_with('.') && name_str != ".env" {
                continue;
            }
            if name_str == "target" || name_str == "node_modules" || name_str == "vendor" {
                continue;
            }

            if path.is_dir() {
                if name_str == "media" || name_str == "uploads" || name_str == "storage" {
                    if let Ok(rel) = path.strip_prefix(root) {
                        results.push(rel.to_string_lossy().to_string());
                    }
                } else {
                    visit_dirs(root, &path, depth + 1, results);
                }
            } else if path.is_file() && (name_str == ".env" || name_str.ends_with(".env")) {
                if let Ok(rel) = path.strip_prefix(root) {
                    results.push(rel.to_string_lossy().to_string());
                }
            }
        }
    }

    visit_dirs(root, root, 0, &mut results);
    results.sort();
    results
}

/// Scans for standard Compose file locations.
fn scan_compose_file(root: &Path) -> Option<String> {
    let candidates = [
        "docker-compose.yml",
        "docker-compose.yaml",
        "compose.yml",
        "compose.yaml",
        "deploy/docker-compose.yml",
        "docker/docker-compose.yml",
    ];

    for c in &candidates {
        if root.join(c).is_file() {
            return Some((*c).to_string());
        }
    }
    None
}

/// Returns true if a key name is a client connection port to a database/message broker/mail service,
/// which must NOT be shifted by slot offsets.
fn is_client_service_port(key: &str) -> bool {
    let upper = key.to_ascii_uppercase();
    upper.contains("DATABASE")
        || upper.contains("DB_")
        || upper.starts_with("DB")
        || upper.contains("POSTGRES")
        || upper.contains("PGPORT")
        || upper.contains("MYSQL")
        || upper.contains("MARIADB")
        || upper.contains("MONGO")
        || upper.contains("REDIS")
        || upper.contains("EMAIL")
        || upper.contains("SMTP")
        || upper.contains("MAIL")
        || upper.contains("AMQP")
        || upper.contains("RABBITMQ")
}

/// Extracts port definitions from `.env` files.
fn extract_ports_from_env_files(root: &Path, env_files: &[String]) -> BTreeMap<String, u16> {
    let mut ports = BTreeMap::new();

    for rel_path in env_files {
        let full_path = root.join(rel_path);
        let content = match fs::read_to_string(&full_path) {
            Ok(c) => c,
            Err(_) => continue,
        };

        for line in content.lines() {
            let trimmed = line.trim();
            if trimmed.is_empty() || trimmed.starts_with('#') {
                continue;
            }

            if let Some((key, val)) = trimmed.split_once('=') {
                let key = key.trim();
                let val = val.trim().trim_matches(|c| c == '\'' || c == '"');

                if (key == "PORT" || key.contains("PORT")) && !is_client_service_port(key) {
                    if let Ok(port) = val.parse::<u16>() {
                        if port > 0 {
                            ports.insert(key.to_string(), port);
                        }
                    }
                }
            }
        }
    }

    ports
}

/// Scans Compose file for shared services and port definitions.
fn scan_compose_details(
    root: &Path,
    compose_file: &str,
    ports: &mut BTreeMap<String, u16>,
) -> DockerConfig {
    let mut docker = DockerConfig {
        compose_file: Some(compose_file.to_string()),
        network: None,
        shared_services: Vec::new(),
    };

    let content = match fs::read_to_string(root.join(compose_file)) {
        Ok(c) => c,
        Err(_) => return docker,
    };

    let services = parse_compose_services(&content);
    let common_shared = [
        "postgres",
        "postgresql",
        "db",
        "database",
        "redis",
        "mysql",
        "mariadb",
        "mongo",
        "mongodb",
        "rabbitmq",
    ];

    for svc in services {
        if common_shared.contains(&svc.name.as_str()) {
            docker.shared_services.push(svc.name);
        }
    }

    // Scan for port interpolation syntax in compose: ${PORT_VAR:-8000}
    for line in content.lines() {
        if let Some(start_idx) = line.find("${") {
            let rest = &line[start_idx + 2..];
            if let Some(end_idx) = rest.find('}') {
                let var_expr = &rest[..end_idx];
                if let Some((var_name, default_val)) = var_expr.split_once(":-") {
                    if (var_name == "PORT" || var_name.contains("PORT"))
                        && !is_client_service_port(var_name)
                        && !ports.contains_key(var_name)
                    {
                        if let Ok(port) = default_val.parse::<u16>() {
                            ports.insert(var_name.to_string(), port);
                        }
                    }
                }
            }
        }
    }

    docker.network = scan_compose_network(&content);

    docker
}

/// Scans Compose file for defined network name.
fn scan_compose_network(content: &str) -> Option<String> {
    let mut in_networks = false;
    let mut networks_indent = 0;
    let mut current_net: Option<String> = None;
    let mut net_indent_level: Option<usize> = None;

    for line in content.lines() {
        let trimmed_end = line.trim_end();
        if trimmed_end.is_empty() || trimmed_end.trim_start().starts_with('#') {
            continue;
        }
        let indent = line.len() - line.trim_start().len();
        let trimmed = trimmed_end.trim();

        if !in_networks {
            if trimmed == "networks:" || trimmed.starts_with("networks:") {
                in_networks = true;
                networks_indent = indent;
            }
            continue;
        }

        if indent <= networks_indent && !trimmed.is_empty() {
            break;
        }

        if let Some(expected_level) = net_indent_level {
            if indent == expected_level && trimmed.ends_with(':') {
                if let Some(net) = current_net {
                    if net != "default" {
                        return Some(net);
                    }
                }
                let name = trimmed
                    .trim_end_matches(':')
                    .trim()
                    .trim_matches(|c| c == '\'' || c == '"');
                current_net = Some(name.to_string());
                continue;
            } else if indent > expected_level {
                if let Some(stripped) = trimmed.strip_prefix("name:") {
                    let val = stripped.trim().trim_matches(|c| c == '\'' || c == '"');
                    if !val.is_empty() {
                        return Some(val.to_string());
                    }
                }
                continue;
            }
        }

        if indent > networks_indent && trimmed.ends_with(':') {
            net_indent_level = Some(indent);
            let name = trimmed
                .trim_end_matches(':')
                .trim()
                .trim_matches(|c| c == '\'' || c == '"');
            current_net = Some(name.to_string());
        }
    }

    if let Some(net) = current_net {
        if net != "default" {
            return Some(net);
        }
    }

    None
}

/// Scans repository root for runtime environments (`pyenv`, `uv`, `venv`),
/// version files, and cache directories to share.
///
/// Returns detected `EnvironmentConfig` and an optional cache directory name to share (e.g. `".venv"`).
///
/// # Examples
///
/// ```
/// use git_claw::workflow::init::scan_environment;
/// use tempfile::tempdir;
/// use std::fs;
///
/// let dir = tempdir().unwrap();
/// fs::write(dir.path().join(".python-version"), "3.12.0\n").unwrap();
/// let (env, cache_dir) = scan_environment(dir.path());
/// assert_eq!(env.r#type.as_deref(), Some("pyenv"));
/// assert_eq!(env.name.as_deref(), Some("3.12.0"));
/// assert!(env.copy_files.contains(&".python-version".to_string()));
/// assert_eq!(cache_dir, None);
/// ```
pub fn scan_environment(root: &Path) -> (EnvironmentConfig, Option<String>) {
    let mut env = EnvironmentConfig::default();

    let py_version_file = root.join(".python-version");
    if py_version_file.is_file() {
        env.r#type = Some("pyenv".to_string());
        if let Ok(content) = fs::read_to_string(&py_version_file) {
            let trimmed = content.trim();
            if !trimmed.is_empty() {
                env.name = Some(trimmed.to_string());
            }
        }
    } else if root.join("uv.lock").is_file() {
        env.r#type = Some("uv".to_string());
    } else if root.join(".venv").is_dir() {
        env.r#type = Some("venv".to_string());
    }

    let standard_files = [".python-version", ".node-version", ".nvmrc", ".envrc"];
    for file in &standard_files {
        if root.join(file).is_file() {
            env.copy_files.push((*file).to_string());
        }
    }

    let cache_dir = if root.join(".venv").is_dir() || root.join("uv.lock").is_file() {
        Some(".venv".to_string())
    } else {
        None
    };

    (env, cache_dir)
}

/// Generates tailored `.git-claw.toml` content.
///
/// # Examples
///
/// ```
/// use git_claw::workflow::init::generate_init_toml;
/// use git_claw::core::config::{DockerConfig, EnvironmentConfig};
/// use std::collections::BTreeMap;
///
/// let docker = DockerConfig::default();
/// let env = EnvironmentConfig {
///     r#type: Some("pyenv".to_string()),
///     name: Some("3.12.0".to_string()),
///     copy_files: vec![".python-version".to_string()],
/// };
/// let cache = vec![".venv".to_string()];
/// let toml = generate_init_toml("main", &BTreeMap::new(), &[], &docker, &env, &cache);
/// assert!(toml.contains("[environment]"));
/// assert!(toml.contains("type = \"pyenv\""));
/// assert!(toml.contains("[cache]"));
/// ```
pub fn generate_init_toml(
    main_branch: &str,
    ports: &BTreeMap<String, u16>,
    files: &[String],
    docker: &DockerConfig,
    environment: &EnvironmentConfig,
    cache_dirs: &[String],
) -> String {
    let mut toml = String::new();
    toml.push_str("[project]\n");
    toml.push_str(&format!("main_branch = \"{}\"\n", main_branch));

    if !ports.is_empty() {
        toml.push_str("\n[ports]\n");
        for (k, v) in ports {
            toml.push_str(&format!("{} = {}\n", k, v));
        }
    }

    if !files.is_empty() {
        toml.push_str("\n[files]\n");
        toml.push_str("copy = [\n");
        for f in files {
            toml.push_str(&format!("    \"{}\",\n", f));
        }
        toml.push_str("]\n");
    }

    let has_env = environment.r#type.is_some()
        || environment.name.is_some()
        || !environment.copy_files.is_empty();

    if has_env {
        toml.push_str("\n[environment]\n");
        if let Some(ref t) = environment.r#type {
            toml.push_str(&format!("type = \"{}\"\n", t));
        }
        if let Some(ref n) = environment.name {
            toml.push_str(&format!("name = \"{}\"\n", n));
        }
        if !environment.copy_files.is_empty() {
            let files_str = environment
                .copy_files
                .iter()
                .map(|f| format!("\"{}\"", f))
                .collect::<Vec<_>>()
                .join(", ");
            toml.push_str(&format!("copy_files = [{}]\n", files_str));
        }
    }

    if !cache_dirs.is_empty() {
        toml.push_str("\n[cache]\n");
        toml.push_str("directories = [\n");
        for d in cache_dirs {
            toml.push_str(&format!("    \"{}\",\n", d));
        }
        toml.push_str("]\n");
    }

    if docker.is_enabled() {
        toml.push_str("\n[docker]\n");
        if let Some(ref cf) = docker.compose_file {
            toml.push_str(&format!("compose_file = \"{}\"\n", cf));
        }
        if let Some(ref net) = docker.network {
            toml.push_str(&format!("network = \"{}\"\n", net));
        }
        if !docker.shared_services.is_empty() {
            let svcs = docker
                .shared_services
                .iter()
                .map(|s| format!("\"{}\"", s))
                .collect::<Vec<_>>()
                .join(", ");
            toml.push_str(&format!("shared_services = [{}]\n", svcs));
        }
    }

    toml
}

/// Runs the repository initialization workflow.
///
/// # Example
///
/// ```
/// use git_claw::workflow::init::{run_init_workflow, InitOptions};
/// use tempfile::tempdir;
///
/// let dir = tempdir().unwrap();
/// let opts = InitOptions { yes: true, repo_root: Some(dir.path()) };
/// let _ = run_init_workflow(opts);
/// ```
pub fn run_init_workflow(options: InitOptions) -> Result<PathBuf, WorkflowError> {
    let root = resolve_toplevel(options.repo_root)?;
    let target = root.join(".git-claw.toml");

    let env_files = scan_env_files(&root);
    let mut ports = extract_ports_from_env_files(&root, &env_files);

    let (environment, cache_dir) = scan_environment(&root);
    let cache_dirs = cache_dir.map(|c| vec![c]).unwrap_or_default();

    let docker = if let Some(compose_file) = scan_compose_file(&root) {
        scan_compose_details(&root, &compose_file, &mut ports)
    } else {
        DockerConfig::default()
    };

    let content = generate_init_toml(
        "main",
        &ports,
        &env_files,
        &docker,
        &environment,
        &cache_dirs,
    );
    fs::write(&target, content)?;

    print_success(format!(
        "Initialized .git-claw.toml configuration at {}",
        target.display()
    ));

    Ok(target)
}

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

    #[test]
    fn test_scan_environment_pyenv_and_venv() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join(".python-version"), "tune\n").unwrap();
        fs::create_dir_all(dir.path().join(".venv")).unwrap();

        let (env, cache_dir) = scan_environment(dir.path());
        assert_eq!(env.r#type.as_deref(), Some("pyenv"));
        assert_eq!(env.name.as_deref(), Some("tune"));
        assert!(env.copy_files.contains(&".python-version".to_string()));
        assert_eq!(cache_dir.as_deref(), Some(".venv"));
    }

    #[test]
    fn test_scan_environment_uv() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join("uv.lock"), "# lockfile").unwrap();

        let (env, cache_dir) = scan_environment(dir.path());
        assert_eq!(env.r#type.as_deref(), Some("uv"));
        assert_eq!(env.name, None);
        assert_eq!(cache_dir.as_deref(), Some(".venv"));
    }

    #[test]
    fn test_scan_environment_node_files() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join(".nvmrc"), "v20.0.0\n").unwrap();
        fs::write(dir.path().join(".node-version"), "20\n").unwrap();
        fs::write(dir.path().join(".envrc"), "use flake\n").unwrap();

        let (env, cache_dir) = scan_environment(dir.path());
        assert_eq!(env.r#type, None);
        assert!(env.copy_files.contains(&".nvmrc".to_string()));
        assert!(env.copy_files.contains(&".node-version".to_string()));
        assert!(env.copy_files.contains(&".envrc".to_string()));
        assert_eq!(cache_dir, None);
    }
}