use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use futures_util::future::{FutureExt, Shared};
use tokio::sync::oneshot;
use crate::error::Error;
use crate::lookup::Lookup;
pub(crate) type Flight = Shared<oneshot::Receiver<Arc<Result<Lookup, Error>>>>;
#[derive(Debug, Default)]
pub(crate) struct Flights(Mutex<HashMap<String, Flight>>);
impl Flights {
pub(crate) fn board<'a, 'b>(
&'a self,
ips: impl IntoIterator<Item = &'b str>,
) -> (Pilot<'a>, Vec<(String, Flight)>) {
let mut flights = self.0.lock().expect("flights lock");
let mut led = HashMap::new();
let mut joined = Vec::new();
for ip in ips {
match flights.get(ip) {
Some(flight) => joined.push((ip.to_owned(), flight.clone())),
None => {
let (sender, receiver) = oneshot::channel();
flights.insert(ip.to_owned(), receiver.shared());
led.insert(ip.to_owned(), sender);
}
}
}
(Pilot { flights: self, led }, joined)
}
}
pub(crate) struct Pilot<'a> {
flights: &'a Flights,
led: HashMap<String, oneshot::Sender<Arc<Result<Lookup, Error>>>>,
}
impl Pilot<'_> {
pub(crate) fn leads(&self, ip: &str) -> bool {
self.led.contains_key(ip)
}
pub(crate) fn land(&mut self, ip: &str, answer: &Result<Lookup, Error>) {
if let Some(sender) = self.led.remove(ip) {
self.flights.0.lock().expect("flights lock").remove(ip);
let _ = sender.send(Arc::new(restate(answer)));
}
}
}
impl Drop for Pilot<'_> {
fn drop(&mut self) {
if self.led.is_empty() {
return;
}
let mut flights = self.flights.0.lock().expect("flights lock");
for ip in self.led.keys() {
flights.remove(ip);
}
}
}
pub(crate) fn restate(answer: &Result<Lookup, Error>) -> Result<Lookup, Error> {
match answer {
Ok(lookup) => Ok(lookup.clone()),
Err(err) => Err(err.restated()),
}
}