use std::io::{self, BufRead, IsTerminal, Write};
use std::path::PathBuf;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SiblingBatchChoice {
ProcessInputOnly,
ProcessAllStopOnError,
ProcessAllSkipOnError,
ProcessAllPromptEach,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ContinueChoice {
Yes,
No,
YesToAll,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ExecutionMode {
Sequential,
Parallel,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CleanupChoice {
Remove,
Keep,
}
#[allow(dead_code)]
pub fn parse_yes_no(value: &str, default: bool) -> bool {
match value.trim().to_ascii_lowercase().as_str() {
"y" | "yes" => true,
"n" | "no" => false,
_ => default,
}
}
pub fn parse_choice(value: &str, choices: usize, default: usize) -> usize {
value
.trim()
.parse::<usize>()
.ok()
.filter(|n| (1..=choices).contains(n))
.unwrap_or(default)
}
pub fn choice<R: BufRead, W: Write>(
input: &mut R,
output: &mut W,
question: &str,
options: &[&str],
default: usize,
) -> io::Result<usize> {
if !io::stdin().is_terminal() {
writeln!(output, "{question}")?;
writeln!(
output,
" ⚙️ Non-interactive mode detected. Auto-selecting default: {default}"
)?;
return Ok(default);
}
writeln!(output, "{question}")?;
for (index, option) in options.iter().enumerate() {
writeln!(output, " {}. {option}", index + 1)?;
}
write!(output, "Choice [{default}]: ")?;
output.flush()?;
let mut line = String::new();
input.read_line(&mut line)?;
Ok(parse_choice(&line, options.len(), default))
}
pub fn sibling_batch_choice<R: BufRead, W: Write>(
input: &mut R,
output: &mut W,
directory: &std::path::Path,
count: usize,
) -> io::Result<SiblingBatchChoice> {
const DEFAULT: SiblingBatchChoice = SiblingBatchChoice::ProcessAllPromptEach;
if !io::stdin().is_terminal() {
writeln!(
output,
"Found {count} MP4 videos in {}",
directory.display()
)?;
writeln!(
output,
" ⚙️ Non-interactive mode detected. Processing the supplied video only."
)?;
return Ok(SiblingBatchChoice::ProcessInputOnly);
}
writeln!(
output,
"Found {count} MP4 videos in {}",
directory.display()
)?;
writeln!(output, "How would you like to proceed?")?;
writeln!(output, " 1. Process the input only")?;
writeln!(
output,
" 2. Process the whole path (return on error, report at the end)"
)?;
writeln!(
output,
" 3. Process the whole path (skip on error, report at the end)"
)?;
writeln!(
output,
" 4. Process the whole path (prompt user on each new video)"
)?;
write!(output, "Choice [4]: ")?;
output.flush()?;
let mut line = String::new();
input.read_line(&mut line)?;
Ok(parse_sibling_choice(&line, DEFAULT))
}
pub fn continue_to_next<R: BufRead, W: Write>(
input: &mut R,
output: &mut W,
next: &std::path::Path,
) -> io::Result<ContinueChoice> {
const DEFAULT: ContinueChoice = ContinueChoice::Yes;
if !io::stdin().is_terminal() {
writeln!(output, "Next video: {}", next.display())?;
writeln!(
output,
" ⚙️ Non-interactive mode detected. Continuing with all remaining videos."
)?;
return Ok(ContinueChoice::YesToAll);
}
writeln!(output, "Next video: {}", next.display())?;
writeln!(output, "Continue?")?;
writeln!(output, " 1. yes")?;
writeln!(output, " 2. no")?;
writeln!(output, " 3. yes to all")?;
write!(output, "Choice [1]: ")?;
output.flush()?;
let mut line = String::new();
input.read_line(&mut line)?;
Ok(parse_continue(&line, DEFAULT))
}
pub fn execution_mode_choice<R: BufRead, W: Write>(
input: &mut R,
output: &mut W,
file_count: usize,
cores: usize,
) -> io::Result<ExecutionMode> {
if !io::stdin().is_terminal() {
writeln!(
output,
"Found {file_count} files. Non-interactive mode: defaulting to sequential."
)?;
return Ok(ExecutionMode::Sequential);
}
writeln!(output, "Found {file_count} files to process.")?;
writeln!(output, "How would you like to run them?")?;
writeln!(output, " 1. Parallel (using {cores} cores)")?;
writeln!(output, " 2. Sequential (one by one)")?;
write!(output, "Choice [1]: ")?;
output.flush()?;
let mut line = String::new();
input.read_line(&mut line)?;
Ok(match line.trim().to_ascii_lowercase().as_str() {
"" | "1" | "parallel" => ExecutionMode::Parallel,
"2" | "sequential" | "seq" => ExecutionMode::Sequential,
_ => ExecutionMode::Parallel,
})
}
pub fn cleanup_residual_choice<R: BufRead, W: Write>(
input: &mut R,
output: &mut W,
residual_files: &[PathBuf],
) -> io::Result<CleanupChoice> {
if residual_files.is_empty() {
return Ok(CleanupChoice::Keep);
}
if !io::stdin().is_terminal() {
writeln!(
output,
"Cancelled batch left {} partial files. Keeping them.",
residual_files.len()
)?;
return Ok(CleanupChoice::Keep);
}
writeln!(
output,
"Cancelled batch left {} partial files:",
residual_files.len()
)?;
for path in residual_files.iter().take(10) {
writeln!(output, " • {}", path.display())?;
}
if residual_files.len() > 10 {
writeln!(output, " ... and {} more", residual_files.len() - 10)?;
}
writeln!(output, "Remove these files?")?;
writeln!(output, " 1. Yes, remove them")?;
writeln!(output, " 2. No, keep them")?;
write!(output, "Choice [1]: ")?;
output.flush()?;
let mut line = String::new();
input.read_line(&mut line)?;
Ok(match line.trim().to_ascii_lowercase().as_str() {
"" | "1" | "y" | "yes" | "remove" => CleanupChoice::Remove,
"2" | "n" | "no" | "keep" => CleanupChoice::Keep,
_ => CleanupChoice::Remove,
})
}
fn parse_sibling_choice(value: &str, default: SiblingBatchChoice) -> SiblingBatchChoice {
let normalized = value.trim().to_ascii_lowercase();
match normalized.as_str() {
"" => default,
"1" | "only" | "input" | "single" => SiblingBatchChoice::ProcessInputOnly,
"2" | "stop" | "error" => SiblingBatchChoice::ProcessAllStopOnError,
"3" | "skip" => SiblingBatchChoice::ProcessAllSkipOnError,
"4" | "prompt" | "ask" | "each" => SiblingBatchChoice::ProcessAllPromptEach,
_ => default,
}
}
fn parse_continue(value: &str, default: ContinueChoice) -> ContinueChoice {
let normalized = value.trim().to_ascii_lowercase();
match normalized.as_str() {
"" => default,
"1" | "y" | "yes" => ContinueChoice::Yes,
"2" | "n" | "no" => ContinueChoice::No,
"3" | "a" | "all" | "yes to all" | "yes-to-all" => ContinueChoice::YesToAll,
_ => default,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parsing_is_safe() {
assert!(parse_yes_no("yes", false));
assert!(!parse_yes_no("?", false));
assert_eq!(parse_choice("9", 3, 2), 2);
}
#[test]
fn parses_sibling_choices() {
let default = SiblingBatchChoice::ProcessAllPromptEach;
assert_eq!(
parse_sibling_choice("1", default),
SiblingBatchChoice::ProcessInputOnly
);
assert_eq!(
parse_sibling_choice("only", default),
SiblingBatchChoice::ProcessInputOnly
);
assert_eq!(
parse_sibling_choice("2", default),
SiblingBatchChoice::ProcessAllStopOnError
);
assert_eq!(
parse_sibling_choice("skip", default),
SiblingBatchChoice::ProcessAllSkipOnError
);
assert_eq!(
parse_sibling_choice("", default),
SiblingBatchChoice::ProcessAllPromptEach
);
assert_eq!(
parse_sibling_choice("wat", default),
SiblingBatchChoice::ProcessAllPromptEach
);
}
#[test]
fn parses_continue_choices() {
let default = ContinueChoice::Yes;
assert_eq!(parse_continue("y", default), ContinueChoice::Yes);
assert_eq!(parse_continue("no", default), ContinueChoice::No);
assert_eq!(
parse_continue("yes to all", default),
ContinueChoice::YesToAll
);
assert_eq!(parse_continue("3", default), ContinueChoice::YesToAll);
assert_eq!(parse_continue("", default), ContinueChoice::Yes);
assert_eq!(parse_continue("??", default), ContinueChoice::Yes);
}
}