use std::process::Command;

mod args;
mod did;
mod knot;

fn main() -> Result<(), ()> {
    // load configuration
    let config = match args::load_config() {
        Ok(res) => res,
        Err(_) => return Err(()),
    };

    // resolve handle to did
    println!("Resolving {}", config.handle);
    let did_doc = match did::get_did(&config.handle) {
        Ok(res) => res,
        Err(_) => return Err(()),
    };
    println!(
        "    Found DID `{0}` hosted at `{1}`",
        did_doc.did, did_doc.pds
    );

    // resolve did+repoName to knotserver
    println!("Resolving @{0}/{1}", config.handle, config.repo_name);
    let knot_server = match knot::find_knot(&did_doc.did, &config.repo_name, &did_doc.pds) {
        Ok(val) => val,
        Err(_) => return Err(()),
    };
    println!("    Found knot `{}`", knot_server);

    // connect to /events on knotserver
    println!(
        "Connecting to `{}`",
        format!("wss://{}/events", knot_server)
    );

    match ws::connect(format!("ws://{}/events", knot_server), |_out| {
        println!("    Connection successful");
        |msg: ws::Message| {
            // parse json
            let body = match json::parse(match msg.as_text() {
                Ok(val) => val,
                Err(_) => return Ok(()),
            }) {
                Ok(val) => val,
                Err(_) => {
                    println!("    Invalid body. Skipping message");
                    return Ok(());
                }
            };

            // filter by did and reponame
            if let Some(repo_did) = body["event"]["repoDid"].as_str()
                && let Some(repo) = body["event"]["repoName"].as_str()
                && repo_did != &did_doc.did
                && repo != &config.repo_name
            {
                // repo doesnt match so skip
                return Ok(());
            }

            println!("        Executing `/bin/sh -c {}`", &config.shell);

            // exec shell command in /bin/sh
            match Command::new("/bin/sh")
                .arg("-c")
                .arg(&config.shell)
                .output()
            {
                Ok(val) => val,
                Err(_) => return Ok(()),
            };

            Ok(())
        }
    }) {
        Ok(_) => {}
        Err(err) => println!("    Connection failed: {}", err),
    };

    return Ok(());
}