// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use crate::internal::FuzzTestRegistration;
use ::engine::engine_ffi;
use anyhow::Context;
use clap::Parser;
use std::env;
use std::ffi::CString;
use std::ffi::OsString;
use std::iter;
use std::path::Path;
use std::sync::OnceLock;
use tempfile::{NamedTempFile, TempDir};

pub use fuzztest_options::{
    ExecutionMode, FuzzOptions, FuzzTestOptions, ReplayCorpusOptions, ReplayCrashOptions,
    RunDuration, TimeBudgetType,
};

/// Returns a lazily-initialized static reference to the global `FuzzTestOptions`.
pub fn get_fuzztest_options() -> &'static FuzzTestOptions {
    static OPTIONS: OnceLock<FuzzTestOptions> = OnceLock::new();
    // We parse FuzzTestOptions from an empty iterator so that clap would parse the options only
    // from environment variables (like `FUZZTEST_FUZZ_FOR` etc.). We (currently) do not envisage
    // support for passing flags on cli as the Rust's libtest harness does not support custom
    // flags.
    OPTIONS.get_or_init(|| FuzzTestOptions::parse_from(iter::empty::<OsString>()))
}

trait ExecutionModeExt {
    /// Prepares the concrete `ExecutionAction` payload for execution by building any required
    /// `CentipedeArgs` or temporary runtime assets.
    fn prepare_action(
        &self,
        options: &FuzzTestOptions,
        current_test_name: &str,
    ) -> anyhow::Result<ExecutionAction>;
}

impl ExecutionModeExt for ExecutionMode {
    /// Prepares the concrete `ExecutionAction` payload for execution by building any required
    /// `CentipedeArgs` or temporary runtime assets.
    fn prepare_action(
        &self,
        options: &FuzzTestOptions,
        current_test_name: &str,
    ) -> anyhow::Result<ExecutionAction> {
        match self {
            ExecutionMode::SmokeTest => Ok(ExecutionAction::SmokeTest),
            ExecutionMode::Fuzz(_)
            | ExecutionMode::ReplayCrash(_)
            | ExecutionMode::ReplayCorpus(_)
            | ExecutionMode::ListCrashIds(_) => {
                let centipede_args =
                    CentipedeArgs::from_execution_mode(self, options, current_test_name, None)?
                        .context(
                            "while attempting to build CentipedeArgs for standalone execution mode",
                        )?;
                Ok(ExecutionAction::Standalone(centipede_args))
            }
            ExecutionMode::ReplayAllCrashes => {
                let list_file = NamedTempFile::new()
                    .context("while attempting to create temp file for ReplayAllCrashes")?;
                let centipede_args = CentipedeArgs::from_execution_mode(
                    self,
                    options,
                    current_test_name,
                    Some(list_file.path()),
                )?
                .context("while attempting to build CentipedeArgs for replay all crashes mode")?;
                Ok(ExecutionAction::ReplayAllCrashes { args: centipede_args, list_file })
            }
            ExecutionMode::ListFuzzTests => {
                anyhow::bail!("ListFuzzTest mode is supported only in cargo-fuzztest");
            }
        }
    }
}

/// The prepared, ready-to-run execution payload passed to the test worker.
///
/// This enum bridges parsed domain intent (`ExecutionMode`) with the concrete runtime
/// assets (`CentipedeArgs`, temporary files, workdir paths) needed to execute the test run.
#[derive(Debug)]
pub enum ExecutionAction {
    /// Run as a smoke test (regular unit test) with random inputs for a short duration.
    SmokeTest,

    /// Run in standalone mode, invoking the Centipede fuzzing controller.
    Standalone(CentipedeArgs),

    /// Replay all crash IDs from the database (carries `list_file` for worker post-processing).
    ReplayAllCrashes { args: CentipedeArgs, list_file: NamedTempFile },
}

/// Encapsulates command-line arguments and lifetime holders for Centipede execution.
#[derive(Debug)]
pub struct CentipedeArgs {
    // Holds the owned C-compatible strings. We must keep these alive because the `views`
    // field contains pointers into the memory owned by these `CString`s.
    _c_strings: Vec<CString>,

    // The (optional) TempDir instance which is to be used as a workdir by centipede.
    // We keep the ownership here so that it is not cleaned while the centipede execution is still
    // in progress.
    _temp_workdir: Option<TempDir>,

    // FFI-compatible views into the arguments in `_c_strings`. These are passed across
    // the FFI boundary to Centipede.
    views: Vec<engine_ffi::FuzzTestBytesView>,
}

impl CentipedeArgs {
    fn new(args: Vec<CString>, temp_workdir: Option<TempDir>) -> Self {
        let views = args
            .iter()
            .map(|arg| engine_ffi::FuzzTestBytesView::from_bytes(arg.as_bytes()))
            .collect();

        Self { _c_strings: args, _temp_workdir: temp_workdir, views }
    }

    /// Decides if Centipede needs to be invoked based on the execution mode,
    /// and constructs the appropriate arguments for it if so.
    ///
    /// Returns `Ok(Some(args))` if Centipede should be invoked, `Ok(None)` for `SmokeTest`,
    /// or `Err` if argument generation fails.
    pub fn from_execution_mode(
        mode: &ExecutionMode,
        options: &FuzzTestOptions,
        current_test_name: &str,
        list_file_path: Option<&Path>,
    ) -> anyhow::Result<Option<Self>> {
        let mode_opts = match mode {
            ExecutionMode::SmokeTest => return Ok(None),
            other => other,
        };

        let mut args = Vec::new();
        let mut add_arg = |arg: String| -> anyhow::Result<()> {
            args.push(CString::new(arg).context("while attempting to create CString arg")?);
            Ok(())
        };

        // ==============================================================================
        // 1. Common Base Arguments (Required across all Centipede executions)
        // ==============================================================================
        let argv0 = env::args().next().context("while attempting to get argv[0]")?;

        add_arg(format!("--binary={argv0} {current_test_name} --exact --nocapture"))?;
        let normalized_test_name = current_test_name.replace("::", ".");
        add_arg(format!("--test_name={normalized_test_name}"))?;

        // Binary identifier is derived from the binary path.
        let binary_id = normalize_binary_identifier(&argv0);
        add_arg(format!("--fuzztest_binary_identifier={binary_id}"))?;

        add_arg("--populate_binary_info=false".to_string())?;
        // TODO(the-shank): provide a way to override this.
        // allow more crashes to be reported when running with FuzzTest (default is 5)
        add_arg("--max_num_crash_reports=20".to_string())?;

        add_arg(format!("--print_runner_log={}", options.print_subprocess_log))?;

        // Add a dummy hash so as to avoid Centipede computing the hash of the binary.
        add_arg("--binary_hash=DUMMY_HASH".to_string())?;

        // ==============================================================================
        // 2. Common Working Directory & Corpus Database Resolution
        // ==============================================================================
        let (opt_corpusdb, opt_workdir_root, opt_workdir) =
            get_corpusdb_and_workdir_root_and_workdir(options)
                .context("while attempting to resolve corpus and workdir options")?;

        if let Some(corpus_db) = opt_corpusdb {
            add_arg(format!("--fuzztest_corpus_database={corpus_db}"))?;
        }

        if let Some(workdir_root) = opt_workdir_root {
            add_arg(format!("--fuzztest_workdir_root={workdir_root}"))?;
        }

        if let Some(temp_workdir) = &opt_workdir {
            let workdir_path = temp_workdir
                .path()
                .to_str()
                .context("while attempting to convert temp dir path to str")?
                .to_string();
            add_arg(format!("--workdir={workdir_path}"))?;
        }

        // ==============================================================================
        // 3. Common Environment Variables Differential
        // ==============================================================================
        let env_diff = Self::default_env_diff();
        add_arg(format!("--env_diff_for_binaries={}", env_diff.join(",")))?;

        // ==============================================================================
        // 4. Mode-Specific Arguments
        // ==============================================================================
        match mode_opts {
            ExecutionMode::Fuzz(fuzz_opts) => {
                match &fuzz_opts.fuzz_for {
                    RunDuration::Indefinitely => {
                        // not specifying `--stop_after` means to run indefinitely.
                    }
                    RunDuration::Fixed(duration) => {
                        let duration_secs = duration.as_secs_f64();
                        if opt_corpusdb.is_some() {
                            add_arg(format!("--fuzztest_time_limit_per_test={duration_secs}s"))?;
                        } else {
                            add_arg(format!("--stop_after={duration_secs}s"))?;
                        }
                    }
                }
                if let Some(jobs) = &fuzz_opts.jobs {
                    add_arg(format!("--j={jobs}"))?;
                }
                if !fuzz_opts.continue_after_crash {
                    add_arg("--exit_on_crash".to_string())?;
                }
                if let Some(execution_id) = &fuzz_opts.execution_id {
                    add_arg(format!("--fuzztest_execution_id={execution_id}"))?;
                }
            }
            ExecutionMode::ReplayCrash(replay_opts) => {
                add_arg("--replay_crash".to_string())?;
                add_arg(format!("--crash_id={}", replay_opts.replay_id))?;
                add_arg("--exit_on_crash".to_string())?;
            }
            ExecutionMode::ReplayAllCrashes => {
                let path = list_file_path
                    .context("while attempting to get list_file path for ReplayAllCrashes")?;
                add_arg("--list_crash_ids=true".to_string())?;
                add_arg(format!("--list_crash_ids_file={}", path.display()))?;
            }
            ExecutionMode::ReplayCorpus(replay_corpus_opts) => {
                add_arg("--fuzztest_only_replay=true".to_string())?;
                add_arg("--fuzztest_replay_coverage_inputs=true".to_string())?;
                add_arg("--load_shards_only=true".to_string())?;
                match replay_corpus_opts.replay_corpus_for {
                    RunDuration::Indefinitely => {
                        // Not specifying `--fuzztest_time_limit_per_test` means to run indefinitely
                    }
                    RunDuration::Fixed(duration) => {
                        let time_limit: humantime::Duration = match replay_corpus_opts
                            .time_budget_type
                        {
                            TimeBudgetType::PerTest => duration,
                            TimeBudgetType::Total => {
                                let num_tests = inventory::iter::<FuzzTestRegistration>().count();
                                if num_tests == 0 {
                                    duration
                                } else {
                                    (*duration.as_ref() / (num_tests as u32)).into()
                                }
                            }
                        };
                        let time_limit_secs = time_limit.as_secs_f64();
                        add_arg(format!("--fuzztest_time_limit_per_test={time_limit_secs}s"))?;
                    }
                }
                if let Some(jobs) = &replay_corpus_opts.jobs {
                    add_arg(format!("--j={jobs}"))?;
                }
                if !replay_corpus_opts.continue_after_crash {
                    add_arg("--exit_on_crash".to_string())?;
                }
                if let Some(execution_id) = &replay_corpus_opts.execution_id {
                    add_arg(format!("--fuzztest_execution_id={execution_id}"))?;
                }
            }
            ExecutionMode::ListCrashIds(list_opts) => {
                add_arg("--list_crash_ids=true".to_string())?;
                add_arg(format!("--list_crash_ids_file={}", list_opts.list_crash_ids_file))?;
            }
            ExecutionMode::SmokeTest => unreachable!(),
            ExecutionMode::ListFuzzTests => unreachable!(),
        }

        Ok(Some(Self::new(args, opt_workdir)))
    }

    /// Generates the default environment variable diff list.
    ///
    /// This replicates the logic in `GetEnvDiffForBinaries` from `centipede_adaptor.cc`.
    ///
    /// When Centipede spawns the test binary as a subprocess, we do not want it to inherit
    /// environment variables set by the test harness (like Blaze/Bazel). Inheriting these
    /// could cause the subprocess to think it's running in a sharded environment, try to
    /// write to restricted output files, or trigger other harness-specific behavior that
    /// interferes with fuzzing.
    fn default_env_diff() -> Vec<String> {
            let env_diff = vec![
            "-TEST_DIAGNOSTICS_OUTPUT_DIR".to_string(),
            "-TEST_INFRASTRUCTURE_FAILURE_FILE".to_string(),
            "-TEST_LOGSPLITTER_OUTPUT_FILE".to_string(),
            "-TEST_PREMATURE_EXIT_FILE".to_string(),
            "-TEST_RANDOM_SEED".to_string(),
            "-TEST_RUN_NUMBER".to_string(),
            "-TEST_SHARD_INDEX".to_string(),
            "-TEST_SHARD_STATUS_FILE".to_string(),
            "-TEST_TOTAL_SHARDS".to_string(),
            "-TEST_UNDECLARED_OUTPUTS_ANNOTATIONS_DIR".to_string(),
            "-TEST_UNDECLARED_OUTPUTS_DIR".to_string(),
            "-TEST_WARNINGS_OUTPUT_FILE".to_string(),
            "-GTEST_OUTPUT".to_string(),
            "-XML_OUTPUT_FILE".to_string(),
        ];

        env_diff
    }

    /// Exposes the FFI-compatible argument views vector for C++ Centipede binding.
    pub fn as_bytes_views(&self) -> engine_ffi::FuzzTestBytesViews {
        engine_ffi::FuzzTestBytesViews { views: self.views.as_ptr(), count: self.views.len() }
    }
}

/// Determines the `ExecutionAction` for the given test name by inspecting global options.
pub fn determine_execution_action(current_test_name: &str) -> ExecutionAction {
    determine_execution_action_internal(get_fuzztest_options(), current_test_name)
}

fn determine_execution_action_internal(
    options: &FuzzTestOptions,
    current_test_name: &str,
) -> ExecutionAction {
    ExecutionMode::from_fuzztest_options(options)
        .prepare_action(options, current_test_name)
        .expect("failed to prepare execution action from fuzztest options")
}

fn get_corpusdb_and_workdir_root_and_workdir(
    options: &FuzzTestOptions,
) -> anyhow::Result<(Option<&str>, Option<&str>, Option<TempDir>)> {
    let corpus_db = options.corpus_db.as_deref();
    let workdir_root = options.workdir_root.as_deref();

    if let Some(corpus_db) = corpus_db {
        if let Some(workdir_root) = workdir_root {
            Ok((
                Some(corpus_db.to_str().context("converting corpus_db to str")?),
                Some(workdir_root),
                None,
            ))
        } else {
            let temp_dir =
                TempDir::new().context("while attempting to create temporary working directory")?;
            Ok((
                Some(corpus_db.to_str().context("converting corpus_db to str")?),
                None,
                Some(temp_dir),
            ))
        }
    } else {
        if workdir_root.is_some() {
            anyhow::bail!("NOT ALLOWED: workdir_root provided without corpus_db")
        } else {
            let temp_dir =
                TempDir::new().context("while attempting to create temporary working directory")?;
            Ok((None, None, Some(temp_dir)))
        }
    }
}

/// Normalizes a binary path to be used as a binary identifier.
///
/// Centipede creates corpus and working directory paths by joining a base
/// directory with the binary identifier (for example, `corpus_database / binary_id`).
///
/// If `binary_path` starts with a `/`, joining paths treats it as an absolute path
/// and ignores the base directory. Stripping the leading slash turns it into a
/// relative path so it joins correctly.
fn normalize_binary_identifier(binary_path: &str) -> &str {
    // TODO(the-shank): Handle absolute paths on windows as well.
    binary_path.strip_prefix('/').unwrap_or(binary_path)
}

#[cfg(test)]
mod tests {
    use super::*;
    use fuzztest_options::env_vars::*;
    use googletest::prelude::*;
    use std::ffi::OsString;

    #[gtest]
    fn test_fuzz_options_parsing_env() {
        assert_single_threaded_test_environment();
        // SAFETY: Single-threaded test environment and no background threads.
        let options = unsafe {
            with_env_var("FUZZTEST_FUZZ_FOR", "5s", || {
                FuzzTestOptions::parse_from(std::iter::empty::<OsString>())
            })
        };

        expect_true!(options.fuzz_for.is_some());
        expect_that!(
            ExecutionMode::from_fuzztest_options(&options),
            matches_pattern!(ExecutionMode::Fuzz(_))
        );
    }

    #[gtest]
    fn test_fuzz_options_parsing_indefinite_env() {
        assert_single_threaded_test_environment();
        // SAFETY: Single-threaded test environment and no background threads.
        let options = unsafe {
            with_env_var("FUZZTEST_FUZZ_FOR", "inf", || {
                FuzzTestOptions::parse_from(std::iter::empty::<OsString>())
            })
        };

        expect_that!(options.fuzz_for, eq(Some(RunDuration::Indefinitely)));
        let mode = ExecutionMode::from_fuzztest_options(&options);
        let ExecutionMode::Fuzz(fuzz_opts) = mode else {
            panic!("Expected ExecutionMode::Fuzz");
        };
        expect_that!(fuzz_opts.fuzz_for, eq(RunDuration::Indefinitely));
    }

    #[gtest]
    fn test_determine_execution_action_standalone_indefinite() {
        let options =
            FuzzTestOptions { fuzz_for: Some(RunDuration::Indefinitely), ..Default::default() };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        // When running indefinitely, --stop_after must be omitted so Centipede runs until
        // interrupted.
        expect_false!(args_str.iter().any(|s| s.starts_with("--stop_after=")));
        expect_true!(args_str.contains(&"--test_name=my_mod.my_test"));
    }

    #[gtest]
    fn test_determine_execution_action_smoke_test() {
        let options = FuzzTestOptions::default();
        let action = determine_execution_action_internal(&options, "my_mod::my_test");
        assert!(matches!(action, ExecutionAction::SmokeTest));
    }

    #[gtest]
    fn test_determine_execution_action_standalone() {
        let expected_duration: RunDuration = "10s".parse().unwrap();
        let options = FuzzTestOptions { fuzz_for: Some(expected_duration), ..Default::default() };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        expect_that!(args._c_strings.len(), eq(args.views.len()));

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        expect_true!(args_str
            .iter()
            .any(|s| s.starts_with("--binary=") && s.contains("my_mod::my_test --exact")));

        expect_true!(args_str.contains(&"--stop_after=10s"));
        expect_true!(args_str.contains(&"--test_name=my_mod.my_test"));
        expect_true!(args_str.iter().any(|s| s.starts_with("--env_diff_for_binaries=")));

        // Verify that a temporary workdir was created and passed as an argument.
        expect_true!(args._temp_workdir.is_some());
        let temp_workdir_path = args._temp_workdir.as_ref().unwrap().path().to_str().unwrap();
        let expected_workdir_arg = format!("--workdir={}", temp_workdir_path);
        expect_true!(args_str.contains(&expected_workdir_arg.as_str()));
    }

    #[gtest]
    fn test_centipede_args_binary_identifier() {
        let expected_duration = "1s".parse().unwrap();
        let options = FuzzTestOptions { fuzz_for: Some(expected_duration), ..Default::default() };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        let argv0 = std::env::args().next().expect("get argv[0]");
        let binary_id = normalize_binary_identifier(&argv0);
        let expected_binary_id_arg = format!("--fuzztest_binary_identifier={binary_id}");

        expect_true!(args_str.contains(&expected_binary_id_arg.as_str()));
    }

    #[gtest]
    fn test_centipede_args_jobs() {
        let expected_duration = "1s".parse().expect("failed to parse duration");
        let options_no_jobs =
            FuzzTestOptions { fuzz_for: Some(expected_duration), ..Default::default() };
        let action_no_jobs =
            determine_execution_action_internal(&options_no_jobs, "my_mod::my_test");
        let ExecutionAction::Standalone(args_no_jobs) = action_no_jobs else {
            panic!("Expected Standalone action");
        };
        let args_str_no_jobs: Vec<&str> =
            args_no_jobs._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();
        assert!(!args_str_no_jobs.iter().any(|s| s.starts_with("--j=")));

        let options_with_jobs = FuzzTestOptions {
            fuzz_for: Some(expected_duration),
            jobs: Some(4),
            ..Default::default()
        };
        let action_with_jobs =
            determine_execution_action_internal(&options_with_jobs, "my_mod::my_test");
        let ExecutionAction::Standalone(args_with_jobs) = action_with_jobs else {
            panic!("Expected Standalone action");
        };
        let args_str_with_jobs: Vec<&str> =
            args_with_jobs._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();
        assert!(args_str_with_jobs.contains(&"--j=4"));
    }

    #[gtest]
    fn test_default_env_diff_set() {
        let duration = "1s".parse().unwrap();
        let options = FuzzTestOptions { fuzz_for: Some(duration), ..Default::default() };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");
        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        let env_diff_arg = args_str
            .iter()
            .find(|s| s.starts_with("--env_diff_for_binaries="))
            .expect("missing --env_diff_for_binaries arg");

        expect_true!(env_diff_arg.contains("-TEST_SHARD_INDEX"));
        expect_true!(env_diff_arg.contains("-XML_OUTPUT_FILE"));
        expect_true!(env_diff_arg.contains("-GTEST_OUTPUT"));
    }

    #[gtest]
    fn test_determine_execution_action_replay_crash_id() {
        let options = FuzzTestOptions {
            replay_id: Some("my_crash_123".to_string()),
            corpus_db: Some("/tmp/corpus_db".into()),
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        expect_true!(args_str.contains(&"--replay_crash"));
        expect_true!(args_str.contains(&"--crash_id=my_crash_123"));
        expect_true!(args_str.contains(&"--fuzztest_corpus_database=/tmp/corpus_db"));
        expect_true!(args_str.contains(&"--test_name=my_mod.my_test"));
        expect_true!(args_str.iter().any(|s| s.starts_with("--workdir=")));
    }

    #[gtest]
    fn test_determine_execution_action_replay_findings() {
        let options = FuzzTestOptions {
            replay_findings: true,
            corpus_db: Some("/tmp/corpus_db".into()),
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::ReplayAllCrashes { args, list_file } = action else {
            panic!("Expected ReplayAllCrashes action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        expect_true!(args_str.contains(&"--list_crash_ids=true"));
        expect_true!(args_str
            .contains(&format!("--list_crash_ids_file={}", list_file.path().display()).as_str()));
        expect_true!(args_str.contains(&"--fuzztest_corpus_database=/tmp/corpus_db"));
        expect_true!(args_str.iter().any(|s| s.starts_with("--workdir=")));
        expect_true!(args_str.contains(&"--test_name=my_mod.my_test"));
    }

    #[gtest]
    fn test_determine_execution_action_replay_corpus() {
        let expected_duration = "10s".parse().expect("failed to parse duration");
        let options = FuzzTestOptions {
            replay_corpus_for: Some(expected_duration),
            time_budget_type: TimeBudgetType::PerTest,
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        assert!(args_str
            .iter()
            .any(|s| s.starts_with("--binary=") && s.contains("my_mod::my_test --exact")));
        assert!(args_str.contains(&"--fuzztest_only_replay=true"));
        assert!(args_str.contains(&"--fuzztest_time_limit_per_test=10s"));
        assert!(!args_str.iter().any(|s| s.starts_with("--j=")));
    }

    #[gtest]
    fn test_determine_execution_action_replay_corpus_with_jobs() {
        let expected_duration = "10s".parse().expect("failed to parse duration");
        let options = FuzzTestOptions {
            replay_corpus_for: Some(expected_duration),
            jobs: Some(4),
            time_budget_type: TimeBudgetType::PerTest,
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        assert!(args_str.contains(&"--j=4"));
        assert!(args_str.contains(&"--fuzztest_only_replay=true"));
        assert!(args_str.contains(&"--fuzztest_time_limit_per_test=10s"));
    }

    #[gtest]
    fn test_determine_execution_action_replay_corpus_indefinite() {
        let options = FuzzTestOptions {
            replay_corpus_for: Some(RunDuration::Indefinitely),
            time_budget_type: TimeBudgetType::PerTest,
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        assert!(args_str
            .iter()
            .any(|s| s.starts_with("--binary=") && s.contains("my_mod::my_test --exact")));
        assert!(args_str.contains(&"--fuzztest_only_replay=true"));
        assert!(args_str.contains(&"--fuzztest_replay_coverage_inputs=true"));
        assert!(args_str.contains(&"--load_shards_only=true"));
        assert!(!args_str.iter().any(|s| s.starts_with("--fuzztest_time_limit_per_test=")));
    }

    #[gtest]
    fn test_determine_execution_action_replay_corpus_total_budget() {
        let expected_duration = "10s".parse().expect("failed to parse duration");
        let options = FuzzTestOptions {
            replay_corpus_for: Some(expected_duration),
            time_budget_type: TimeBudgetType::Total,
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        let num_tests = inventory::iter::<FuzzTestRegistration>().count();
        let RunDuration::Fixed(fixed_duration) = expected_duration else {
            panic!("expected Fixed duration");
        };
        let expected_limit = if num_tests == 0 {
            fixed_duration
        } else {
            (*fixed_duration.as_ref() / (num_tests as u32)).into()
        };
        let expected_limit_str = format!("--fuzztest_time_limit_per_test={}", expected_limit);

        assert!(args_str.contains(&expected_limit_str.as_str()));
    }

    #[gtest]
    fn test_determine_execution_action_replay_corpus_indefinite_total_budget() {
        let options = FuzzTestOptions {
            replay_corpus_for: Some(RunDuration::Indefinitely),
            time_budget_type: TimeBudgetType::Total,
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        assert!(args_str.contains(&"--fuzztest_only_replay=true"));
        assert!(!args_str.iter().any(|s| s.starts_with("--fuzztest_time_limit_per_test=")));
    }

    #[gtest]
    fn test_get_corpusdb_and_workdir_default_creates_temp_workdir() -> Result<()> {
        let options = FuzzTestOptions::default();
        let (corpus_db, workdir_root, workdir) =
            get_corpusdb_and_workdir_root_and_workdir(&options).or_fail()?;
        expect_true!(corpus_db.is_none());
        expect_true!(workdir_root.is_none());
        expect_true!(workdir.is_some());
        Ok(())
    }

    #[gtest]
    fn test_get_corpusdb_and_workdir_succeeds_with_corpusdb_and_workdir_root() -> Result<()> {
        let options = FuzzTestOptions {
            corpus_db: Some("/tmp/db".into()),
            workdir_root: Some("/tmp/root".to_string()),
            ..Default::default()
        };
        let (corpus_db, workdir_root, workdir) =
            get_corpusdb_and_workdir_root_and_workdir(&options).or_fail()?;
        expect_that!(corpus_db, eq(Some("/tmp/db")));
        expect_that!(workdir_root, eq(Some("/tmp/root")));
        expect_true!(workdir.is_none());
        Ok(())
    }

    #[gtest]
    fn test_get_corpusdb_and_workdir_succeeds_with_corpusdb_only() -> Result<()> {
        let options = FuzzTestOptions { corpus_db: Some("/tmp/db".into()), ..Default::default() };
        let (corpus_db, workdir_root, workdir) =
            get_corpusdb_and_workdir_root_and_workdir(&options).or_fail()?;
        expect_that!(corpus_db, eq(Some("/tmp/db")));
        expect_true!(workdir_root.is_none());
        expect_true!(workdir.is_some());
        Ok(())
    }

    #[gtest]
    fn test_replay_id_requires_corpus_db() {
        assert_single_threaded_test_environment();
        // SAFETY: Single-threaded test environment and no background threads.
        let result = unsafe {
            with_env_vars(
                [("FUZZTEST_REPLAY_ID", Some("my_crash_123")), ("FUZZTEST_CORPUS_DB", None)],
                || FuzzTestOptions::try_parse_from(std::iter::empty::<OsString>()),
            )
        };

        let err = result.expect_err("parsing should fail when corpus_db is missing");
        expect_that!(err.kind(), eq(clap::error::ErrorKind::MissingRequiredArgument));
    }

    #[gtest]
    fn test_replay_id_with_corpus_db_succeeds() {
        assert_single_threaded_test_environment();
        // SAFETY: Single-threaded test environment and no background threads.
        let options = unsafe {
            with_env_vars(
                [
                    ("FUZZTEST_REPLAY_ID", Some("my_crash_123")),
                    ("FUZZTEST_CORPUS_DB", Some("/tmp/corpus_db")),
                ],
                || FuzzTestOptions::try_parse_from(std::iter::empty::<OsString>()),
            )
        }
        .expect("parsing should succeed when both replay_id and corpus_db are present");

        expect_that!(options.replay_id.as_deref(), eq(Some("my_crash_123")));
        expect_that!(options.corpus_db.as_deref(), eq(Some(Path::new("/tmp/corpus_db"))));
    }

    #[gtest]
    fn test_centipede_args_fuzz_for_duration_without_corpus_db() {
        // When corpus_db is not provided, fuzzing for a fixed duration should pass --stop_after
        // to Centipede so it stops fuzzing after the specified duration.
        let duration = "1s".parse().expect("fixed test string should parse as duration");
        let options =
            FuzzTestOptions { fuzz_for: Some(duration), corpus_db: None, ..Default::default() };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action when fuzzing for duration");
        };

        let args_str: Vec<&str> = args
            ._c_strings
            .iter()
            .map(|s| s.to_str().expect("args strings should be valid UTF-8"))
            .collect();

        expect_true!(args_str.contains(&"--stop_after=1s"));
        expect_false!(args_str.iter().any(|s| s.starts_with("--fuzztest_time_limit_per_test=")));
    }

    #[gtest]
    fn test_centipede_args_fuzz_for_duration_with_corpus_db() {
        // When corpus_db is set, fuzzing for a duration should pass --fuzztest_time_limit_per_test
        // instead of --stop_after, because Centipede uses time_limit_per_test when running against
        // a corpus database.
        let duration = "1s".parse().expect("fixed test string should parse as duration");
        let options = FuzzTestOptions {
            fuzz_for: Some(duration),
            corpus_db: Some("/tmp/corpus_db".into()),
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action when fuzzing with corpus_db and duration");
        };

        let args_str: Vec<&str> = args
            ._c_strings
            .iter()
            .map(|s| s.to_str().expect("args strings should be valid UTF-8"))
            .collect();

        expect_true!(args_str.contains(&"--fuzztest_time_limit_per_test=1s"));
        expect_true!(args_str.contains(&"--fuzztest_corpus_database=/tmp/corpus_db"));
        expect_false!(args_str.iter().any(|s| s.starts_with("--stop_after=")));
    }

    #[gtest]
    fn test_determine_execution_action_list_crash_ids() {
        let options = FuzzTestOptions {
            list_crash_ids: true,
            list_crash_ids_file: Some("/tmp/custom_crashes.txt".to_string()),
            corpus_db: Some("/tmp/corpus_db".into()),
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");

        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action for ListCrashIds");
        };

        let args_str: Vec<&str> =
            args._c_strings.iter().map(|s| s.to_str().expect("invalid utf8")).collect();

        expect_true!(args_str.contains(&"--list_crash_ids=true"));
        expect_true!(args_str.contains(&"--list_crash_ids_file=/tmp/custom_crashes.txt"));
        expect_true!(args_str.contains(&"--fuzztest_corpus_database=/tmp/corpus_db"));
        expect_true!(args_str.iter().any(|s| s.starts_with("--workdir=")));
        expect_true!(args_str.contains(&"--test_name=my_mod.my_test"));
    }

    #[gtest]
    fn test_determine_execution_action_fuzz_continue_after_crash_false() {
        let options = FuzzTestOptions {
            fuzz_for: Some("5s".parse().unwrap()),
            continue_after_crash: false,
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");
        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };
        let args_str: Vec<&str> = args._c_strings.iter().map(|s| s.to_str().unwrap()).collect();
        expect_true!(args_str.contains(&"--exit_on_crash"));
    }

    #[gtest]
    fn test_determine_execution_action_fuzz_continue_after_crash_true() {
        let options = FuzzTestOptions {
            fuzz_for: Some("5s".parse().unwrap()),
            continue_after_crash: true,
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");
        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };
        let args_str: Vec<&str> = args._c_strings.iter().map(|s| s.to_str().unwrap()).collect();
        expect_false!(args_str.contains(&"--exit_on_crash"));
    }

    #[gtest]
    fn test_determine_execution_action_replay_corpus_continue_after_crash_false() {
        let options = FuzzTestOptions {
            replay_corpus_for: Some("5s".parse().unwrap()),
            continue_after_crash: false,
            corpus_db: Some("/tmp/corpus_db".into()),
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");
        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };
        let args_str: Vec<&str> = args._c_strings.iter().map(|s| s.to_str().unwrap()).collect();
        expect_true!(args_str.contains(&"--exit_on_crash"));
    }

    #[gtest]
    fn test_determine_execution_action_replay_corpus_continue_after_crash_true() {
        let options = FuzzTestOptions {
            replay_corpus_for: Some("5s".parse().unwrap()),
            continue_after_crash: true,
            corpus_db: Some("/tmp/corpus_db".into()),
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");
        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };
        let args_str: Vec<&str> = args._c_strings.iter().map(|s| s.to_str().unwrap()).collect();
        expect_false!(args_str.contains(&"--exit_on_crash"));
    }

    #[gtest]
    fn test_determine_execution_action_fuzz_with_execution_id() {
        let options = FuzzTestOptions {
            fuzz_for: Some("5s".parse().unwrap()),
            corpus_db: Some("/tmp/corpus_db".into()),
            execution_id: Some("my_exec_123".to_string()),
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");
        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };
        let args_str: Vec<&str> = args._c_strings.iter().map(|s| s.to_str().unwrap()).collect();
        expect_true!(args_str.contains(&"--fuzztest_execution_id=my_exec_123"));
    }

    #[gtest]
    fn test_determine_execution_action_replay_corpus_with_execution_id() {
        let options = FuzzTestOptions {
            replay_corpus_for: Some("5s".parse().unwrap()),
            corpus_db: Some("/tmp/corpus_db".into()),
            execution_id: Some("my_exec_456".to_string()),
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");
        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };
        let args_str: Vec<&str> = args._c_strings.iter().map(|s| s.to_str().unwrap()).collect();
        expect_true!(args_str.contains(&"--fuzztest_execution_id=my_exec_456"));
    }

    #[gtest]
    fn test_determine_execution_action_fuzz_without_execution_id() {
        let options = FuzzTestOptions {
            fuzz_for: Some("5s".parse().unwrap()),
            corpus_db: Some("/tmp/corpus_db".into()),
            execution_id: None,
            ..Default::default()
        };
        let action = determine_execution_action_internal(&options, "my_mod::my_test");
        let ExecutionAction::Standalone(args) = action else {
            panic!("Expected Standalone action");
        };
        let args_str: Vec<&str> = args._c_strings.iter().map(|s| s.to_str().unwrap()).collect();
        expect_false!(args_str.iter().any(|s| s.starts_with("--fuzztest_execution_id=")));
    }
}