extern crate semver;
extern crate toml;

use std::io::Write;

/// reads a security advisory of the form
/// https://github.com/RustSec/advisory-db/blob/a24932e220dfa9be8b0b501210fef8a0bc7ef43e/EXAMPLE_ADVISORY.md
/// and a crate version number,
/// and returns 0 if the crate version is patched
/// and returns 1 if the crate version is *not* patched
///
/// If PRINT_ADVISORY is set, the advisory is printed if it matches.

fn main() {
    let mut args = std::env::args_os();
    let file = args.nth(1).expect("security advisory md file is $1");
    let crate_version = args
        .nth(0)
        .expect("crate version is $2")
        .into_string()
        .expect("crate version string not utf8");
    let crate_version = semver::Version::parse(&crate_version)
        .expect(&format!("this is not a semver version: {}", &crate_version));
    let filename = file.to_string_lossy();

    let content = std::fs::read(&file).expect(&format!("could not read {}", filename));
    let content = std::str::from_utf8(&content)
        .expect(&format!("file {} was not encoded as utf-8", filename));
    let content = content.trim_start();

    let toml_start = content
        .strip_prefix("```toml")
        .expect(&format!("file did not start with ```toml: {}", filename));
    let toml_end_index = toml_start.find("```").expect(&format!(
        "the toml section did not end, no `` found: {}",
        filename
    ));
    let toml = &toml_start[..toml_end_index];
    let toml: toml::Value = toml::de::from_slice(toml.as_bytes())
        .expect(&format!("could not parse toml: {}", filename));

    let versions = toml
        .as_table()
        .expect(&format!("the toml is not a table: {}", filename))
        .get("versions")
        .expect(&format!(
            "the toml does not contain the versions field: {}",
            filename
        ))
        .as_table()
        .expect(&format!(
            "the toml versions field must be a table: {}",
            filename
        ));

    let unaffected = match versions.get("unaffected") {
        Some(u) => u
            .as_array()
            .expect(&format!(
                "the toml versions.unaffected field must be a list of semvers: {}",
                filename
            ))
            .iter()
            .map(|v| {
                semver::VersionReq::parse(
                    v.as_str()
                        .expect(&format!("the version field {} is not a string", v)),
                )
                .expect(&format!(
                    "the version field {} is not a valid semver VersionReq",
                    v
                ))
            })
            .collect(),
        None => vec![],
    };

    let mut patched: Vec<semver::VersionReq> = versions
        .get("patched")
        .expect(&format!(
            "the toml versions.patched field must exist: {}",
            filename
        ))
        .as_array()
        .expect(&format!(
            "the toml versions.patched field must be a list of semvers: {}",
            filename
        ))
        .iter()
        .map(|v| {
            semver::VersionReq::parse(
                v.as_str()
                    .expect(&format!("the version field {} is not a string", v)),
            )
            .expect(&format!(
                "the version field {} is not a valid semver VersionReq",
                v
            ))
        })
        .collect();

    patched.extend_from_slice(&unaffected[..]);
    let is_patched_or_unaffected = patched.iter().any(|req| req.matches(&crate_version));

    if is_patched_or_unaffected {
        std::process::exit(0);
    } else {
        if std::env::var_os("PRINT_ADVISORY").is_some() {
            write!(
                std::io::stderr(),
                "Advisory {} matched!\n{}\n",
                filename,
                content
            )
            .unwrap();
        }
        std::process::exit(1);
    }
}