use radicle::git::RefString;

use radicle::Profile;

use radicle_ci_broker::{

    event::BrokerEvent,

    msg::{Oid, RepoId, RequestBuilder, Response, RunId, RunResult},

};

fn main() {

    let rid = RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8").expect("create rid");

    let commit =

        Oid::try_from("b4fb1e347be7db19f0859717062f94116b5bec9f").expect("create commit id");

    let name = RefString::try_from("refs/namespaces/z6MkgEMYod7Hxfy9qCvDv5hYHkZ4ciWmLFgfvm3Wn1b2w2FV/refs/heads/patches/8d8232ddcb217fa1402eec4d955e227ef3bb5881").expect("create name");

    let be = BrokerEvent::RefChanged {

        rid,

        name,

        oid: commit,

        old: None,

    };

    let profile = Profile::load().expect("create profile");

    let trigger = RequestBuilder::default()

        .profile(&profile)

        .broker_event(&be)

        .build_trigger()

        .expect("create trigger");

    println!("Trigger request:\n{}\n", trigger);

    let triggered = Response::triggered(RunId::from("any-string-works-as-run-id"));

    println!(

        "Triggered response:\n{}\n",

        serde_json::to_string(&triggered).expect("serialize message")

    );

    let triggered = Response::triggered_with_url(

        RunId::from("any-string-works-as-run-id"),

        "https://ci.example.com/xyzzy",

    );

    println!(

        "Triggered response with URL:\n{}\n",

        serde_json::to_string(&triggered).expect("serialize message")

    );

    let finished = Response::finished(RunResult::Success);

    println!(

        "Successful response:\n{}\n",

        serde_json::to_string(&finished).expect("serialize message")

    );

    let finished = Response::finished(RunResult::Failure);

    println!(

        "Failure response:\n{}\n",

        serde_json::to_string(&finished).expect("serialize message")

    );

}

//! Show broker events that are allowed by a filter. This is meant to

//! be helpful for testing a filter configuration.

use anyhow::anyhow;

use log::info;

use std::path::PathBuf;

use radicle::prelude::Profile;

use radicle_ci_broker::{config::Config, event::NodeEventSource};

fn main() {

    if let Err(e) = fallible_main() {

        eprintln!("ERROR: {}", e);

        let mut e = e.source();

        while let Some(source) = e {

            eprintln!("caused by: {}", source);

            e = source.source();

        }

    }

}

fn fallible_main() -> anyhow::Result<()> {

    pretty_env_logger::init();

    let mut args = std::env::args().skip(1);

    let filename: PathBuf = if let Some(filename) = args.next() {

        PathBuf::from(filename)

    } else {

        return Err(anyhow!("usage: filter-events CONFIG"));

    };

    info!("using file: {:?}", filename);

    let config = Config::load(&filename)?;

    let profile = Profile::load()?;

    let mut source = NodeEventSource::new(&profile)?;

    for filter in config.filters.iter() {

        source.allow(filter.clone());

    }

    // This loop ends when there's an error, e.g., failure to read an

    // event from the node.

    loop {

        for e in source.event()? {

            println!("{:#?}", e);

        }

    }

}

use std::str::FromStr;

use radicle::git::{Oid, RefString};

use radicle::{

    node::Event,

    prelude::{NodeId, RepoId},

    storage::RefUpdate,

};

fn main() {

    let event = Event::RefsFetched {

        remote: NodeId::from_str("z6MkgEMYod7Hxfy9qCvDv5hYHkZ4ciWmLFgfvm3Wn1b2w2FV").unwrap(),

        rid: RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8").unwrap(),

        updated: vec![RefUpdate::Skipped {

            name: RefString::try_from("shutdown").expect("create name"),

            oid: Oid::try_from("0").unwrap(),

        }],

    };

    println!("{}", serde_json::to_string(&event).unwrap());

    println!();

    let event = Event::RefsFetched {

        remote: NodeId::from_str("z6MkgEMYod7Hxfy9qCvDv5hYHkZ4ciWmLFgfvm3Wn1b2w2FV").unwrap(),

        rid: RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8").unwrap(),

        updated: vec![RefUpdate::Updated {

            name: RefString::try_from("shutdown").expect("create name"),

            old: Oid::try_from("0").unwrap(),

            new: Oid::try_from("0").unwrap(),

        }],

    };

    println!("{}", serde_json::to_string(&event).unwrap());

}

use std::{path::Path, str::FromStr};

use radicle::git::Oid;

use radicle::identity::Did;

use radicle::prelude::RepoId;

use radicle_ci_broker::{

    msg::{Author, Revision, RunId, RunResult},

    pages::{PageBuilder, PageError},

    run::{Run, RunState, Whence},

};

const DOMAIN: &str = "radicle.liw.fi";

const RID_1: &str = "rad:z3gqcJUoA1n9HaHKufZs5FCSGazv5";

const COMMIT_1: &str = "a48081f2717f069d456ec09f31d9e639b232dbed";

const USERID_1: &str = "J. Random Hacker <jrh@example.com>";

const AUTHOR_DID_3: &str = "did:key:z6MkgEMYod7Hxfy9qCvDv5hYHkZ4ciWmLFgfvm3Wn1b2w2FV";

const DIR: &str = "html";

fn main() -> Result<(), PageError> {

    let mut page = PageBuilder::default().node_alias(DOMAIN).build()?;

    let rid1 = rid(RID_1);

    let mut run1 = Run::new(

        rid1,

        "heartwood",

        Whence::branch("master", oid(COMMIT_1), Some(USERID_1)),

        "2024-02-27T18:29:25+02:00".into(),

    );

    run1.set_adapter_run_id(RunId::default());

    run1.set_state(RunState::Running);

    run1.set_result(RunResult::Success);

    page.push_run(run1.clone());

    let mut run2 = run1.clone();

    run2.set_state(RunState::Finished);

    page.push_run(run2);

    let mut run3 = Run::new(

        rid1,

        "heartwood",

        Whence::patch(

            oid(COMMIT_1),

            oid(COMMIT_1),

            Revision {

                id: oid(COMMIT_1),

                author: author(AUTHOR_DID_3),

                description: "Dummy patch description".into(),

                base: oid(COMMIT_1),

                oid: oid(COMMIT_1),

                timestamp: 0,

            },

            Some("Helpful Person <helpful@example.com>"),

        ),

        "2024-02-27T18:29:09+02:00".into(),

    );

    run3.set_adapter_run_id(RunId::default());

    run3.set_state(RunState::Finished);

    run3.set_result(RunResult::Failure);

    page.push_run(run3);

    let rid2 = RepoId::from_urn("rad:zwTxygwuz5LDGBq255RA2CbNGrz8").unwrap();

    let alias2 = "radicle-ci-broker";

    let mut run4 = Run::new(

        rid2,

        alias2,

        Whence::branch(

            "master",

            oid(COMMIT_1),

            Some("J. Random Hacker <random@example.com>"),

        ),

        "2024-02-27T18:29:25+02:00".into(),

    );

    run4.set_adapter_run_id(RunId::default());

    run4.set_state(RunState::Finished);

    run4.set_result(RunResult::Success);

    page.push_run(run4);

    page.write(Path::new(DIR)).unwrap();

    Ok(())

}

fn rid(urn: &str) -> RepoId {

    RepoId::from_urn(urn).unwrap()

}

fn oid(commit_id: &str) -> Oid {

    Oid::from_str(commit_id).unwrap()

}

fn did(did: &str) -> Did {

    Did::from_str(did).unwrap()

}

fn author(id: &str) -> Author {

    Author {

        id: did(id),

        alias: None,

    }

}

use radicle_ci_broker::msg::Response;

fn main() {

    for line in std::io::stdin().lines() {

        let line = line.unwrap();

        let resp = Response::from_str(&line).unwrap();

        println!("{line}");

        println!("{resp:#?}");

        println!();

    }

}