use std::collections::{HashMap, HashSet, hash_map::Entry};
use serde_json::{Map, Value};
use super::{FoldOutcome, applied, string};
#[derive(Debug, Default)]
pub(super) struct Requests {
observed: u64,
pub(super) pending: HashMap<String, (u64, Value)>,
pending_by_turn: HashMap<String, HashSet<String>>,
pub(super) resolved: HashMap<String, (u64, Value)>,
}
impl Requests {
pub(super) fn request(&mut self, id: &str, params: &Map<String, Value>) -> bool {
if self.resolved.contains_key(id) {
return false;
}
self.unindex(id);
if let Some(turn_id) = string(params, "turnId") {
self.pending_by_turn
.entry(turn_id.to_owned())
.or_default()
.insert(id.to_owned());
}
let params = Value::Object(params.clone());
match self.pending.entry(id.to_owned()) {
Entry::Occupied(mut slot) => slot.get_mut().1 = params,
Entry::Vacant(slot) => {
slot.insert((self.observed, params));
self.observed += 1;
}
}
true
}
fn unindex(&mut self, id: &str) {
let Some((_, Value::Object(map))) = self.pending.get(id) else {
return;
};
let Some(turn_id) = string(map, "turnId").map(str::to_owned) else {
return;
};
if let Some(ids) = self.pending_by_turn.get_mut(&turn_id) {
ids.remove(id);
if ids.is_empty() {
self.pending_by_turn.remove(&turn_id);
}
}
}
pub(super) fn resolve(&mut self, id: &str, params: &Map<String, Value>) -> bool {
self.unindex(id);
self.pending.remove(id);
match self.resolved.entry(id.to_owned()) {
Entry::Vacant(slot) => {
slot.insert((self.observed, Value::Object(params.clone())));
self.observed += 1;
true
}
Entry::Occupied(_) => false,
}
}
pub(super) fn retire_turn(&mut self, turn_id: &str) {
if let Some(ids) = self.pending_by_turn.remove(turn_id) {
for id in &ids {
self.pending.remove(id);
}
}
}
}
pub(super) fn params_of(entry: Option<&(u64, Value)>) -> Option<&Value> {
entry.map(|(_, params)| params)
}
pub(super) fn in_observed_order(entries: &HashMap<String, (u64, Value)>) -> Vec<&Value> {
let mut ordered: Vec<_> = entries.values().collect();
ordered.sort_unstable_by_key(|(observed, _)| *observed);
ordered.into_iter().map(|(_, params)| params).collect()
}
pub(super) fn request(store: &mut Requests, params: &Map<String, Value>, key: &str) -> FoldOutcome {
applied(string(params, key).is_some_and(|id| store.request(id, params)))
}
pub(super) fn resolve(store: &mut Requests, params: &Map<String, Value>, key: &str) -> FoldOutcome {
string(params, key).map_or(FoldOutcome::Ignored, |id| FoldOutcome::Resolution {
first: store.resolve(id, params),
})
}