fn default_cache_enabled() -> bool {

  true

}

fn default_fail_fast() -> bool {

  true

}

  pub fn run(&self, context: &mut TaskContext) -> anyhow::Result<()> {

    match self {

      Task::Task(args) => args.run(context),

  }

  pub(crate) fn normalized_secret_settings(&self) -> Option<SecretSettings> {

    merge_optional_secret_settings(

      Some(SecretSettings::from_legacy(

        self.vault_location.clone(),

        self.keys_location.clone(),

        self.key_name.clone(),

        self.gpg_key_id.clone(),

        self.secrets_path.clone(),

      )),

      self.secrets.clone(),

    .filter(|settings| !settings.is_empty())

  }

  pub(crate) fn validation_legacy_secret_settings(&self) -> SecretSettings {

    self.raw_legacy_secret_settings.clone().unwrap_or_else(|| {

      SecretSettings::from_legacy(

        self.vault_location.clone(),

        self.keys_location.clone(),

        self.key_name.clone(),

        self.gpg_key_id.clone(),

        self.secrets_path.clone(),

    })

  }

  pub(crate) fn normalize_secret_settings(&mut self) {

    if self.raw_legacy_secret_settings.is_none() {

      self.raw_legacy_secret_settings = Some(SecretSettings::from_legacy(

        self.vault_location.clone(),

        self.keys_location.clone(),

        self.key_name.clone(),

        self.gpg_key_id.clone(),

        self.secrets_path.clone(),

      ));

    }

    if self.raw_secrets.is_none() {

      self.raw_secrets = self.secrets.clone();

    }

    self.secrets = self.normalized_secret_settings();

    if let Some(secrets) = &self.secrets {

      self.vault_location = secrets.vault_location.clone();

      self.keys_location = secrets.keys_location.clone();

      self.key_name = secrets.key_name.clone();

      self.gpg_key_id = secrets.gpg_key_id.clone();

      self.secrets_path = secrets.secrets_path.clone().unwrap_or_default();

    }

  }

  pub fn run(&self, context: &mut TaskContext) -> anyhow::Result<()> {

    assert!(!self.commands.is_empty());

    self.validate_parallel_commands()?;

    let started = Instant::now();

    let tick_interval = Duration::from_millis(80);

    if let Some(shell) = &self.shell {

    }

    if let Some(ignore_errors) = &self.ignore_errors {

    }

    if let Some(verbose) = &self.verbose {

    }

    let config_base_dir = self.config_base_dir(context);

    let task_secret_config = resolve_secret_config(

      &config_base_dir,

      None,

      self.secrets.as_ref(),

      context.task_root.secrets.as_ref(),

    context.set_secret_config(task_secret_config.clone());

    if !context.is_nested {

      let root_env = context.task_root.environment.clone();

      let root_env_files = load_env_files_in_dir(&context.task_root.env_file, &config_base_dir)?;

      context.extend_env_vars(root_env);

      context.extend_env_vars(root_env_files);

    }

    let defined_env = self.load_static_env(context)?;

    let additional_env = self.load_env_file(context)?;

    let secret_env = self.load_secret_env(context)?;

    context.extend_env_vars(defined_env);

    context.extend_env_vars(additional_env);

    context.extend_env_vars(secret_env);

    let mut rng = rand::thread_rng();

    let pb_style =

      ProgressStyle::with_template("{spinner:.green} [{prefix:.bold.dim}] {wide_msg:.cyan/blue} ")?

        .tick_chars("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⦿");

    let depends_on_pb = context.multi.add(ProgressBar::new(self.depends_on.len() as u64));

    if !self.depends_on.is_empty() {

      depends_on_pb.set_style(pb_style.clone());

      depends_on_pb.set_message("Running task dependencies...");

      depends_on_pb.enable_steady_tick(tick_interval);

      for (i, dependency) in self.depends_on.iter().enumerate() {

        thread::sleep(Duration::from_millis(rng.gen_range(40..300)));

        depends_on_pb.set_prefix(format!("{}/{}", i + 1, self.depends_on.len()));

        dependency.run(context)?;

        depends_on_pb.inc(1);

      let message = format!("Dependencies completed in {}.", HumanDuration(started.elapsed()));

      if context.is_nested {

        depends_on_pb.finish_and_clear();

      } else {

    }

    let precondition_pb = context

      .multi

      .add(ProgressBar::new(self.preconditions.len() as u64));

    if !self.preconditions.is_empty() {

    }

    if self.should_skip_from_cache(context)? {

    }

    if self.is_parallel() {

      self.execute_commands_parallel(context)?;

      let command_pb = context.multi.add(ProgressBar::new(self.commands.len() as u64));

      command_pb.set_style(pb_style);

      command_pb.set_message("Running task command...");

      command_pb.enable_steady_tick(tick_interval);

      for (i, command) in self.commands.iter().enumerate() {

        thread::sleep(Duration::from_millis(rng.gen_range(100..400)));

        command_pb.set_prefix(format!("{}/{}", i + 1, self.commands.len()));

        self.refresh_output_env(context)?;

        command.execute(context)?;

        command_pb.inc(1);

      let message = format!("Commands completed in {}.", HumanDuration(started.elapsed()));

      if context.is_nested {

        command_pb.finish_and_clear();

      } else {

    self.update_cache(context)?;

    Ok(())

  }

  fn validate_parallel_commands(&self) -> anyhow::Result<()> {

    if !self.is_parallel() {

      return Ok(());

    }

    for command in &self.commands {

      match command {

        CommandRunner::LocalRun(local_run) if local_run.is_parallel_safe() => continue,

        CommandRunner::LocalRun(local_run) if local_run.interactive_enabled() => {

          return Err(anyhow::anyhow!(

            "Interactive local commands cannot be run in parallel"

          ))

          return Err(anyhow::anyhow!(

            "Local commands with `retrigger: true` cannot be run in parallel"

          ))

    Ok(())

  }

  fn execute_commands_parallel(&self, context: &TaskContext) -> anyhow::Result<()> {

    context.clear_cancellation();

    let (tx, rx): (Sender<CommandResult>, Receiver<CommandResult>) = channel();

    let mut handles = vec![];

    let command_count = self.commands.len();

    let max_parallel = self.max_parallel().min(command_count.max(1));

    let fail_fast = self.fail_fast();

    let command_pb = context.multi.add(ProgressBar::new(command_count as u64));

    command_pb.set_style(ProgressStyle::with_template(

      "{spinner:.green} [{prefix:.bold.dim}] {wide_msg:.cyan/blue} ",

    command_pb.set_prefix("?/?");

    command_pb.set_message("Running task commands in parallel...");

    command_pb.enable_steady_tick(Duration::from_millis(80));

    let mut failures = Vec::new();

    let commands: Vec<_> = self.commands.to_vec();

    let mut completed = 0;

    let mut iter = commands.into_iter().enumerate();

    let mut running = 0usize;

    let mut stop_scheduling = false;

    while completed < command_count {

      while !stop_scheduling && running < max_parallel {

        let Some((i, command)) = iter.next() else {

          break;

        let tx = tx.clone();

        let context = context.clone();

        let handle = thread::spawn(move || {

          let result = match command.execute_cancellable(&context) {

            Ok(_) => CommandResult {

              index: i,

              success: true,

              message: format!("Command {} completed successfully", i + 1),

            },

          tx.send(result).unwrap();

        });

        handles.push(handle);

        running += 1;

      if running == 0 {

      }

      match rx.recv() {

        Ok(result) => {

          running -= 1;

          let index = result.index;

          if !result.success && !context.ignore_errors() {

          }

          completed += 1;

          command_pb.set_prefix(format!("{}/{}", completed, command_count));

          command_pb.inc(1);

          command_pb.set_message(format!(

            index + 1

    for handle in handles {

      handle.join().unwrap();

    }

    context.clear_cancellation();

    if !failures.is_empty() {

    }

    let message = "Commands completed in parallel";

    if context.is_nested {

    } else {

      command_pb.finish_with_message(message);

    }

    Ok(())

  }

  fn load_static_env(&self, context: &TaskContext) -> anyhow::Result<HashMap<String, String>> {

    let mut local_env: HashMap<String, String> = HashMap::new();

    for (key, value) in &self.environment {

    Ok(local_env)

  }

  fn refresh_output_env(&self, context: &mut TaskContext) -> anyhow::Result<()> {

    let mut updated_env = HashMap::new();

    for (key, value) in &self.environment {

    context.extend_env_vars(updated_env);

    Ok(())

  }

  fn load_env_file(&self, context: &TaskContext) -> anyhow::Result<HashMap<String, String>> {

    load_env_files_in_dir(&self.env_file, &self.config_base_dir(context))

  }

  fn load_secret_env(&self, context: &TaskContext) -> anyhow::Result<HashMap<String, String>> {

    let secret_config = context

      .secret_config

      .as_ref()

      .ok_or_else(|| anyhow::anyhow!("Secret config missing from task context"))?;

    load_secret_env(secret_config)

  }

  pub(crate) fn execution_mode(&self) -> ExecutionMode {

    self

      .execution

      .as_ref()

      .and_then(|execution| execution.mode.clone())

      .or_else(|| {

        self.parallel.map(|parallel| {

          if parallel {

            ExecutionMode::Parallel

        })

      })

      .unwrap_or(ExecutionMode::Sequential)

  }

  pub(crate) fn is_parallel(&self) -> bool {

    self.execution_mode().is_parallel()

  }

  pub(crate) fn max_parallel(&self) -> usize {

    self

      .execution

      .as_ref()

      .and_then(|execution| execution.max_parallel)

      .unwrap_or(self.commands.len().max(1))

  }

  pub(crate) fn fail_fast(&self) -> bool {

    self

      .execution

      .as_ref()

      .map(|execution| execution.fail_fast)

      .unwrap_or(true)

  }

  fn cache_enabled(&self) -> bool {

    self.cache.as_ref().map(|cache| cache.enabled).unwrap_or(false)

  }

  fn should_skip_from_cache(&self, context: &TaskContext) -> anyhow::Result<bool> {

    if context.force || !self.cache_enabled() || self.outputs.is_empty() {

      return Ok(false);

  }

  fn update_cache(&self, context: &TaskContext) -> anyhow::Result<()> {

    if !self.cache_enabled() || self.outputs.is_empty() {

      return Ok(());

  }

  pub(crate) fn config_base_dir_from_root(&self, root: &super::TaskRoot) -> std::path::PathBuf {

    root.config_base_dir()

  }

  pub(crate) fn task_base_dir_from_root(&self, root: &super::TaskRoot) -> std::path::PathBuf {

    let config_base_dir = self.config_base_dir_from_root(root);

    let mut work_dirs = self

      .commands

      .iter()

      .filter_map(|command| match command {

        CommandRunner::LocalRun(local_run) => local_run.work_dir.as_ref(),

        _ => None,

      })

      .map(|work_dir| resolve_path(&config_base_dir, work_dir))

      .collect::<Vec<_>>();

    work_dirs.sort();

    work_dirs.dedup();

    if work_dirs.len() == 1 {

      config_base_dir

  }

  fn config_base_dir(&self, context: &TaskContext) -> std::path::PathBuf {

    self.config_base_dir_from_root(&context.task_root)

  }

  fn is_parallel(&self) -> bool {

    matches!(self, ExecutionMode::Parallel)

  }

fn stable_task_fingerprint(task: &TaskArgs) -> String {

  let mut labels: Vec<_> = task

    .labels

    .iter()

    .map(|(key, value)| (key.clone(), value.clone()))

    .collect();

  labels.sort();

  let mut environment: Vec<_> = task

    .environment

    .iter()

    .map(|(key, value)| (key.clone(), value.clone()))

    .collect();

  environment.sort();

  let mut secrets_path = task.secrets_path.clone();

  secrets_path.sort();

  let mut out = String::new();

  write_section(&mut out, "commands", stable_commands_fingerprint(&task.commands));

  write_section(

    &mut out,

    "preconditions",

    stable_preconditions_fingerprint(&task.preconditions),

  write_section(

    &mut out,

    "depends_on",

    stable_dependencies_fingerprint(&task.depends_on),

  write_section(&mut out, "labels", stable_string_pairs_fingerprint(&labels));

  write_section(&mut out, "description", json_value(&task.description));

  write_section(

    &mut out,

    "environment",

    stable_string_pairs_fingerprint(&environment),

  write_section(&mut out, "env_file", stable_strings_fingerprint(&task.env_file));

  write_section(

    &mut out,

    "secrets",

    stable_secret_settings_fingerprint(task.normalized_secret_settings().as_ref()),

  write_section(&mut out, "shell", stable_shell_fingerprint(task.shell.as_ref()));

  write_section(

    &mut out,

    "execution_mode",

    json_value(&execution_mode_name(&task.execution_mode())),

  write_section(

    &mut out,

    "max_parallel",

    json_option_usize(

      task

        .execution

        .as_ref()

        .and_then(|execution| execution.max_parallel),

  write_section(&mut out, "fail_fast", json_bool(task.fail_fast()));

  write_section(&mut out, "cache_enabled", json_bool(task.cache_enabled()));

  write_section(&mut out, "inputs", stable_strings_fingerprint(&task.inputs));

  write_section(&mut out, "outputs", stable_strings_fingerprint(&task.outputs));

  write_section(&mut out, "ignore_errors", json_option_bool(task.ignore_errors));

  write_section(&mut out, "verbose", json_option_bool(task.verbose));

  write_section(

    &mut out,

    "legacy_secrets_path",

    stable_strings_fingerprint(&secrets_path),

  out

}

fn write_section(out: &mut String, name: &str, value: String) {

  let _ = write!(out, "{name}={value};");

}

fn stable_commands_fingerprint(commands: &[CommandRunner]) -> String {

  let values = commands

    .iter()

    .map(stable_command_fingerprint)

    .collect::<Vec<_>>();

  json_value(&values)

}

fn stable_command_fingerprint(command: &CommandRunner) -> String {

  match command {

    CommandRunner::LocalRun(local_run) => format!(

      json_value(&local_run.command),

      stable_shell_fingerprint(local_run.shell.as_ref()),

      json_option_string(local_run.test.as_ref()),

      json_option_string(local_run.work_dir.as_ref()),

      json_option_bool(local_run.interactive),

      json_option_bool(local_run.retrigger),

      json_option_bool(local_run.ignore_errors),

      json_option_string(local_run.save_output_as.as_ref()),

      json_option_bool(local_run.verbose),

}

fn stable_preconditions_fingerprint(preconditions: &[Precondition]) -> String {

  let values = preconditions

    .iter()

    .map(|precondition| {

    .collect::<Vec<_>>();

  json_value(&values)

}

fn stable_dependencies_fingerprint(dependencies: &[TaskDependency]) -> String {

  let values = dependencies

    .iter()

    .map(|dependency| dependency.resolve_name().to_string())

    .collect::<Vec<_>>();

  json_value(&values)

}

fn stable_string_pairs_fingerprint(values: &[(String, String)]) -> String {

  let values = values

    .iter()

    .map(|(key, value)| format!("{}={}", json_value(key), json_value(value)))

    .collect::<Vec<_>>();

  json_value(&values)

}

fn stable_strings_fingerprint(values: &[String]) -> String {

  json_value(values)

}

fn stable_secret_settings_fingerprint(settings: Option<&SecretSettings>) -> String {

  let Some(settings) = settings else {

    return "null".to_string();

  format!(

    json_option_string(settings.backend.as_ref().map(|backend| match backend {

      crate::secrets::SecretBackend::BuiltInPgp => "built_in_pgp",

    })),

    json_option_string(settings.vault_location.as_ref()),

    json_option_string(settings.keys_location.as_ref()),

    json_option_string(settings.key_name.as_ref()),

    json_option_string(settings.gpg_key_id.as_ref()),

    json_option_vec_strings(settings.secrets_path.as_ref()),

}

fn stable_shell_fingerprint(shell: Option<&Shell>) -> String {

  match shell {

    None => "null".to_string(),

    Some(Shell::String(command)) => format!("string:{}", json_value(command)),

}

fn execution_mode_name(mode: &ExecutionMode) -> &'static str {

  match mode {

    ExecutionMode::Sequential => "sequential",

    ExecutionMode::Parallel => "parallel",

}

fn json_value<T: Serialize + ?Sized>(value: &T) -> String {

  serde_json::to_string(value).expect("task fingerprint serialization should succeed")

}

fn json_bool(value: bool) -> String {

  json_value(&value)

}

fn json_option_bool(value: Option<bool>) -> String {

  json_value(&value)

}

fn json_option_usize(value: Option<usize>) -> String {

  json_value(&value)

}

fn json_option_string(value: Option<impl AsRef<str>>) -> String {

  json_value(&value.as_ref().map(|value| value.as_ref().to_string()))

}

fn json_option_vec_strings(value: Option<&Vec<String>>) -> String {

  json_value(&value.cloned())

}

  fn test_task_1() -> anyhow::Result<()> {

      let yaml = "

        commands:

          - command: echo \"Hello, World!\"

            ignore_errors: false

            verbose: false

        depends_on:

          - name: task1

        description: This is a task

        environment:

          FOO: bar

        env_file:

          - test.env

          - test2.env

      ";

      let task = serde_yaml::from_str::<Task>(yaml)?;

      if let Task::Task(task) = &task {

        if let CommandRunner::LocalRun(local_run) = &task.commands[0] {

          assert_eq!(local_run.command, "echo \"Hello, World!\"");

          assert_eq!(local_run.work_dir, None);

          assert_eq!(local_run.ignore_errors, Some(false));

          assert_eq!(local_run.verbose, Some(false));

        if let TaskDependency::TaskDependency(args) = &task.depends_on[0] {

          assert_eq!(args.name, "task1");

        assert_eq!(task.labels.len(), 0);

        assert_eq!(task.description, "This is a task");

        assert_eq!(task.environment.len(), 1);

        assert_eq!(task.env_file.len(), 2);

      Ok(())

  }

  fn test_task_2() -> anyhow::Result<()> {

      let yaml = "

        commands:

          - command: echo 'Hello, World!'

            ignore_errors: false

            verbose: false

        description: This is a task

        environment:

          FOO: bar

          BAR: foo

      ";

      let task = serde_yaml::from_str::<Task>(yaml)?;

      if let Task::Task(task) = &task {

        if let CommandRunner::LocalRun(local_run) = &task.commands[0] {

          assert_eq!(local_run.command, "echo 'Hello, World!'");

          assert_eq!(local_run.work_dir, None);

          assert_eq!(local_run.ignore_errors, Some(false));

          assert_eq!(local_run.verbose, Some(false));

        assert_eq!(task.description, "This is a task");

        assert_eq!(task.depends_on.len(), 0);

        assert_eq!(task.labels.len(), 0);

        assert_eq!(task.env_file.len(), 0);

        assert_eq!(task.environment.len(), 2);

      Ok(())

  }

  fn test_task_3() -> anyhow::Result<()> {

      let yaml = "

        commands:

          - command: echo 'Hello, World!'

      ";

      let task = serde_yaml::from_str::<Task>(yaml)?;

      if let Task::Task(task) = &task {

        if let CommandRunner::LocalRun(local_run) = &task.commands[0] {

          assert_eq!(local_run.command, "echo 'Hello, World!'");

          assert_eq!(local_run.work_dir, None);

          assert_eq!(local_run.ignore_errors, None);

          assert_eq!(local_run.verbose, None);

        assert_eq!(task.description.len(), 0);

        assert_eq!(task.depends_on.len(), 0);

        assert_eq!(task.labels.len(), 0);

        assert_eq!(task.env_file.len(), 0);

        assert_eq!(task.environment.len(), 0);

      Ok(())

  }

  fn test_task_4() -> anyhow::Result<()> {

      let yaml = "

        commands:

          - container_command:

              - echo

              - Hello, World!

            image: docker.io/library/hello-world:latest

      ";

      let task = serde_yaml::from_str::<Task>(yaml)?;

      if let Task::Task(task) = &task {

        if let CommandRunner::ContainerRun(container_run) = &task.commands[0] {

          assert_eq!(container_run.container_command.len(), 2);

          assert_eq!(container_run.container_command[0], "echo");

          assert_eq!(container_run.container_command[1], "Hello, World!");

          assert_eq!(container_run.image, "docker.io/library/hello-world:latest");

          assert_eq!(container_run.mounted_paths, Vec::<String>::new());

          assert_eq!(container_run.ignore_errors, None);

          assert_eq!(container_run.verbose, None);

        assert_eq!(task.description.len(), 0);

        assert_eq!(task.depends_on.len(), 0);

        assert_eq!(task.labels.len(), 0);

        assert_eq!(task.env_file.len(), 0);

        assert_eq!(task.environment.len(), 0);

      Ok(())

  }

  fn test_task_5() -> anyhow::Result<()> {

      let yaml = "

        commands:

          - container_command:

              - echo

              - Hello, World!

            image: docker.io/library/hello-world:latest

            mounted_paths:

              - /tmp

              - /var/tmp

      ";

      let task = serde_yaml::from_str::<Task>(yaml)?;

      if let Task::Task(task) = &task {

        if let CommandRunner::ContainerRun(container_run) = &task.commands[0] {

          assert_eq!(container_run.container_command.len(), 2);

          assert_eq!(container_run.container_command[0], "echo");

          assert_eq!(container_run.container_command[1], "Hello, World!");

          assert_eq!(container_run.image, "docker.io/library/hello-world:latest");

          assert_eq!(container_run.mounted_paths, vec!["/tmp", "/var/tmp"]);

          assert_eq!(container_run.ignore_errors, None);

          assert_eq!(container_run.verbose, None);

        assert_eq!(task.description.len(), 0);

        assert_eq!(task.depends_on.len(), 0);

        assert_eq!(task.labels.len(), 0);

        assert_eq!(task.env_file.len(), 0);

        assert_eq!(task.environment.len(), 0);

      Ok(())

  }

  fn test_task_6() -> anyhow::Result<()> {

      let yaml = "

        commands:

          - container_command:

              - echo

              - Hello, World!

            image: docker.io/library/hello-world:latest

            mounted_paths:

              - /tmp

              - /var/tmp

            ignore_errors: true

      ";

      let task = serde_yaml::from_str::<Task>(yaml)?;

      if let Task::Task(task) = &task {

        if let CommandRunner::ContainerRun(container_run) = &task.commands[0] {

          assert_eq!(container_run.container_command.len(), 2);

          assert_eq!(container_run.container_command[0], "echo");

          assert_eq!(container_run.container_command[1], "Hello, World!");

          assert_eq!(container_run.image, "docker.io/library/hello-world:latest");

          assert_eq!(container_run.mounted_paths, vec!["/tmp", "/var/tmp"]);

          assert_eq!(container_run.ignore_errors, Some(true));

          assert_eq!(container_run.verbose, None);

        assert_eq!(task.description.len(), 0);

        assert_eq!(task.depends_on.len(), 0);

        assert_eq!(task.labels.len(), 0);

        assert_eq!(task.env_file.len(), 0);

        assert_eq!(task.environment.len(), 0);