prodigy 0.4.4

// Comprehensive integration tests for resume functionality
// Tests actual resume behavior from different interruption points
//
// NOTE: These tests currently fail because they don't create the worktrees
// that the resume command expects. The test isolation (PRODIGY_HOME) is working
// correctly - the tests can find their checkpoints. The issue is that resume
// requires worktrees to exist, but the tests only create checkpoints without
// corresponding worktrees. This is a test architecture issue that needs to be
// addressed separately from test isolation.

use super::test_utils::*;
use serde_json::json;
use std::fs;
use std::path::{Path, PathBuf};
use tempfile::TempDir;

/// Helper to setup isolated PRODIGY_HOME for a test
///
/// Returns a TempDir that will be used as PRODIGY_HOME.
/// IMPORTANT: Do NOT use std::env::set_var to set PRODIGY_HOME globally - it's not
/// thread-safe and will cause race conditions in parallel tests. Instead, pass the
/// path directly to subprocesses via CliTest::env().
fn setup_test_prodigy_home() -> TempDir {
    TempDir::new().expect("Failed to create temp directory for PRODIGY_HOME")
}

/// Helper to create a test checkpoint
///
/// Creates checkpoints in the specified prodigy_home directory.
/// IMPORTANT: Pass the prodigy_home path directly, don't rely on global env vars.
fn create_test_checkpoint(
    prodigy_home: &Path,
    workflow_id: &str,
    commands_executed: usize,
    total_commands: usize,
    variables: serde_json::Value,
) {
    let session_dir = prodigy_home
        .join("state")
        .join(workflow_id)
        .join("checkpoints");

    // Create the directory structure
    fs::create_dir_all(&session_dir).expect("Failed to create checkpoint directory");

    // Create a mock worktree directory (resume expects this to exist)
    let worktree_dir = prodigy_home
        .join("worktrees")
        .join("prodigy") // Default repo name used by resume command
        .join(workflow_id);
    fs::create_dir_all(&worktree_dir).expect("Failed to create worktree directory");

    // Initialize as a git repository (resume command runs git commands in the worktree)
    std::process::Command::new("git")
        .arg("init")
        .current_dir(&worktree_dir)
        .output()
        .expect("Failed to initialize git repository in worktree");

    // Note: Workflow file should be created in the project root by the test
    // The checkpoint will reference it, and resume will look for it in the --path location

    // Create a properly structured WorkflowCheckpoint
    let now = chrono::Utc::now();
    let checkpoint = json!({
        "workflow_id": workflow_id,
        "execution_state": {
            "current_step_index": commands_executed,
            "total_steps": total_commands,
            "status": "Interrupted",
            "start_time": now.to_rfc3339(),
            "last_checkpoint": now.to_rfc3339(),
            "current_iteration": null,
            "total_iterations": null
        },
        "completed_steps": (0..commands_executed).map(|i| {
            json!({
                "step_index": i,
                "command": format!("shell: echo 'Command {}'", i + 1),
                "success": true,
                "output": format!("Command {} output", i + 1),
                "captured_variables": {},
                "duration": {
                    "secs": 1,
                    "nanos": 0
                },
                "completed_at": now.to_rfc3339(),
                "retry_state": null
            })
        }).collect::<Vec<_>>(),
        "variable_state": variables,
        "mapreduce_state": null,
        "timestamp": now.to_rfc3339(),
        "version": 1,
        "workflow_hash": "test-hash-12345",
        "total_steps": total_commands,
        "workflow_name": "test-resume-workflow",
        "workflow_path": "test-resume-workflow.yaml"
    });

    // Save as {workflow_id}.checkpoint.json
    let checkpoint_file = session_dir.join(format!("{}.checkpoint.json", workflow_id));
    fs::write(
        &checkpoint_file,
        serde_json::to_string_pretty(&checkpoint).unwrap(),
    )
    .expect("Failed to write checkpoint file");

    // Create a UnifiedSession in global storage (UnifiedSessionManager stores these)
    // Resume now uses UnifiedSessionManager through CookSessionAdapter
    let unified_session = json!({
        "id": workflow_id,
        "session_type": "Workflow",
        "status": "Paused",  // Paused status is resumable
        "started_at": now.to_rfc3339(),
        "updated_at": now.to_rfc3339(),
        "completed_at": null,
        "metadata": {},
        "checkpoints": [],
        "timings": {},
        "error": null,
        "workflow_data": {
            "workflow_id": workflow_id,
            "workflow_name": "test-resume-workflow",
            "current_step": commands_executed,
            "total_steps": total_commands,
            "completed_steps": (0..commands_executed).collect::<Vec<_>>(),
            "variables": {},
            "iterations_completed": 0,
            "files_changed": 0,
            "worktree_name": workflow_id
        },
        "mapreduce_data": null
    });

    // Save session in UnifiedSessionManager location (PRODIGY_HOME/sessions/)
    let sessions_dir = prodigy_home.join("sessions");
    fs::create_dir_all(&sessions_dir).expect("Failed to create sessions directory");
    fs::write(
        sessions_dir.join(format!("{}.json", workflow_id)),
        serde_json::to_string_pretty(&unified_session).unwrap(),
    )
    .expect("Failed to write session file");
}

/// Helper to create a test workflow file
fn create_test_workflow(workflow_dir: &Path, filename: &str) -> PathBuf {
    let workflow_content = r#"
name: test-resume-workflow
description: Test workflow for resume functionality

commands:
  - shell: "echo 'Command 1 executed'"
    id: cmd1
  - shell: "echo 'Command 2 executed'"
    id: cmd2
  - shell: "echo 'Command 3 executed'"
    id: cmd3
  - shell: "echo 'Command 4 executed'"
    id: cmd4
  - shell: "echo 'Final command executed'"
    id: cmd5
"#;

    fs::create_dir_all(workflow_dir).unwrap();
    let workflow_path = workflow_dir.join(filename);
    fs::write(&workflow_path, workflow_content).unwrap();
    workflow_path
}

#[test]
fn test_resume_from_early_interruption() {
    // Setup isolated PRODIGY_HOME for this test (no global env var modification)
    let prodigy_home = setup_test_prodigy_home();

    // Create CliTest first to get its temp directory
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create workflow file - use a name that matches what the checkpoint expects
    let _workflow_path = create_test_workflow(&test_dir, "test-resume-workflow.yaml");

    // Create checkpoint with actual worktree
    let workflow_id = "session-resume-early-12345";
    let variables = json!({
        "variable1": "test-value",
        "shell": {
            "output": "Command 1 output"
        }
    });
    let _worktree_path = create_test_checkpoint_with_worktree(
        prodigy_home.path(),
        &test_dir,
        workflow_id,
        1, // commands_executed
        5, // total_commands
        variables,
    )
    .expect("Failed to create test checkpoint with worktree");

    // Verify the checkpoint file was created
    let checkpoint_dir = prodigy_home
        .path()
        .join("state")
        .join(workflow_id)
        .join("checkpoints");
    let checkpoint_file = checkpoint_dir.join(format!("{}.checkpoint.json", workflow_id));
    assert!(
        checkpoint_file.exists(),
        "Checkpoint file should exist at {:?}",
        checkpoint_file
    );

    // Resume the workflow - explicitly pass PRODIGY_HOME to subprocess
    test = test
        .env("PRODIGY_HOME", prodigy_home.path().to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should successfully resume
    if output.exit_code != exit_codes::SUCCESS {
        eprintln!("Resume failed!");
        eprintln!("Exit code: {}", output.exit_code);
        eprintln!("STDOUT:\n{}", output.stdout);
        eprintln!("STDERR:\n{}", output.stderr);
    }
    assert_eq!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume failed with stderr: {}",
        output.stderr
    );

    // Check for the actual output format
    assert!(
        output.stdout_contains("Resuming session:")
            || output.stdout_contains("Resuming workflow from checkpoint")
            || output.stdout_contains("Resuming from iteration"),
        "Expected resume message not found in stdout: {}",
        output.stdout
    );
    // Check that workflow completed
    assert!(
        output.stdout_contains("Resumed session completed successfully")
            || output.stdout_contains("Session complete"),
        "Expected completion message not found in stdout: {}",
        output.stdout
    );
}

#[test]
fn test_resume_from_middle_interruption() {
    // Setup isolated PRODIGY_HOME for this test (no global env var modification)
    let prodigy_home = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create workflow file - use a name that matches what the checkpoint expects
    let _workflow_path = create_test_workflow(&test_dir, "test-resume-workflow.yaml");

    // Create checkpoint after 3 commands with actual worktree
    let workflow_id = "session-resume-middle-67890";
    let variables = json!({
        "variable1": "test-value",
        "shell": {
            "output": "Command 3 output"
        },
        "cmd1_output": "Command 1 completed",
        "cmd2_output": "Command 2 completed"
    });

    let _worktree_path = create_test_checkpoint_with_worktree(
        prodigy_home.path(),
        &test_dir,
        workflow_id,
        3, // commands_executed
        5, // total_commands
        variables,
    )
    .expect("Failed to create test checkpoint with worktree");

    // Resume the workflow - explicitly pass PRODIGY_HOME to subprocess
    test = test
        .env("PRODIGY_HOME", prodigy_home.path().to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should successfully resume from command 4
    assert_eq!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume failed with stderr: {}",
        output.stderr
    );
    assert!(
        output.stdout_contains("Resuming session:")
            || output.stdout_contains("Resuming workflow from checkpoint")
            || output.stdout_contains("Resuming from iteration"),
        "Expected resume message not found in stdout: {}",
        output.stdout
    );
    // Check that workflow completed
    assert!(
        output.stdout_contains("Resumed session completed successfully")
            || output.stdout_contains("Session complete"),
        "Expected completion message not found in stdout: {}",
        output.stdout
    );
}

#[test]
fn test_resume_with_variable_preservation() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home_dir = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create a workflow that uses variables
    let workflow_content = r#"
name: test-variable-workflow
description: Test workflow with variables

commands:
  - shell: "echo 'Setting up variables'"
    capture_output: var1
  - shell: "echo 'Using ${var1}'"
    capture_output: var2
  - shell: "echo 'Final: ${var1} and ${var2}'"
"#;

    // Create workflow file with the expected name from checkpoint
    let workflow_path = test_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, workflow_content).unwrap();

    // Create checkpoint with variables and actual worktree
    let workflow_id = "session-resume-vars-11111";
    let variables = json!({
        "var1": "First variable value",
        "var2": "Second variable value",
        "shell": {
            "output": "Previous command output"
        }
    });

    let prodigy_home = prodigy_home_dir.path().to_path_buf();
    let _worktree_path = create_test_checkpoint_with_worktree(
        &prodigy_home,
        &test_dir,
        workflow_id,
        2, // commands_executed
        3, // total_commands
        variables,
    )
    .expect("Failed to create test checkpoint with worktree");

    // Resume the workflow
    test = test
        .env("PRODIGY_HOME", prodigy_home.to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should complete successfully - variable interpolation details may vary in test mode
    assert_eq!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume should succeed. Stdout: {}\nStderr: {}",
        output.stdout,
        output.stderr
    );
    // Just verify workflow completed
    assert!(
        output.stdout_contains("Resumed session completed successfully")
            || output.stdout_contains("Session complete")
            || output.stdout_contains("completed"),
        "Expected completion message. Stdout: {}",
        output.stdout
    );
}

#[test]
fn test_resume_with_retry_state() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home_dir = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create workflow with retry logic
    let workflow_content = r#"
name: test-retry-workflow
description: Test workflow with retries

commands:
  - shell: "echo 'Command 1'"
  - shell: "test -f /tmp/retry-test-marker || exit 1"
    retry: 3
    id: retry_command
  - shell: "echo 'Success after retry'"
"#;

    // Create workflow file with the expected name from checkpoint
    let workflow_path = test_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, workflow_content).unwrap();

    // Create checkpoint with actual worktree
    let workflow_id = "session-resume-retry-22222";
    let prodigy_home = prodigy_home_dir.path().to_path_buf();
    let _worktree_path = create_test_checkpoint_with_worktree(
        &prodigy_home,
        &test_dir,
        workflow_id,
        1, // commands_executed
        3, // total_commands
        json!({}),
    )
    .expect("Failed to create test checkpoint with worktree");

    // Create the marker file so retry succeeds
    fs::write("/tmp/retry-test-marker", "test").ok();

    // Resume the workflow
    test = test
        .env("PRODIGY_HOME", prodigy_home.to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should complete successfully
    assert_eq!(output.exit_code, exit_codes::SUCCESS);
    // In test mode or with simplified execution, retry details may not be shown
    // Just check that it completed

    // Clean up
    fs::remove_file("/tmp/retry-test-marker").ok();
}

#[test]
fn test_resume_completed_workflow() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home = setup_test_prodigy_home();

    // Create CliTest first to get its temp directory
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create a completed session state in the unified session format
    let workflow_id = "session-resume-complete-33333";
    let now = chrono::Utc::now();

    // Create a mock worktree directory (resume expects this to exist)
    // prodigy_home is already a TempDir from setup_test_prodigy_home()
    let worktree_dir = prodigy_home
        .path()
        .to_path_buf()
        .join("worktrees")
        .join("prodigy")
        .join(workflow_id);
    fs::create_dir_all(&worktree_dir).expect("Failed to create worktree directory");

    // Initialize as a git repository (resume command runs git commands in the worktree)
    std::process::Command::new("git")
        .arg("init")
        .current_dir(&worktree_dir)
        .output()
        .expect("Failed to initialize git repository in worktree");

    // Create unified session in UnifiedSession format (status: Completed means not resumable)
    let unified_session = json!({
        "id": workflow_id,
        "session_type": "Workflow",
        "status": "Completed",  // Completed sessions are not resumable
        "started_at": now.to_rfc3339(),
        "updated_at": now.to_rfc3339(),
        "completed_at": now.to_rfc3339(),
        "metadata": {},
        "checkpoints": [],
        "timings": {},
        "error": null,
        "workflow_data": {
            "workflow_id": workflow_id,
            "workflow_name": "test-workflow",
            "current_step": 5,
            "total_steps": 5,
            "completed_steps": [0, 1, 2, 3, 4],
            "variables": {},
            "iterations_completed": 1,
            "files_changed": 0,
            "worktree_name": workflow_id
        },
        "mapreduce_data": null
    });

    // Save in UnifiedSessionManager location (PRODIGY_HOME/sessions/)
    let sessions_dir = prodigy_home.path().to_path_buf().join("sessions");
    fs::create_dir_all(&sessions_dir).unwrap();
    fs::write(
        sessions_dir.join(format!("{}.json", workflow_id)),
        serde_json::to_string_pretty(&unified_session).unwrap(),
    )
    .unwrap();

    // Try to resume completed workflow
    test = test
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should indicate workflow cannot be resumed (either completed or no checkpoints)
    // A completed workflow should fail to resume
    assert_ne!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume should fail for completed workflow"
    );
    // Should indicate either already completed or no checkpoints found
    assert!(
        output.stderr.contains("already completed")
            || output.stderr.contains("nothing to resume")
            || output.stderr.contains("No checkpoints found")
            || output.stdout.contains("already completed"),
        "Expected appropriate error message, got stdout: {}\nstderr: {}",
        output.stdout,
        output.stderr
    );
}

#[test]
fn test_resume_with_force_restart() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home_dir = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create workflow and checkpoint - use standard name
    let _workflow_path = create_test_workflow(&test_dir, "test-resume-workflow.yaml");
    let workflow_id = "session-resume-force-44444";

    let prodigy_home = prodigy_home_dir.path().to_path_buf();
    let _worktree_path = create_test_checkpoint_with_worktree(
        &prodigy_home,
        &test_dir,
        workflow_id,
        3, // commands_executed
        5, // total_commands
        json!({}),
    )
    .expect("Failed to create test checkpoint with worktree");

    // Resume with --force flag
    test = test
        .env("PRODIGY_HOME", prodigy_home.to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--force")
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should complete successfully (--force behavior may vary)
    assert_eq!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Force restart should succeed. Stdout: {}\nStderr: {}",
        output.stdout,
        output.stderr
    );
    // Just verify it completed
    assert!(
        output.stdout_contains("completed")
            || output.stdout_contains("Session complete")
            || output.stdout_contains("Resumed"),
        "Expected completion or resume message. Stdout: {}",
        output.stdout
    );
}

#[test]
fn test_resume_parallel_workflow() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create a parallel workflow
    let workflow_content = r#"
name: test-parallel-workflow
description: Test parallel execution resume

parallel:
  max_workers: 3
  commands:
    - shell: "echo 'Parallel 1'"
      id: p1
    - shell: "echo 'Parallel 2'"
      id: p2
    - shell: "echo 'Parallel 3'"
      id: p3
    - shell: "echo 'Parallel 4'"
      id: p4

commands:
  - shell: "echo 'After parallel'"
"#;

    // Use standard test workflow name that checkpoint helper expects
    let workflow_path = test_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, workflow_content).unwrap();

    // Create checkpoint with partial parallel execution and actual worktree
    let workflow_id = "session-resume-parallel-55555";
    let prodigy_home = prodigy_home.path().to_path_buf();
    let _worktree_path = create_test_checkpoint_with_worktree(
        &prodigy_home,
        &test_dir,
        workflow_id,
        0, // commands_executed
        5, // total_commands
        json!({}),
    )
    .expect("Failed to create test checkpoint with worktree");

    // Resume the workflow - explicitly pass PRODIGY_HOME to subprocess
    test = test
        .env("PRODIGY_HOME", prodigy_home.to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should resume workflow (parallel execution details may vary)
    if output.exit_code != exit_codes::SUCCESS {
        eprintln!("Resume failed with exit code: {}", output.exit_code);
        eprintln!("STDOUT:\n{}", output.stdout);
        eprintln!("STDERR:\n{}", output.stderr);
    }
    assert_eq!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume failed with exit code: {}, stderr: {}, stdout: {}",
        output.exit_code,
        output.stderr,
        output.stdout
    );
    // Check that resume was initiated
    assert!(
        output.stdout_contains("Resuming") || output.stdout_contains("Found checkpoint"),
        "Expected resume message not found"
    );
}

#[test]
fn test_resume_with_checkpoint_cleanup() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create workflow - use name that matches checkpoint
    let _workflow_path = create_test_workflow(&test_dir, "test-resume-workflow.yaml");
    let workflow_id = "session-resume-cleanup-66666";

    // Create checkpoint with actual worktree
    let prodigy_home = prodigy_home.path().to_path_buf();
    let _worktree_path = create_test_checkpoint_with_worktree(
        &prodigy_home,
        &test_dir,
        workflow_id,
        4, // commands_executed
        5, // total_commands
        json!({}),
    )
    .expect("Failed to create test checkpoint with worktree");

    // Checkpoint files are saved in PRODIGY_HOME
    let checkpoint_file = prodigy_home
        .join("state")
        .join(workflow_id)
        .join("checkpoints")
        .join(format!("{}.checkpoint.json", workflow_id));
    assert!(
        checkpoint_file.exists(),
        "Checkpoint should exist before resume"
    );

    // Resume and complete workflow
    test = test
        .env("PRODIGY_HOME", prodigy_home.to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should complete and clean up checkpoint
    assert_eq!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume failed with stderr: {}",
        output.stderr
    );
    // Check that the workflow executed the final command
    assert!(
        output.stdout_contains(
            "[TEST MODE] Would execute Shell command: echo 'Final command executed'"
        ) || output.stdout_contains("Final command executed")
            || output.stdout_contains("completed"),
        "Expected completion message not found in stdout: {}",
        output.stdout
    );

    // Note: Checkpoint cleanup behavior may vary based on configuration
    // Not asserting on checkpoint file cleanup here
}

#[test]
#[ignore = "Error recovery during resume not fully implemented"]
fn test_resume_with_error_recovery() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();
    let _checkpoint_dir = test_dir.join(".prodigy").join("checkpoints");
    let workflow_dir = test_dir.clone();

    // Create workflow with error handling
    let workflow_content = r#"
name: test-error-workflow
description: Test error recovery during resume

commands:
  - shell: "echo 'Command 1'"
  - shell: "echo 'Command 2'"
  - shell: "exit 1"
    id: failing_command
    on_failure: "echo 'Error handled'"
  - shell: "echo 'Continue after error'"
"#;

    // Create workflow file with the expected name from checkpoint
    let workflow_path = workflow_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, workflow_content).unwrap();

    // Create checkpoint before error
    let workflow_id = "resume-error-77777";
    create_test_checkpoint(prodigy_home.path(), workflow_id, 2, 4, json!({}));

    // Resume the workflow
    test = test
        .env("PRODIGY_HOME", prodigy_home.path().to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should complete successfully
    assert_eq!(output.exit_code, exit_codes::SUCCESS);
    // Error handling may not produce specific output in test execution
}

#[test]
fn test_resume_multiple_checkpoints() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();
    let _checkpoint_dir = test_dir.join(".prodigy").join("checkpoints");

    // Create multiple checkpoints
    for i in 1..=3 {
        let workflow_id = format!("workflow-{}", i);
        create_test_checkpoint(prodigy_home.path(), &workflow_id, i, 5, json!({}));
    }

    // List available checkpoints (when list command is implemented)
    // This test is a placeholder for when 'prodigy checkpoints list' is added

    // Verify checkpoint files exist in PRODIGY_HOME
    for i in 1..=3 {
        let workflow_id = format!("workflow-{}", i);
        let checkpoint_file = prodigy_home
            .path()
            .join("state")
            .join(&workflow_id)
            .join("checkpoints")
            .join(format!("{}.checkpoint.json", workflow_id));
        assert!(
            checkpoint_file.exists(),
            "Checkpoint should exist at {:?}",
            checkpoint_file
        );
    }
}

#[test]
#[ignore = "MapReduce resume not fully implemented"]
fn test_resume_with_mapreduce_state() {
    // Setup isolated PRODIGY_HOME for this test
    let _prodigy_home = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();
    let checkpoint_dir = test_dir.join(".prodigy").join("checkpoints");
    let workflow_dir = test_dir.clone();

    // Create MapReduce workflow
    let workflow_content = r#"
name: test-mapreduce-workflow
mode: mapreduce

map:
  input: "items.json"
  agent_template:
    - shell: "echo 'Processing ${item}'"
  max_parallel: 2

reduce:
  - shell: "echo 'Reducing results'"
"#;

    // Create workflow file with the expected name from checkpoint
    let workflow_path = workflow_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, workflow_content).unwrap();

    // Create items file
    let items = json!(["item1", "item2", "item3", "item4"]);
    fs::write(workflow_dir.join("items.json"), items.to_string()).unwrap();

    // Create checkpoint with MapReduce state
    let workflow_id = "resume-mapreduce-88888";
    let now = chrono::Utc::now();
    let checkpoint = json!({
        "workflow_id": workflow_id,
        "execution_state": {
            "current_step_index": 0,
            "total_steps": 2,
            "status": "Interrupted",
            "start_time": now.to_rfc3339(),
            "last_checkpoint": now.to_rfc3339(),
            "current_iteration": null,
            "total_iterations": null
        },
        "completed_steps": [],
        "variable_state": {},
        "mapreduce_state": {
            "phase": "map",
            "completed_items": ["item1", "item2"],
            "pending_items": ["item3", "item4"],
            "map_results": {
                "item1": {"status": "success", "output": "Processed item1"},
                "item2": {"status": "success", "output": "Processed item2"}
            }
        },
        "timestamp": now.to_rfc3339(),
        "version": 1,
        "workflow_hash": "test-hash-88888",
        "total_steps": 2,
        "workflow_name": "test-resume-workflow",
        "workflow_path": null
    });

    fs::create_dir_all(&checkpoint_dir).unwrap();
    fs::write(
        checkpoint_dir.join(format!("{}.checkpoint.json", workflow_id)),
        serde_json::to_string_pretty(&checkpoint).unwrap(),
    )
    .unwrap();

    // Resume the workflow
    test = test
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should complete successfully
    assert_eq!(output.exit_code, exit_codes::SUCCESS);
    // MapReduce may not produce specific output in test execution
}

#[test]
fn test_resume_workflow_with_on_failure_handlers() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home_dir = setup_test_prodigy_home();

    // Use CliTest to get a temp directory with git initialized
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create a workflow with on_failure_handlers at different steps
    let workflow_content = r#"name: test-resume-workflow
description: Test resuming workflow with on_failure handlers

commands:
  - shell: "echo 'Step 1 completed' > step1.txt"
    id: step1

  - shell: "echo 'Step 2 completed' > step2.txt"
    id: step2

  - shell: "test -f trigger-failure.txt && exit 1 || echo 'Step 3 completed' > step3.txt"
    id: step3
    on_failure:
      claude: "/fix-error --message 'Step 3 failed, cleaning up'"

  - shell: "echo 'Step 4 completed' > step4.txt"
    id: step4

  - shell: "echo 'Final step completed' > final.txt"
    id: final
"#;

    // Save workflow file - name must match what create_test_checkpoint expects
    let workflow_path = test_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, workflow_content).unwrap();

    // Create checkpoint with actual worktree
    let workflow_id = "session-on-failure-resume-test";
    let prodigy_home = prodigy_home_dir.path().to_path_buf();
    let _worktree_path = create_test_checkpoint_with_worktree(
        &prodigy_home,
        &test_dir,
        workflow_id,
        2, // commands_executed
        5, // total_commands
        json!({}),
    )
    .expect("Failed to create test checkpoint with worktree");

    // Create trigger file to cause step 3 to fail initially (if needed)
    fs::write(test_dir.join("trigger-failure.txt"), "trigger").unwrap();

    // Resume the workflow
    test = test
        .env("PRODIGY_HOME", prodigy_home.to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Workflow should complete successfully
    assert_eq!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Workflow should complete successfully. Output: {}\nStderr: {}",
        output.stdout,
        output.stderr
    );

    // Just verify that the workflow completed
    assert!(
        output.stdout_contains("completed")
            || output.stdout_contains("Session complete")
            || output.stdout_contains("successfully"),
        "Workflow should show completion. Output: {}",
        output.stdout
    );
}

#[test]
fn test_checkpoint_with_error_recovery_state_serialization() {
    // Test that error recovery state can be properly serialized/deserialized in checkpoints
    let now = chrono::Utc::now();
    let workflow_id = "test-error-state-serialization";

    let checkpoint_with_error_state = json!({
        "workflow_id": workflow_id,
        "execution_state": {
            "current_step_index": 2,
            "total_steps": 4,
            "status": "Interrupted",
            "start_time": now.to_rfc3339(),
            "last_checkpoint": now.to_rfc3339(),
            "current_iteration": null,
            "total_iterations": null
        },
        "completed_steps": [
            {
                "step_index": 0,
                "command": "shell: echo 'Step 1'",
                "success": true,
                "output": "Step 1 output",
                "captured_variables": {},
                "duration": { "secs": 1, "nanos": 0 },
                "completed_at": now.to_rfc3339(),
                "retry_state": null
            }
        ],
        "variable_state": {
            "__error_recovery_state": json!({
                "active_handlers": [{
                    "id": "handler-1",
                    "commands": [
                        {"shell": "echo 'Handling error'"},
                        {"shell": "rm -f error.txt"}
                    ],
                    "strategy": "retry",
                    "scope": "step",
                    "timeout": { "secs": 30, "nanos": 0 }
                }],
                "error_context": {
                    "message": "Command failed",
                    "exit_code": "1"
                },
                "handler_execution_history": [],
                "correlation_id": "test-123",
                "recovery_attempts": 1,
                "max_recovery_attempts": 3
            }),
            "other_var": "some_value"
        },
        "mapreduce_state": null,
        "timestamp": now.to_rfc3339(),
        "version": 1,
        "workflow_hash": "test-hash",
        "total_steps": 4,
        "workflow_name": "test-workflow",
        "workflow_path": null
    });

    // Verify the JSON structure is valid
    let checkpoint_str = serde_json::to_string(&checkpoint_with_error_state).unwrap();
    let parsed_checkpoint: serde_json::Value = serde_json::from_str(&checkpoint_str).unwrap();

    // Verify error recovery state is present
    assert!(parsed_checkpoint["variable_state"]["__error_recovery_state"].is_object());

    // Verify we can extract the error recovery state
    let error_state = &parsed_checkpoint["variable_state"]["__error_recovery_state"];
    assert_eq!(error_state["correlation_id"], "test-123");
    assert_eq!(error_state["recovery_attempts"], 1);
    assert_eq!(error_state["max_recovery_attempts"], 3);

    // Verify handlers are preserved
    let handlers = error_state["active_handlers"].as_array().unwrap();
    assert_eq!(handlers.len(), 1);
    assert_eq!(handlers[0]["id"], "handler-1");
    assert_eq!(handlers[0]["strategy"], "retry");
}

#[test]
fn test_end_to_end_error_handler_execution_after_resume() {
    // Setup isolated PRODIGY_HOME for this test
    let prodigy_home = setup_test_prodigy_home();

    // Comprehensive end-to-end test that verifies error handlers execute correctly after resume
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create a simpler workflow that will fail at a specific step and has error handlers
    let workflow_content = r#"
name: test-resume-workflow
description: Test error handler execution during resume

commands:
  - shell: "echo 'Step 1: Initialize'"
    id: step1

  - shell: "echo 'Step 2: Pre-error setup'"
    id: step2

  - shell: "exit 1"
    id: step3_with_error
    on_failure:
      claude: "/fix-error --output 'Error handler executed'"

  - shell: "echo 'Step 4: Post-recovery'"
    id: step4

  - shell: "echo 'Step 5: Completion'"
    id: final_step
"#;

    // Save workflow file - using standard name expected by checkpoint system
    let workflow_path = test_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, workflow_content).unwrap();

    // Create checkpoint with actual worktree and error recovery state
    let workflow_id = "session-end-to-end-error-handler-test";
    let prodigy_home = prodigy_home.path().to_path_buf();

    // Create variables with error recovery state
    let variables = json!({
        "__error_recovery_state": {
            "active_handlers": [{
                "id": "step3-error-handler",
                "command": {
                    "claude": "/fix-error --output 'Error handler executed'"
                },
                "strategy": "retry"
            }],
            "correlation_id": "test-correlation-123",
            "recovery_attempts": 1,
            "max_recovery_attempts": 3
        }
    });

    let _worktree_path = create_test_checkpoint_with_worktree(
        &prodigy_home,
        &test_dir,
        workflow_id,
        2, // commands_executed (steps 1 and 2 completed, failed at step 3)
        5, // total_commands
        variables,
    )
    .expect("Failed to create test checkpoint with worktree");

    // Resume the workflow - error handlers should execute - explicitly pass PRODIGY_HOME to subprocess
    test = test
        .env("PRODIGY_HOME", prodigy_home.to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let resume_output = test.run();

    // Verify successful completion
    assert_eq!(
        resume_output.exit_code,
        exit_codes::SUCCESS,
        "Resume should complete successfully. Stdout: {}\nStderr: {}",
        resume_output.stdout,
        resume_output.stderr
    );

    // Verify the workflow completed successfully
    assert!(
        resume_output.stdout_contains("Resumed session completed successfully")
            || resume_output.stdout_contains("Session complete")
            || resume_output.stdout_contains("completed"),
        "Expected completion message not found in output: {}",
        resume_output.stdout
    );

    // Note: Checkpoint cleanup is handled by the system and may vary based on configuration
    // Not asserting on checkpoint file existence here
}

// Phase 1 Tests: Uncovered Error Paths

#[test]
fn test_resume_session_not_found_error() {
    // Test for error path: session not found in unified storage AND worktree file missing (lines 290-299)
    let prodigy_home = setup_test_prodigy_home();
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create workflow file
    let _workflow_path = create_test_workflow(&test_dir, "test-resume-workflow.yaml");

    // Try to resume a session that doesn't exist (no checkpoint, no unified session)
    let nonexistent_session_id = "session-does-not-exist-12345";

    test = test
        .env("PRODIGY_HOME", prodigy_home.path().to_str().unwrap())
        .arg("resume")
        .arg(nonexistent_session_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should fail with session not found error
    assert_ne!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume should fail when session doesn't exist"
    );

    // Should contain error message about session not found or no checkpoints
    assert!(
        output.stderr.contains("Session not found")
            || output.stderr.contains("not found")
            || output.stderr.contains("No checkpoints found"),
        "Expected 'Session not found' or 'No checkpoints found' error. Stderr: {}",
        output.stderr
    );
}

#[test]
fn test_resume_non_resumable_session_status() {
    // Test for error path: non-resumable session status (lines 311-314)
    let prodigy_home = setup_test_prodigy_home();
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create workflow file
    let _workflow_path = create_test_workflow(&test_dir, "test-resume-workflow.yaml");

    // Create a session with Failed status (not resumable)
    let workflow_id = "session-failed-status-12345";
    let now = chrono::Utc::now();

    // Create worktree
    let worktree_dir = prodigy_home
        .path()
        .join("worktrees")
        .join("prodigy")
        .join(workflow_id);
    fs::create_dir_all(&worktree_dir).unwrap();
    std::process::Command::new("git")
        .arg("init")
        .current_dir(&worktree_dir)
        .output()
        .unwrap();

    // Create unified session with Failed status
    let unified_session = json!({
        "id": workflow_id,
        "session_type": "Workflow",
        "status": "Failed",  // Failed status is NOT resumable
        "started_at": now.to_rfc3339(),
        "updated_at": now.to_rfc3339(),
        "completed_at": null,
        "metadata": {},
        "checkpoints": [],
        "timings": {},
        "error": "Previous error",
        "workflow_data": {
            "workflow_id": workflow_id,
            "workflow_name": "test-resume-workflow",
            "current_step": 2,
            "total_steps": 5,
            "completed_steps": [0, 1],
            "variables": {},
            "iterations_completed": 0,
            "files_changed": 0,
            "worktree_name": workflow_id
        },
        "mapreduce_data": null
    });

    let sessions_dir = prodigy_home.path().join("sessions");
    fs::create_dir_all(&sessions_dir).unwrap();
    fs::write(
        sessions_dir.join(format!("{}.json", workflow_id)),
        serde_json::to_string_pretty(&unified_session).unwrap(),
    )
    .unwrap();

    // Try to resume the failed session
    test = test
        .env("PRODIGY_HOME", prodigy_home.path().to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should fail with non-resumable status error
    assert_ne!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume should fail for non-resumable session status"
    );

    // Should contain error message about session not being resumable
    assert!(
        output.stderr.contains("not resumable") || output.stderr.contains("Failed"),
        "Expected 'not resumable' error. Stderr: {}",
        output.stderr
    );
}

#[test]
#[ignore = "Workflow hash validation not currently enforced in resume flow"]
fn test_resume_workflow_hash_mismatch() {
    // Test for error path: workflow hash mismatch (lines 323-325)
    // Note: This test is ignored because the current implementation may not strictly enforce
    // workflow hash validation during resume, or the validation happens at a different stage
    let prodigy_home = setup_test_prodigy_home();
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create workflow file
    let _workflow_path = create_test_workflow(&test_dir, "test-resume-workflow.yaml");

    let workflow_id = "session-hash-mismatch-12345";

    // Create checkpoint with a specific workflow hash
    let variables = json!({});
    let _worktree_path = create_test_checkpoint_with_worktree(
        prodigy_home.path(),
        &test_dir,
        workflow_id,
        2,
        5,
        variables,
    )
    .unwrap();

    // Modify the workflow file to change its hash
    let modified_workflow_content = r#"
name: test-resume-workflow
description: Modified workflow - different hash

commands:
  - shell: "echo 'Modified Command 1'"
    id: cmd1
  - shell: "echo 'Modified Command 2'"
    id: cmd2
  - shell: "echo 'Modified Command 3'"
    id: cmd3
  - shell: "echo 'Modified Command 4'"
    id: cmd4
  - shell: "echo 'Modified Final command'"
    id: cmd5
"#;
    let workflow_path = test_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, modified_workflow_content).unwrap();

    // Try to resume with modified workflow
    test = test
        .env("PRODIGY_HOME", prodigy_home.path().to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should fail with workflow hash mismatch error
    assert_ne!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume should fail when workflow hash doesn't match. Stdout: {}\nStderr: {}",
        output.stdout,
        output.stderr
    );

    // Should contain error message about workflow modification
    assert!(
        output.stderr.contains("Workflow has been modified")
            || output.stderr.contains("hash")
            || output.stderr.contains("changed"),
        "Expected workflow modification error. Stderr: {}",
        output.stderr
    );
}

#[test]
fn test_resume_missing_workflow_state() {
    // Test for error path: missing workflow_state (lines 426-428)
    let prodigy_home = setup_test_prodigy_home();
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create workflow file
    let _workflow_path = create_test_workflow(&test_dir, "test-resume-workflow.yaml");

    let workflow_id = "session-no-workflow-state-12345";
    let now = chrono::Utc::now();

    // Create worktree
    let worktree_dir = prodigy_home
        .path()
        .join("worktrees")
        .join("prodigy")
        .join(workflow_id);
    fs::create_dir_all(&worktree_dir).unwrap();
    std::process::Command::new("git")
        .arg("init")
        .current_dir(&worktree_dir)
        .output()
        .unwrap();

    // Create unified session WITHOUT workflow_data (which would lead to no workflow_state)
    let unified_session = json!({
        "id": workflow_id,
        "session_type": "Workflow",
        "status": "Paused",
        "started_at": now.to_rfc3339(),
        "updated_at": now.to_rfc3339(),
        "completed_at": null,
        "metadata": {},
        "checkpoints": [],
        "timings": {},
        "error": null,
        "workflow_data": null,  // Missing workflow data
        "mapreduce_data": null
    });

    let sessions_dir = prodigy_home.path().join("sessions");
    fs::create_dir_all(&sessions_dir).unwrap();
    fs::write(
        sessions_dir.join(format!("{}.json", workflow_id)),
        serde_json::to_string_pretty(&unified_session).unwrap(),
    )
    .unwrap();

    // Try to resume session without workflow state
    test = test
        .env("PRODIGY_HOME", prodigy_home.path().to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should fail with missing workflow state error
    assert_ne!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume should fail when workflow state is missing"
    );

    // Should contain error message about missing workflow state or no checkpoints
    // The implementation may fail at checkpoint loading before reaching workflow state check
    assert!(
        output.stderr.contains("no workflow state")
            || output.stderr.contains("workflow state")
            || output.stderr.contains("No checkpoints found"),
        "Expected missing workflow state or no checkpoints error. Stderr: {}",
        output.stderr
    );
}

#[test]
fn test_resume_interrupted_again_during_resume() {
    // Test for error path: session interrupted during resume (lines 385-396)
    // This test simulates a workflow that gets interrupted again during resume
    let prodigy_home = setup_test_prodigy_home();
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create a workflow that will simulate interruption
    // In practice, this would require sending SIGINT during execution
    // For this test, we'll create a workflow that exits early
    let workflow_content = r#"
name: test-resume-workflow
description: Test workflow that simulates interruption

commands:
  - shell: "echo 'Command 1 executed'"
    id: cmd1
  - shell: "echo 'Command 2 executed'"
    id: cmd2
  - shell: "echo 'Command 3 - simulating interruption' && exit 130"
    id: cmd3
  - shell: "echo 'Command 4 executed'"
    id: cmd4
  - shell: "echo 'Final command executed'"
    id: cmd5
"#;

    let workflow_path = test_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, workflow_content).unwrap();

    let workflow_id = "session-interrupted-again-12345";

    // Create checkpoint
    let variables = json!({});
    let _worktree_path = create_test_checkpoint_with_worktree(
        prodigy_home.path(),
        &test_dir,
        workflow_id,
        2,
        5,
        variables,
    )
    .unwrap();

    // Resume the workflow
    test = test
        .env("PRODIGY_HOME", prodigy_home.path().to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // The workflow should handle the interruption
    // Exit code 130 indicates SIGINT (Ctrl+C)
    // The system should save a checkpoint and allow resume
    // We're testing that the error path is covered, not necessarily that it succeeds
    if output.exit_code == exit_codes::SUCCESS {
        // If it succeeded, that's fine - the interruption was handled
        assert!(output.stdout_contains("completed") || output.stdout_contains("Resumed"));
    } else {
        // If it failed, it should indicate interruption
        assert!(
            output.stderr.contains("interrupted")
                || output.stdout.contains("interrupted")
                || output.stderr.contains("Resume with:"),
            "Expected interruption message. Stdout: {}\nStderr: {}",
            output.stdout,
            output.stderr
        );
    }
}

#[test]
fn test_resume_failure_during_resume() {
    // Test for error path: session failure during resume (lines 398-406)
    let prodigy_home = setup_test_prodigy_home();
    let mut test = CliTest::new();
    let test_dir = test.temp_path().to_path_buf();

    // Create a workflow that will fail during resume
    let workflow_content = r#"
name: test-resume-workflow
description: Test workflow that fails during resume

commands:
  - shell: "echo 'Command 1 executed'"
    id: cmd1
  - shell: "echo 'Command 2 executed'"
    id: cmd2
  - shell: "echo 'Command 3 - failing' && exit 1"
    id: cmd3
  - shell: "echo 'Command 4 executed'"
    id: cmd4
  - shell: "echo 'Final command executed'"
    id: cmd5
"#;

    let workflow_path = test_dir.join("test-resume-workflow.yaml");
    fs::write(&workflow_path, workflow_content).unwrap();

    let workflow_id = "session-failed-during-resume-12345";

    // Create checkpoint
    let variables = json!({});
    let _worktree_path = create_test_checkpoint_with_worktree(
        prodigy_home.path(),
        &test_dir,
        workflow_id,
        2,
        5,
        variables,
    )
    .unwrap();

    // Resume the workflow
    test = test
        .env("PRODIGY_HOME", prodigy_home.path().to_str().unwrap())
        .arg("resume")
        .arg(workflow_id)
        .arg("--path")
        .arg(test_dir.to_str().unwrap());

    let output = test.run();

    // Should fail during resume
    assert_ne!(
        output.exit_code,
        exit_codes::SUCCESS,
        "Resume should fail when workflow command fails"
    );

    // Should contain error message about resumed session failing
    assert!(
        output.stderr.contains("failed") || output.stderr.contains("error"),
        "Expected failure message. Stderr: {}",
        output.stderr
    );
}