wsb 0.85.227722

use crate::fleet::config::GitModules;
use crate::fleet::error::{Result, SuperGitError};
use crate::fleet::git::GitOps;
use crate::fleet::output::Formatter;
use std::path::{Path, PathBuf};
use std::process::Command;

/// A single action taken during the merge-back process, for audit trail.
#[derive(Debug)]
struct Action {
    repo_name: String,
    description: String,
    succeeded: bool,
}

/// Tracks everything the merge-back does for chronological replay on failure.
struct AuditLog {
    actions: Vec<Action>,
}

impl AuditLog {
    fn new() -> Self {
        Self {
            actions: Vec::new(),
        }
    }

    fn record(&mut self, repo_name: &str, description: &str, succeeded: bool) {
        self.actions.push(Action {
            repo_name: repo_name.to_string(),
            description: description.to_string(),
            succeeded,
        });
    }

    fn print_and_fail(&self, final_error: &str) -> SuperGitError {
        eprintln!();
        Formatter::print_error("Merge-back failed. Chronological action log:");
        eprintln!();
        for (i, action) in self.actions.iter().enumerate() {
            let symbol = if action.succeeded { "✓" } else { "✗" };
            let color_symbol = if action.succeeded {
                format!("\x1b[32m{}\x1b[0m", symbol) // green
            } else {
                format!("\x1b[31m{}\x1b[0m", symbol) // red
            };
            eprintln!(
                "  {:>3}. {} [{}] {}",
                i + 1,
                color_symbol,
                action.repo_name,
                action.description,
            );
        }
        eprintln!();
        SuperGitError::Other(final_error.to_string())
    }
}

/// Info collected about each repo during pre-flight.
struct RepoInfo {
    name: String,
    path: PathBuf,
    current_branch: String,
    main_branch: String,
}

pub fn execute<P: AsRef<Path>>(
    repo_root: P,
    message: &str,
    dry_run: bool,
    verbose: bool,
) -> Result<()> {
    let repo_root = repo_root.as_ref();
    let gitmodules = GitModules::parse(repo_root)?;

    Formatter::print_info(&format!(
        "Merge-back: superproject + {} submodule(s)",
        gitmodules.submodules.len()
    ));

    // ── Phase 1: Pre-flight checks ──────────────────────────────────────
    Formatter::print_info("Running pre-flight checks...");

    let mut repos: Vec<RepoInfo> = Vec::new();

    // Check superproject
    {
        let super_repo = GitOps::open_repo(repo_root)?;

        if GitOps::is_detached_head(&super_repo)? {
            return Err(SuperGitError::Other(
                "Superproject is in detached HEAD state".to_string(),
            ));
        }

        let current_branch = GitOps::current_branch(&super_repo)?;
        let main_branch = GitOps::get_default_branch(&super_repo)?;

        if current_branch == main_branch {
            return Err(SuperGitError::Other(format!(
                "Superproject is already on '{}'. Merge-back requires being on a feature branch.",
                main_branch
            )));
        }

        // Verify main branch exists (get_default_branch already does this, but be explicit)
        if !GitOps::branch_exists(&super_repo, &main_branch)? {
            return Err(SuperGitError::Other(format!(
                "Superproject has no '{}' branch",
                main_branch
            )));
        }

        if verbose {
            Formatter::print_info(&format!(
                "Superproject: on '{}', will merge into '{}'",
                current_branch, main_branch
            ));
        }

        repos.push(RepoInfo {
            name: "[SUPERPROJECT]".to_string(),
            path: repo_root.to_path_buf(),
            current_branch,
            main_branch,
        });
    }

    // Check each submodule
    for submodule in &gitmodules.submodules {
        let submodule_path = repo_root.join(&submodule.path);

        if !submodule_path.exists() {
            return Err(SuperGitError::Other(format!(
                "Submodule '{}' is not initialized. All submodules must be initialized for merge-back.",
                submodule.name
            )));
        }

        let sub_repo = GitOps::open_repo(&submodule_path)?;

        if GitOps::is_detached_head(&sub_repo)? {
            return Err(SuperGitError::Other(format!(
                "Submodule '{}' is in detached HEAD state",
                submodule.name
            )));
        }

        let current_branch = GitOps::current_branch(&sub_repo)?;
        let main_branch = GitOps::get_default_branch(&sub_repo)?;

        if current_branch == main_branch {
            return Err(SuperGitError::Other(format!(
                "Submodule '{}' is already on '{}'. Merge-back requires all repos to be on a feature branch.",
                submodule.name, main_branch
            )));
        }

        if !GitOps::branch_exists(&sub_repo, &main_branch)? {
            return Err(SuperGitError::Other(format!(
                "Submodule '{}' has no '{}' branch",
                submodule.name, main_branch
            )));
        }

        if verbose {
            Formatter::print_info(&format!(
                "'{}': on '{}', will merge into '{}'",
                submodule.name, current_branch, main_branch
            ));
        }

        repos.push(RepoInfo {
            name: submodule.name.clone(),
            path: submodule_path,
            current_branch,
            main_branch,
        });
    }

    Formatter::print_success(&format!(
        "Pre-flight passed for {} repo(s)",
        repos.len()
    ));

    if dry_run {
        Formatter::print_warning("DRY RUN: No changes will be made");
        println!();
        Formatter::print_info("Merge-back plan:");
        for repo in &repos {
            println!(
                "  {} [{}] '{}' → checkout '{}' → merge --ff-only '{}' → push",
                "→".cyan(),
                repo.name,
                repo.current_branch,
                repo.main_branch,
                repo.current_branch,
            );
        }
        return Ok(());
    }

    // ── Phase 2: Stage, commit, push all repos on current branch ────────
    let mut log = AuditLog::new();

    // Stage and commit all repos
    for repo_info in &repos {
        let repo = GitOps::open_repo(&repo_info.path).map_err(|e| {
            log.record(&repo_info.name, &format!("Open repo: {}", e), false);
            log.print_and_fail(&format!("Failed to open '{}'", repo_info.name))
        })?;

        let is_clean = GitOps::is_clean(&repo).map_err(|e| {
            log.record(&repo_info.name, &format!("Check clean: {}", e), false);
            log.print_and_fail(&format!("Failed to check status of '{}'", repo_info.name))
        })?;

        if !is_clean {
            // Stage
            let add_output = Command::new("git")
                .arg("add")
                .arg("-A")
                .current_dir(&repo_info.path)
                .output()
                .map_err(|e| {
                    log.record(&repo_info.name, &format!("Stage (git add -A): {}", e), false);
                    log.print_and_fail(&format!("Failed to stage in '{}'", repo_info.name))
                })?;

            if !add_output.status.success() {
                let err = String::from_utf8_lossy(&add_output.stderr);
                log.record(&repo_info.name, &format!("Stage (git add -A): {}", err), false);
                return Err(log.print_and_fail(&format!("Failed to stage in '{}'", repo_info.name)));
            }
            log.record(&repo_info.name, "Staged all changes (git add -A)", true);

            // Commit
            let commit_output = Command::new("git")
                .arg("commit")
                .arg("-m")
                .arg(message)
                .current_dir(&repo_info.path)
                .output()
                .map_err(|e| {
                    log.record(&repo_info.name, &format!("Commit: {}", e), false);
                    log.print_and_fail(&format!("Failed to commit in '{}'", repo_info.name))
                })?;

            if !commit_output.status.success() {
                let stderr = String::from_utf8_lossy(&commit_output.stderr);
                if !stderr.contains("nothing to commit") && !stderr.contains("nothing added") {
                    log.record(&repo_info.name, &format!("Commit: {}", stderr), false);
                    return Err(log.print_and_fail(&format!("Failed to commit in '{}'", repo_info.name)));
                }
                log.record(&repo_info.name, "Nothing to commit (clean after staging)", true);
            } else {
                log.record(
                    &repo_info.name,
                    &format!("Committed on '{}': {}", repo_info.current_branch, message),
                    true,
                );
            }
        } else {
            log.record(&repo_info.name, "Already clean, no commit needed", true);
        }
    }

    // Push all repos
    for repo_info in &repos {
        let push_output = Command::new("git")
            .arg("push")
            .arg("--set-upstream")
            .arg("origin")
            .arg("HEAD")
            .current_dir(&repo_info.path)
            .output()
            .map_err(|e| {
                log.record(&repo_info.name, &format!("Push: {}", e), false);
                log.print_and_fail(&format!("Failed to push '{}'", repo_info.name))
            })?;

        if !push_output.status.success() {
            let stderr = String::from_utf8_lossy(&push_output.stderr);
            if stderr.contains("Everything up-to-date") || stderr.contains("up to date") {
                log.record(&repo_info.name, "Push: already up to date", true);
            } else {
                log.record(&repo_info.name, &format!("Push: {}", stderr), false);
                return Err(log.print_and_fail(&format!("Failed to push '{}'", repo_info.name)));
            }
        } else {
            log.record(
                &repo_info.name,
                &format!("Pushed '{}' to origin", repo_info.current_branch),
                true,
            );
        }
    }

    // ── Phase 3: Checkout main in all repos ─────────────────────────────
    for repo_info in &repos {
        let checkout_output = Command::new("git")
            .arg("checkout")
            .arg(&repo_info.main_branch)
            .current_dir(&repo_info.path)
            .output()
            .map_err(|e| {
                log.record(
                    &repo_info.name,
                    &format!("Checkout '{}': {}", repo_info.main_branch, e),
                    false,
                );
                log.print_and_fail(&format!(
                    "Failed to checkout '{}' in '{}'",
                    repo_info.main_branch, repo_info.name
                ))
            })?;

        if !checkout_output.status.success() {
            let stderr = String::from_utf8_lossy(&checkout_output.stderr);
            log.record(
                &repo_info.name,
                &format!("Checkout '{}': {}", repo_info.main_branch, stderr),
                false,
            );
            return Err(log.print_and_fail(&format!(
                "Failed to checkout '{}' in '{}'",
                repo_info.main_branch, repo_info.name
            )));
        }
        log.record(
            &repo_info.name,
            &format!("Checked out '{}'", repo_info.main_branch),
            true,
        );
    }

    // ── Phase 4: Fast-forward merge from feature branch ─────────────────
    for repo_info in &repos {
        let merge_output = Command::new("git")
            .arg("merge")
            .arg("--ff-only")
            .arg(&repo_info.current_branch)
            .current_dir(&repo_info.path)
            .output()
            .map_err(|e| {
                log.record(
                    &repo_info.name,
                    &format!(
                        "Merge --ff-only '{}' into '{}': {}",
                        repo_info.current_branch, repo_info.main_branch, e
                    ),
                    false,
                );
                log.print_and_fail(&format!(
                    "Failed to merge '{}' into '{}' in '{}'",
                    repo_info.current_branch, repo_info.main_branch, repo_info.name
                ))
            })?;

        if !merge_output.status.success() {
            let stderr = String::from_utf8_lossy(&merge_output.stderr);
            log.record(
                &repo_info.name,
                &format!(
                    "Merge --ff-only '{}' into '{}': {}",
                    repo_info.current_branch, repo_info.main_branch, stderr
                ),
                false,
            );
            return Err(log.print_and_fail(&format!(
                "Cannot fast-forward merge '{}' into '{}' in '{}'. \
                 The branch may have diverged from '{}'. \
                 Rebase onto '{}' first.",
                repo_info.current_branch,
                repo_info.main_branch,
                repo_info.name,
                repo_info.main_branch,
                repo_info.main_branch,
            )));
        }
        log.record(
            &repo_info.name,
            &format!(
                "Merged '{}' into '{}' (fast-forward)",
                repo_info.current_branch, repo_info.main_branch
            ),
            true,
        );
    }

    // ── Phase 5: Push main in all repos ─────────────────────────────────
    for repo_info in &repos {
        let push_output = Command::new("git")
            .arg("push")
            .arg("origin")
            .arg(&repo_info.main_branch)
            .current_dir(&repo_info.path)
            .output()
            .map_err(|e| {
                log.record(
                    &repo_info.name,
                    &format!("Push '{}': {}", repo_info.main_branch, e),
                    false,
                );
                log.print_and_fail(&format!(
                    "Failed to push '{}' in '{}'",
                    repo_info.main_branch, repo_info.name
                ))
            })?;

        if !push_output.status.success() {
            let stderr = String::from_utf8_lossy(&push_output.stderr);
            if stderr.contains("Everything up-to-date") || stderr.contains("up to date") {
                log.record(
                    &repo_info.name,
                    &format!("Push '{}': already up to date", repo_info.main_branch),
                    true,
                );
            } else {
                log.record(
                    &repo_info.name,
                    &format!("Push '{}': {}", repo_info.main_branch, stderr),
                    false,
                );
                return Err(log.print_and_fail(&format!(
                    "Failed to push '{}' in '{}'",
                    repo_info.main_branch, repo_info.name
                )));
            }
        } else {
            log.record(
                &repo_info.name,
                &format!("Pushed '{}' to origin", repo_info.main_branch),
                true,
            );
        }
    }

    // ── Done ────────────────────────────────────────────────────────────
    println!();
    Formatter::print_success("Merge-back complete!");
    println!();
    for repo_info in &repos {
        Formatter::print_success(&format!(
            "[{}] '{}' merged into '{}' and pushed",
            repo_info.name, repo_info.current_branch, repo_info.main_branch
        ));
    }

    Ok(())
}

use colored::Colorize;