use crate::depth_check::depths;

        let pdb = db.clone();

        // If this task fails the worst that will happen is I compare more
        // names than I otherwise would. .
        let check =
            tokio::spawn(async move {
                let prefs =
                    pdb.list_preferences().await.unwrap_or_else(|_| Vec::new());
                tokio::task::spawn_blocking(move || {
                    depths(prefs.into_iter().map(|(better, worse)| {
                        (better as usize, worse as usize)
                    }))
                })
                .await
                .unwrap_or_else(|_| Vec::new())
            });

            for name in db
                .list_names()
                .await
                .ok()
                .into_iter()
                .flat_map(Vec::into_iter)
            {
                match ntx.send(name).await {
                    Ok(_) => (),
                    Err(_) => break,

            let names = db.list_names().await;
            let depth_list = check.await.unwrap_or_else(|_| Vec::new());
            for name in names.ok().into_iter().flat_map(Vec::into_iter) {
                if depth_list.get(name.1 as usize).cloned().unwrap_or(0)
                    < count.into()
                {
                    match ntx.send(name).await {
                        Ok(_) => (),
                        Err(_) => break,
                    }

        let pivot: *mut IDedName =
            unsafe { i.offset(j.offset_from(i) / 2) };

        let pivot: *mut IDedName = unsafe { i.offset(j.offset_from(i) / 2) };

mod depth_check;

pub fn depths<I: IntoIterator<Item = (usize, usize)>>(
    preferences: I,
) -> Vec<usize> {
    let mut workspace = Vec::new();
    let mut result = Vec::new();
    for (better, worse) in preferences {
        while workspace.len() <= worse {
            workspace.push(Vec::new());
            result.push(0);
        }
        workspace[worse].push(better);
    }
    let mut stack: Vec<(usize, Option<usize>)> =
        (0..workspace.len()).rev().map(|x| (x, None)).collect();
    while let Some((i, r)) = stack.pop() {
        let d = std::mem::take(&mut workspace[i]);
        if !d.is_empty() {
            stack.push((i, r));
            for j in d {
                stack.push((j, Some(i)));
            }
        } else if let Some(s) = r {
            result[s] = result[s].max(result[i] + 1);
        }
    }
    result
}