rung-core 0.8.0

//! State persistence for .git/rung/ directory.

use std::collections::VecDeque;
use std::fs;
use std::path::{Path, PathBuf};

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

use crate::error::{Error, Result};
use crate::stack::Stack;

/// Manages the .git/rung/ directory state.
#[derive(Debug)]
pub struct State {
    /// Path to the .git/rung/ directory.
    rung_dir: PathBuf,
}

impl State {
    /// File names within .git/rung/
    const STACK_FILE: &'static str = "stack.json";
    const CONFIG_FILE: &'static str = "config.toml";
    const SYNC_STATE_FILE: &'static str = "sync_state";
    const RESTACK_STATE_FILE: &'static str = "restack_state";
    const SPLIT_STATE_FILE: &'static str = "split_state";
    const FOLD_STATE_FILE: &'static str = "fold_state";
    const REFS_DIR: &'static str = "refs";

    /// Create a new State instance for the given repository.
    ///
    /// # Errors
    /// Returns error if the path doesn't contain a .git directory.
    pub fn new(repo_path: impl AsRef<Path>) -> Result<Self> {
        let git_dir = repo_path.as_ref().join(".git");
        if !git_dir.exists() {
            return Err(Error::NotARepository);
        }

        Ok(Self {
            rung_dir: git_dir.join("rung"),
        })
    }

    /// Initialize the .git/rung/ directory structure.
    ///
    /// # Errors
    /// Returns error if directory creation fails.
    pub fn init(&self) -> Result<()> {
        fs::create_dir_all(&self.rung_dir)?;
        fs::create_dir_all(self.rung_dir.join(Self::REFS_DIR))?;

        // Create empty stack if it doesn't exist
        if !self.stack_path().exists() {
            self.save_stack(&Stack::new())?;
        }

        Ok(())
    }

    /// Check if rung is initialized in this repository.
    #[must_use]
    pub fn is_initialized(&self) -> bool {
        self.rung_dir.exists() && self.stack_path().exists()
    }

    /// Get the path to the rung directory.
    #[must_use]
    pub fn rung_dir(&self) -> &Path {
        &self.rung_dir
    }

    // === Stack operations ===

    fn stack_path(&self) -> PathBuf {
        self.rung_dir.join(Self::STACK_FILE)
    }

    /// Load the stack from disk.
    ///
    /// # Errors
    /// Returns error if file doesn't exist or can't be parsed.
    pub fn load_stack(&self) -> Result<Stack> {
        if !self.is_initialized() {
            return Err(Error::NotInitialized);
        }

        let content = fs::read_to_string(self.stack_path())?;
        let stack: Stack = serde_json::from_str(&content)?;
        Ok(stack)
    }

    /// Save the stack to disk.
    ///
    /// # Errors
    /// Returns error if serialization or write fails.
    pub fn save_stack(&self, stack: &Stack) -> Result<()> {
        let content = serde_json::to_string_pretty(stack)?;
        fs::write(self.stack_path(), content)?;
        Ok(())
    }

    // === Config operations ===

    fn config_path(&self) -> PathBuf {
        self.rung_dir.join(Self::CONFIG_FILE)
    }

    /// Load the config from disk.
    ///
    /// Returns default config if file doesn't exist.
    ///
    /// # Errors
    /// Returns error if file exists but can't be parsed.
    pub fn load_config(&self) -> Result<crate::config::Config> {
        crate::config::Config::load(self.config_path())
    }

    /// Save the config to disk.
    ///
    /// # Errors
    /// Returns error if serialization or write fails.
    pub fn save_config(&self, config: &crate::config::Config) -> Result<()> {
        config.save(self.config_path())
    }

    /// Get the default branch name from config, falling back to "main".
    ///
    /// # Errors
    /// Returns error if config can't be loaded.
    pub fn default_branch(&self) -> Result<String> {
        let config = self.load_config()?;
        Ok(config
            .general
            .default_branch
            .unwrap_or_else(|| "main".into()))
    }

    // === Sync state operations ===

    fn sync_state_path(&self) -> PathBuf {
        self.rung_dir.join(Self::SYNC_STATE_FILE)
    }

    /// Check if a sync is in progress.
    #[must_use]
    pub fn is_sync_in_progress(&self) -> bool {
        self.sync_state_path().exists()
    }

    /// Load the current sync state.
    ///
    /// # Errors
    /// Returns error if no sync is in progress or file can't be read.
    pub fn load_sync_state(&self) -> Result<SyncState> {
        if !self.is_sync_in_progress() {
            return Err(Error::NoBackupFound);
        }

        let content = fs::read_to_string(self.sync_state_path())?;
        let state: SyncState = serde_json::from_str(&content)?;
        Ok(state)
    }

    /// Save sync state (called during sync operation).
    ///
    /// # Errors
    /// Returns error if serialization or write fails.
    pub fn save_sync_state(&self, state: &SyncState) -> Result<()> {
        let content = serde_json::to_string_pretty(state)?;
        fs::write(self.sync_state_path(), content)?;
        Ok(())
    }

    /// Clear sync state (called when sync completes or aborts).
    ///
    /// # Errors
    /// Returns error if file removal fails.
    pub fn clear_sync_state(&self) -> Result<()> {
        let path = self.sync_state_path();
        if path.exists() {
            fs::remove_file(path)?;
        }
        Ok(())
    }

    // === Restack state operations ===

    fn restack_state_path(&self) -> PathBuf {
        self.rung_dir.join(Self::RESTACK_STATE_FILE)
    }

    /// Check if a restack is in progress.
    #[must_use]
    pub fn is_restack_in_progress(&self) -> bool {
        self.restack_state_path().exists()
    }

    /// Load the current restack state.
    ///
    /// # Errors
    /// Returns error if no restack is in progress or file can't be read.
    pub fn load_restack_state(&self) -> Result<RestackState> {
        if !self.is_restack_in_progress() {
            return Err(Error::NoBackupFound);
        }

        let content = fs::read_to_string(self.restack_state_path())?;
        let state: RestackState = serde_json::from_str(&content)?;
        Ok(state)
    }

    /// Save restack state (called during restack operation).
    ///
    /// # Errors
    /// Returns error if serialization or write fails.
    pub fn save_restack_state(&self, state: &RestackState) -> Result<()> {
        let content = serde_json::to_string_pretty(state)?;
        fs::write(self.restack_state_path(), content)?;
        Ok(())
    }

    /// Clear restack state (called when restack completes or aborts).
    ///
    /// # Errors
    /// Returns error if file removal fails.
    pub fn clear_restack_state(&self) -> Result<()> {
        let path = self.restack_state_path();
        if path.exists() {
            fs::remove_file(path)?;
        }
        Ok(())
    }

    // === Split state operations ===

    fn split_state_path(&self) -> PathBuf {
        self.rung_dir.join(Self::SPLIT_STATE_FILE)
    }

    /// Check if a split is in progress.
    #[must_use]
    pub fn is_split_in_progress(&self) -> bool {
        self.split_state_path().exists()
    }

    /// Load the current split state.
    ///
    /// # Errors
    /// Returns error if no split is in progress or file can't be read.
    pub fn load_split_state(&self) -> Result<SplitState> {
        if !self.is_split_in_progress() {
            return Err(Error::NoBackupFound);
        }

        let content = fs::read_to_string(self.split_state_path())?;
        let state: SplitState = serde_json::from_str(&content)?;
        Ok(state)
    }

    /// Save split state (called during split operation).
    ///
    /// # Errors
    /// Returns error if serialization or write fails.
    pub fn save_split_state(&self, state: &SplitState) -> Result<()> {
        let content = serde_json::to_string_pretty(state)?;
        fs::write(self.split_state_path(), content)?;
        Ok(())
    }

    /// Clear split state (called when split completes or aborts).
    ///
    /// # Errors
    /// Returns error if file removal fails.
    pub fn clear_split_state(&self) -> Result<()> {
        let path = self.split_state_path();
        if path.exists() {
            fs::remove_file(path)?;
        }
        Ok(())
    }

    // === Fold state operations ===

    fn fold_state_path(&self) -> PathBuf {
        self.rung_dir.join(Self::FOLD_STATE_FILE)
    }

    /// Check if a fold is in progress.
    #[must_use]
    pub fn is_fold_in_progress(&self) -> bool {
        self.fold_state_path().exists()
    }

    /// Load the current fold state.
    ///
    /// # Errors
    /// Returns error if no fold is in progress or file can't be read.
    pub fn load_fold_state(&self) -> Result<FoldState> {
        if !self.is_fold_in_progress() {
            return Err(Error::NoBackupFound);
        }

        let content = fs::read_to_string(self.fold_state_path())?;
        let state: FoldState = serde_json::from_str(&content)?;
        Ok(state)
    }

    /// Save fold state (called during fold operation).
    ///
    /// # Errors
    /// Returns error if serialization or write fails.
    pub fn save_fold_state(&self, state: &FoldState) -> Result<()> {
        let content = serde_json::to_string_pretty(state)?;
        fs::write(self.fold_state_path(), content)?;
        Ok(())
    }

    /// Clear fold state (called when fold completes or aborts).
    ///
    /// # Errors
    /// Returns error if file removal fails.
    pub fn clear_fold_state(&self) -> Result<()> {
        let path = self.fold_state_path();
        if path.exists() {
            fs::remove_file(path)?;
        }
        Ok(())
    }

    // === Backup operations ===

    fn refs_dir(&self) -> PathBuf {
        self.rung_dir.join(Self::REFS_DIR)
    }

    /// Create a backup of branch refs.
    ///
    /// Returns the backup ID (timestamp).
    ///
    /// # Errors
    /// Returns error if directory creation or file write fails.
    pub fn create_backup(&self, branches: &[(&str, &str)]) -> Result<String> {
        let backup_id = Utc::now().timestamp().to_string();
        let backup_dir = self.refs_dir().join(&backup_id);
        fs::create_dir_all(&backup_dir)?;

        for (branch_name, commit_sha) in branches {
            let safe_name = branch_name.replace('/', "-");
            fs::write(backup_dir.join(safe_name), commit_sha)?;
        }

        Ok(backup_id)
    }

    /// Get the most recent backup ID.
    ///
    /// # Errors
    /// Returns error if no backups exist.
    pub fn latest_backup(&self) -> Result<String> {
        let refs_dir = self.refs_dir();
        if !refs_dir.exists() {
            return Err(Error::NoBackupFound);
        }

        let mut backups: Vec<_> = fs::read_dir(&refs_dir)?
            .filter_map(std::result::Result::ok)
            .filter(|e| e.path().is_dir())
            .filter_map(|e| e.file_name().to_str().map(String::from))
            .filter_map(|name| name.parse::<i64>().ok().map(|ts| (ts, name)))
            .collect();

        backups.sort_by_key(|(ts, _)| std::cmp::Reverse(*ts));

        backups
            .into_iter()
            .next()
            .map(|(_, name)| name)
            .ok_or(Error::NoBackupFound)
    }

    /// Load a backup's branch refs.
    ///
    /// Returns a vec of (`branch_name`, `commit_sha`) pairs.
    ///
    /// # Errors
    /// Returns error if backup doesn't exist or can't be read.
    pub fn load_backup(&self, backup_id: &str) -> Result<Vec<(String, String)>> {
        let backup_dir = self.refs_dir().join(backup_id);
        if !backup_dir.exists() {
            return Err(Error::NoBackupFound);
        }

        let mut refs = vec![];
        for entry in fs::read_dir(&backup_dir)? {
            let entry = entry?;
            if entry.path().is_file() {
                let name = entry
                    .file_name()
                    .to_str()
                    .ok_or_else(|| Error::StateParseError {
                        file: entry.path(),
                        message: "invalid filename".into(),
                    })?
                    .replace('-', "/");
                let sha = fs::read_to_string(entry.path())?.trim().to_string();
                refs.push((name, sha));
            }
        }

        Ok(refs)
    }

    /// Delete a backup.
    ///
    /// # Errors
    /// Returns error if deletion fails.
    pub fn delete_backup(&self, backup_id: &str) -> Result<()> {
        let backup_dir = self.refs_dir().join(backup_id);
        if backup_dir.exists() {
            fs::remove_dir_all(backup_dir)?;
        }
        Ok(())
    }

    /// Clean up old backups, keeping only the most recent N.
    ///
    /// # Errors
    /// Returns error if cleanup fails.
    pub fn cleanup_backups(&self, keep: usize) -> Result<()> {
        let refs_dir = self.refs_dir();
        if !refs_dir.exists() {
            return Ok(());
        }

        let mut backups: Vec<_> = fs::read_dir(&refs_dir)?
            .filter_map(std::result::Result::ok)
            .filter(|e| e.path().is_dir())
            .filter_map(|e| {
                e.file_name()
                    .to_str()
                    .and_then(|s| s.parse::<i64>().ok())
                    .map(|ts| (ts, e.path()))
            })
            .collect();

        backups.sort_by_key(|(ts, _)| std::cmp::Reverse(*ts));

        for (_, path) in backups.into_iter().skip(keep) {
            fs::remove_dir_all(path)?;
        }

        Ok(())
    }
}

// === Trait Implementation ===

use crate::traits::StateStore;

impl StateStore for State {
    fn is_initialized(&self) -> bool {
        Self::is_initialized(self)
    }

    fn init(&self) -> Result<()> {
        Self::init(self)
    }

    fn rung_dir(&self) -> &Path {
        Self::rung_dir(self)
    }

    fn load_stack(&self) -> Result<Stack> {
        Self::load_stack(self)
    }

    fn save_stack(&self, stack: &Stack) -> Result<()> {
        Self::save_stack(self, stack)
    }

    fn load_config(&self) -> Result<crate::config::Config> {
        Self::load_config(self)
    }

    fn save_config(&self, config: &crate::config::Config) -> Result<()> {
        Self::save_config(self, config)
    }

    fn default_branch(&self) -> Result<String> {
        Self::default_branch(self)
    }

    fn is_sync_in_progress(&self) -> bool {
        Self::is_sync_in_progress(self)
    }

    fn load_sync_state(&self) -> Result<SyncState> {
        Self::load_sync_state(self)
    }

    fn save_sync_state(&self, state: &SyncState) -> Result<()> {
        Self::save_sync_state(self, state)
    }

    fn clear_sync_state(&self) -> Result<()> {
        Self::clear_sync_state(self)
    }

    fn is_restack_in_progress(&self) -> bool {
        Self::is_restack_in_progress(self)
    }

    fn load_restack_state(&self) -> Result<RestackState> {
        Self::load_restack_state(self)
    }

    fn save_restack_state(&self, state: &RestackState) -> Result<()> {
        Self::save_restack_state(self, state)
    }

    fn clear_restack_state(&self) -> Result<()> {
        Self::clear_restack_state(self)
    }

    fn is_split_in_progress(&self) -> bool {
        Self::is_split_in_progress(self)
    }

    fn load_split_state(&self) -> Result<SplitState> {
        Self::load_split_state(self)
    }

    fn save_split_state(&self, state: &SplitState) -> Result<()> {
        Self::save_split_state(self, state)
    }

    fn clear_split_state(&self) -> Result<()> {
        Self::clear_split_state(self)
    }

    fn is_fold_in_progress(&self) -> bool {
        Self::is_fold_in_progress(self)
    }

    fn load_fold_state(&self) -> Result<FoldState> {
        Self::load_fold_state(self)
    }

    fn save_fold_state(&self, state: &FoldState) -> Result<()> {
        Self::save_fold_state(self, state)
    }

    fn clear_fold_state(&self) -> Result<()> {
        Self::clear_fold_state(self)
    }

    fn create_backup(&self, branches: &[(&str, &str)]) -> Result<String> {
        Self::create_backup(self, branches)
    }

    fn latest_backup(&self) -> Result<String> {
        Self::latest_backup(self)
    }

    fn load_backup(&self, backup_id: &str) -> Result<Vec<(String, String)>> {
        Self::load_backup(self, backup_id)
    }

    fn delete_backup(&self, backup_id: &str) -> Result<()> {
        Self::delete_backup(self, backup_id)
    }

    fn cleanup_backups(&self, keep: usize) -> Result<()> {
        Self::cleanup_backups(self, keep)
    }
}

/// State tracked during an in-progress sync operation.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SyncState {
    /// When the sync started.
    pub started_at: DateTime<Utc>,

    /// Backup ID for this sync.
    pub backup_id: String,

    /// Branch currently being rebased.
    pub current_branch: String,

    /// Branches that have been successfully rebased.
    pub completed: Vec<String>,

    /// Branches remaining to be rebased.
    /// Uses `VecDeque` for O(1) `pop_front()` in `advance()`.
    pub remaining: VecDeque<String>,
}

impl SyncState {
    /// Create a new sync state.
    #[must_use]
    pub fn new(backup_id: String, branches: Vec<String>) -> Self {
        let current = branches.first().cloned().unwrap_or_default();
        let remaining: VecDeque<String> = branches.into_iter().skip(1).collect();

        Self {
            started_at: Utc::now(),
            backup_id,
            current_branch: current,
            completed: vec![],
            remaining,
        }
    }

    /// Mark current branch as complete and move to next.
    pub fn advance(&mut self) {
        if !self.current_branch.is_empty() {
            self.completed
                .push(std::mem::take(&mut self.current_branch));
        }
        self.current_branch = self.remaining.pop_front().unwrap_or_default();
    }

    /// Check if sync is complete.
    #[must_use]
    pub fn is_complete(&self) -> bool {
        self.current_branch.is_empty() && self.remaining.is_empty()
    }
}

/// Info about a branch that diverged from its remote tracking branch.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DivergenceRecord {
    /// Branch name.
    pub branch: String,
    /// Commits ahead of remote.
    pub ahead: usize,
    /// Commits behind remote.
    pub behind: usize,
}

/// State tracked during an in-progress restack operation.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RestackState {
    /// When the restack started.
    pub started_at: DateTime<Utc>,

    /// Backup ID for this restack.
    pub backup_id: String,

    /// The branch being restacked.
    pub target_branch: String,

    /// The new parent branch.
    pub new_parent: String,

    /// The old parent branch (for display/recovery).
    pub old_parent: Option<String>,

    /// Original branch user was on (to restore after completion).
    pub original_branch: String,

    /// Branch currently being rebased.
    pub current_branch: String,

    /// Branches that have been successfully rebased.
    pub completed: Vec<String>,

    /// Branches remaining to be rebased (target + children if `include_children`).
    pub remaining: VecDeque<String>,

    /// Whether the stack.json has been updated with new parent.
    pub stack_updated: bool,

    /// Branches that were diverged from remote when restack started (--force was used).
    #[serde(default)]
    pub diverged_branches: Vec<DivergenceRecord>,
}

impl RestackState {
    /// Create a new restack state.
    #[must_use]
    pub fn new(
        backup_id: String,
        target_branch: String,
        new_parent: String,
        old_parent: Option<String>,
        original_branch: String,
        branches_to_rebase: Vec<String>,
        diverged_branches: Vec<DivergenceRecord>,
    ) -> Self {
        let current = branches_to_rebase.first().cloned().unwrap_or_default();
        let remaining: VecDeque<String> = branches_to_rebase.into_iter().skip(1).collect();

        Self {
            started_at: Utc::now(),
            backup_id,
            target_branch,
            new_parent,
            old_parent,
            original_branch,
            current_branch: current,
            completed: vec![],
            remaining,
            stack_updated: false,
            diverged_branches,
        }
    }

    /// Mark current branch as complete and move to next.
    pub fn advance(&mut self) {
        if !self.current_branch.is_empty() {
            self.completed
                .push(std::mem::take(&mut self.current_branch));
        }
        self.current_branch = self.remaining.pop_front().unwrap_or_default();
    }

    /// Check if restack is complete.
    #[must_use]
    pub fn is_complete(&self) -> bool {
        self.current_branch.is_empty() && self.remaining.is_empty()
    }

    /// Mark the stack as updated.
    pub const fn mark_stack_updated(&mut self) {
        self.stack_updated = true;
    }
}

/// A point in the commit history where the branch will be split.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SplitPoint {
    /// The commit SHA to split at.
    pub commit_sha: String,

    /// The commit message (for display).
    pub message: String,

    /// The new branch name for commits up to (and including) this point.
    pub branch_name: String,
}

/// State tracked during an in-progress split operation.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SplitState {
    /// When the split started.
    pub started_at: DateTime<Utc>,

    /// Backup ID for this split.
    pub backup_id: String,

    /// The source branch being split.
    pub source_branch: String,

    /// The parent branch of the source branch.
    pub parent_branch: String,

    /// Original branch user was on (to restore after abort).
    pub original_branch: String,

    /// Split points defining where to split the branch.
    pub split_points: Vec<SplitPoint>,

    /// Index of the current split point being processed.
    pub current_index: usize,

    /// Branches that have been successfully created.
    pub completed: Vec<String>,

    /// Whether the stack.json has been updated.
    pub stack_updated: bool,
}

impl SplitState {
    /// Create a new split state.
    #[must_use]
    pub fn new(
        backup_id: String,
        source_branch: String,
        parent_branch: String,
        original_branch: String,
        split_points: Vec<SplitPoint>,
    ) -> Self {
        Self {
            started_at: Utc::now(),
            backup_id,
            source_branch,
            parent_branch,
            original_branch,
            split_points,
            current_index: 0,
            completed: vec![],
            stack_updated: false,
        }
    }

    /// Get the current split point being processed.
    #[must_use]
    pub fn current_split_point(&self) -> Option<&SplitPoint> {
        self.split_points.get(self.current_index)
    }

    /// Mark current split point as complete and move to next.
    pub fn advance(&mut self) {
        if self.current_index >= self.split_points.len() {
            return;
        }
        self.completed
            .push(self.split_points[self.current_index].branch_name.clone());
        self.current_index += 1;
    }

    /// Check if split is complete.
    #[must_use]
    pub const fn is_complete(&self) -> bool {
        self.current_index >= self.split_points.len()
    }

    /// Mark the stack as updated.
    pub const fn mark_stack_updated(&mut self) {
        self.stack_updated = true;
    }
}

/// State tracked during an in-progress fold operation.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FoldState {
    /// When the fold started.
    pub started_at: DateTime<Utc>,

    /// Backup ID for this fold.
    pub backup_id: String,

    /// The target branch that will contain all commits after folding.
    pub target_branch: String,

    /// Branches being folded into the target (in order from parent to child).
    pub branches_to_fold: Vec<String>,

    /// The parent of the topmost branch being folded (new parent of target).
    pub new_parent: String,

    /// Original branch user was on (to restore after abort).
    pub original_branch: String,

    /// PR numbers associated with folded branches (to be closed).
    pub prs_to_close: Vec<u64>,

    /// Branches that have been successfully removed from stack.
    pub completed: Vec<String>,

    /// Whether the stack.json has been updated.
    pub stack_updated: bool,

    /// Serialized original stack JSON (for restoration on abort).
    #[serde(default)]
    pub original_stack_json: Option<String>,
}

impl FoldState {
    /// Create a new fold state.
    #[must_use]
    pub fn new(
        backup_id: String,
        target_branch: String,
        branches_to_fold: Vec<String>,
        new_parent: String,
        original_branch: String,
        prs_to_close: Vec<u64>,
    ) -> Self {
        Self {
            started_at: Utc::now(),
            backup_id,
            target_branch,
            branches_to_fold,
            new_parent,
            original_branch,
            prs_to_close,
            completed: vec![],
            stack_updated: false,
            original_stack_json: None,
        }
    }

    /// Store the original stack JSON for restoration.
    pub fn set_original_stack(&mut self, stack_json: String) {
        self.original_stack_json = Some(stack_json);
    }

    /// Mark the stack as updated.
    pub const fn mark_stack_updated(&mut self) {
        self.stack_updated = true;
    }
}

#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    fn setup_test_repo() -> (TempDir, State) {
        let temp = TempDir::new().unwrap();
        fs::create_dir(temp.path().join(".git")).unwrap();
        let state = State::new(temp.path()).unwrap();
        (temp, state)
    }

    #[test]
    fn test_init_and_check() {
        let (_temp, state) = setup_test_repo();

        assert!(!state.is_initialized());
        state.init().unwrap();
        assert!(state.is_initialized());
    }

    #[test]
    fn test_stack_persistence() {
        let (_temp, state) = setup_test_repo();
        state.init().unwrap();

        let mut stack = Stack::new();
        stack.add_branch(crate::stack::StackBranch::try_new("feature/test", Some("main")).unwrap());

        state.save_stack(&stack).unwrap();
        let loaded = state.load_stack().unwrap();

        assert_eq!(loaded.len(), 1);
        assert_eq!(loaded.branches[0].name, "feature/test");
    }

    #[test]
    fn test_backup_operations() {
        let (_temp, state) = setup_test_repo();
        state.init().unwrap();

        let branches = vec![("feature/a", "abc123"), ("feature/b", "def456")];
        let backup_id = state.create_backup(&branches).unwrap();

        let loaded = state.load_backup(&backup_id).unwrap();
        assert_eq!(loaded.len(), 2);

        let latest = state.latest_backup().unwrap();
        assert_eq!(latest, backup_id);

        state.delete_backup(&backup_id).unwrap();
        assert!(state.latest_backup().is_err());
    }
}