use super::{Held, Tasks};
use crate::state_unit::StateUnit;
use crate::timing::SEARCH_DEBOUNCE;
use futures_core::Stream;
use serde::Serialize;
use std::future::{pending, poll_fn};
use std::pin::Pin;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::watch;
use tokio::time::Instant;
#[derive(Debug, Clone, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SearchState<T> {
pub results: Vec<T>,
pub is_searching: bool,
}
impl<T> SearchState<T> {
fn of(results: Vec<T>, is_searching: bool) -> SearchState<T> {
SearchState {
results,
is_searching,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SearchPipelineOptions {
pub debounce: Duration,
pub initial_query: String,
}
impl Default for SearchPipelineOptions {
fn default() -> SearchPipelineOptions {
SearchPipelineOptions {
debounce: SEARCH_DEBOUNCE,
initial_query: String::new(),
}
}
}
type Answers<T> = Pin<Box<dyn Stream<Item = Option<Vec<T>>> + Send>>;
struct Shared<T> {
query: Held<String>,
state: Held<SearchState<T>>,
tasks: Tasks,
}
pub struct SearchPipeline<T> {
shared: Arc<Shared<T>>,
}
impl<T: Clone + PartialEq + Send + Sync + 'static> SearchPipeline<T> {
pub fn new<F, S>(search: F, options: SearchPipelineOptions) -> SearchPipeline<T>
where
F: Fn(&str) -> S + Send + 'static,
S: Stream<Item = Option<Vec<T>>> + Send + 'static,
{
let shared = Arc::new(Shared {
query: Held::new(options.initial_query),
state: Held::new(SearchState::of(Vec::new(), false)),
tasks: Tasks::new(),
});
shared.tasks.spawn(run(
shared.clone(),
move |query: &str| -> Answers<T> { Box::pin(search(query)) },
options.debounce,
));
SearchPipeline { shared }
}
pub fn query(&self) -> watch::Receiver<String> {
self.shared.query.read()
}
pub fn state(&self) -> watch::Receiver<SearchState<T>> {
self.shared.state.read()
}
pub fn set_query(&self, value: &str) {
self.shared.query.set(value.to_owned());
}
}
async fn run<T: Clone + PartialEq + Send + Sync + 'static>(
shared: Arc<Shared<T>>,
search: impl Fn(&str) -> Answers<T> + Send,
debounce: Duration,
) {
let mut query = shared.query.read();
let mut settles = Some(Instant::now() + debounce);
let mut searched: Option<String> = None;
let mut answers: Option<Answers<T>> = None;
loop {
tokio::select! {
biased;
changed = query.changed() => {
if changed.is_err() {
return;
}
settles = Some(Instant::now() + debounce);
}
() = async {
match settles {
Some(at) => tokio::time::sleep_until(at).await,
None => pending().await,
}
} => {
settles = None;
let settled = query.borrow_and_update().clone();
if searched.as_ref() == Some(&settled) {
continue;
}
let wanted = settled.trim().to_owned();
searched = Some(settled);
if wanted.is_empty() {
answers = None;
shared.state.set(SearchState::of(Vec::new(), false));
} else {
shared.state.set(SearchState::of(Vec::new(), true));
answers = Some(search(&wanted));
}
}
answer = async {
match answers.as_mut() {
Some(answers) => poll_fn(|cx| answers.as_mut().poll_next(cx)).await,
None => pending().await,
}
} => match answer {
Some(results) => {
let is_searching = results.is_none();
shared
.state
.set(SearchState::of(results.unwrap_or_default(), is_searching));
}
None => answers = None,
},
}
}
}
impl<T> StateUnit for SearchPipeline<T> {
fn dispose(&self) {
self.shared.tasks.stop();
self.shared.query.end();
self.shared.state.end();
}
}
impl<T> Drop for SearchPipeline<T> {
fn drop(&mut self) {
self.dispose();
}
}