cascade_cli/cli/commands/

stack.rs

use crate::bitbucket::BitbucketIntegration;
use crate::cli::output::Output;
use crate::errors::{CascadeError, Result};
use crate::git::{find_repository_root, GitRepository};
use crate::stack::{CleanupManager, CleanupOptions, CleanupResult, StackManager, StackStatus};
use clap::{Subcommand, ValueEnum};
use dialoguer::{theme::ColorfulTheme, Confirm};
// Progress bars removed - using professional Output module instead
use std::env;
use tracing::{debug, warn};
use uuid::Uuid;

/// CLI argument version of RebaseStrategy
#[derive(ValueEnum, Clone, Debug)]
pub enum RebaseStrategyArg {
    /// Force-push rebased commits to original branches (preserves PR history)
    ForcePush,
    /// Interactive rebase with conflict resolution
    Interactive,
}

#[derive(ValueEnum, Clone, Debug)]
pub enum MergeStrategyArg {
    /// Create a merge commit
    Merge,
    /// Squash all commits into one
    Squash,
    /// Fast-forward merge when possible
    FastForward,
}

impl From<MergeStrategyArg> for crate::bitbucket::pull_request::MergeStrategy {
    fn from(arg: MergeStrategyArg) -> Self {
        match arg {
            MergeStrategyArg::Merge => Self::Merge,
            MergeStrategyArg::Squash => Self::Squash,
            MergeStrategyArg::FastForward => Self::FastForward,
        }
    }
}

#[derive(Debug, Subcommand)]
pub enum StackAction {
    /// Create a new stack
    Create {
        /// Name of the stack
        name: String,
        /// Base branch for the stack
        #[arg(long, short)]
        base: Option<String>,
        /// Description of the stack
        #[arg(long, short)]
        description: Option<String>,
    },

    /// List all stacks
    List {
        /// Show detailed information
        #[arg(long, short)]
        verbose: bool,
        /// Show only active stack
        #[arg(long)]
        active: bool,
        /// Output format (name, id, status)
        #[arg(long)]
        format: Option<String>,
    },

    /// Switch to a different stack
    Switch {
        /// Name of the stack to switch to
        name: String,
    },

    /// Deactivate the current stack (turn off stack mode)
    Deactivate {
        /// Force deactivation without confirmation
        #[arg(long)]
        force: bool,
    },

    /// Show the current stack status  
    Show {
        /// Show detailed pull request information
        #[arg(short, long)]
        verbose: bool,
        /// Show mergability status for all PRs
        #[arg(short, long)]
        mergeable: bool,
    },

    /// Push current commit to the top of the stack
    Push {
        /// Branch name for this commit
        #[arg(long, short)]
        branch: Option<String>,
        /// Commit message (if creating a new commit)
        #[arg(long, short)]
        message: Option<String>,
        /// Use specific commit hash instead of HEAD
        #[arg(long)]
        commit: Option<String>,
        /// Push commits since this reference (e.g., HEAD~3)
        #[arg(long)]
        since: Option<String>,
        /// Push multiple specific commits (comma-separated)
        #[arg(long)]
        commits: Option<String>,
        /// Squash unpushed commits before pushing (optional: specify count)
        #[arg(long, num_args = 0..=1, default_missing_value = "0")]
        squash: Option<usize>,
        /// Squash all commits since this reference (e.g., HEAD~5)
        #[arg(long)]
        squash_since: Option<String>,
        /// Auto-create feature branch when pushing from base branch
        #[arg(long)]
        auto_branch: bool,
        /// Allow pushing commits from base branch (not recommended)
        #[arg(long)]
        allow_base_branch: bool,
        /// Show what would be pushed without actually pushing
        #[arg(long)]
        dry_run: bool,
    },

    /// Pop the top commit from the stack
    Pop {
        /// Keep the branch (don't delete it)
        #[arg(long)]
        keep_branch: bool,
    },

    /// Submit a stack entry for review
    Submit {
        /// Stack entry number (1-based, defaults to all unsubmitted)
        entry: Option<usize>,
        /// Pull request title
        #[arg(long, short)]
        title: Option<String>,
        /// Pull request description
        #[arg(long, short)]
        description: Option<String>,
        /// Submit range of entries (e.g., "1-3" or "2,4,6")
        #[arg(long)]
        range: Option<String>,
        /// Create draft pull requests (default: true, use --no-draft to create ready PRs)
        #[arg(long, default_value_t = true)]
        draft: bool,
        /// Open the PR(s) in your default browser after submission (default: true, use --no-open to disable)
        #[arg(long, default_value_t = true)]
        open: bool,
    },

    /// Check status of all pull requests in a stack
    Status {
        /// Name of the stack (defaults to active stack)
        name: Option<String>,
    },

    /// List all pull requests for the repository
    Prs {
        /// Filter by state (open, merged, declined)
        #[arg(long)]
        state: Option<String>,
        /// Show detailed information
        #[arg(long, short)]
        verbose: bool,
    },

    /// Check stack status with remote repository (read-only)
    Check {
        /// Force check even if there are issues
        #[arg(long)]
        force: bool,
    },

    /// Sync stack with remote repository (pull + rebase + cleanup)
    Sync {
        /// Force sync even if there are conflicts
        #[arg(long)]
        force: bool,
        /// Also cleanup merged branches after sync
        #[arg(long)]
        cleanup: bool,
        /// Interactive mode for conflict resolution
        #[arg(long, short)]
        interactive: bool,
    },

    /// Rebase stack on updated base branch
    Rebase {
        /// Interactive rebase
        #[arg(long, short)]
        interactive: bool,
        /// Target base branch (defaults to stack's base branch)
        #[arg(long)]
        onto: Option<String>,
        /// Rebase strategy to use
        #[arg(long, value_enum)]
        strategy: Option<RebaseStrategyArg>,
    },

    /// Continue an in-progress rebase after resolving conflicts
    ContinueRebase,

    /// Abort an in-progress rebase
    AbortRebase,

    /// Show rebase status and conflict resolution guidance
    RebaseStatus,

    /// Delete a stack
    Delete {
        /// Name of the stack to delete
        name: String,
        /// Force deletion without confirmation
        #[arg(long)]
        force: bool,
    },

    /// Validate stack integrity and handle branch modifications
    ///
    /// Checks that stack branches match their expected commit hashes.
    /// Detects when branches have been manually modified (extra commits added).
    ///
    /// Available --fix modes:
    /// • incorporate: Update stack entry to include extra commits
    /// • split: Create new stack entry for extra commits  
    /// • reset: Remove extra commits (DESTRUCTIVE - loses work)
    ///
    /// Without --fix, runs interactively asking for each modification.
    Validate {
        /// Name of the stack (defaults to active stack)
        name: Option<String>,
        /// Auto-fix mode: incorporate, split, or reset
        #[arg(long)]
        fix: Option<String>,
    },

    /// Land (merge) approved stack entries
    Land {
        /// Stack entry number to land (1-based index, optional)
        entry: Option<usize>,
        /// Force land even with blocking issues (dangerous)
        #[arg(short, long)]
        force: bool,
        /// Dry run - show what would be landed without doing it
        #[arg(short, long)]
        dry_run: bool,
        /// Use server-side validation (safer, checks approvals/builds)
        #[arg(long)]
        auto: bool,
        /// Wait for builds to complete before merging
        #[arg(long)]
        wait_for_builds: bool,
        /// Merge strategy to use
        #[arg(long, value_enum, default_value = "squash")]
        strategy: Option<MergeStrategyArg>,
        /// Maximum time to wait for builds (seconds)
        #[arg(long, default_value = "1800")]
        build_timeout: u64,
    },

    /// Auto-land all ready PRs (shorthand for land --auto)
    AutoLand {
        /// Force land even with blocking issues (dangerous)
        #[arg(short, long)]
        force: bool,
        /// Dry run - show what would be landed without doing it
        #[arg(short, long)]
        dry_run: bool,
        /// Wait for builds to complete before merging
        #[arg(long)]
        wait_for_builds: bool,
        /// Merge strategy to use
        #[arg(long, value_enum, default_value = "squash")]
        strategy: Option<MergeStrategyArg>,
        /// Maximum time to wait for builds (seconds)
        #[arg(long, default_value = "1800")]
        build_timeout: u64,
    },

    /// List pull requests from Bitbucket
    ListPrs {
        /// Filter by state (open, merged, declined)
        #[arg(short, long)]
        state: Option<String>,
        /// Show detailed information
        #[arg(short, long)]
        verbose: bool,
    },

    /// Continue an in-progress land operation after resolving conflicts
    ContinueLand,

    /// Abort an in-progress land operation  
    AbortLand,

    /// Show status of in-progress land operation
    LandStatus,

    /// Clean up merged and stale branches
    Cleanup {
        /// Show what would be cleaned up without actually deleting
        #[arg(long)]
        dry_run: bool,
        /// Skip confirmation prompts
        #[arg(long)]
        force: bool,
        /// Include stale branches in cleanup
        #[arg(long)]
        include_stale: bool,
        /// Age threshold for stale branches (days)
        #[arg(long, default_value = "30")]
        stale_days: u32,
        /// Also cleanup remote tracking branches
        #[arg(long)]
        cleanup_remote: bool,
        /// Include non-stack branches in cleanup
        #[arg(long)]
        include_non_stack: bool,
        /// Show detailed information about cleanup candidates
        #[arg(long)]
        verbose: bool,
    },

    /// Repair data consistency issues in stack metadata
    Repair,
}

pub async fn run(action: StackAction) -> Result<()> {
    match action {
        StackAction::Create {
            name,
            base,
            description,
        } => create_stack(name, base, description).await,
        StackAction::List {
            verbose,
            active,
            format,
        } => list_stacks(verbose, active, format).await,
        StackAction::Switch { name } => switch_stack(name).await,
        StackAction::Deactivate { force } => deactivate_stack(force).await,
        StackAction::Show { verbose, mergeable } => show_stack(verbose, mergeable).await,
        StackAction::Push {
            branch,
            message,
            commit,
            since,
            commits,
            squash,
            squash_since,
            auto_branch,
            allow_base_branch,
            dry_run,
        } => {
            push_to_stack(
                branch,
                message,
                commit,
                since,
                commits,
                squash,
                squash_since,
                auto_branch,
                allow_base_branch,
                dry_run,
            )
            .await
        }
        StackAction::Pop { keep_branch } => pop_from_stack(keep_branch).await,
        StackAction::Submit {
            entry,
            title,
            description,
            range,
            draft,
            open,
        } => submit_entry(entry, title, description, range, draft, open).await,
        StackAction::Status { name } => check_stack_status(name).await,
        StackAction::Prs { state, verbose } => list_pull_requests(state, verbose).await,
        StackAction::Check { force } => check_stack(force).await,
        StackAction::Sync {
            force,
            cleanup,
            interactive,
        } => sync_stack(force, cleanup, interactive).await,
        StackAction::Rebase {
            interactive,
            onto,
            strategy,
        } => rebase_stack(interactive, onto, strategy).await,
        StackAction::ContinueRebase => continue_rebase().await,
        StackAction::AbortRebase => abort_rebase().await,
        StackAction::RebaseStatus => rebase_status().await,
        StackAction::Delete { name, force } => delete_stack(name, force).await,
        StackAction::Validate { name, fix } => validate_stack(name, fix).await,
        StackAction::Land {
            entry,
            force,
            dry_run,
            auto,
            wait_for_builds,
            strategy,
            build_timeout,
        } => {
            land_stack(
                entry,
                force,
                dry_run,
                auto,
                wait_for_builds,
                strategy,
                build_timeout,
            )
            .await
        }
        StackAction::AutoLand {
            force,
            dry_run,
            wait_for_builds,
            strategy,
            build_timeout,
        } => auto_land_stack(force, dry_run, wait_for_builds, strategy, build_timeout).await,
        StackAction::ListPrs { state, verbose } => list_pull_requests(state, verbose).await,
        StackAction::ContinueLand => continue_land().await,
        StackAction::AbortLand => abort_land().await,
        StackAction::LandStatus => land_status().await,
        StackAction::Cleanup {
            dry_run,
            force,
            include_stale,
            stale_days,
            cleanup_remote,
            include_non_stack,
            verbose,
        } => {
            cleanup_branches(
                dry_run,
                force,
                include_stale,
                stale_days,
                cleanup_remote,
                include_non_stack,
                verbose,
            )
            .await
        }
        StackAction::Repair => repair_stack_data().await,
    }
}

// Public functions for shortcut commands
pub async fn show(verbose: bool, mergeable: bool) -> Result<()> {
    show_stack(verbose, mergeable).await
}

#[allow(clippy::too_many_arguments)]
pub async fn push(
    branch: Option<String>,
    message: Option<String>,
    commit: Option<String>,
    since: Option<String>,
    commits: Option<String>,
    squash: Option<usize>,
    squash_since: Option<String>,
    auto_branch: bool,
    allow_base_branch: bool,
    dry_run: bool,
) -> Result<()> {
    push_to_stack(
        branch,
        message,
        commit,
        since,
        commits,
        squash,
        squash_since,
        auto_branch,
        allow_base_branch,
        dry_run,
    )
    .await
}

pub async fn pop(keep_branch: bool) -> Result<()> {
    pop_from_stack(keep_branch).await
}

pub async fn land(
    entry: Option<usize>,
    force: bool,
    dry_run: bool,
    auto: bool,
    wait_for_builds: bool,
    strategy: Option<MergeStrategyArg>,
    build_timeout: u64,
) -> Result<()> {
    land_stack(
        entry,
        force,
        dry_run,
        auto,
        wait_for_builds,
        strategy,
        build_timeout,
    )
    .await
}

pub async fn autoland(
    force: bool,
    dry_run: bool,
    wait_for_builds: bool,
    strategy: Option<MergeStrategyArg>,
    build_timeout: u64,
) -> Result<()> {
    auto_land_stack(force, dry_run, wait_for_builds, strategy, build_timeout).await
}

pub async fn sync(force: bool, skip_cleanup: bool, interactive: bool) -> Result<()> {
    sync_stack(force, skip_cleanup, interactive).await
}

pub async fn rebase(
    interactive: bool,
    onto: Option<String>,
    strategy: Option<RebaseStrategyArg>,
) -> Result<()> {
    rebase_stack(interactive, onto, strategy).await
}

pub async fn deactivate(force: bool) -> Result<()> {
    deactivate_stack(force).await
}

pub async fn switch(name: String) -> Result<()> {
    switch_stack(name).await
}

async fn create_stack(
    name: String,
    base: Option<String>,
    description: Option<String>,
) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut manager = StackManager::new(&repo_root)?;
    let stack_id = manager.create_stack(name.clone(), base.clone(), description.clone())?;

    // Get the created stack to check its working branch
    let stack = manager
        .get_stack(&stack_id)
        .ok_or_else(|| CascadeError::config("Failed to get created stack"))?;

    // Use the new output format
    Output::stack_info(
        &name,
        &stack_id.to_string(),
        &stack.base_branch,
        stack.working_branch.as_deref(),
        true, // is_active
    );

    if let Some(desc) = description {
        Output::sub_item(format!("Description: {desc}"));
    }

    // Provide helpful guidance based on the working branch situation
    if stack.working_branch.is_none() {
        Output::warning(format!(
            "You're currently on the base branch '{}'",
            stack.base_branch
        ));
        Output::next_steps(&[
            &format!("Create a feature branch: git checkout -b {name}"),
            "Make changes and commit them",
            "Run 'ca push' to add commits to this stack",
        ]);
    } else {
        Output::next_steps(&[
            "Make changes and commit them",
            "Run 'ca push' to add commits to this stack",
            "Use 'ca submit' when ready to create pull requests",
        ]);
    }

    Ok(())
}

async fn list_stacks(verbose: bool, active_only: bool, format: Option<String>) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let manager = StackManager::new(&repo_root)?;
    let mut stacks = manager.list_stacks();

    if active_only {
        stacks.retain(|(_, _, _, _, active_marker)| active_marker.is_some());
    }

    if let Some(ref format) = format {
        match format.as_str() {
            "json" => {
                let mut json_stacks = Vec::new();

                for (stack_id, name, status, entry_count, active_marker) in &stacks {
                    let (entries_json, working_branch, base_branch) =
                        if let Some(stack_obj) = manager.get_stack(stack_id) {
                            let entries_json = stack_obj
                                .entries
                                .iter()
                                .enumerate()
                                .map(|(idx, entry)| {
                                    serde_json::json!({
                                        "position": idx + 1,
                                        "entry_id": entry.id.to_string(),
                                        "branch_name": entry.branch.clone(),
                                        "commit_hash": entry.commit_hash.clone(),
                                        "short_hash": entry.short_hash(),
                                        "is_submitted": entry.is_submitted,
                                        "is_merged": entry.is_merged,
                                        "pull_request_id": entry.pull_request_id.clone(),
                                    })
                                })
                                .collect::<Vec<_>>();

                            (
                                entries_json,
                                stack_obj.working_branch.clone(),
                                Some(stack_obj.base_branch.clone()),
                            )
                        } else {
                            (Vec::new(), None, None)
                        };

                    let status_label = format!("{status:?}");

                    json_stacks.push(serde_json::json!({
                        "id": stack_id.to_string(),
                        "name": name,
                        "status": status_label,
                        "entry_count": entry_count,
                        "is_active": active_marker.is_some(),
                        "base_branch": base_branch,
                        "working_branch": working_branch,
                        "entries": entries_json,
                    }));
                }

                let json_output = serde_json::json!({ "stacks": json_stacks });
                let serialized = serde_json::to_string_pretty(&json_output)?;
                println!("{serialized}");
                return Ok(());
            }
            "name" => {
                for (_, name, _, _, _) in &stacks {
                    println!("{name}");
                }
                return Ok(());
            }
            "id" => {
                for (stack_id, _, _, _, _) in &stacks {
                    println!("{}", stack_id);
                }
                return Ok(());
            }
            "status" => {
                for (_, name, status, _, active_marker) in &stacks {
                    let status_label = format!("{status:?}");
                    let marker = if active_marker.is_some() {
                        " (active)"
                    } else {
                        ""
                    };
                    println!("{name}: {status_label}{marker}");
                }
                return Ok(());
            }
            other => {
                return Err(CascadeError::config(format!(
                    "Unsupported format '{}'. Supported formats: name, id, status, json",
                    other
                )));
            }
        }
    }

    if stacks.is_empty() {
        if active_only {
            Output::info("No active stack. Activate one with 'ca stack switch <name>'");
        } else {
            Output::info("No stacks found. Create one with: ca stack create <name>");
        }
        return Ok(());
    }

    println!("Stacks:");
    for (stack_id, name, status, entry_count, active_marker) in stacks {
        let status_icon = match status {
            StackStatus::Clean => "✓",
            StackStatus::Dirty => "~",
            StackStatus::OutOfSync => "!",
            StackStatus::Conflicted => "✗",
            StackStatus::Rebasing => "↔",
            StackStatus::NeedsSync => "~",
            StackStatus::Corrupted => "✗",
        };

        let active_indicator = if active_marker.is_some() {
            " (active)"
        } else {
            ""
        };

        // Get the actual stack object to access branch information
        let stack = manager.get_stack(&stack_id);

        if verbose {
            println!("  {status_icon} {name} [{entry_count}]{active_indicator}");
            println!("    ID: {stack_id}");
            if let Some(stack_meta) = manager.get_stack_metadata(&stack_id) {
                println!("    Base: {}", stack_meta.base_branch);
                if let Some(desc) = &stack_meta.description {
                    println!("    Description: {desc}");
                }
                println!(
                    "    Commits: {} total, {} submitted",
                    stack_meta.total_commits, stack_meta.submitted_commits
                );
                if stack_meta.has_conflicts {
                    Output::warning("    Has conflicts");
                }
            }

            // Show branch information in verbose mode
            if let Some(stack_obj) = stack {
                if !stack_obj.entries.is_empty() {
                    println!("    Branches:");
                    for (i, entry) in stack_obj.entries.iter().enumerate() {
                        let entry_num = i + 1;
                        let submitted_indicator = if entry.is_submitted {
                            "[submitted]"
                        } else {
                            ""
                        };
                        let branch_name = &entry.branch;
                        let short_message = if entry.message.len() > 40 {
                            format!("{}...", &entry.message[..37])
                        } else {
                            entry.message.clone()
                        };
                        println!("      {entry_num}. {submitted_indicator} {branch_name} - {short_message}");
                    }
                }
            }
            println!();
        } else {
            // Show compact branch info in non-verbose mode
            let branch_info = if let Some(stack_obj) = stack {
                if stack_obj.entries.is_empty() {
                    String::new()
                } else if stack_obj.entries.len() == 1 {
                    format!(" → {}", stack_obj.entries[0].branch)
                } else {
                    let first_branch = &stack_obj.entries[0].branch;
                    let last_branch = &stack_obj.entries.last().unwrap().branch;
                    format!(" → {first_branch} … {last_branch}")
                }
            } else {
                String::new()
            };

            println!("  {status_icon} {name} [{entry_count}]{branch_info}{active_indicator}");
        }
    }

    if !verbose {
        println!("\nUse --verbose for more details");
    }

    Ok(())
}

async fn switch_stack(name: String) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut manager = StackManager::new(&repo_root)?;
    let repo = GitRepository::open(&repo_root)?;

    // Get stack information before switching
    let stack = manager
        .get_stack_by_name(&name)
        .ok_or_else(|| CascadeError::config(format!("Stack '{name}' not found")))?;

    // Determine the target branch and provide appropriate messaging
    if let Some(working_branch) = &stack.working_branch {
        // Stack has a working branch - try to switch to it
        let current_branch = repo.get_current_branch().ok();

        if current_branch.as_ref() != Some(working_branch) {
            Output::progress(format!(
                "Switching to stack working branch: {working_branch}"
            ));

            // Check if target branch exists
            if repo.branch_exists(working_branch) {
                match repo.checkout_branch(working_branch) {
                    Ok(_) => {
                        Output::success(format!("Checked out branch: {working_branch}"));
                    }
                    Err(e) => {
                        Output::warning(format!("Failed to checkout '{working_branch}': {e}"));
                        Output::sub_item("Stack activated but stayed on current branch");
                        Output::sub_item(format!(
                            "You can manually checkout with: git checkout {working_branch}"
                        ));
                    }
                }
            } else {
                Output::warning(format!(
                    "Stack working branch '{working_branch}' doesn't exist locally"
                ));
                Output::sub_item("Stack activated but stayed on current branch");
                Output::sub_item(format!(
                    "You may need to fetch from remote: git fetch origin {working_branch}"
                ));
            }
        } else {
            Output::success(format!("Already on stack working branch: {working_branch}"));
        }
    } else {
        // No working branch - provide guidance
        Output::warning(format!("Stack '{name}' has no working branch set"));
        Output::sub_item(
            "This typically happens when a stack was created while on the base branch",
        );

        Output::tip("To start working on this stack:");
        Output::bullet(format!("Create a feature branch: git checkout -b {name}"));
        Output::bullet("The stack will automatically track this as its working branch");
        Output::bullet("Then use 'ca push' to add commits to the stack");

        Output::sub_item(format!("Base branch: {}", stack.base_branch));
    }

    // Activate the stack (this will record the correct current branch)
    manager.set_active_stack_by_name(&name)?;
    Output::success(format!("Switched to stack '{name}'"));

    Ok(())
}

async fn deactivate_stack(force: bool) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut manager = StackManager::new(&repo_root)?;

    let active_stack = manager.get_active_stack();

    if active_stack.is_none() {
        Output::info("No active stack to deactivate");
        return Ok(());
    }

    let stack_name = active_stack.unwrap().name.clone();

    if !force {
        Output::warning(format!(
            "This will deactivate stack '{stack_name}' and return to normal Git workflow"
        ));
        Output::sub_item(format!(
            "You can reactivate it later with 'ca stacks switch {stack_name}'"
        ));
        // Interactive confirmation to deactivate stack
        let should_deactivate = Confirm::with_theme(&ColorfulTheme::default())
            .with_prompt("Continue with deactivation?")
            .default(false)
            .interact()
            .map_err(|e| CascadeError::config(format!("Failed to get user confirmation: {e}")))?;

        if !should_deactivate {
            Output::info("Cancelled deactivation");
            return Ok(());
        }
    }

    // Deactivate the stack
    manager.set_active_stack(None)?;

    Output::success(format!("Deactivated stack '{stack_name}'"));
    Output::sub_item("Stack management is now OFF - you can use normal Git workflow");
    Output::sub_item(format!("To reactivate: ca stacks switch {stack_name}"));

    Ok(())
}

async fn show_stack(verbose: bool, show_mergeable: bool) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;

    // Get stack information first to avoid borrow conflicts
    let (stack_id, stack_name, stack_base, stack_working, stack_entries) = {
        let active_stack = stack_manager.get_active_stack().ok_or_else(|| {
            CascadeError::config(
                "No active stack. Use 'ca stacks create' or 'ca stacks switch' to select a stack"
                    .to_string(),
            )
        })?;

        (
            active_stack.id,
            active_stack.name.clone(),
            active_stack.base_branch.clone(),
            active_stack.working_branch.clone(),
            active_stack.entries.clone(),
        )
    };

    // Use the new output format for stack info
    Output::stack_info(
        &stack_name,
        &stack_id.to_string(),
        &stack_base,
        stack_working.as_deref(),
        true, // is_active
    );
    Output::sub_item(format!("Total entries: {}", stack_entries.len()));

    if stack_entries.is_empty() {
        Output::info("No entries in this stack yet");
        Output::tip("Use 'ca push' to add commits to this stack");
        return Ok(());
    }

    // Show entries
    Output::section("Stack Entries");
    for (i, entry) in stack_entries.iter().enumerate() {
        let entry_num = i + 1;
        let short_hash = entry.short_hash();
        let short_msg = entry.short_message(50);

        // Get source branch information for pending entries only
        // (submitted entries have their own branch, so source is no longer relevant)
        let metadata = stack_manager.get_repository_metadata();
        let source_branch_info = if !entry.is_submitted {
            if let Some(commit_meta) = metadata.get_commit(&entry.commit_hash) {
                if commit_meta.source_branch != commit_meta.branch
                    && !commit_meta.source_branch.is_empty()
                {
                    format!(" (from {})", commit_meta.source_branch)
                } else {
                    String::new()
                }
            } else {
                String::new()
            }
        } else {
            String::new()
        };

        // Use colored status: pending (yellow), submitted (muted green)
        let status_colored = Output::entry_status(entry.is_submitted, false);

        Output::numbered_item(
            entry_num,
            format!("{short_hash} {status_colored} {short_msg}{source_branch_info}"),
        );

        if verbose {
            Output::sub_item(format!("Branch: {}", entry.branch));
            Output::sub_item(format!(
                "Created: {}",
                entry.created_at.format("%Y-%m-%d %H:%M")
            ));
            if let Some(pr_id) = &entry.pull_request_id {
                Output::sub_item(format!("PR: #{pr_id}"));
            }

            // Display full commit message
            Output::sub_item("Commit Message:");
            let lines: Vec<&str> = entry.message.lines().collect();
            for line in lines {
                Output::sub_item(format!("  {line}"));
            }
        }
    }

    // Enhanced PR status if requested and available
    if show_mergeable {
        Output::section("Mergability Status");

        // Load configuration and create Bitbucket integration
        let config_dir = crate::config::get_repo_config_dir(&repo_root)?;
        let config_path = config_dir.join("config.json");
        let settings = crate::config::Settings::load_from_file(&config_path)?;

        let cascade_config = crate::config::CascadeConfig {
            bitbucket: Some(settings.bitbucket.clone()),
            git: settings.git.clone(),
            auth: crate::config::AuthConfig::default(),
            cascade: settings.cascade.clone(),
        };

        let mut integration =
            crate::bitbucket::BitbucketIntegration::new(stack_manager, cascade_config)?;

        match integration.check_enhanced_stack_status(&stack_id).await {
            Ok(status) => {
                Output::bullet(format!("Total entries: {}", status.total_entries));
                Output::bullet(format!("Submitted: {}", status.submitted_entries));
                Output::bullet(format!("Open PRs: {}", status.open_prs));
                Output::bullet(format!("Merged PRs: {}", status.merged_prs));
                Output::bullet(format!("Declined PRs: {}", status.declined_prs));
                Output::bullet(format!(
                    "Completion: {:.1}%",
                    status.completion_percentage()
                ));

                if !status.enhanced_statuses.is_empty() {
                    Output::section("Pull Request Status");
                    let mut ready_to_land = 0;

                    for enhanced in &status.enhanced_statuses {
                        let status_display = enhanced.get_display_status();
                        let ready_icon = if enhanced.is_ready_to_land() {
                            ready_to_land += 1;
                            "[READY]"
                        } else {
                            "[PENDING]"
                        };

                        Output::bullet(format!(
                            "{} PR #{}: {} ({})",
                            ready_icon, enhanced.pr.id, enhanced.pr.title, status_display
                        ));

                        if verbose {
                            println!(
                                "      {} -> {}",
                                enhanced.pr.from_ref.display_id, enhanced.pr.to_ref.display_id
                            );

                            // Show blocking reasons if not ready
                            if !enhanced.is_ready_to_land() {
                                let blocking = enhanced.get_blocking_reasons();
                                if !blocking.is_empty() {
                                    println!("      Blocking: {}", blocking.join(", "));
                                }
                            }

                            // Show review details (actual count from Bitbucket)
                            println!(
                                "      Reviews: {} approval{}",
                                enhanced.review_status.current_approvals,
                                if enhanced.review_status.current_approvals == 1 {
                                    ""
                                } else {
                                    "s"
                                }
                            );

                            if enhanced.review_status.needs_work_count > 0 {
                                println!(
                                    "      {} reviewers requested changes",
                                    enhanced.review_status.needs_work_count
                                );
                            }

                            // Show build status
                            if let Some(build) = &enhanced.build_status {
                                let build_icon = match build.state {
                                    crate::bitbucket::pull_request::BuildState::Successful => "✓",
                                    crate::bitbucket::pull_request::BuildState::Failed => "✗",
                                    crate::bitbucket::pull_request::BuildState::InProgress => "~",
                                    _ => "○",
                                };
                                println!("      Build: {} {:?}", build_icon, build.state);
                            }

                            if let Some(url) = enhanced.pr.web_url() {
                                println!("      URL: {url}");
                            }
                            println!();
                        }
                    }

                    if ready_to_land > 0 {
                        println!(
                            "\n🎯 {} PR{} ready to land! Use 'ca land' to land them all.",
                            ready_to_land,
                            if ready_to_land == 1 { " is" } else { "s are" }
                        );
                    }
                }
            }
            Err(e) => {
                tracing::debug!("Failed to get enhanced stack status: {}", e);
                Output::warning("Could not fetch mergability status");
                Output::sub_item("Use 'ca stack show --verbose' for basic PR information");
            }
        }
    } else {
        // Original PR status display for compatibility
        let config_dir = crate::config::get_repo_config_dir(&repo_root)?;
        let config_path = config_dir.join("config.json");
        let settings = crate::config::Settings::load_from_file(&config_path)?;

        let cascade_config = crate::config::CascadeConfig {
            bitbucket: Some(settings.bitbucket.clone()),
            git: settings.git.clone(),
            auth: crate::config::AuthConfig::default(),
            cascade: settings.cascade.clone(),
        };

        let integration =
            crate::bitbucket::BitbucketIntegration::new(stack_manager, cascade_config)?;

        match integration.check_stack_status(&stack_id).await {
            Ok(status) => {
                println!("\nPull Request Status:");
                println!("   Total entries: {}", status.total_entries);
                println!("   Submitted: {}", status.submitted_entries);
                println!("   Open PRs: {}", status.open_prs);
                println!("   Merged PRs: {}", status.merged_prs);
                println!("   Declined PRs: {}", status.declined_prs);
                println!("   Completion: {:.1}%", status.completion_percentage());

                if !status.pull_requests.is_empty() {
                    println!("\nPull Requests:");
                    for pr in &status.pull_requests {
                        let state_icon = match pr.state {
                            crate::bitbucket::PullRequestState::Open => "→",
                            crate::bitbucket::PullRequestState::Merged => "✓",
                            crate::bitbucket::PullRequestState::Declined => "✗",
                        };
                        println!(
                            "   {} PR #{}: {} ({} -> {})",
                            state_icon,
                            pr.id,
                            pr.title,
                            pr.from_ref.display_id,
                            pr.to_ref.display_id
                        );
                        if let Some(url) = pr.web_url() {
                            println!("      URL: {url}");
                        }
                    }
                }

                println!();
                Output::tip("Use 'ca stack --mergeable' to see detailed status including build and review information");
            }
            Err(e) => {
                tracing::debug!("Failed to check stack status: {}", e);
            }
        }
    }

    Ok(())
}

#[allow(clippy::too_many_arguments)]
async fn push_to_stack(
    branch: Option<String>,
    message: Option<String>,
    commit: Option<String>,
    since: Option<String>,
    commits: Option<String>,
    squash: Option<usize>,
    squash_since: Option<String>,
    auto_branch: bool,
    allow_base_branch: bool,
    dry_run: bool,
) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut manager = StackManager::new(&repo_root)?;
    let repo = GitRepository::open(&repo_root)?;

    // Check for branch changes and prompt user if needed
    if !manager.check_for_branch_change()? {
        return Ok(()); // User chose to cancel or deactivate stack
    }

    // Get the active stack to check base branch
    let active_stack = manager.get_active_stack().ok_or_else(|| {
        CascadeError::config("No active stack. Create a stack first with 'ca stack create'")
    })?;

    // 🛡️ BASE BRANCH PROTECTION
    let current_branch = repo.get_current_branch()?;
    let base_branch = &active_stack.base_branch;

    if current_branch == *base_branch {
        Output::error(format!(
            "You're currently on the base branch '{base_branch}'"
        ));
        Output::sub_item("Making commits directly on the base branch is not recommended.");
        Output::sub_item("This can pollute the base branch with work-in-progress commits.");

        // Check if user explicitly allowed base branch work
        if allow_base_branch {
            Output::warning("Proceeding anyway due to --allow-base-branch flag");
        } else {
            // Check if we have uncommitted changes
            let has_changes = repo.is_dirty()?;

            if has_changes {
                if auto_branch {
                    // Auto-create branch and commit changes
                    let feature_branch = format!("feature/{}-work", active_stack.name);
                    Output::progress(format!(
                        "Auto-creating feature branch '{feature_branch}'..."
                    ));

                    repo.create_branch(&feature_branch, None)?;
                    repo.checkout_branch(&feature_branch)?;

                    Output::success(format!("Created and switched to '{feature_branch}'"));
                    println!("   You can now commit and push your changes safely");

                    // Continue with normal flow
                } else {
                    println!("\nYou have uncommitted changes. Here are your options:");
                    println!("   1. Create a feature branch first:");
                    println!("      git checkout -b feature/my-work");
                    println!("      git commit -am \"your work\"");
                    println!("      ca push");
                    println!("\n   2. Auto-create a branch (recommended):");
                    println!("      ca push --auto-branch");
                    println!("\n   3. Force push to base branch (dangerous):");
                    println!("      ca push --allow-base-branch");

                    return Err(CascadeError::config(
                        "Refusing to push uncommitted changes from base branch. Use one of the options above."
                    ));
                }
            } else {
                // Check if there are existing commits to push
                let commits_to_check = if let Some(commits_str) = &commits {
                    commits_str
                        .split(',')
                        .map(|s| s.trim().to_string())
                        .collect::<Vec<String>>()
                } else if let Some(since_ref) = &since {
                    let since_commit = repo.resolve_reference(since_ref)?;
                    let head_commit = repo.get_head_commit()?;
                    let commits = repo.get_commits_between(
                        &since_commit.id().to_string(),
                        &head_commit.id().to_string(),
                    )?;
                    commits.into_iter().map(|c| c.id().to_string()).collect()
                } else if commit.is_none() {
                    let mut unpushed = Vec::new();
                    let head_commit = repo.get_head_commit()?;
                    let mut current_commit = head_commit;

                    loop {
                        let commit_hash = current_commit.id().to_string();
                        let already_in_stack = active_stack
                            .entries
                            .iter()
                            .any(|entry| entry.commit_hash == commit_hash);

                        if already_in_stack {
                            break;
                        }

                        unpushed.push(commit_hash);

                        if let Some(parent) = current_commit.parents().next() {
                            current_commit = parent;
                        } else {
                            break;
                        }
                    }

                    unpushed.reverse();
                    unpushed
                } else {
                    vec![repo.get_head_commit()?.id().to_string()]
                };

                if !commits_to_check.is_empty() {
                    if auto_branch {
                        // Auto-create feature branch and cherry-pick commits
                        let feature_branch = format!("feature/{}-work", active_stack.name);
                        Output::progress(format!(
                            "Auto-creating feature branch '{feature_branch}'..."
                        ));

                        repo.create_branch(&feature_branch, Some(base_branch))?;
                        repo.checkout_branch(&feature_branch)?;

                        // Cherry-pick the commits to the new branch
                        println!(
                            "🍒 Cherry-picking {} commit(s) to new branch...",
                            commits_to_check.len()
                        );
                        for commit_hash in &commits_to_check {
                            match repo.cherry_pick(commit_hash) {
                                Ok(_) => println!("   ✅ Cherry-picked {}", &commit_hash[..8]),
                                Err(e) => {
                                    Output::error(format!(
                                        "Failed to cherry-pick {}: {}",
                                        &commit_hash[..8],
                                        e
                                    ));
                                    Output::tip("You may need to resolve conflicts manually");
                                    return Err(CascadeError::branch(format!(
                                        "Failed to cherry-pick commit {commit_hash}: {e}"
                                    )));
                                }
                            }
                        }

                        println!(
                            "✅ Successfully moved {} commit(s) to '{feature_branch}'",
                            commits_to_check.len()
                        );
                        println!(
                            "   You're now on the feature branch and can continue with 'ca push'"
                        );

                        // Continue with normal flow
                    } else {
                        println!(
                            "\n💡 Found {} commit(s) to push from base branch '{base_branch}'",
                            commits_to_check.len()
                        );
                        println!("   These commits are currently ON the base branch, which may not be intended.");
                        println!("\n   Options:");
                        println!("   1. Auto-create feature branch and cherry-pick commits:");
                        println!("      ca push --auto-branch");
                        println!("\n   2. Manually create branch and move commits:");
                        println!("      git checkout -b feature/my-work");
                        println!("      ca push");
                        println!("\n   3. Force push from base branch (not recommended):");
                        println!("      ca push --allow-base-branch");

                        return Err(CascadeError::config(
                            "Refusing to push commits from base branch. Use --auto-branch or create a feature branch manually."
                        ));
                    }
                }
            }
        }
    }

    // Handle squash operations first
    if let Some(squash_count) = squash {
        if squash_count == 0 {
            // User used --squash without specifying count, auto-detect unpushed commits
            let active_stack = manager.get_active_stack().ok_or_else(|| {
                CascadeError::config(
                    "No active stack. Create a stack first with 'ca stacks create'",
                )
            })?;

            let unpushed_count = get_unpushed_commits(&repo, active_stack)?.len();

            if unpushed_count == 0 {
                Output::info("  No unpushed commits to squash");
            } else if unpushed_count == 1 {
                Output::info("  Only 1 unpushed commit, no squashing needed");
            } else {
                println!(" Auto-detected {unpushed_count} unpushed commits, squashing...");
                squash_commits(&repo, unpushed_count, None).await?;
                Output::success(" Squashed {unpushed_count} unpushed commits into one");
            }
        } else {
            println!(" Squashing last {squash_count} commits...");
            squash_commits(&repo, squash_count, None).await?;
            Output::success(" Squashed {squash_count} commits into one");
        }
    } else if let Some(since_ref) = squash_since {
        println!(" Squashing commits since {since_ref}...");
        let since_commit = repo.resolve_reference(&since_ref)?;
        let commits_count = count_commits_since(&repo, &since_commit.id().to_string())?;
        squash_commits(&repo, commits_count, Some(since_ref.clone())).await?;
        Output::success(" Squashed {commits_count} commits since {since_ref} into one");
    }

    // Determine which commits to push
    let commits_to_push = if let Some(commits_str) = commits {
        // Parse comma-separated commit hashes
        commits_str
            .split(',')
            .map(|s| s.trim().to_string())
            .collect::<Vec<String>>()
    } else if let Some(since_ref) = since {
        // Get commits since the specified reference
        let since_commit = repo.resolve_reference(&since_ref)?;
        let head_commit = repo.get_head_commit()?;

        // Get commits between since_ref and HEAD
        let commits = repo.get_commits_between(
            &since_commit.id().to_string(),
            &head_commit.id().to_string(),
        )?;
        commits.into_iter().map(|c| c.id().to_string()).collect()
    } else if let Some(hash) = commit {
        // Single specific commit
        vec![hash]
    } else {
        // Default: Get all unpushed commits (commits on current branch but not on base branch)
        let active_stack = manager.get_active_stack().ok_or_else(|| {
            CascadeError::config("No active stack. Create a stack first with 'ca stacks create'")
        })?;

        // Get commits that are on current branch but not on the base branch
        let base_branch = &active_stack.base_branch;
        let current_branch = repo.get_current_branch()?;

        // If we're on the base branch, only include commits that aren't already in the stack
        if current_branch == *base_branch {
            let mut unpushed = Vec::new();
            let head_commit = repo.get_head_commit()?;
            let mut current_commit = head_commit;

            // Walk back from HEAD until we find a commit that's already in the stack
            loop {
                let commit_hash = current_commit.id().to_string();
                let already_in_stack = active_stack
                    .entries
                    .iter()
                    .any(|entry| entry.commit_hash == commit_hash);

                if already_in_stack {
                    break;
                }

                unpushed.push(commit_hash);

                // Move to parent commit
                if let Some(parent) = current_commit.parents().next() {
                    current_commit = parent;
                } else {
                    break;
                }
            }

            unpushed.reverse(); // Reverse to get chronological order
            unpushed
        } else {
            // Use git's commit range calculation to find commits on current branch but not on base
            match repo.get_commits_between(base_branch, &current_branch) {
                Ok(commits) => {
                    let mut unpushed: Vec<String> =
                        commits.into_iter().map(|c| c.id().to_string()).collect();

                    // Filter out commits that are already in the stack
                    unpushed.retain(|commit_hash| {
                        !active_stack
                            .entries
                            .iter()
                            .any(|entry| entry.commit_hash == *commit_hash)
                    });

                    unpushed.reverse(); // Reverse to get chronological order (oldest first)
                    unpushed
                }
                Err(e) => {
                    return Err(CascadeError::branch(format!(
                            "Failed to calculate commits between '{base_branch}' and '{current_branch}': {e}. \
                             This usually means the branches have diverged or don't share common history."
                        )));
                }
            }
        }
    };

    if commits_to_push.is_empty() {
        Output::info("  No commits to push to stack");
        return Ok(());
    }

    // 🛡️ SAFEGUARDS: Analyze commits before pushing
    analyze_commits_for_safeguards(&commits_to_push, &repo, dry_run).await?;

    // Early return for dry run mode
    if dry_run {
        return Ok(());
    }

    // Push each commit to the stack
    let mut pushed_count = 0;
    let mut source_branches = std::collections::HashSet::new();

    for (i, commit_hash) in commits_to_push.iter().enumerate() {
        let commit_obj = repo.get_commit(commit_hash)?;
        let commit_msg = commit_obj.message().unwrap_or("").to_string();

        // Check which branch this commit belongs to
        let commit_source_branch = repo
            .find_branch_containing_commit(commit_hash)
            .unwrap_or_else(|_| current_branch.clone());
        source_branches.insert(commit_source_branch.clone());

        // Generate branch name (use provided branch for first commit, generate for others)
        let branch_name = if i == 0 && branch.is_some() {
            branch.clone().unwrap()
        } else {
            // Create a temporary GitRepository for branch name generation
            let temp_repo = GitRepository::open(&repo_root)?;
            let branch_mgr = crate::git::BranchManager::new(temp_repo);
            branch_mgr.generate_branch_name(&commit_msg)
        };

        // Use provided message for first commit, original message for others
        let final_message = if i == 0 && message.is_some() {
            message.clone().unwrap()
        } else {
            commit_msg.clone()
        };

        let entry_id = manager.push_to_stack(
            branch_name.clone(),
            commit_hash.clone(),
            final_message.clone(),
            commit_source_branch.clone(),
        )?;
        pushed_count += 1;

        Output::success(format!(
            "Pushed commit {}/{} to stack",
            i + 1,
            commits_to_push.len()
        ));
        Output::sub_item(format!(
            "Commit: {} ({})",
            &commit_hash[..8],
            commit_msg.split('\n').next().unwrap_or("")
        ));
        Output::sub_item(format!("Branch: {branch_name}"));
        Output::sub_item(format!("Source: {commit_source_branch}"));
        Output::sub_item(format!("Entry ID: {entry_id}"));
        println!();
    }

    // 🚨 SCATTERED COMMIT WARNING
    if source_branches.len() > 1 {
        Output::warning("Scattered Commit Detection");
        Output::sub_item(format!(
            "You've pushed commits from {} different Git branches:",
            source_branches.len()
        ));
        for branch in &source_branches {
            Output::bullet(branch.to_string());
        }

        Output::section("This can lead to confusion because:");
        Output::bullet("Stack appears sequential but commits are scattered across branches");
        Output::bullet("Team members won't know which branch contains which work");
        Output::bullet("Branch cleanup becomes unclear after merge");
        Output::bullet("Rebase operations become more complex");

        Output::tip("Consider consolidating work to a single feature branch:");
        Output::bullet("Create a new feature branch: git checkout -b feature/consolidated-work");
        Output::bullet("Cherry-pick commits in order: git cherry-pick <commit1> <commit2> ...");
        Output::bullet("Delete old scattered branches");
        Output::bullet("Push the consolidated branch to your stack");
        println!();
    }

    Output::success(format!(
        "Successfully pushed {} commit{} to stack",
        pushed_count,
        if pushed_count == 1 { "" } else { "s" }
    ));

    Ok(())
}

async fn pop_from_stack(keep_branch: bool) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut manager = StackManager::new(&repo_root)?;
    let repo = GitRepository::open(&repo_root)?;

    let entry = manager.pop_from_stack()?;

    Output::success("Popped commit from stack");
    Output::sub_item(format!(
        "Commit: {} ({})",
        entry.short_hash(),
        entry.short_message(50)
    ));
    Output::sub_item(format!("Branch: {}", entry.branch));

    // Delete branch if requested and it's not the current branch
    if !keep_branch && entry.branch != repo.get_current_branch()? {
        match repo.delete_branch(&entry.branch) {
            Ok(_) => Output::sub_item(format!("Deleted branch: {}", entry.branch)),
            Err(e) => Output::warning(format!("Could not delete branch {}: {}", entry.branch, e)),
        }
    }

    Ok(())
}

async fn submit_entry(
    entry: Option<usize>,
    title: Option<String>,
    description: Option<String>,
    range: Option<String>,
    draft: bool,
    open: bool,
) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut stack_manager = StackManager::new(&repo_root)?;

    // Check for branch changes and prompt user if needed
    if !stack_manager.check_for_branch_change()? {
        return Ok(()); // User chose to cancel or deactivate stack
    }

    // Load configuration first
    let config_dir = crate::config::get_repo_config_dir(&repo_root)?;
    let config_path = config_dir.join("config.json");
    let settings = crate::config::Settings::load_from_file(&config_path)?;

    // Create the main config structure
    let cascade_config = crate::config::CascadeConfig {
        bitbucket: Some(settings.bitbucket.clone()),
        git: settings.git.clone(),
        auth: crate::config::AuthConfig::default(),
        cascade: settings.cascade.clone(),
    };

    // Get the active stack
    let active_stack = stack_manager.get_active_stack().ok_or_else(|| {
        CascadeError::config("No active stack. Create a stack first with 'ca stack create'")
    })?;
    let stack_id = active_stack.id;

    // Determine which entries to submit
    let entries_to_submit = if let Some(range_str) = range {
        // Parse range (e.g., "1-3" or "2,4,6")
        let mut entries = Vec::new();

        if range_str.contains('-') {
            // Handle range like "1-3"
            let parts: Vec<&str> = range_str.split('-').collect();
            if parts.len() != 2 {
                return Err(CascadeError::config(
                    "Invalid range format. Use 'start-end' (e.g., '1-3')",
                ));
            }

            let start: usize = parts[0]
                .parse()
                .map_err(|_| CascadeError::config("Invalid start number in range"))?;
            let end: usize = parts[1]
                .parse()
                .map_err(|_| CascadeError::config("Invalid end number in range"))?;

            if start == 0
                || end == 0
                || start > active_stack.entries.len()
                || end > active_stack.entries.len()
            {
                return Err(CascadeError::config(format!(
                    "Range out of bounds. Stack has {} entries",
                    active_stack.entries.len()
                )));
            }

            for i in start..=end {
                entries.push((i, active_stack.entries[i - 1].clone()));
            }
        } else {
            // Handle comma-separated list like "2,4,6"
            for entry_str in range_str.split(',') {
                let entry_num: usize = entry_str.trim().parse().map_err(|_| {
                    CascadeError::config(format!("Invalid entry number: {entry_str}"))
                })?;

                if entry_num == 0 || entry_num > active_stack.entries.len() {
                    return Err(CascadeError::config(format!(
                        "Entry {} out of bounds. Stack has {} entries",
                        entry_num,
                        active_stack.entries.len()
                    )));
                }

                entries.push((entry_num, active_stack.entries[entry_num - 1].clone()));
            }
        }

        entries
    } else if let Some(entry_num) = entry {
        // Single entry specified
        if entry_num == 0 || entry_num > active_stack.entries.len() {
            return Err(CascadeError::config(format!(
                "Invalid entry number: {}. Stack has {} entries",
                entry_num,
                active_stack.entries.len()
            )));
        }
        vec![(entry_num, active_stack.entries[entry_num - 1].clone())]
    } else {
        // Default: Submit all unsubmitted entries
        active_stack
            .entries
            .iter()
            .enumerate()
            .filter(|(_, entry)| !entry.is_submitted)
            .map(|(i, entry)| (i + 1, entry.clone())) // Convert to 1-based indexing
            .collect::<Vec<(usize, _)>>()
    };

    if entries_to_submit.is_empty() {
        Output::info("No entries to submit");
        return Ok(());
    }

    // Professional output for submission
    Output::section(format!(
        "Submitting {} {}",
        entries_to_submit.len(),
        if entries_to_submit.len() == 1 {
            "entry"
        } else {
            "entries"
        }
    ));
    println!();

    // Create a new StackManager for the integration (since the original was moved)
    let integration_stack_manager = StackManager::new(&repo_root)?;
    let mut integration =
        BitbucketIntegration::new(integration_stack_manager, cascade_config.clone())?;

    // Submit each entry
    let mut submitted_count = 0;
    let mut failed_entries = Vec::new();
    let mut pr_urls = Vec::new(); // Collect URLs to open
    let total_entries = entries_to_submit.len();

    for (entry_num, entry_to_submit) in &entries_to_submit {
        // Show what we're submitting
        let tree_char = if entries_to_submit.len() == 1 {
            "→"
        } else if entry_num == &entries_to_submit.len() {
            "└─"
        } else {
            "├─"
        };
        print!(
            "   {} Entry {}: {}... ",
            tree_char, entry_num, entry_to_submit.branch
        );
        std::io::Write::flush(&mut std::io::stdout()).ok();

        // Use provided title/description only for first entry or single entry submissions
        let entry_title = if total_entries == 1 {
            title.clone()
        } else {
            None
        };
        let entry_description = if total_entries == 1 {
            description.clone()
        } else {
            None
        };

        match integration
            .submit_entry(
                &stack_id,
                &entry_to_submit.id,
                entry_title,
                entry_description,
                draft,
            )
            .await
        {
            Ok(pr) => {
                submitted_count += 1;
                Output::success(format!("PR #{}", pr.id));
                if let Some(url) = pr.web_url() {
                    Output::sub_item(format!(
                        "{} → {}",
                        pr.from_ref.display_id, pr.to_ref.display_id
                    ));
                    Output::sub_item(format!("URL: {url}"));
                    pr_urls.push(url); // Collect for opening later
                }
            }
            Err(e) => {
                Output::error("Failed");
                // Extract clean error message (remove git stderr noise)
                let clean_error = if e.to_string().contains("non-fast-forward") {
                    "Branch has diverged (was rebased after initial submission). Update to v0.1.41+ to auto force-push.".to_string()
                } else if e.to_string().contains("authentication") {
                    "Authentication failed. Check your Bitbucket credentials.".to_string()
                } else {
                    // Extract first meaningful line, skip git hints
                    e.to_string()
                        .lines()
                        .filter(|l| !l.trim().starts_with("hint:") && !l.trim().is_empty())
                        .take(1)
                        .collect::<Vec<_>>()
                        .join(" ")
                        .trim()
                        .to_string()
                };
                Output::sub_item(format!("Error: {}", clean_error));
                failed_entries.push((*entry_num, clean_error));
            }
        }
    }

    println!();

    // Update all PR descriptions in the stack if any PRs were created/exist
    let has_any_prs = active_stack
        .entries
        .iter()
        .any(|e| e.pull_request_id.is_some());
    if has_any_prs && submitted_count > 0 {
        match integration.update_all_pr_descriptions(&stack_id).await {
            Ok(updated_prs) => {
                if !updated_prs.is_empty() {
                    Output::sub_item(format!(
                        "Updated {} PR description{} with stack hierarchy",
                        updated_prs.len(),
                        if updated_prs.len() == 1 { "" } else { "s" }
                    ));
                }
            }
            Err(e) => {
                // Suppress benign 409 "out of date" errors - these happen when PR was just created
                // and Bitbucket's version hasn't propagated yet. The PR still gets created successfully.
                let error_msg = e.to_string();
                if !error_msg.contains("409") && !error_msg.contains("out-of-date") {
                    // Only show non-409 errors, and make them concise
                    let clean_error = error_msg.lines().next().unwrap_or("Unknown error").trim();
                    Output::warning(format!(
                        "Could not update some PR descriptions: {}",
                        clean_error
                    ));
                    Output::sub_item(
                        "PRs were created successfully - descriptions can be updated manually",
                    );
                }
            }
        }
    }

    // Summary
    if failed_entries.is_empty() {
        Output::success(format!(
            "{} {} submitted successfully!",
            submitted_count,
            if submitted_count == 1 {
                "entry"
            } else {
                "entries"
            }
        ));
    } else {
        println!();
        Output::section("Submission Summary");
        Output::success(format!("Successful: {submitted_count}"));
        Output::error(format!("Failed: {}", failed_entries.len()));

        if !failed_entries.is_empty() {
            println!();
            Output::tip("Retry failed entries:");
            for (entry_num, _) in &failed_entries {
                Output::bullet(format!("ca stack submit {entry_num}"));
            }
        }
    }

    // Open PRs in browser if requested (default: true)
    if open && !pr_urls.is_empty() {
        println!();
        for url in &pr_urls {
            if let Err(e) = open::that(url) {
                Output::warning(format!("Could not open browser: {}", e));
                Output::tip(format!("Open manually: {}", url));
            }
        }
    }

    Ok(())
}

async fn check_stack_status(name: Option<String>) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;

    // Load configuration
    let config_dir = crate::config::get_repo_config_dir(&repo_root)?;
    let config_path = config_dir.join("config.json");
    let settings = crate::config::Settings::load_from_file(&config_path)?;

    // Create the main config structure
    let cascade_config = crate::config::CascadeConfig {
        bitbucket: Some(settings.bitbucket.clone()),
        git: settings.git.clone(),
        auth: crate::config::AuthConfig::default(),
        cascade: settings.cascade.clone(),
    };

    // Get stack information BEFORE moving stack_manager
    let stack = if let Some(name) = name {
        stack_manager
            .get_stack_by_name(&name)
            .ok_or_else(|| CascadeError::config(format!("Stack '{name}' not found")))?
    } else {
        stack_manager.get_active_stack().ok_or_else(|| {
            CascadeError::config("No active stack. Use 'ca stack list' to see available stacks")
        })?
    };
    let stack_id = stack.id;

    Output::section(format!("Stack: {}", stack.name));
    Output::sub_item(format!("ID: {}", stack.id));
    Output::sub_item(format!("Base: {}", stack.base_branch));

    if let Some(description) = &stack.description {
        Output::sub_item(format!("Description: {description}"));
    }

    // Create Bitbucket integration (this takes ownership of stack_manager)
    let integration = crate::bitbucket::BitbucketIntegration::new(stack_manager, cascade_config)?;

    // Check stack status
    match integration.check_stack_status(&stack_id).await {
        Ok(status) => {
            Output::section("Pull Request Status");
            Output::sub_item(format!("Total entries: {}", status.total_entries));
            Output::sub_item(format!("Submitted: {}", status.submitted_entries));
            Output::sub_item(format!("Open PRs: {}", status.open_prs));
            Output::sub_item(format!("Merged PRs: {}", status.merged_prs));
            Output::sub_item(format!("Declined PRs: {}", status.declined_prs));
            Output::sub_item(format!(
                "Completion: {:.1}%",
                status.completion_percentage()
            ));

            if !status.pull_requests.is_empty() {
                Output::section("Pull Requests");
                for pr in &status.pull_requests {
                    let state_icon = match pr.state {
                        crate::bitbucket::PullRequestState::Open => "🔄",
                        crate::bitbucket::PullRequestState::Merged => "✅",
                        crate::bitbucket::PullRequestState::Declined => "❌",
                    };
                    Output::bullet(format!(
                        "{} PR #{}: {} ({} -> {})",
                        state_icon, pr.id, pr.title, pr.from_ref.display_id, pr.to_ref.display_id
                    ));
                    if let Some(url) = pr.web_url() {
                        Output::sub_item(format!("URL: {url}"));
                    }
                }
            }
        }
        Err(e) => {
            tracing::debug!("Failed to check stack status: {}", e);
            return Err(e);
        }
    }

    Ok(())
}

async fn list_pull_requests(state: Option<String>, verbose: bool) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;

    // Load configuration
    let config_dir = crate::config::get_repo_config_dir(&repo_root)?;
    let config_path = config_dir.join("config.json");
    let settings = crate::config::Settings::load_from_file(&config_path)?;

    // Create the main config structure
    let cascade_config = crate::config::CascadeConfig {
        bitbucket: Some(settings.bitbucket.clone()),
        git: settings.git.clone(),
        auth: crate::config::AuthConfig::default(),
        cascade: settings.cascade.clone(),
    };

    // Create Bitbucket integration
    let integration = crate::bitbucket::BitbucketIntegration::new(stack_manager, cascade_config)?;

    // Parse state filter
    let pr_state = if let Some(state_str) = state {
        match state_str.to_lowercase().as_str() {
            "open" => Some(crate::bitbucket::PullRequestState::Open),
            "merged" => Some(crate::bitbucket::PullRequestState::Merged),
            "declined" => Some(crate::bitbucket::PullRequestState::Declined),
            _ => {
                return Err(CascadeError::config(format!(
                    "Invalid state '{state_str}'. Use: open, merged, declined"
                )))
            }
        }
    } else {
        None
    };

    // Get pull requests
    match integration.list_pull_requests(pr_state).await {
        Ok(pr_page) => {
            if pr_page.values.is_empty() {
                Output::info("No pull requests found.");
                return Ok(());
            }

            println!("Pull Requests ({} total):", pr_page.values.len());
            for pr in &pr_page.values {
                let state_icon = match pr.state {
                    crate::bitbucket::PullRequestState::Open => "○",
                    crate::bitbucket::PullRequestState::Merged => "✓",
                    crate::bitbucket::PullRequestState::Declined => "✗",
                };
                println!("   {} PR #{}: {}", state_icon, pr.id, pr.title);
                if verbose {
                    println!(
                        "      From: {} -> {}",
                        pr.from_ref.display_id, pr.to_ref.display_id
                    );
                    println!(
                        "      Author: {}",
                        pr.author
                            .user
                            .display_name
                            .as_deref()
                            .unwrap_or(&pr.author.user.name)
                    );
                    if let Some(url) = pr.web_url() {
                        println!("      URL: {url}");
                    }
                    if let Some(desc) = &pr.description {
                        if !desc.is_empty() {
                            println!("      Description: {desc}");
                        }
                    }
                    println!();
                }
            }

            if !verbose {
                println!("\nUse --verbose for more details");
            }
        }
        Err(e) => {
            warn!("Failed to list pull requests: {}", e);
            return Err(e);
        }
    }

    Ok(())
}

async fn check_stack(_force: bool) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut manager = StackManager::new(&repo_root)?;

    let active_stack = manager
        .get_active_stack()
        .ok_or_else(|| CascadeError::config("No active stack"))?;
    let stack_id = active_stack.id;

    manager.sync_stack(&stack_id)?;

    Output::success("Stack check completed successfully");

    Ok(())
}

pub async fn continue_sync() -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)?;

    Output::section("Continuing sync from where it left off");
    println!();

    // Check if there's an in-progress cherry-pick
    let cherry_pick_head = repo_root.join(".git").join("CHERRY_PICK_HEAD");
    if !cherry_pick_head.exists() {
        return Err(CascadeError::config(
            "No in-progress cherry-pick found. Nothing to continue.\n\n\
             Use 'ca sync' to start a new sync."
                .to_string(),
        ));
    }

    Output::info("Staging all resolved files");

    // Stage all resolved files
    std::process::Command::new("git")
        .args(["add", "-A"])
        .current_dir(&repo_root)
        .output()
        .map_err(CascadeError::Io)?;

    let sync_state = crate::stack::SyncState::load(&repo_root).ok();

    Output::info("Continuing cherry-pick");

    // Continue the cherry-pick
    let continue_output = std::process::Command::new("git")
        .args(["cherry-pick", "--continue"])
        .current_dir(&repo_root)
        .output()
        .map_err(CascadeError::Io)?;

    if !continue_output.status.success() {
        let stderr = String::from_utf8_lossy(&continue_output.stderr);
        return Err(CascadeError::Branch(format!(
            "Failed to continue cherry-pick: {}\n\n\
             Make sure all conflicts are resolved.",
            stderr
        )));
    }

    Output::success("Cherry-pick continued successfully");
    println!();

    // Now we need to:
    // 1. Figure out which stack branch this temp branch belongs to
    // 2. Force-push the temp branch to the actual stack branch
    // 3. Checkout to the working branch
    // 4. Continue with sync_stack() to process remaining entries

    let git_repo = crate::git::GitRepository::open(&repo_root)?;
    let current_branch = git_repo.get_current_branch()?;

    let stack_branch = if let Some(state) = &sync_state {
        if !state.current_entry_branch.is_empty() {
            if !state.current_temp_branch.is_empty() && current_branch != state.current_temp_branch
            {
                tracing::warn!(
                    "Sync state temp branch '{}' differs from current branch '{}'",
                    state.current_temp_branch,
                    current_branch
                );
            }
            state.current_entry_branch.clone()
        } else if let Some(idx) = current_branch.rfind("-temp-") {
            current_branch[..idx].to_string()
        } else {
            return Err(CascadeError::config(format!(
                "Current branch '{}' doesn't appear to be a temp branch created by cascade.\n\
                 Expected format: <branch>-temp-<timestamp>",
                current_branch
            )));
        }
    } else if let Some(idx) = current_branch.rfind("-temp-") {
        current_branch[..idx].to_string()
    } else {
        return Err(CascadeError::config(format!(
            "Current branch '{}' doesn't appear to be a temp branch created by cascade.\n\
             Expected format: <branch>-temp-<timestamp>",
            current_branch
        )));
    };

    Output::info(format!("Updating stack branch: {}", stack_branch));

    // Force-push temp branch to stack branch
    let output = std::process::Command::new("git")
        .args(["branch", "-f", &stack_branch])
        .current_dir(&repo_root)
        .output()
        .map_err(CascadeError::Io)?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(CascadeError::validation(format!(
            "Failed to update branch '{}': {}\n\n\
            This could be due to:\n\
            • Git lock file (.git/index.lock or .git/refs/heads/{}.lock)\n\
            • Insufficient permissions\n\
            • Branch is checked out in another worktree\n\n\
            Recovery:\n\
            1. Check for lock files: find .git -name '*.lock'\n\
            2. Remove stale lock files if safe\n\
            3. Run 'ca sync' to retry",
            stack_branch,
            stderr.trim(),
            stack_branch
        )));
    }

    // Load stack to get working branch and update metadata
    let mut manager = crate::stack::StackManager::new(&repo_root)?;

    // CRITICAL: Update the stack entry's commit hash to the new rebased commit
    // This prevents sync_stack() from thinking the working branch has "untracked" commits
    let new_commit_hash = git_repo.get_branch_head(&stack_branch)?;

    let (stack_id, entry_id_opt, working_branch) = if let Some(state) = &sync_state {
        let stack_uuid = Uuid::parse_str(&state.stack_id)
            .map_err(|e| CascadeError::config(format!("Invalid stack ID in sync state: {e}")))?;

        let stack_snapshot = manager
            .get_stack(&stack_uuid)
            .cloned()
            .ok_or_else(|| CascadeError::config("Stack not found in sync state".to_string()))?;

        let working_branch = stack_snapshot
            .working_branch
            .clone()
            .ok_or_else(|| CascadeError::config("Stack has no working branch".to_string()))?;

        let entry_id = if !state.current_entry_id.is_empty() {
            Uuid::parse_str(&state.current_entry_id).ok()
        } else {
            stack_snapshot
                .entries
                .iter()
                .find(|e| e.branch == stack_branch)
                .map(|e| e.id)
        };

        (stack_uuid, entry_id, working_branch)
    } else {
        let active_stack = manager
            .get_active_stack()
            .ok_or_else(|| CascadeError::config("No active stack found"))?;

        let entry_id = active_stack
            .entries
            .iter()
            .find(|e| e.branch == stack_branch)
            .map(|e| e.id);

        let working_branch = active_stack
            .working_branch
            .as_ref()
            .ok_or_else(|| CascadeError::config("Active stack has no working branch"))?
            .clone();

        (active_stack.id, entry_id, working_branch)
    };

    // Now we can mutably borrow manager to update the entry
    let entry_id = entry_id_opt.ok_or_else(|| {
        CascadeError::config(format!(
            "Could not find stack entry for branch '{}'",
            stack_branch
        ))
    })?;

    let stack = manager
        .get_stack_mut(&stack_id)
        .ok_or_else(|| CascadeError::config("Could not get mutable stack reference"))?;

    stack
        .update_entry_commit_hash(&entry_id, new_commit_hash.clone())
        .map_err(CascadeError::config)?;

    manager.save_to_disk()?;

    // Get the top of the stack to update the working branch
    let top_commit = {
        let active_stack = manager
            .get_active_stack()
            .ok_or_else(|| CascadeError::config("No active stack found"))?;

        if let Some(last_entry) = active_stack.entries.last() {
            git_repo.get_branch_head(&last_entry.branch)?
        } else {
            new_commit_hash.clone()
        }
    };

    Output::info(format!(
        "Checking out to working branch: {}",
        working_branch
    ));

    // Checkout to working branch
    git_repo.checkout_branch_unsafe(&working_branch)?;

    // Update working branch to point to the top of the rebased stack
    // In the continue_sync() context, we KNOW we just finished rebasing, so the
    // working branch's old commits are pre-rebase versions that should be replaced.
    // We unconditionally update here because:
    // 1. The user just resolved conflicts and continued the rebase
    // 2. The stack entry metadata has been updated to the new rebased commits
    // 3. Any "old" commits on the working branch are the pre-rebase versions
    // 4. The subsequent sync_stack() call will do final safety checks
    if let Ok(working_head) = git_repo.get_branch_head(&working_branch) {
        if working_head != top_commit {
            git_repo.update_branch_to_commit(&working_branch, &top_commit)?;
        }
    }

    if sync_state.is_some() {
        crate::stack::SyncState::delete(&repo_root)?;
    }

    println!();
    Output::info("Resuming sync to complete the rebase...");
    println!();

    // Continue with the full sync to process remaining entries
    sync_stack(false, false, false).await
}

pub async fn abort_sync() -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)?;

    Output::section("Aborting sync");
    println!();

    // Check if there's an in-progress cherry-pick
    let cherry_pick_head = repo_root.join(".git").join("CHERRY_PICK_HEAD");
    if !cherry_pick_head.exists() {
        return Err(CascadeError::config(
            "No in-progress cherry-pick found. Nothing to abort.\n\n\
             The sync may have already completed or been aborted."
                .to_string(),
        ));
    }

    Output::info("Aborting cherry-pick");

    // Abort the cherry-pick with CASCADE_SKIP_HOOKS to avoid hook interference
    let abort_output = std::process::Command::new("git")
        .args(["cherry-pick", "--abort"])
        .env("CASCADE_SKIP_HOOKS", "1")
        .current_dir(&repo_root)
        .output()
        .map_err(CascadeError::Io)?;

    if !abort_output.status.success() {
        let stderr = String::from_utf8_lossy(&abort_output.stderr);
        return Err(CascadeError::Branch(format!(
            "Failed to abort cherry-pick: {}",
            stderr
        )));
    }

    Output::success("Cherry-pick aborted");

    // Load sync state if it exists to clean up temp branches
    let git_repo = crate::git::GitRepository::open(&repo_root)?;

    if let Ok(state) = crate::stack::SyncState::load(&repo_root) {
        println!();
        Output::info("Cleaning up temporary branches");

        // Clean up all temp branches
        for temp_branch in &state.temp_branches {
            if let Err(e) = git_repo.delete_branch_unsafe(temp_branch) {
                tracing::warn!("Could not delete temp branch '{}': {}", temp_branch, e);
            }
        }

        // Return to original branch
        Output::info(format!(
            "Returning to original branch: {}",
            state.original_branch
        ));
        if let Err(e) = git_repo.checkout_branch_unsafe(&state.original_branch) {
            // Fall back to base branch if original branch checkout fails
            tracing::warn!("Could not checkout original branch: {}", e);
            if let Err(e2) = git_repo.checkout_branch_unsafe(&state.target_base) {
                tracing::warn!("Could not checkout base branch: {}", e2);
            }
        }

        // Delete sync state file
        crate::stack::SyncState::delete(&repo_root)?;
    } else {
        // No state file - try to figure out where to go
        let current_branch = git_repo.get_current_branch()?;

        // If on a temp branch, try to parse and return to original
        if let Some(idx) = current_branch.rfind("-temp-") {
            let original_branch = &current_branch[..idx];
            Output::info(format!("Returning to branch: {}", original_branch));

            if let Err(e) = git_repo.checkout_branch_unsafe(original_branch) {
                tracing::warn!("Could not checkout original branch: {}", e);
            }

            // Try to delete the temp branch
            if let Err(e) = git_repo.delete_branch_unsafe(&current_branch) {
                tracing::warn!("Could not delete temp branch: {}", e);
            }
        }
    }

    println!();
    Output::success("Sync aborted");
    println!();
    Output::tip("You can start a fresh sync with: ca sync");

    Ok(())
}

async fn sync_stack(force: bool, cleanup: bool, interactive: bool) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut stack_manager = StackManager::new(&repo_root)?;

    // Exit edit mode if active (sync will invalidate commit SHAs)
    // TODO: Add error recovery to restore edit mode if sync fails
    if stack_manager.is_in_edit_mode() {
        debug!("Exiting edit mode before sync (commit SHAs will change)");
        stack_manager.exit_edit_mode()?;
    }

    let git_repo = GitRepository::open(&repo_root)?;

    if git_repo.is_dirty()? {
        return Err(CascadeError::branch(
            "Working tree has uncommitted changes. Commit or stash them before running 'ca sync'."
                .to_string(),
        ));
    }

    // Get active stack
    let active_stack = stack_manager.get_active_stack().ok_or_else(|| {
        CascadeError::config("No active stack. Create a stack first with 'ca stack create'")
    })?;

    let base_branch = active_stack.base_branch.clone();
    let _stack_name = active_stack.name.clone();

    // Save the original working branch before any checkouts
    let original_branch = git_repo.get_current_branch().ok();

    // Sync starts silently - user will see the rebase output

    // Step 1: Pull latest changes from base branch (silent unless error)
    match git_repo.checkout_branch_silent(&base_branch) {
        Ok(_) => {
            match git_repo.pull(&base_branch) {
                Ok(_) => {
                    // Silent success - only show on verbose or error
                }
                Err(e) => {
                    if force {
                        Output::warning(format!("Pull failed: {e} (continuing due to --force)"));
                    } else {
                        Output::error(format!("Failed to pull latest changes: {e}"));
                        Output::tip("Use --force to skip pull and continue with rebase");
                        return Err(CascadeError::branch(format!(
                            "Failed to pull latest changes from '{base_branch}': {e}. Use --force to continue anyway."
                        )));
                    }
                }
            }
        }
        Err(e) => {
            if force {
                Output::warning(format!(
                    "Failed to checkout '{base_branch}': {e} (continuing due to --force)"
                ));
            } else {
                Output::error(format!(
                    "Failed to checkout base branch '{base_branch}': {e}"
                ));
                Output::tip("Use --force to bypass checkout issues and continue anyway");
                return Err(CascadeError::branch(format!(
                    "Failed to checkout base branch '{base_branch}': {e}. Use --force to continue anyway."
                )));
            }
        }
    }

    // Step 2: Reconcile metadata with current Git state before checking integrity
    // This fixes stale metadata from previous bugs or interrupted operations
    let mut updated_stack_manager = StackManager::new(&repo_root)?;
    let stack_id = active_stack.id;

    // Update entry commit hashes to match current branch HEADs
    // This prevents false "branch modification" errors from stale metadata
    if let Some(stack) = updated_stack_manager.get_stack_mut(&stack_id) {
        let mut updates = Vec::new();
        for entry in &stack.entries {
            if let Ok(current_commit) = git_repo.get_branch_head(&entry.branch) {
                if entry.commit_hash != current_commit {
                    let is_safe_descendant = match git_repo.commit_exists(&entry.commit_hash) {
                        Ok(true) => {
                            match git_repo.is_descendant_of(&current_commit, &entry.commit_hash) {
                                Ok(result) => result,
                                Err(e) => {
                                    warn!(
                                    "Cannot verify ancestry for '{}': {} - treating as unsafe to prevent potential data loss",
                                    entry.branch, e
                                );
                                    false
                                }
                            }
                        }
                        Ok(false) => {
                            debug!(
                                "Recorded commit {} for '{}' no longer exists in repository",
                                &entry.commit_hash[..8],
                                entry.branch
                            );
                            false
                        }
                        Err(e) => {
                            warn!(
                                "Cannot verify commit existence for '{}': {} - treating as unsafe to prevent potential data loss",
                                entry.branch, e
                            );
                            false
                        }
                    };

                    if is_safe_descendant {
                        debug!(
                            "Reconciling entry '{}': updating hash from {} to {} (current branch HEAD)",
                            entry.branch,
                            &entry.commit_hash[..8],
                            &current_commit[..8]
                        );
                        updates.push((entry.id, current_commit));
                    } else {
                        warn!(
                            "Skipped automatic reconciliation for entry '{}' because local HEAD ({}) does not descend from recorded commit ({})",
                            entry.branch,
                            &current_commit[..8],
                            &entry.commit_hash[..8]
                        );
                        // This commonly happens after 'ca entry amend' without --restack
                        // The amended commit replaces the old one (not a descendant)
                    }
                }
            }
        }

        // Apply updates using safe wrapper
        for (entry_id, new_hash) in updates {
            stack
                .update_entry_commit_hash(&entry_id, new_hash)
                .map_err(CascadeError::config)?;
        }

        // Save reconciled metadata
        updated_stack_manager.save_to_disk()?;
    }

    match updated_stack_manager.sync_stack(&stack_id) {
        Ok(_) => {
            // Check the updated status
            if let Some(updated_stack) = updated_stack_manager.get_stack(&stack_id) {
                // Check for empty stack first
                if updated_stack.entries.is_empty() {
                    println!(); // Spacing
                    Output::info("Stack has no entries yet");
                    Output::tip("Use 'ca push' to add commits to this stack");
                    return Ok(());
                }

                match &updated_stack.status {
                    crate::stack::StackStatus::NeedsSync => {
                        // Load configuration for Bitbucket integration
                        let config_dir = crate::config::get_repo_config_dir(&repo_root)?;
                        let config_path = config_dir.join("config.json");
                        let settings = crate::config::Settings::load_from_file(&config_path)?;

                        let cascade_config = crate::config::CascadeConfig {
                            bitbucket: Some(settings.bitbucket.clone()),
                            git: settings.git.clone(),
                            auth: crate::config::AuthConfig::default(),
                            cascade: settings.cascade.clone(),
                        };

                        println!(); // Spacing

                        // Use the existing rebase system with force-push strategy
                        // This preserves PR history by force-pushing to original branches
                        let options = crate::stack::RebaseOptions {
                            strategy: crate::stack::RebaseStrategy::ForcePush,
                            interactive,
                            target_base: Some(base_branch.clone()),
                            preserve_merges: true,
                            auto_resolve: !interactive, // Re-enabled with safety checks
                            max_retries: 3,
                            skip_pull: Some(true), // Skip pull since we already pulled above
                            original_working_branch: original_branch.clone(), // Pass the saved working branch
                        };

                        let mut rebase_manager = crate::stack::RebaseManager::new(
                            updated_stack_manager,
                            git_repo,
                            options,
                        );

                        // Rebase all entries (static output)
                        let rebase_result = rebase_manager.rebase_stack(&stack_id);

                        match rebase_result {
                            Ok(result) => {
                                if !result.branch_mapping.is_empty() {
                                    // Update PRs if enabled
                                    if let Some(ref _bitbucket_config) = cascade_config.bitbucket {
                                        // Reload stack manager to get latest metadata after rebase
                                        let integration_stack_manager =
                                            StackManager::new(&repo_root)?;
                                        let mut integration =
                                            crate::bitbucket::BitbucketIntegration::new(
                                                integration_stack_manager,
                                                cascade_config,
                                            )?;

                                        // Update PRs (static output)
                                        let pr_result = integration
                                            .update_prs_after_rebase(
                                                &stack_id,
                                                &result.branch_mapping,
                                            )
                                            .await;

                                        match pr_result {
                                            Ok(updated_prs) => {
                                                if !updated_prs.is_empty() {
                                                    Output::success(format!(
                                                        "Updated {} pull request{}",
                                                        updated_prs.len(),
                                                        if updated_prs.len() == 1 {
                                                            ""
                                                        } else {
                                                            "s"
                                                        }
                                                    ));
                                                }
                                            }
                                            Err(e) => {
                                                Output::warning(format!(
                                                    "Failed to update pull requests: {e}"
                                                ));
                                            }
                                        }
                                    }
                                }
                            }
                            Err(e) => {
                                // Error already contains instructions, just propagate it
                                return Err(e);
                            }
                        }
                    }
                    crate::stack::StackStatus::Clean => {
                        // Already up to date - silent success
                    }
                    other => {
                        // Only show unexpected status
                        Output::info(format!("Stack status: {other:?}"));
                    }
                }
            }
        }
        Err(e) => {
            if force {
                Output::warning(format!(
                    "Failed to check stack status: {e} (continuing due to --force)"
                ));
            } else {
                return Err(e);
            }
        }
    }

    // Step 3: Cleanup merged branches (optional) - only if explicitly requested
    if cleanup {
        let git_repo_for_cleanup = GitRepository::open(&repo_root)?;
        match perform_simple_cleanup(&stack_manager, &git_repo_for_cleanup, false).await {
            Ok(result) => {
                if result.total_candidates > 0 {
                    Output::section("Cleanup Summary");
                    if !result.cleaned_branches.is_empty() {
                        Output::success(format!(
                            "Cleaned up {} merged branches",
                            result.cleaned_branches.len()
                        ));
                        for branch in &result.cleaned_branches {
                            Output::sub_item(format!("🗑️  Deleted: {branch}"));
                        }
                    }
                    if !result.skipped_branches.is_empty() {
                        Output::sub_item(format!(
                            "Skipped {} branches",
                            result.skipped_branches.len()
                        ));
                    }
                    if !result.failed_branches.is_empty() {
                        for (branch, error) in &result.failed_branches {
                            Output::warning(format!("Failed to clean up {branch}: {error}"));
                        }
                    }
                }
            }
            Err(e) => {
                Output::warning(format!("Branch cleanup failed: {e}"));
            }
        }
    }

    // NOTE: Don't checkout the original branch here!
    // The rebase_with_force_push() function already returned us to the working branch
    // using checkout_branch_unsafe(). If we try to checkout again with the safe version,
    // it will see the rebased working tree and think there are staged changes
    // (because the working branch HEAD was updated during rebase but we're still on the old tree).
    // Trust that the rebase left us in the correct state.

    Output::success("Sync completed successfully!");

    Ok(())
}

async fn rebase_stack(
    interactive: bool,
    onto: Option<String>,
    strategy: Option<RebaseStrategyArg>,
) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;
    let git_repo = GitRepository::open(&repo_root)?;

    // Load configuration for potential Bitbucket integration
    let config_dir = crate::config::get_repo_config_dir(&repo_root)?;
    let config_path = config_dir.join("config.json");
    let settings = crate::config::Settings::load_from_file(&config_path)?;

    // Create the main config structure
    let cascade_config = crate::config::CascadeConfig {
        bitbucket: Some(settings.bitbucket.clone()),
        git: settings.git.clone(),
        auth: crate::config::AuthConfig::default(),
        cascade: settings.cascade.clone(),
    };

    // Get active stack
    let active_stack = stack_manager.get_active_stack().ok_or_else(|| {
        CascadeError::config("No active stack. Create a stack first with 'ca stack create'")
    })?;
    let stack_id = active_stack.id;

    let active_stack = stack_manager
        .get_stack(&stack_id)
        .ok_or_else(|| CascadeError::config("Active stack not found"))?
        .clone();

    if active_stack.entries.is_empty() {
        Output::info("Stack is empty. Nothing to rebase.");
        return Ok(());
    }

    // Determine rebase strategy (force-push is the industry standard for stacked diffs)
    let rebase_strategy = if let Some(cli_strategy) = strategy {
        match cli_strategy {
            RebaseStrategyArg::ForcePush => crate::stack::RebaseStrategy::ForcePush,
            RebaseStrategyArg::Interactive => crate::stack::RebaseStrategy::Interactive,
        }
    } else {
        // Default to force-push (industry standard for preserving PR history)
        crate::stack::RebaseStrategy::ForcePush
    };

    // Save original branch before any operations
    let original_branch = git_repo.get_current_branch().ok();

    debug!("   Strategy: {:?}", rebase_strategy);
    debug!("   Interactive: {}", interactive);
    debug!("   Target base: {:?}", onto);
    debug!("   Entries: {}", active_stack.entries.len());

    println!(); // Spacing

    // Start spinner for rebase
    let rebase_spinner = crate::utils::spinner::Spinner::new_with_output_below(format!(
        "Rebasing stack: {}",
        active_stack.name
    ));

    // Create rebase options
    let options = crate::stack::RebaseOptions {
        strategy: rebase_strategy.clone(),
        interactive,
        target_base: onto,
        preserve_merges: true,
        auto_resolve: !interactive, // Re-enabled with safety checks
        max_retries: 3,
        skip_pull: None, // Normal rebase should pull latest changes
        original_working_branch: original_branch,
    };

    // Check if there's already a rebase in progress
    let mut rebase_manager = crate::stack::RebaseManager::new(stack_manager, git_repo, options);

    if rebase_manager.is_rebase_in_progress() {
        Output::warning("Rebase already in progress!");
        Output::tip("Use 'git status' to check the current state");
        Output::next_steps(&[
            "Run 'ca stack continue-rebase' to continue",
            "Run 'ca stack abort-rebase' to abort",
        ]);
        rebase_spinner.stop();
        return Ok(());
    }

    // Perform the rebase
    let rebase_result = rebase_manager.rebase_stack(&stack_id);

    // Stop spinner before showing results
    rebase_spinner.stop();
    println!(); // Spacing

    match rebase_result {
        Ok(result) => {
            Output::success("Rebase completed!");
            Output::sub_item(result.get_summary());

            if result.has_conflicts() {
                Output::warning(format!(
                    "{} conflicts were resolved",
                    result.conflicts.len()
                ));
                for conflict in &result.conflicts {
                    Output::bullet(&conflict[..8.min(conflict.len())]);
                }
            }

            if !result.branch_mapping.is_empty() {
                Output::section("Branch mapping");
                for (old, new) in &result.branch_mapping {
                    Output::bullet(format!("{old} -> {new}"));
                }

                // Handle PR updates if enabled
                if let Some(ref _bitbucket_config) = cascade_config.bitbucket {
                    // Create a new StackManager for the integration (since the original was moved)
                    let integration_stack_manager = StackManager::new(&repo_root)?;
                    let mut integration = BitbucketIntegration::new(
                        integration_stack_manager,
                        cascade_config.clone(),
                    )?;

                    match integration
                        .update_prs_after_rebase(&stack_id, &result.branch_mapping)
                        .await
                    {
                        Ok(updated_prs) => {
                            if !updated_prs.is_empty() {
                                println!("   🔄 Preserved pull request history:");
                                for pr_update in updated_prs {
                                    println!("      ✅ {pr_update}");
                                }
                            }
                        }
                        Err(e) => {
                            Output::warning(format!("Failed to update pull requests: {e}"));
                            Output::sub_item("You may need to manually update PRs in Bitbucket");
                        }
                    }
                }
            }

            Output::success(format!(
                "{} commits successfully rebased",
                result.success_count()
            ));

            // Show next steps
            if matches!(rebase_strategy, crate::stack::RebaseStrategy::ForcePush) {
                println!();
                Output::section("Next steps");
                if !result.branch_mapping.is_empty() {
                    Output::numbered_item(1, "Branches have been rebased and force-pushed");
                    Output::numbered_item(
                        2,
                        "Pull requests updated automatically (history preserved)",
                    );
                    Output::numbered_item(3, "Review the updated PRs in Bitbucket");
                    Output::numbered_item(4, "Test your changes");
                } else {
                    println!("   1. Review the rebased stack");
                    println!("   2. Test your changes");
                    println!("   3. Submit new pull requests with 'ca stack submit'");
                }
            }
        }
        Err(e) => {
            warn!("❌ Rebase failed: {}", e);
            Output::tip(" Tips for resolving rebase issues:");
            println!("   - Check for uncommitted changes with 'git status'");
            println!("   - Ensure base branch is up to date");
            println!("   - Try interactive mode: 'ca stack rebase --interactive'");
            return Err(e);
        }
    }

    Ok(())
}

pub async fn continue_rebase() -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;
    let git_repo = crate::git::GitRepository::open(&repo_root)?;
    let options = crate::stack::RebaseOptions::default();
    let rebase_manager = crate::stack::RebaseManager::new(stack_manager, git_repo, options);

    if !rebase_manager.is_rebase_in_progress() {
        Output::info("  No rebase in progress");
        return Ok(());
    }

    println!(" Continuing rebase...");
    match rebase_manager.continue_rebase() {
        Ok(_) => {
            Output::success(" Rebase continued successfully");
            println!("   Check 'ca stack rebase-status' for current state");
        }
        Err(e) => {
            warn!("❌ Failed to continue rebase: {}", e);
            Output::tip(" You may need to resolve conflicts first:");
            println!("   1. Edit conflicted files");
            println!("   2. Stage resolved files with 'git add'");
            println!("   3. Run 'ca stack continue-rebase' again");
        }
    }

    Ok(())
}

pub async fn abort_rebase() -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;
    let git_repo = crate::git::GitRepository::open(&repo_root)?;
    let options = crate::stack::RebaseOptions::default();
    let rebase_manager = crate::stack::RebaseManager::new(stack_manager, git_repo, options);

    if !rebase_manager.is_rebase_in_progress() {
        Output::info("  No rebase in progress");
        return Ok(());
    }

    Output::warning("Aborting rebase...");
    match rebase_manager.abort_rebase() {
        Ok(_) => {
            Output::success(" Rebase aborted successfully");
            println!("   Repository restored to pre-rebase state");
        }
        Err(e) => {
            warn!("❌ Failed to abort rebase: {}", e);
            println!("⚠️  You may need to manually clean up the repository state");
        }
    }

    Ok(())
}

async fn rebase_status() -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;
    let git_repo = crate::git::GitRepository::open(&repo_root)?;

    println!("Rebase Status");

    // Check if rebase is in progress by checking git state directly
    let git_dir = current_dir.join(".git");
    let rebase_in_progress = git_dir.join("REBASE_HEAD").exists()
        || git_dir.join("rebase-merge").exists()
        || git_dir.join("rebase-apply").exists();

    if rebase_in_progress {
        println!("   Status: 🔄 Rebase in progress");
        println!(
            "   
📝 Actions available:"
        );
        println!("     - 'ca stack continue-rebase' to continue");
        println!("     - 'ca stack abort-rebase' to abort");
        println!("     - 'git status' to see conflicted files");

        // Check for conflicts
        match git_repo.get_status() {
            Ok(statuses) => {
                let mut conflicts = Vec::new();
                for status in statuses.iter() {
                    if status.status().contains(git2::Status::CONFLICTED) {
                        if let Some(path) = status.path() {
                            conflicts.push(path.to_string());
                        }
                    }
                }

                if !conflicts.is_empty() {
                    println!("   ⚠️  Conflicts in {} files:", conflicts.len());
                    for conflict in conflicts {
                        println!("      - {conflict}");
                    }
                    println!(
                        "   
💡 To resolve conflicts:"
                    );
                    println!("     1. Edit the conflicted files");
                    println!("     2. Stage resolved files: git add <file>");
                    println!("     3. Continue: ca stack continue-rebase");
                }
            }
            Err(e) => {
                warn!("Failed to get git status: {}", e);
            }
        }
    } else {
        println!("   Status: ✅ No rebase in progress");

        // Show stack status instead
        if let Some(active_stack) = stack_manager.get_active_stack() {
            println!("   Active stack: {}", active_stack.name);
            println!("   Entries: {}", active_stack.entries.len());
            println!("   Base branch: {}", active_stack.base_branch);
        }
    }

    Ok(())
}

async fn delete_stack(name: String, force: bool) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut manager = StackManager::new(&repo_root)?;

    let stack = manager
        .get_stack_by_name(&name)
        .ok_or_else(|| CascadeError::config(format!("Stack '{name}' not found")))?;
    let stack_id = stack.id;

    if !force && !stack.entries.is_empty() {
        return Err(CascadeError::config(format!(
            "Stack '{}' has {} entries. Use --force to delete anyway",
            name,
            stack.entries.len()
        )));
    }

    let deleted = manager.delete_stack(&stack_id)?;

    Output::success(format!("Deleted stack '{}'", deleted.name));
    if !deleted.entries.is_empty() {
        Output::warning(format!("{} entries were removed", deleted.entries.len()));
    }

    Ok(())
}

async fn validate_stack(name: Option<String>, fix_mode: Option<String>) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut manager = StackManager::new(&repo_root)?;

    if let Some(name) = name {
        // Validate specific stack
        let stack = manager
            .get_stack_by_name(&name)
            .ok_or_else(|| CascadeError::config(format!("Stack '{name}' not found")))?;

        let stack_id = stack.id;

        // Basic structure validation first
        match stack.validate() {
            Ok(_message) => {
                Output::success(format!("Stack '{}' structure validation passed", name));
            }
            Err(e) => {
                Output::error(format!(
                    "Stack '{}' structure validation failed: {}",
                    name, e
                ));
                return Err(CascadeError::config(e));
            }
        }

        // Handle branch modifications (includes Git integrity checks)
        manager.handle_branch_modifications(&stack_id, fix_mode)?;

        println!();
        Output::success(format!("Stack '{name}' validation completed"));
        Ok(())
    } else {
        // Validate all stacks
        Output::section("Validating all stacks");
        println!();

        // Get all stack IDs through public method
        let all_stacks = manager.get_all_stacks();
        let stack_ids: Vec<uuid::Uuid> = all_stacks.iter().map(|s| s.id).collect();

        if stack_ids.is_empty() {
            Output::info("No stacks found");
            return Ok(());
        }

        let mut all_valid = true;
        for stack_id in stack_ids {
            let stack = manager.get_stack(&stack_id).unwrap();
            let stack_name = &stack.name;

            println!("Checking stack '{stack_name}':");

            // Basic structure validation
            match stack.validate() {
                Ok(message) => {
                    Output::sub_item(format!("Structure: {message}"));
                }
                Err(e) => {
                    Output::sub_item(format!("Structure: {e}"));
                    all_valid = false;
                    continue;
                }
            }

            // Handle branch modifications
            match manager.handle_branch_modifications(&stack_id, fix_mode.clone()) {
                Ok(_) => {
                    Output::sub_item("Git integrity: OK");
                }
                Err(e) => {
                    Output::sub_item(format!("Git integrity: {e}"));
                    all_valid = false;
                }
            }
            println!();
        }

        if all_valid {
            Output::success("All stacks passed validation");
        } else {
            Output::warning("Some stacks have validation issues");
            return Err(CascadeError::config("Stack validation failed".to_string()));
        }

        Ok(())
    }
}

/// Get commits that are not yet in any stack entry
#[allow(dead_code)]
fn get_unpushed_commits(repo: &GitRepository, stack: &crate::stack::Stack) -> Result<Vec<String>> {
    let mut unpushed = Vec::new();
    let head_commit = repo.get_head_commit()?;
    let mut current_commit = head_commit;

    // Walk back from HEAD until we find a commit that's already in the stack
    loop {
        let commit_hash = current_commit.id().to_string();
        let already_in_stack = stack
            .entries
            .iter()
            .any(|entry| entry.commit_hash == commit_hash);

        if already_in_stack {
            break;
        }

        unpushed.push(commit_hash);

        // Move to parent commit
        if let Some(parent) = current_commit.parents().next() {
            current_commit = parent;
        } else {
            break;
        }
    }

    unpushed.reverse(); // Reverse to get chronological order
    Ok(unpushed)
}

/// Squash the last N commits into a single commit
pub async fn squash_commits(
    repo: &GitRepository,
    count: usize,
    since_ref: Option<String>,
) -> Result<()> {
    if count <= 1 {
        return Ok(()); // Nothing to squash
    }

    // Get the current branch
    let _current_branch = repo.get_current_branch()?;

    // Determine the range for interactive rebase
    let rebase_range = if let Some(ref since) = since_ref {
        since.clone()
    } else {
        format!("HEAD~{count}")
    };

    println!("   Analyzing {count} commits to create smart squash message...");

    // Get the commits that will be squashed to create a smart message
    let head_commit = repo.get_head_commit()?;
    let mut commits_to_squash = Vec::new();
    let mut current = head_commit;

    // Collect the last N commits
    for _ in 0..count {
        commits_to_squash.push(current.clone());
        if current.parent_count() > 0 {
            current = current.parent(0).map_err(CascadeError::Git)?;
        } else {
            break;
        }
    }

    // Generate smart commit message from the squashed commits
    let smart_message = generate_squash_message(&commits_to_squash)?;
    println!(
        "   Smart message: {}",
        smart_message.lines().next().unwrap_or("")
    );

    // Get the commit we want to reset to (the commit before our range)
    let reset_target = if since_ref.is_some() {
        // If squashing since a reference, reset to that reference
        format!("{rebase_range}~1")
    } else {
        // If squashing last N commits, reset to N commits before
        format!("HEAD~{count}")
    };

    // Soft reset to preserve changes in staging area
    repo.reset_soft(&reset_target)?;

    // Stage all changes (they should already be staged from the reset --soft)
    repo.stage_all()?;

    // Create the new commit with the smart message
    let new_commit_hash = repo.commit(&smart_message)?;

    println!(
        "   Created squashed commit: {} ({})",
        &new_commit_hash[..8],
        smart_message.lines().next().unwrap_or("")
    );
    println!("   💡 Tip: Use 'git commit --amend' to edit the commit message if needed");

    Ok(())
}

/// Generate a smart commit message from multiple commits being squashed
pub fn generate_squash_message(commits: &[git2::Commit]) -> Result<String> {
    if commits.is_empty() {
        return Ok("Squashed commits".to_string());
    }

    // Get all commit messages
    let messages: Vec<String> = commits
        .iter()
        .map(|c| c.message().unwrap_or("").trim().to_string())
        .filter(|m| !m.is_empty())
        .collect();

    if messages.is_empty() {
        return Ok("Squashed commits".to_string());
    }

    // Strategy 1: If the last commit looks like a "Final:" commit, use it
    if let Some(last_msg) = messages.first() {
        // first() because we're in reverse chronological order
        if last_msg.starts_with("Final:") || last_msg.starts_with("final:") {
            return Ok(last_msg
                .trim_start_matches("Final:")
                .trim_start_matches("final:")
                .trim()
                .to_string());
        }
    }

    // Strategy 2: If most commits are WIP, find the most descriptive non-WIP message
    let wip_count = messages
        .iter()
        .filter(|m| {
            m.to_lowercase().starts_with("wip") || m.to_lowercase().contains("work in progress")
        })
        .count();

    if wip_count > messages.len() / 2 {
        // Mostly WIP commits, find the best non-WIP one or create a summary
        let non_wip: Vec<&String> = messages
            .iter()
            .filter(|m| {
                !m.to_lowercase().starts_with("wip")
                    && !m.to_lowercase().contains("work in progress")
            })
            .collect();

        if let Some(best_msg) = non_wip.first() {
            return Ok(best_msg.to_string());
        }

        // All are WIP, try to extract the feature being worked on
        let feature = extract_feature_from_wip(&messages);
        return Ok(feature);
    }

    // Strategy 3: Use the last (most recent) commit message
    Ok(messages.first().unwrap().clone())
}

/// Extract feature name from WIP commit messages
pub fn extract_feature_from_wip(messages: &[String]) -> String {
    // Look for patterns like "WIP: add authentication" -> "Add authentication"
    for msg in messages {
        // Check both case variations, but preserve original case
        if msg.to_lowercase().starts_with("wip:") {
            if let Some(rest) = msg
                .strip_prefix("WIP:")
                .or_else(|| msg.strip_prefix("wip:"))
            {
                let feature = rest.trim();
                if !feature.is_empty() && feature.len() > 3 {
                    // Capitalize first letter only, preserve rest
                    let mut chars: Vec<char> = feature.chars().collect();
                    if let Some(first) = chars.first_mut() {
                        *first = first.to_uppercase().next().unwrap_or(*first);
                    }
                    return chars.into_iter().collect();
                }
            }
        }
    }

    // Fallback: Use the latest commit without WIP prefix
    if let Some(first) = messages.first() {
        let cleaned = first
            .trim_start_matches("WIP:")
            .trim_start_matches("wip:")
            .trim_start_matches("WIP")
            .trim_start_matches("wip")
            .trim();

        if !cleaned.is_empty() {
            return format!("Implement {cleaned}");
        }
    }

    format!("Squashed {} commits", messages.len())
}

/// Count commits since a given reference
pub fn count_commits_since(repo: &GitRepository, since_commit_hash: &str) -> Result<usize> {
    let head_commit = repo.get_head_commit()?;
    let since_commit = repo.get_commit(since_commit_hash)?;

    let mut count = 0;
    let mut current = head_commit;

    // Walk backwards from HEAD until we reach the since commit
    loop {
        if current.id() == since_commit.id() {
            break;
        }

        count += 1;

        // Get parent commit
        if current.parent_count() == 0 {
            break; // Reached root commit
        }

        current = current.parent(0).map_err(CascadeError::Git)?;
    }

    Ok(count)
}

/// Land (merge) approved stack entries
async fn land_stack(
    entry: Option<usize>,
    force: bool,
    dry_run: bool,
    auto: bool,
    wait_for_builds: bool,
    strategy: Option<MergeStrategyArg>,
    build_timeout: u64,
) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;

    // Get stack ID and active stack before moving stack_manager
    let stack_id = stack_manager
        .get_active_stack()
        .map(|s| s.id)
        .ok_or_else(|| {
            CascadeError::config(
                "No active stack. Use 'ca stack create' or 'ca stack switch' to select a stack"
                    .to_string(),
            )
        })?;

    let active_stack = stack_manager
        .get_active_stack()
        .cloned()
        .ok_or_else(|| CascadeError::config("No active stack found".to_string()))?;

    // Load configuration and create Bitbucket integration
    let config_dir = crate::config::get_repo_config_dir(&repo_root)?;
    let config_path = config_dir.join("config.json");
    let settings = crate::config::Settings::load_from_file(&config_path)?;

    let cascade_config = crate::config::CascadeConfig {
        bitbucket: Some(settings.bitbucket.clone()),
        git: settings.git.clone(),
        auth: crate::config::AuthConfig::default(),
        cascade: settings.cascade.clone(),
    };

    let mut integration =
        crate::bitbucket::BitbucketIntegration::new(stack_manager, cascade_config)?;

    // Get enhanced status
    let status = integration.check_enhanced_stack_status(&stack_id).await?;

    if status.enhanced_statuses.is_empty() {
        println!("❌ No pull requests found to land");
        return Ok(());
    }

    // Filter PRs that are ready to land
    let ready_prs: Vec<_> = status
        .enhanced_statuses
        .iter()
        .filter(|pr_status| {
            // If specific entry requested, only include that one
            if let Some(entry_num) = entry {
                // Find the corresponding stack entry for this PR
                if let Some(stack_entry) = active_stack.entries.get(entry_num.saturating_sub(1)) {
                    // Check if this PR corresponds to the requested entry
                    if pr_status.pr.from_ref.display_id != stack_entry.branch {
                        return false;
                    }
                } else {
                    return false; // Invalid entry number
                }
            }

            if force {
                // If force is enabled, include any open PR
                pr_status.pr.state == crate::bitbucket::pull_request::PullRequestState::Open
            } else {
                pr_status.is_ready_to_land()
            }
        })
        .collect();

    if ready_prs.is_empty() {
        if let Some(entry_num) = entry {
            println!("❌ Entry {entry_num} is not ready to land or doesn't exist");
        } else {
            println!("❌ No pull requests are ready to land");
        }

        // Show what's blocking them
        println!("\n🚫 Blocking Issues:");
        for pr_status in &status.enhanced_statuses {
            if pr_status.pr.state == crate::bitbucket::pull_request::PullRequestState::Open {
                let blocking = pr_status.get_blocking_reasons();
                if !blocking.is_empty() {
                    println!("   PR #{}: {}", pr_status.pr.id, blocking.join(", "));
                }
            }
        }

        if !force {
            println!("\n💡 Use --force to land PRs with blocking issues (dangerous!)");
        }
        return Ok(());
    }

    if dry_run {
        if let Some(entry_num) = entry {
            println!("🏃 Dry Run - Entry {entry_num} that would be landed:");
        } else {
            println!("🏃 Dry Run - PRs that would be landed:");
        }
        for pr_status in &ready_prs {
            println!("   ✅ PR #{}: {}", pr_status.pr.id, pr_status.pr.title);
            if !pr_status.is_ready_to_land() && force {
                let blocking = pr_status.get_blocking_reasons();
                println!(
                    "      ⚠️  Would force land despite: {}",
                    blocking.join(", ")
                );
            }
        }
        return Ok(());
    }

    // Default behavior: land all ready PRs (safest approach)
    // Only land specific entry if explicitly requested
    if entry.is_some() && ready_prs.len() > 1 {
        println!(
            "🎯 {} PRs are ready to land, but landing only entry #{}",
            ready_prs.len(),
            entry.unwrap()
        );
    }

    // Setup auto-merge conditions
    let merge_strategy: crate::bitbucket::pull_request::MergeStrategy =
        strategy.unwrap_or(MergeStrategyArg::Squash).into();
    let auto_merge_conditions = crate::bitbucket::pull_request::AutoMergeConditions {
        merge_strategy: merge_strategy.clone(),
        wait_for_builds,
        build_timeout: std::time::Duration::from_secs(build_timeout),
        allowed_authors: None, // Allow all authors for now
    };

    // Land the PRs
    println!(
        "🚀 Landing {} PR{}...",
        ready_prs.len(),
        if ready_prs.len() == 1 { "" } else { "s" }
    );

    let pr_manager = crate::bitbucket::pull_request::PullRequestManager::new(
        crate::bitbucket::BitbucketClient::new(&settings.bitbucket)?,
    );

    // Land PRs in dependency order
    let mut landed_count = 0;
    let mut failed_count = 0;
    let total_ready_prs = ready_prs.len();

    for pr_status in ready_prs {
        let pr_id = pr_status.pr.id;

        print!("🚀 Landing PR #{}: {}", pr_id, pr_status.pr.title);

        let land_result = if auto {
            // Use auto-merge with conditions checking
            pr_manager
                .auto_merge_if_ready(pr_id, &auto_merge_conditions)
                .await
        } else {
            // Manual merge without auto-conditions
            pr_manager
                .merge_pull_request(pr_id, merge_strategy.clone())
                .await
                .map(
                    |pr| crate::bitbucket::pull_request::AutoMergeResult::Merged {
                        pr: Box::new(pr),
                        merge_strategy: merge_strategy.clone(),
                    },
                )
        };

        match land_result {
            Ok(crate::bitbucket::pull_request::AutoMergeResult::Merged { .. }) => {
                println!(" ✅");
                landed_count += 1;

                // 🔄 AUTO-RETARGETING: After each merge, retarget remaining PRs
                if landed_count < total_ready_prs {
                    println!(" Retargeting remaining PRs to latest base...");

                    // 1️⃣ CRITICAL: Update base branch to get latest merged state
                    let base_branch = active_stack.base_branch.clone();
                    let git_repo = crate::git::GitRepository::open(&repo_root)?;

                    println!("   📥 Updating base branch: {base_branch}");
                    match git_repo.pull(&base_branch) {
                        Ok(_) => println!("   ✅ Base branch updated successfully"),
                        Err(e) => {
                            println!("   ⚠️  Warning: Failed to update base branch: {e}");
                            println!(
                                "   💡 You may want to manually run: git pull origin {base_branch}"
                            );
                        }
                    }

                    // 2️⃣ Use rebase system to retarget remaining PRs
                    let temp_manager = StackManager::new(&repo_root)?;
                    let stack_for_count = temp_manager
                        .get_stack(&stack_id)
                        .ok_or_else(|| CascadeError::config("Stack not found"))?;
                    let entry_count = stack_for_count.entries.len();
                    let plural = if entry_count == 1 { "entry" } else { "entries" };

                    println!(); // Spacing
                    let rebase_spinner = crate::utils::spinner::Spinner::new(format!(
                        "Retargeting {} {}",
                        entry_count, plural
                    ));

                    let mut rebase_manager = crate::stack::RebaseManager::new(
                        StackManager::new(&repo_root)?,
                        git_repo,
                        crate::stack::RebaseOptions {
                            strategy: crate::stack::RebaseStrategy::ForcePush,
                            target_base: Some(base_branch.clone()),
                            ..Default::default()
                        },
                    );

                    let rebase_result = rebase_manager.rebase_stack(&stack_id);

                    rebase_spinner.stop();
                    println!(); // Spacing

                    match rebase_result {
                        Ok(rebase_result) => {
                            if !rebase_result.branch_mapping.is_empty() {
                                // Update PRs using the rebase result
                                let retarget_config = crate::config::CascadeConfig {
                                    bitbucket: Some(settings.bitbucket.clone()),
                                    git: settings.git.clone(),
                                    auth: crate::config::AuthConfig::default(),
                                    cascade: settings.cascade.clone(),
                                };
                                let mut retarget_integration = BitbucketIntegration::new(
                                    StackManager::new(&repo_root)?,
                                    retarget_config,
                                )?;

                                match retarget_integration
                                    .update_prs_after_rebase(
                                        &stack_id,
                                        &rebase_result.branch_mapping,
                                    )
                                    .await
                                {
                                    Ok(updated_prs) => {
                                        if !updated_prs.is_empty() {
                                            println!(
                                                "   ✅ Updated {} PRs with new targets",
                                                updated_prs.len()
                                            );
                                        }
                                    }
                                    Err(e) => {
                                        println!("   ⚠️  Failed to update remaining PRs: {e}");
                                        println!(
                                            "   💡 You may need to run: ca stack rebase --onto {base_branch}"
                                        );
                                    }
                                }
                            }
                        }
                        Err(e) => {
                            // 🚨 CONFLICTS DETECTED - Give clear next steps
                            println!("   ❌ Auto-retargeting conflicts detected!");
                            println!("   📝 To resolve conflicts and continue landing:");
                            println!("      1. Resolve conflicts in the affected files");
                            println!("      2. Stage resolved files: git add <files>");
                            println!("      3. Continue the process: ca stack continue-land");
                            println!("      4. Or abort the operation: ca stack abort-land");
                            println!();
                            println!("   💡 Check current status: ca stack land-status");
                            println!("   ⚠️  Error details: {e}");

                            // Stop the land operation here - user needs to resolve conflicts
                            break;
                        }
                    }
                }
            }
            Ok(crate::bitbucket::pull_request::AutoMergeResult::NotReady { blocking_reasons }) => {
                println!(" ❌ Not ready: {}", blocking_reasons.join(", "));
                failed_count += 1;
                if !force {
                    break;
                }
            }
            Ok(crate::bitbucket::pull_request::AutoMergeResult::Failed { error }) => {
                println!(" ❌ Failed: {error}");
                failed_count += 1;
                if !force {
                    break;
                }
            }
            Err(e) => {
                println!(" ❌");
                eprintln!("Failed to land PR #{pr_id}: {e}");
                failed_count += 1;

                if !force {
                    break;
                }
            }
        }
    }

    // Show summary
    println!("\n🎯 Landing Summary:");
    println!("   ✅ Successfully landed: {landed_count}");
    if failed_count > 0 {
        println!("   ❌ Failed to land: {failed_count}");
    }

    if landed_count > 0 {
        Output::success(" Landing operation completed!");
    } else {
        println!("❌ No PRs were successfully landed");
    }

    Ok(())
}

/// Auto-land all ready PRs (shorthand for land --auto)
async fn auto_land_stack(
    force: bool,
    dry_run: bool,
    wait_for_builds: bool,
    strategy: Option<MergeStrategyArg>,
    build_timeout: u64,
) -> Result<()> {
    // This is a shorthand for land with --auto
    land_stack(
        None,
        force,
        dry_run,
        true, // auto = true
        wait_for_builds,
        strategy,
        build_timeout,
    )
    .await
}

async fn continue_land() -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;
    let git_repo = crate::git::GitRepository::open(&repo_root)?;
    let options = crate::stack::RebaseOptions::default();
    let rebase_manager = crate::stack::RebaseManager::new(stack_manager, git_repo, options);

    if !rebase_manager.is_rebase_in_progress() {
        Output::info("  No rebase in progress");
        return Ok(());
    }

    println!(" Continuing land operation...");
    match rebase_manager.continue_rebase() {
        Ok(_) => {
            Output::success(" Land operation continued successfully");
            println!("   Check 'ca stack land-status' for current state");
        }
        Err(e) => {
            warn!("❌ Failed to continue land operation: {}", e);
            Output::tip(" You may need to resolve conflicts first:");
            println!("   1. Edit conflicted files");
            println!("   2. Stage resolved files with 'git add'");
            println!("   3. Run 'ca stack continue-land' again");
        }
    }

    Ok(())
}

async fn abort_land() -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;
    let git_repo = crate::git::GitRepository::open(&repo_root)?;
    let options = crate::stack::RebaseOptions::default();
    let rebase_manager = crate::stack::RebaseManager::new(stack_manager, git_repo, options);

    if !rebase_manager.is_rebase_in_progress() {
        Output::info("  No rebase in progress");
        return Ok(());
    }

    println!("⚠️  Aborting land operation...");
    match rebase_manager.abort_rebase() {
        Ok(_) => {
            Output::success(" Land operation aborted successfully");
            println!("   Repository restored to pre-land state");
        }
        Err(e) => {
            warn!("❌ Failed to abort land operation: {}", e);
            println!("⚠️  You may need to manually clean up the repository state");
        }
    }

    Ok(())
}

async fn land_status() -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;
    let git_repo = crate::git::GitRepository::open(&repo_root)?;

    println!("Land Status");

    // Check if land operation is in progress by checking git state directly
    let git_dir = repo_root.join(".git");
    let land_in_progress = git_dir.join("REBASE_HEAD").exists()
        || git_dir.join("rebase-merge").exists()
        || git_dir.join("rebase-apply").exists();

    if land_in_progress {
        println!("   Status: 🔄 Land operation in progress");
        println!(
            "   
📝 Actions available:"
        );
        println!("     - 'ca stack continue-land' to continue");
        println!("     - 'ca stack abort-land' to abort");
        println!("     - 'git status' to see conflicted files");

        // Check for conflicts
        match git_repo.get_status() {
            Ok(statuses) => {
                let mut conflicts = Vec::new();
                for status in statuses.iter() {
                    if status.status().contains(git2::Status::CONFLICTED) {
                        if let Some(path) = status.path() {
                            conflicts.push(path.to_string());
                        }
                    }
                }

                if !conflicts.is_empty() {
                    println!("   ⚠️  Conflicts in {} files:", conflicts.len());
                    for conflict in conflicts {
                        println!("      - {conflict}");
                    }
                    println!(
                        "   
💡 To resolve conflicts:"
                    );
                    println!("     1. Edit the conflicted files");
                    println!("     2. Stage resolved files: git add <file>");
                    println!("     3. Continue: ca stack continue-land");
                }
            }
            Err(e) => {
                warn!("Failed to get git status: {}", e);
            }
        }
    } else {
        println!("   Status: ✅ No land operation in progress");

        // Show stack status instead
        if let Some(active_stack) = stack_manager.get_active_stack() {
            println!("   Active stack: {}", active_stack.name);
            println!("   Entries: {}", active_stack.entries.len());
            println!("   Base branch: {}", active_stack.base_branch);
        }
    }

    Ok(())
}

async fn repair_stack_data() -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let mut stack_manager = StackManager::new(&repo_root)?;

    println!("🔧 Repairing stack data consistency...");

    stack_manager.repair_all_stacks()?;

    Output::success(" Stack data consistency repaired successfully!");
    Output::tip(" Run 'ca stack --mergeable' to see updated status");

    Ok(())
}

/// Clean up merged and stale branches
async fn cleanup_branches(
    dry_run: bool,
    force: bool,
    include_stale: bool,
    stale_days: u32,
    cleanup_remote: bool,
    include_non_stack: bool,
    verbose: bool,
) -> Result<()> {
    let current_dir = env::current_dir()
        .map_err(|e| CascadeError::config(format!("Could not get current directory: {e}")))?;

    let repo_root = find_repository_root(&current_dir)
        .map_err(|e| CascadeError::config(format!("Could not find git repository: {e}")))?;

    let stack_manager = StackManager::new(&repo_root)?;
    let git_repo = GitRepository::open(&repo_root)?;

    let result = perform_cleanup(
        &stack_manager,
        &git_repo,
        dry_run,
        force,
        include_stale,
        stale_days,
        cleanup_remote,
        include_non_stack,
        verbose,
    )
    .await?;

    // Display results
    if result.total_candidates == 0 {
        Output::success("No branches found that need cleanup");
        return Ok(());
    }

    Output::section("Cleanup Results");

    if dry_run {
        Output::sub_item(format!(
            "Found {} branches that would be cleaned up",
            result.total_candidates
        ));
    } else {
        if !result.cleaned_branches.is_empty() {
            Output::success(format!(
                "Successfully cleaned up {} branches",
                result.cleaned_branches.len()
            ));
            for branch in &result.cleaned_branches {
                Output::sub_item(format!("🗑️  Deleted: {branch}"));
            }
        }

        if !result.skipped_branches.is_empty() {
            Output::sub_item(format!(
                "Skipped {} branches",
                result.skipped_branches.len()
            ));
            if verbose {
                for (branch, reason) in &result.skipped_branches {
                    Output::sub_item(format!("⏭️  {branch}: {reason}"));
                }
            }
        }

        if !result.failed_branches.is_empty() {
            Output::warning(format!(
                "Failed to clean up {} branches",
                result.failed_branches.len()
            ));
            for (branch, error) in &result.failed_branches {
                Output::sub_item(format!("❌ {branch}: {error}"));
            }
        }
    }

    Ok(())
}

/// Perform cleanup with the given options
#[allow(clippy::too_many_arguments)]
async fn perform_cleanup(
    stack_manager: &StackManager,
    git_repo: &GitRepository,
    dry_run: bool,
    force: bool,
    include_stale: bool,
    stale_days: u32,
    cleanup_remote: bool,
    include_non_stack: bool,
    verbose: bool,
) -> Result<CleanupResult> {
    let options = CleanupOptions {
        dry_run,
        force,
        include_stale,
        cleanup_remote,
        stale_threshold_days: stale_days,
        cleanup_non_stack: include_non_stack,
    };

    let stack_manager_copy = StackManager::new(stack_manager.repo_path())?;
    let git_repo_copy = GitRepository::open(git_repo.path())?;
    let mut cleanup_manager = CleanupManager::new(stack_manager_copy, git_repo_copy, options);

    // Find candidates
    let candidates = cleanup_manager.find_cleanup_candidates()?;

    if candidates.is_empty() {
        return Ok(CleanupResult {
            cleaned_branches: Vec::new(),
            failed_branches: Vec::new(),
            skipped_branches: Vec::new(),
            total_candidates: 0,
        });
    }

    // Show candidates if verbose or dry run
    if verbose || dry_run {
        Output::section("Cleanup Candidates");
        for candidate in &candidates {
            let reason_icon = match candidate.reason {
                crate::stack::CleanupReason::FullyMerged => "🔀",
                crate::stack::CleanupReason::StackEntryMerged => "✅",
                crate::stack::CleanupReason::Stale => "⏰",
                crate::stack::CleanupReason::Orphaned => "👻",
            };

            Output::sub_item(format!(
                "{} {} - {} ({})",
                reason_icon,
                candidate.branch_name,
                candidate.reason_to_string(),
                candidate.safety_info
            ));
        }
    }

    // If not force and not dry run, ask for confirmation
    if !force && !dry_run && !candidates.is_empty() {
        Output::warning(format!("About to delete {} branches", candidates.len()));

        // Show first few branch names for context
        let preview_count = 5.min(candidates.len());
        for candidate in candidates.iter().take(preview_count) {
            println!("  • {}", candidate.branch_name);
        }
        if candidates.len() > preview_count {
            println!("  ... and {} more", candidates.len() - preview_count);
        }
        println!(); // Spacing before prompt

        // Interactive confirmation to proceed with cleanup
        let should_continue = Confirm::with_theme(&ColorfulTheme::default())
            .with_prompt("Continue with branch cleanup?")
            .default(false)
            .interact()
            .map_err(|e| CascadeError::config(format!("Failed to get user confirmation: {e}")))?;

        if !should_continue {
            Output::sub_item("Cleanup cancelled");
            return Ok(CleanupResult {
                cleaned_branches: Vec::new(),
                failed_branches: Vec::new(),
                skipped_branches: Vec::new(),
                total_candidates: candidates.len(),
            });
        }
    }

    // Perform cleanup
    cleanup_manager.perform_cleanup(&candidates)
}

/// Simple perform_cleanup for sync command
async fn perform_simple_cleanup(
    stack_manager: &StackManager,
    git_repo: &GitRepository,
    dry_run: bool,
) -> Result<CleanupResult> {
    perform_cleanup(
        stack_manager,
        git_repo,
        dry_run,
        false, // force
        false, // include_stale
        30,    // stale_days
        false, // cleanup_remote
        false, // include_non_stack
        false, // verbose
    )
    .await
}

/// Analyze commits for various safeguards before pushing
async fn analyze_commits_for_safeguards(
    commits_to_push: &[String],
    repo: &GitRepository,
    dry_run: bool,
) -> Result<()> {
    const LARGE_COMMIT_THRESHOLD: usize = 10;
    const WEEK_IN_SECONDS: i64 = 7 * 24 * 3600;

    // 🛡️ SAFEGUARD 1: Large commit count warning
    if commits_to_push.len() > LARGE_COMMIT_THRESHOLD {
        println!(
            "⚠️  Warning: About to push {} commits to stack",
            commits_to_push.len()
        );
        println!("   This may indicate a merge commit issue or unexpected commit range.");
        println!("   Large commit counts often result from merging instead of rebasing.");

        if !dry_run && !confirm_large_push(commits_to_push.len())? {
            return Err(CascadeError::config("Push cancelled by user"));
        }
    }

    // Get commit objects for further analysis
    let commit_objects: Result<Vec<_>> = commits_to_push
        .iter()
        .map(|hash| repo.get_commit(hash))
        .collect();
    let commit_objects = commit_objects?;

    // 🛡️ SAFEGUARD 2: Merge commit detection
    let merge_commits: Vec<_> = commit_objects
        .iter()
        .filter(|c| c.parent_count() > 1)
        .collect();

    if !merge_commits.is_empty() {
        println!(
            "⚠️  Warning: {} merge commits detected in push",
            merge_commits.len()
        );
        println!("   This often indicates you merged instead of rebased.");
        println!("   Consider using 'ca sync' to rebase on the base branch.");
        println!("   Merge commits in stacks can cause confusion and duplicate work.");
    }

    // 🛡️ SAFEGUARD 3: Commit age warning
    if commit_objects.len() > 1 {
        let oldest_commit_time = commit_objects.first().unwrap().time().seconds();
        let newest_commit_time = commit_objects.last().unwrap().time().seconds();
        let time_span = newest_commit_time - oldest_commit_time;

        if time_span > WEEK_IN_SECONDS {
            let days = time_span / (24 * 3600);
            println!("⚠️  Warning: Commits span {days} days");
            println!("   This may indicate merged history rather than new work.");
            println!("   Recent work should typically span hours or days, not weeks.");
        }
    }

    // 🛡️ SAFEGUARD 4: Better range detection suggestions
    if commits_to_push.len() > 5 {
        Output::tip(" Tip: If you only want recent commits, use:");
        println!(
            "   ca push --since HEAD~{}  # pushes last {} commits",
            std::cmp::min(commits_to_push.len(), 5),
            std::cmp::min(commits_to_push.len(), 5)
        );
        println!("   ca push --commits <hash1>,<hash2>  # pushes specific commits");
        println!("   ca push --dry-run  # preview what would be pushed");
    }

    // 🛡️ SAFEGUARD 5: Dry run mode
    if dry_run {
        println!("🔍 DRY RUN: Would push {} commits:", commits_to_push.len());
        for (i, (commit_hash, commit_obj)) in commits_to_push
            .iter()
            .zip(commit_objects.iter())
            .enumerate()
        {
            let summary = commit_obj.summary().unwrap_or("(no message)");
            let short_hash = &commit_hash[..std::cmp::min(commit_hash.len(), 7)];
            println!("  {}: {} ({})", i + 1, summary, short_hash);
        }
        Output::tip(" Run without --dry-run to actually push these commits.");
    }

    Ok(())
}

/// Prompt user for confirmation when pushing large number of commits
fn confirm_large_push(count: usize) -> Result<bool> {
    // Interactive confirmation for large push
    let should_continue = Confirm::with_theme(&ColorfulTheme::default())
        .with_prompt(format!("Continue pushing {count} commits?"))
        .default(false)
        .interact()
        .map_err(|e| CascadeError::config(format!("Failed to get user confirmation: {e}")))?;

    Ok(should_continue)
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::process::Command;
    use tempfile::TempDir;

    fn create_test_repo() -> Result<(TempDir, std::path::PathBuf)> {
        let temp_dir = TempDir::new()
            .map_err(|e| CascadeError::config(format!("Failed to create temp directory: {e}")))?;
        let repo_path = temp_dir.path().to_path_buf();

        // Initialize git repository
        let output = Command::new("git")
            .args(["init"])
            .current_dir(&repo_path)
            .output()
            .map_err(|e| CascadeError::config(format!("Failed to run git init: {e}")))?;
        if !output.status.success() {
            return Err(CascadeError::config("Git init failed".to_string()));
        }

        let output = Command::new("git")
            .args(["config", "user.name", "Test User"])
            .current_dir(&repo_path)
            .output()
            .map_err(|e| CascadeError::config(format!("Failed to run git config: {e}")))?;
        if !output.status.success() {
            return Err(CascadeError::config(
                "Git config user.name failed".to_string(),
            ));
        }

        let output = Command::new("git")
            .args(["config", "user.email", "test@example.com"])
            .current_dir(&repo_path)
            .output()
            .map_err(|e| CascadeError::config(format!("Failed to run git config: {e}")))?;
        if !output.status.success() {
            return Err(CascadeError::config(
                "Git config user.email failed".to_string(),
            ));
        }

        // Create initial commit
        std::fs::write(repo_path.join("README.md"), "# Test")
            .map_err(|e| CascadeError::config(format!("Failed to write file: {e}")))?;
        let output = Command::new("git")
            .args(["add", "."])
            .current_dir(&repo_path)
            .output()
            .map_err(|e| CascadeError::config(format!("Failed to run git add: {e}")))?;
        if !output.status.success() {
            return Err(CascadeError::config("Git add failed".to_string()));
        }

        let output = Command::new("git")
            .args(["commit", "-m", "Initial commit"])
            .current_dir(&repo_path)
            .output()
            .map_err(|e| CascadeError::config(format!("Failed to run git commit: {e}")))?;
        if !output.status.success() {
            return Err(CascadeError::config("Git commit failed".to_string()));
        }

        // Initialize cascade
        crate::config::initialize_repo(&repo_path, Some("https://test.bitbucket.com".to_string()))?;

        Ok((temp_dir, repo_path))
    }

    #[tokio::test]
    async fn test_create_stack() {
        let (temp_dir, repo_path) = match create_test_repo() {
            Ok(repo) => repo,
            Err(_) => {
                println!("Skipping test due to git environment setup failure");
                return;
            }
        };
        // IMPORTANT: temp_dir must stay in scope to prevent early cleanup of test directory
        let _ = &temp_dir;

        // Note: create_test_repo() already initializes Cascade configuration

        // Change to the repo directory (with proper error handling)
        let original_dir = env::current_dir().map_err(|_| "Failed to get current dir");
        match env::set_current_dir(&repo_path) {
            Ok(_) => {
                let result = create_stack(
                    "test-stack".to_string(),
                    None, // Use default branch
                    Some("Test description".to_string()),
                )
                .await;

                // Restore original directory (best effort)
                if let Ok(orig) = original_dir {
                    let _ = env::set_current_dir(orig);
                }

                assert!(
                    result.is_ok(),
                    "Stack creation should succeed in initialized repository"
                );
            }
            Err(_) => {
                // Skip test if we can't change directories (CI environment issue)
                println!("Skipping test due to directory access restrictions");
            }
        }
    }

    #[tokio::test]
    async fn test_list_empty_stacks() {
        let (temp_dir, repo_path) = match create_test_repo() {
            Ok(repo) => repo,
            Err(_) => {
                println!("Skipping test due to git environment setup failure");
                return;
            }
        };
        // IMPORTANT: temp_dir must stay in scope to prevent early cleanup of test directory
        let _ = &temp_dir;

        // Note: create_test_repo() already initializes Cascade configuration

        // Change to the repo directory (with proper error handling)
        let original_dir = env::current_dir().map_err(|_| "Failed to get current dir");
        match env::set_current_dir(&repo_path) {
            Ok(_) => {
                let result = list_stacks(false, false, None).await;

                // Restore original directory (best effort)
                if let Ok(orig) = original_dir {
                    let _ = env::set_current_dir(orig);
                }

                assert!(
                    result.is_ok(),
                    "Listing stacks should succeed in initialized repository"
                );
            }
            Err(_) => {
                // Skip test if we can't change directories (CI environment issue)
                println!("Skipping test due to directory access restrictions");
            }
        }
    }

    // Tests for squashing functionality

    #[test]
    fn test_extract_feature_from_wip_basic() {
        let messages = vec![
            "WIP: add authentication".to_string(),
            "WIP: implement login flow".to_string(),
        ];

        let result = extract_feature_from_wip(&messages);
        assert_eq!(result, "Add authentication");
    }

    #[test]
    fn test_extract_feature_from_wip_capitalize() {
        let messages = vec!["WIP: fix user validation bug".to_string()];

        let result = extract_feature_from_wip(&messages);
        assert_eq!(result, "Fix user validation bug");
    }

    #[test]
    fn test_extract_feature_from_wip_fallback() {
        let messages = vec![
            "WIP user interface changes".to_string(),
            "wip: css styling".to_string(),
        ];

        let result = extract_feature_from_wip(&messages);
        // Should create a fallback message since no "WIP:" prefix found
        assert!(result.contains("Implement") || result.contains("Squashed") || result.len() > 5);
    }

    #[test]
    fn test_extract_feature_from_wip_empty() {
        let messages = vec![];

        let result = extract_feature_from_wip(&messages);
        assert_eq!(result, "Squashed 0 commits");
    }

    #[test]
    fn test_extract_feature_from_wip_short_message() {
        let messages = vec!["WIP: x".to_string()]; // Too short

        let result = extract_feature_from_wip(&messages);
        assert!(result.starts_with("Implement") || result.contains("Squashed"));
    }

    // Integration tests for squashing that don't require real git commits

    #[test]
    fn test_squash_message_final_strategy() {
        // This test would need real git2::Commit objects, so we'll test the logic indirectly
        // through the extract_feature_from_wip function which handles the core logic

        let messages = [
            "Final: implement user authentication system".to_string(),
            "WIP: add tests".to_string(),
            "WIP: fix validation".to_string(),
        ];

        // Test that we can identify final commits
        assert!(messages[0].starts_with("Final:"));

        // Test message extraction
        let extracted = messages[0].trim_start_matches("Final:").trim();
        assert_eq!(extracted, "implement user authentication system");
    }

    #[test]
    fn test_squash_message_wip_detection() {
        let messages = [
            "WIP: start feature".to_string(),
            "WIP: continue work".to_string(),
            "WIP: almost done".to_string(),
            "Regular commit message".to_string(),
        ];

        let wip_count = messages
            .iter()
            .filter(|m| {
                m.to_lowercase().starts_with("wip") || m.to_lowercase().contains("work in progress")
            })
            .count();

        assert_eq!(wip_count, 3); // Should detect 3 WIP commits
        assert!(wip_count > messages.len() / 2); // Majority are WIP

        // Should find the non-WIP message
        let non_wip: Vec<&String> = messages
            .iter()
            .filter(|m| {
                !m.to_lowercase().starts_with("wip")
                    && !m.to_lowercase().contains("work in progress")
            })
            .collect();

        assert_eq!(non_wip.len(), 1);
        assert_eq!(non_wip[0], "Regular commit message");
    }

    #[test]
    fn test_squash_message_all_wip() {
        let messages = vec![
            "WIP: add feature A".to_string(),
            "WIP: add feature B".to_string(),
            "WIP: finish implementation".to_string(),
        ];

        let result = extract_feature_from_wip(&messages);
        // Should use the first message as the main feature
        assert_eq!(result, "Add feature A");
    }

    #[test]
    fn test_squash_message_edge_cases() {
        // Test empty messages
        let empty_messages: Vec<String> = vec![];
        let result = extract_feature_from_wip(&empty_messages);
        assert_eq!(result, "Squashed 0 commits");

        // Test messages with only whitespace
        let whitespace_messages = vec!["   ".to_string(), "\t\n".to_string()];
        let result = extract_feature_from_wip(&whitespace_messages);
        assert!(result.contains("Squashed") || result.contains("Implement"));

        // Test case sensitivity
        let mixed_case = vec!["wip: Add Feature".to_string()];
        let result = extract_feature_from_wip(&mixed_case);
        assert_eq!(result, "Add Feature");
    }

    // Tests for auto-land functionality

    #[tokio::test]
    async fn test_auto_land_wrapper() {
        // Test that auto_land_stack correctly calls land_stack with auto=true
        let (temp_dir, repo_path) = match create_test_repo() {
            Ok(repo) => repo,
            Err(_) => {
                println!("Skipping test due to git environment setup failure");
                return;
            }
        };
        // IMPORTANT: temp_dir must stay in scope to prevent early cleanup of test directory
        let _ = &temp_dir;

        // Initialize cascade in the test repo
        crate::config::initialize_repo(&repo_path, Some("https://test.bitbucket.com".to_string()))
            .expect("Failed to initialize Cascade in test repo");

        let original_dir = env::current_dir().map_err(|_| "Failed to get current dir");
        match env::set_current_dir(&repo_path) {
            Ok(_) => {
                // Create a stack first
                let result = create_stack(
                    "test-stack".to_string(),
                    None,
                    Some("Test stack for auto-land".to_string()),
                )
                .await;

                if let Ok(orig) = original_dir {
                    let _ = env::set_current_dir(orig);
                }

                // For now, just test that the function can be called without panic
                // (It will fail due to missing Bitbucket config, but that's expected)
                assert!(
                    result.is_ok(),
                    "Stack creation should succeed in initialized repository"
                );
            }
            Err(_) => {
                println!("Skipping test due to directory access restrictions");
            }
        }
    }

    #[test]
    fn test_auto_land_action_enum() {
        // Test that AutoLand action is properly defined
        use crate::cli::commands::stack::StackAction;

        // This ensures the AutoLand variant exists and has the expected fields
        let _action = StackAction::AutoLand {
            force: false,
            dry_run: true,
            wait_for_builds: true,
            strategy: Some(MergeStrategyArg::Squash),
            build_timeout: 1800,
        };

        // Test passes if we reach this point without errors
    }

    #[test]
    fn test_merge_strategy_conversion() {
        // Test that MergeStrategyArg converts properly
        let squash_strategy = MergeStrategyArg::Squash;
        let merge_strategy: crate::bitbucket::pull_request::MergeStrategy = squash_strategy.into();

        match merge_strategy {
            crate::bitbucket::pull_request::MergeStrategy::Squash => {
                // Correct conversion
            }
            _ => unreachable!("SquashStrategyArg only has Squash variant"),
        }

        let merge_strategy = MergeStrategyArg::Merge;
        let converted: crate::bitbucket::pull_request::MergeStrategy = merge_strategy.into();

        match converted {
            crate::bitbucket::pull_request::MergeStrategy::Merge => {
                // Correct conversion
            }
            _ => unreachable!("MergeStrategyArg::Merge maps to MergeStrategy::Merge"),
        }
    }

    #[test]
    fn test_auto_merge_conditions_structure() {
        // Test that AutoMergeConditions can be created with expected values
        use std::time::Duration;

        let conditions = crate::bitbucket::pull_request::AutoMergeConditions {
            merge_strategy: crate::bitbucket::pull_request::MergeStrategy::Squash,
            wait_for_builds: true,
            build_timeout: Duration::from_secs(1800),
            allowed_authors: None,
        };

        // Verify the conditions are set as expected for auto-land
        assert!(conditions.wait_for_builds);
        assert_eq!(conditions.build_timeout.as_secs(), 1800);
        assert!(conditions.allowed_authors.is_none());
        assert!(matches!(
            conditions.merge_strategy,
            crate::bitbucket::pull_request::MergeStrategy::Squash
        ));
    }

    #[test]
    fn test_polling_constants() {
        // Test that polling frequency is documented and reasonable
        use std::time::Duration;

        // The polling frequency should be 30 seconds as mentioned in documentation
        let expected_polling_interval = Duration::from_secs(30);

        // Verify it's a reasonable value (not too frequent, not too slow)
        assert!(expected_polling_interval.as_secs() >= 10); // At least 10 seconds
        assert!(expected_polling_interval.as_secs() <= 60); // At most 1 minute
        assert_eq!(expected_polling_interval.as_secs(), 30); // Exactly 30 seconds
    }

    #[test]
    fn test_build_timeout_defaults() {
        // Verify build timeout default is reasonable
        const DEFAULT_TIMEOUT: u64 = 1800; // 30 minutes
        assert_eq!(DEFAULT_TIMEOUT, 1800);
        // Test that our default timeout value is within reasonable bounds
        let timeout_value = 1800u64;
        assert!(timeout_value >= 300); // At least 5 minutes
        assert!(timeout_value <= 3600); // At most 1 hour
    }

    #[test]
    fn test_scattered_commit_detection() {
        use std::collections::HashSet;

        // Test scattered commit detection logic
        let mut source_branches = HashSet::new();
        source_branches.insert("feature-branch-1".to_string());
        source_branches.insert("feature-branch-2".to_string());
        source_branches.insert("feature-branch-3".to_string());

        // Single branch should not trigger warning
        let single_branch = HashSet::from(["main".to_string()]);
        assert_eq!(single_branch.len(), 1);

        // Multiple branches should trigger warning
        assert!(source_branches.len() > 1);
        assert_eq!(source_branches.len(), 3);

        // Verify branch names are preserved correctly
        assert!(source_branches.contains("feature-branch-1"));
        assert!(source_branches.contains("feature-branch-2"));
        assert!(source_branches.contains("feature-branch-3"));
    }

    #[test]
    fn test_source_branch_tracking() {
        // Test that source branch tracking correctly handles different scenarios

        // Same branch should be consistent
        let branch_a = "feature-work";
        let branch_b = "feature-work";
        assert_eq!(branch_a, branch_b);

        // Different branches should be detected
        let branch_1 = "feature-ui";
        let branch_2 = "feature-api";
        assert_ne!(branch_1, branch_2);

        // Branch naming patterns
        assert!(branch_1.starts_with("feature-"));
        assert!(branch_2.starts_with("feature-"));
    }

    // Tests for new default behavior (removing --all flag)

    #[tokio::test]
    async fn test_push_default_behavior() {
        // Test the push_to_stack function structure and error handling in an isolated environment
        let (temp_dir, repo_path) = match create_test_repo() {
            Ok(repo) => repo,
            Err(_) => {
                println!("Skipping test due to git environment setup failure");
                return;
            }
        };
        // IMPORTANT: temp_dir must stay in scope to prevent early cleanup of test directory
        let _ = &temp_dir;

        // Verify directory exists before changing to it
        if !repo_path.exists() {
            println!("Skipping test due to temporary directory creation issue");
            return;
        }

        // Change to the test repository directory to ensure isolation
        let original_dir = env::current_dir().map_err(|_| "Failed to get current dir");

        match env::set_current_dir(&repo_path) {
            Ok(_) => {
                // Test that push_to_stack properly handles the case when no stack is active
                let result = push_to_stack(
                    None,  // branch
                    None,  // message
                    None,  // commit
                    None,  // since
                    None,  // commits
                    None,  // squash
                    None,  // squash_since
                    false, // auto_branch
                    false, // allow_base_branch
                    false, // dry_run
                )
                .await;

                // Restore original directory (best effort)
                if let Ok(orig) = original_dir {
                    let _ = env::set_current_dir(orig);
                }

                // Should fail gracefully with appropriate error message when no stack is active
                match &result {
                    Err(e) => {
                        let error_msg = e.to_string();
                        // This is the expected behavior - no active stack should produce this error
                        assert!(
                            error_msg.contains("No active stack")
                                || error_msg.contains("config")
                                || error_msg.contains("current directory")
                                || error_msg.contains("Not a git repository")
                                || error_msg.contains("could not find repository"),
                            "Expected 'No active stack' or repository error, got: {error_msg}"
                        );
                    }
                    Ok(_) => {
                        // If it somehow succeeds, that's also fine (e.g., if environment is set up differently)
                        println!(
                            "Push succeeded unexpectedly - test environment may have active stack"
                        );
                    }
                }
            }
            Err(_) => {
                // Skip test if we can't change directories (CI environment issue)
                println!("Skipping test due to directory access restrictions");
            }
        }

        // Verify we can construct the command structure correctly
        let push_action = StackAction::Push {
            branch: None,
            message: None,
            commit: None,
            since: None,
            commits: None,
            squash: None,
            squash_since: None,
            auto_branch: false,
            allow_base_branch: false,
            dry_run: false,
        };

        assert!(matches!(
            push_action,
            StackAction::Push {
                branch: None,
                message: None,
                commit: None,
                since: None,
                commits: None,
                squash: None,
                squash_since: None,
                auto_branch: false,
                allow_base_branch: false,
                dry_run: false
            }
        ));
    }

    #[tokio::test]
    async fn test_submit_default_behavior() {
        // Test the submit_entry function structure and error handling in an isolated environment
        let (temp_dir, repo_path) = match create_test_repo() {
            Ok(repo) => repo,
            Err(_) => {
                println!("Skipping test due to git environment setup failure");
                return;
            }
        };
        // IMPORTANT: temp_dir must stay in scope to prevent early cleanup of test directory
        let _ = &temp_dir;

        // Verify directory exists before changing to it
        if !repo_path.exists() {
            println!("Skipping test due to temporary directory creation issue");
            return;
        }

        // Change to the test repository directory to ensure isolation
        let original_dir = match env::current_dir() {
            Ok(dir) => dir,
            Err(_) => {
                println!("Skipping test due to current directory access restrictions");
                return;
            }
        };

        match env::set_current_dir(&repo_path) {
            Ok(_) => {
                // Test that submit_entry properly handles the case when no stack is active
                let result = submit_entry(
                    None,  // entry (should default to all unsubmitted)
                    None,  // title
                    None,  // description
                    None,  // range
                    false, // draft
                    true,  // open
                )
                .await;

                // Restore original directory
                let _ = env::set_current_dir(original_dir);

                // Should fail gracefully with appropriate error message when no stack is active
                match &result {
                    Err(e) => {
                        let error_msg = e.to_string();
                        // This is the expected behavior - no active stack should produce this error
                        assert!(
                            error_msg.contains("No active stack")
                                || error_msg.contains("config")
                                || error_msg.contains("current directory")
                                || error_msg.contains("Not a git repository")
                                || error_msg.contains("could not find repository"),
                            "Expected 'No active stack' or repository error, got: {error_msg}"
                        );
                    }
                    Ok(_) => {
                        // If it somehow succeeds, that's also fine (e.g., if environment is set up differently)
                        println!("Submit succeeded unexpectedly - test environment may have active stack");
                    }
                }
            }
            Err(_) => {
                // Skip test if we can't change directories (CI environment issue)
                println!("Skipping test due to directory access restrictions");
            }
        }

        // Verify we can construct the command structure correctly
        let submit_action = StackAction::Submit {
            entry: None,
            title: None,
            description: None,
            range: None,
            draft: true, // Default changed to true
            open: true,
        };

        assert!(matches!(
            submit_action,
            StackAction::Submit {
                entry: None,
                title: None,
                description: None,
                range: None,
                draft: true, // Default changed to true
                open: true
            }
        ));
    }

    #[test]
    fn test_targeting_options_still_work() {
        // Test that specific targeting options still work correctly

        // Test commit list parsing
        let commits = "abc123,def456,ghi789";
        let parsed: Vec<&str> = commits.split(',').map(|s| s.trim()).collect();
        assert_eq!(parsed.len(), 3);
        assert_eq!(parsed[0], "abc123");
        assert_eq!(parsed[1], "def456");
        assert_eq!(parsed[2], "ghi789");

        // Test range parsing would work
        let range = "1-3";
        assert!(range.contains('-'));
        let parts: Vec<&str> = range.split('-').collect();
        assert_eq!(parts.len(), 2);

        // Test since reference pattern
        let since_ref = "HEAD~3";
        assert!(since_ref.starts_with("HEAD"));
        assert!(since_ref.contains('~'));
    }

    #[test]
    fn test_command_flow_logic() {
        // These just test the command structure exists
        assert!(matches!(
            StackAction::Push {
                branch: None,
                message: None,
                commit: None,
                since: None,
                commits: None,
                squash: None,
                squash_since: None,
                auto_branch: false,
                allow_base_branch: false,
                dry_run: false
            },
            StackAction::Push { .. }
        ));

        assert!(matches!(
            StackAction::Submit {
                entry: None,
                title: None,
                description: None,
                range: None,
                draft: false,
                open: true
            },
            StackAction::Submit { .. }
        ));
    }

    #[tokio::test]
    async fn test_deactivate_command_structure() {
        // Test that deactivate command structure exists and can be constructed
        let deactivate_action = StackAction::Deactivate { force: false };

        // Verify it matches the expected pattern
        assert!(matches!(
            deactivate_action,
            StackAction::Deactivate { force: false }
        ));

        // Test with force flag
        let force_deactivate = StackAction::Deactivate { force: true };
        assert!(matches!(
            force_deactivate,
            StackAction::Deactivate { force: true }
        ));
    }
}