#[cfg(feature = "std")]
fn main() {
    use std::{
        io::Write,
        path::{Path, PathBuf},
    };

    static ABLEOS_PATH_RESOLVER: hblang::PathResolver =
        &|mut path: &str, mut from: &str, tmp: &mut PathBuf| {
            tmp.clear();

            path = match path {
                "stn" => {
                    from = "";
                    "./sysdata/libraries/stn/src/lib.hb"
                }
                _ => path,
            };

            match path.split_once(':') {
                Some(("lib", p)) => tmp.extend(["./sysdata/libraries", p, "src/lib.hb"]),
                Some(("stn", p)) => {
                    tmp.extend(["./sysdata/libraries/stn/src", &(p.to_owned() + ".hb")])
                }
                Some(("sysdata", p)) => tmp.extend(["./sysdata", p]),
                None => match Path::new(from).parent() {
                    Some(parent) => tmp.extend([parent, Path::new(path)]),
                    None => tmp.push(path),
                },
                _ => panic!("path: '{path}' is invalid: unexpected ':'"),
            };
            tmp.canonicalize()
                .map_err(|source| hblang::CantLoadFile { path: std::mem::take(tmp), source })
        };

    fn run(out: &mut Vec<u8>, warnings: &mut String) -> std::io::Result<()> {
        let args = std::env::args().collect::<Vec<_>>();
        let args = args.iter().map(String::as_str).collect::<Vec<_>>();
        let resolvers = &[("ableos", ABLEOS_PATH_RESOLVER)];
        let opts = hblang::Options::from_args(&args, out, resolvers)?;
        let file = args.iter().filter(|a| !a.starts_with('-')).nth(1).copied().unwrap_or("main.hb");

        hblang::run_compiler(file, opts, out, warnings)
    }

    log::set_logger(&hblang::fs::Logger).unwrap();
    log::set_max_level(log::LevelFilter::Error);

    let mut out = Vec::new();
    let mut warnings = String::new();
    match run(&mut out, &mut warnings) {
        Ok(_) => {
            std::io::stderr().write_all(warnings.as_bytes()).unwrap();
            std::io::stdout().write_all(&out).unwrap()
        }
        Err(_) => {
            std::io::stderr().write_all(warnings.as_bytes()).unwrap();
            std::io::stderr().write_all(&out).unwrap();
            std::process::exit(1);
        }
    }
}