mod debounce;
use debounce::{Debouncer, State};

use std::thread::sleep;
use std::time::Duration;

    let mut debouncer = Debouncer::new(Duration::from_millis(500));

        for event in inotify.read_events_blocking(&mut buffer)? {
            let processor = &processors[&event.wd];
            let filename = processor.path.join(event.name.unwrap());
            println!("Processing {:?}", filename);
            process(&filename, &processor.command, &processor.args[..])
                .unwrap_or_else(|e| eprintln!("Error: {}", e))

        debouncer.new_events(
            inotify
                .read_events_blocking(&mut buffer)?
                .map(|e| (e.wd, e.name.unwrap().to_owned())),
        );
        loop {
            match debouncer.get() {
                State::Empty => break,
                State::Wait(duration) => sleep(
                    duration
                        .checked_sub(Duration::from_millis(100))
                        .unwrap_or(duration),
                ),
                State::Ready((wd, name)) => {
                    let processor = &processors[&wd];
                    let filename = processor.path.join(name);
                    println!("Processing {:?}", filename);
                    process(&filename, &processor.command, &processor.args[..])
                        .unwrap_or_else(|e| eprintln!("Error: {}", e));
                }
            }
            debouncer.new_events(
                inotify
                    .read_events(&mut buffer)?
                    .map(|e| (e.wd, e.name.unwrap().to_owned())),
            );