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,
seed: Seed,
recorded: &[IndexMap<Id, RawAnswer>],
overrides: RawAnswers,
reanswer: bool,
) -> Result<Replay<'a>, EvalError> {
replay_resume_with_overrides(template, seed, recorded, &[], &overrides, reanswer)
}
fn update_queue(
recorded: &[RawAnswers],
overrides: &RawAnswers,
presets: &RawAnswers,
) -> HashMap<Id, VecDeque<RawAnswer>> {
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()]));
}
queue
}
pub(crate) fn replay_resume<'a>(
template: &'a Template,
seed: Seed,
recorded: &[RawAnswers],
staged: &[RawAnswers],
reanswer: bool,
) -> Result<Replay<'a>, EvalError> {
replay_resume_with_overrides(
template,
seed,
recorded,
staged,
&RawAnswers::new(),
reanswer,
)
}
fn replay_resume_with_overrides<'a>(
template: &'a Template,
mut seed: Seed,
recorded: &[RawAnswers],
staged: &[RawAnswers],
overrides: &RawAnswers,
reanswer: bool,
) -> Result<Replay<'a>, EvalError> {
let mut queue = update_queue(recorded, overrides, &seed.defaults);
for submission in recorded {
seed.defaults.extend(submission.clone());
}
seed.defaults.extend(overrides.clone());
let mut interview = Interview::start(template, seed)?;
let mut submissions = Vec::new();
for staged_sub in staged {
let replayed: RawAnswers = staged_sub.iter().filter(|(id, _)| {
!matches!(template.question(id).map(|q| &q.kind), Some(crate::template::QuestionKind::Document { contract }) if contract.admitted().is_some())
}).map(|(id, raw)| (id.clone(), raw.clone())).collect();
if !staged_sub.is_empty() && replayed.is_empty() {
submissions.push(staged_sub.clone());
continue;
}
let pending = match interview {
Interview::Asking(pending) => pending,
other => {
interview = other;
break;
}
};
consume_staged(&mut queue, staged_sub);
interview = match pending.answer(replayed) {
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,
template.part_question().map(|q| &q.id),
reanswer,
submissions,
)
}
fn drive_from_queue<'a>(
mut interview: Interview<'a>,
mut queue: HashMap<Id, VecDeque<RawAnswer>>,
part_question: Option<&Id>,
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 || part_question == Some(&prompt.id),
)),
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> {
into_update_drive(replay_resume(template, seed, recorded, staged, reanswer))
}
pub(crate) fn drive_update_resume_with_overrides<'a>(
template: &'a Template,
seed: Seed,
recorded: &[RawAnswers],
staged: &[RawAnswers],
overrides: &RawAnswers,
reanswer: bool,
) -> Result<UpdateDrive<'a>, EvalError> {
into_update_drive(replay_resume_with_overrides(
template, seed, recorded, staged, overrides, reanswer,
))
}
fn into_update_drive(result: Result<Replay<'_>, EvalError>) -> Result<UpdateDrive<'_>, EvalError> {
Ok(match result? {
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;
pub(crate) fn covered_answers(
pending: &Pending<'_>,
recorded: &[RawAnswers],
accepted: &[RawAnswers],
overrides: &RawAnswers,
presets: &RawAnswers,
reanswer: bool,
) -> Result<RawAnswers, EvalError> {
if reanswer {
return Ok(RawAnswers::new());
}
let mut queue = update_queue(recorded, overrides, presets);
for submission in accepted {
consume_staged(&mut queue, submission);
}
let mut covered = RawAnswers::new();
for item in &pending.batch().items {
let Item::Prompt(prompt) = item else {
continue;
};
let Some(raw) = queue
.get(&prompt.id)
.and_then(|values| values.front())
.cloned()
else {
continue;
};
match pending.check(&prompt.id, raw.clone()) {
Ok(_) => {
covered.insert(prompt.id.clone(), raw);
}
Err(CheckError::Rejected(_)) => {}
Err(CheckError::Eval(error)) => return Err(error),
}
}
Ok(covered)
}