use std::collections::{HashMap, VecDeque};
use indexmap::IndexMap;
use crate::interview::{
AnswerError, CheckError, Completed, Ended, EvalError, Interview, Item, Pending, RawAnswer,
RawAnswers, Rejections, Seed,
};
use crate::template::{Id, Template};
#[allow(clippy::large_enum_variant)]
pub(crate) enum Replay<'a> {
Completed {
completed: Completed,
submissions: Vec<IndexMap<Id, RawAnswer>>,
},
Ask {
pending: Box<Pending<'a>>,
rejections: Rejections,
submissions: Vec<IndexMap<Id, RawAnswer>>,
},
Ended(Ended),
}
fn build_queue(recorded: &[IndexMap<Id, RawAnswer>]) -> HashMap<Id, VecDeque<RawAnswer>> {
let mut queue: HashMap<Id, VecDeque<RawAnswer>> = HashMap::new();
for submission in recorded {
for (id, raw) in submission {
queue.entry(id.clone()).or_default().push_back(raw.clone());
}
}
queue
}
fn consume_staged(
queue: &mut HashMap<Id, VecDeque<RawAnswer>>,
staged_sub: &IndexMap<Id, RawAnswer>,
) {
for id in staged_sub.keys() {
if let Some(values) = queue.get_mut(id) {
values.pop_front();
}
}
}
pub(crate) fn replay<'a>(
template: &'a Template,
mut seed: Seed,
recorded: &[IndexMap<Id, RawAnswer>],
overrides: RawAnswers,
reanswer: bool,
) -> Result<Replay<'a>, EvalError> {
let presets = seed.defaults.clone();
let mut queue = build_queue(recorded);
for (id, raw) in &overrides {
queue.insert(id.clone(), VecDeque::from([raw.clone()]));
}
for (id, raw) in &presets {
queue
.entry(id.clone())
.or_insert_with(|| VecDeque::from([raw.clone()]));
}
for submission in recorded {
for (id, raw) in submission {
seed.defaults.insert(id.clone(), raw.clone());
}
}
for (id, raw) in overrides {
seed.defaults.insert(id, raw);
}
let interview = Interview::start(template, seed)?;
drive_from_queue(interview, queue, reanswer, Vec::new())
}
pub(crate) fn replay_resume<'a>(
template: &'a Template,
mut seed: Seed,
recorded: &[IndexMap<Id, RawAnswer>],
staged: &[IndexMap<Id, RawAnswer>],
reanswer: bool,
) -> Result<Replay<'a>, EvalError> {
let presets = seed.defaults.clone();
let mut queue = build_queue(recorded);
for (id, raw) in &presets {
queue
.entry(id.clone())
.or_insert_with(|| VecDeque::from([raw.clone()]));
}
for submission in recorded {
for (id, raw) in submission {
seed.defaults.insert(id.clone(), raw.clone());
}
}
let mut interview = Interview::start(template, seed)?;
let mut submissions = Vec::new();
for staged_sub in staged {
let pending = match interview {
Interview::Asking(pending) => pending,
other => {
interview = other;
break;
}
};
consume_staged(&mut queue, staged_sub);
interview = match pending.answer(staged_sub.clone()) {
Ok(next) => {
submissions.push(staged_sub.clone());
next
}
Err(AnswerError::Rejected {
pending,
rejections,
}) => {
return Ok(Replay::Ask {
pending: Box::new(pending),
rejections,
submissions,
});
}
Err(AnswerError::Eval(error)) => return Err(error),
};
}
drive_from_queue(interview, queue, reanswer, submissions)
}
fn drive_from_queue<'a>(
mut interview: Interview<'a>,
mut queue: HashMap<Id, VecDeque<RawAnswer>>,
reanswer: bool,
mut submissions: Vec<IndexMap<Id, RawAnswer>>,
) -> Result<Replay<'a>, EvalError> {
loop {
let pending = match interview {
Interview::Complete(completed) => {
return Ok(Replay::Completed {
completed,
submissions,
});
}
Interview::Ended(ended) => return Ok(Replay::Ended(ended)),
Interview::Asking(pending) => pending,
};
if reanswer {
return Ok(Replay::Ask {
pending: Box::new(pending),
rejections: Vec::new(),
submissions,
});
}
let prompts: Vec<(Id, bool)> = pending
.batch()
.items
.iter()
.filter_map(|item| match item {
Item::Prompt(prompt) => Some((prompt.id.clone(), prompt.constraints.required)),
Item::Message(_) => None,
})
.collect();
let mut raw: RawAnswers = IndexMap::new();
let mut rejections = Rejections::new();
let mut complete = true;
for (id, required) in &prompts {
match queue.get(id).and_then(|values| values.front()).cloned() {
Some(value) => match pending.check(id, value.clone()) {
Ok(_) => {
raw.insert(id.clone(), value);
}
Err(CheckError::Rejected(rejection)) => {
rejections.push(rejection);
if let Some(values) = queue.get_mut(id) {
values.pop_front();
}
if *required {
complete = false;
}
}
Err(CheckError::Eval(error)) => return Err(error),
},
None => {
if *required {
complete = false;
}
}
}
}
if !complete {
return Ok(Replay::Ask {
pending: Box::new(pending),
rejections,
submissions,
});
}
for id in raw.keys() {
if let Some(values) = queue.get_mut(id) {
values.pop_front();
}
}
match pending.answer(raw.clone()) {
Ok(next) => {
submissions.push(raw);
interview = next;
}
Err(AnswerError::Rejected {
pending,
rejections,
}) => {
return Ok(Replay::Ask {
pending: Box::new(pending),
rejections,
submissions,
});
}
Err(AnswerError::Eval(error)) => return Err(error),
}
}
}
#[allow(clippy::large_enum_variant)]
pub enum UpdateDrive<'a> {
Completed {
completed: Completed,
submissions: Vec<IndexMap<Id, RawAnswer>>,
},
Ask {
pending: Pending<'a>,
rejections: Rejections,
submissions: Vec<IndexMap<Id, RawAnswer>>,
},
Ended(Ended),
}
pub fn drive_update<'a>(
template: &'a Template,
seed: Seed,
recorded: &[IndexMap<Id, RawAnswer>],
overrides: RawAnswers,
reanswer: bool,
) -> Result<UpdateDrive<'a>, EvalError> {
Ok(
match replay(template, seed, recorded, overrides, reanswer)? {
Replay::Completed {
completed,
submissions,
} => UpdateDrive::Completed {
completed,
submissions,
},
Replay::Ask {
pending,
rejections,
submissions,
} => UpdateDrive::Ask {
pending: *pending,
rejections,
submissions,
},
Replay::Ended(ended) => UpdateDrive::Ended(ended),
},
)
}
pub fn drive_update_resume<'a>(
template: &'a Template,
seed: Seed,
recorded: &[IndexMap<Id, RawAnswer>],
staged: &[IndexMap<Id, RawAnswer>],
reanswer: bool,
) -> Result<UpdateDrive<'a>, EvalError> {
Ok(
match replay_resume(template, seed, recorded, staged, reanswer)? {
Replay::Completed {
completed,
submissions,
} => UpdateDrive::Completed {
completed,
submissions,
},
Replay::Ask {
pending,
rejections,
submissions,
} => UpdateDrive::Ask {
pending: *pending,
rejections,
submissions,
},
Replay::Ended(ended) => UpdateDrive::Ended(ended),
},
)
}
#[cfg(test)]
mod tests;