use std::{    path::{Path, PathBuf},    sync::{Arc, OnceLock},    time::Duration,}; use notify::{Config, RecommendedWatcher, Watcher};use parking_lot::Mutex; use crate::{Event, StreamFlags}; pub struct EventStream {    watcher: Arc<Mutex<RecommendedWatcher>>,    paths: Vec<PathBuf>,    event_fn: Arc<OnceLock<Box<dyn Fn(Vec<Event>) -> bool + 'static + Send + Sync>>>,} pub struct Handle(Arc<Mutex<RecommendedWatcher>>); impl EventStream {    pub fn new(paths: &[&Path], latency: Duration) -> (Self, Handle) {        let event_fn: Arc<OnceLock<Box<dyn Fn(Vec<Event>) -> bool + 'static + Send + Sync>>> =            Arc::new(OnceLock::new());         let paths: Vec<_> = paths.iter().map(|path| path.to_path_buf()).collect();         let mut watcher = notify::recommended_watcher({            let event_fn = event_fn.clone();            let paths = paths.clone();            move |res: Result<notify::Event, _>| {                if let Ok(event) = res {                    let flags = StreamFlags::empty();                     // match event.kind {                    //     EventKind::Access(access) => match access {                    //         notify::event::AccessKind::Any => todo!(),                    //         notify::event::AccessKind::Read => todo!(),                    //         notify::event::AccessKind::Open(_) => todo!(),                    //         notify::event::AccessKind::Close(_) => todo!(),                    //         notify::event::AccessKind::Other => todo!(),                    //     },                    //     EventKind::Create(create) => match create {                    //         notify::event::CreateKind::Any => todo!(),                    //         notify::event::CreateKind::File => todo!(),                    //         notify::event::CreateKind::Folder => todo!(),                    //         notify::event::CreateKind::Other => todo!(),                    //     },                    //     EventKind::Modify(modify) => match modify {                    //         notify::event::ModifyKind::Any => todo!(),                    //         notify::event::ModifyKind::Data(_) => todo!(),                    //         notify::event::ModifyKind::Metadata(_) => todo!(),                    //         notify::event::ModifyKind::Name(_) => todo!(),                    //         notify::event::ModifyKind::Other => todo!(),                    //     },                    //     EventKind::Remove(remove) => match remove {                    //         notify::event::RemoveKind::Any => todo!(),                    //         notify::event::RemoveKind::File => todo!(),                    //         notify::event::RemoveKind::Folder => todo!(),                    //         notify::event::RemoveKind::Other => todo!(),                    //     },                    //     EventKind::Other => todo!(),                    //     EventKind::Any => todo!(),                    // };                     let events = event                        .paths                        .iter()                        .filter(|evt_path| {                            paths                                .iter()                                .any(|requested_path| evt_path.starts_with(requested_path))                        })                        .map(|path| Event {                            event_id: 0,                            flags,                            path: path.to_path_buf(),                        })                        .collect::<Vec<_>>();                     if !events.is_empty() {                        event_fn                            .get()                            .expect("Watcher cannot produce events until paths are provided")(                            events,                        );                    }                }            }        })        .expect("Failed to watch requested path");         watcher            .configure(Config::default().with_poll_interval(latency))            .expect("Failed to watch requested path");         let watcher = Arc::new(Mutex::new(watcher));        (            Self {                watcher: watcher.clone(),                event_fn: event_fn.clone(),                paths,            },            Handle(watcher),        )    }     pub fn run(self, f: impl Fn(Vec<Event>) -> bool + 'static + Send + Sync) {        self.event_fn.get_or_init(|| Box::new(f));         let mut watcher = self.watcher.lock();        for path in self.paths {            watcher                .watch(                    dbg!(path.parent().unwrap_or(&path)),                    notify::RecursiveMode::Recursive,                )                .expect("Failed to watch requested path");        }    }}