lyt 0.1.1

use clap::Parser;
use lyt::build::{build_pages, Args};
use notify::{RecursiveMode, Result, Watcher};
use notify_debouncer_full::{new_debouncer, DebouncedEvent};
use std::time::Duration;

const REBUILD_EXTENSIONS: [&str; 3] = ["md", "toml", "hbs"];

fn main() -> Result<()> {
    let args = Args::parse();

    let paths = lyt::build::Paths::new(&args.input_dir, &args.output_dir);

    println!("Building...");

    build_pages(
        args.verbose,
        &paths.pages_path,
        &paths.output_dir,
        &paths.templates_path,
    );

    if args.watch {
        let (tx, rx) = std::sync::mpsc::channel();

        let mut debouncer = new_debouncer(Duration::from_secs(2), None, tx)?;

        debouncer
            .watcher()
            .watch(&paths.input_dir, RecursiveMode::Recursive)?;

        debouncer
            .cache()
            .add_root(&paths.input_dir, RecursiveMode::Recursive);

        println!("Watching for changes...");

        for res in rx {
            match res {
                Ok(event) => {
                    if should_rebuild(event) {
                        println!("Rebuilding...");
                        build_pages(
                            args.verbose,
                            &paths.pages_path,
                            &paths.output_dir,
                            &paths.templates_path,
                        );
                        println!("Rebuild complete.");
                    }
                }
                Err(e) => println!("watch error: {:?}", e),
            }
        }

        return Ok(());
    }

    println!("lyt out.");

    Ok(())
}

fn should_rebuild(event: Vec<DebouncedEvent>) -> bool {
    event.iter().any(|e| {
        e.paths.iter().any(|p| {
            REBUILD_EXTENSIONS.contains(&p.extension().unwrap_or_default().to_str().unwrap())
        })
    })
}