"ureq",

/// Fetch an artifact from its COB locations and write it to `dest`. For

/// blobs that have HTTP/HTTPS locations, HTTP is tried first because it

/// is fast and typically succeeds without NAT traversal; iroh is used

/// when HTTP fails or no HTTP URLs are listed. Collections always go

/// through iroh (radicle-artifact does not implement HTTP collection

/// fetch). Streams `artifact_progress` events keyed by `cid` so the UI

/// can render a progress bar per row.

    let emit = |stage: &str, bytes: Option<u64>| {

        let mut payload = serde_json::json!({ "cid": cid, "stage": stage });

        if let Some(b) = bytes {

            payload["bytes"] = serde_json::json!(b);

        }

        let _ = app.emit("artifact_progress", payload);

    };

    emit("connecting", None);

    let mut errors: Vec<String> = Vec::new();

    let http_urls = fetch::http_urls(&locations);

    let try_http_first = !http_urls.is_empty() && matches!(kind, fetch::ArtifactKind::Blob);

    if try_http_first {

        for url in &http_urls {

            let url_clone = url.clone();

            let cid_clone = parsed_cid;

            let dest_clone = dest.clone();

            match tauri::async_runtime::spawn_blocking(move || {

                fetch::fetch_http_blob(&url_clone, &cid_clone, &dest_clone)

            })

            .await?

            {

                Ok(()) => {

                    emit("done", None);

                    return Ok(());

                }

                Err(e) => errors.push(format!("{url}: {e}")),

            }

        }

    }

    // Either no HTTP URLs, or every HTTP attempt failed — fall through to

    // the iroh path, which loads bytes into the persistent store and then

    // exports them to the destination.

    let iroh_result = fetch::fetch_artifact(

    .await;

    match iroh_result {

        Ok(()) => {

            emit("writing", None);

            fetch::export(&iroh.blobs, hash, kind, &dest).await?;

            emit("done", None);

            Ok(())

        }

        Err(e) => {

            errors.push(format!("iroh: {e}"));

            // If HTTP wasn't even an option and iroh failed, surface the

            // raw iroh error so the user sees something actionable.

            if errors.len() == 1 {

                return Err(e);

            }

            Err(Error::AllTransportsFailed {

                cid: cid.clone(),

                reasons: errors.join("; "),

            })

        }

    }

ureq = { version = "3.3.0" }

    /// The artifact has no usable locations of any supported scheme.

    #[error("no locations available for {cid}")]

    NoLocations { cid: String },

    /// All transport attempts (iroh + HTTP) failed for the requested CID.

    /// The aggregated messages from each attempt are joined into one string

    /// for surfacing in the UI.

    #[error("all transports failed for {cid}: {reasons}")]

    AllTransportsFailed { cid: String, reasons: String },

            Error::NoLocations { .. } => "ArtifactError.NoLocations",

            Error::AllTransportsFailed { .. } => "ArtifactError.AllTransportsFailed",

// Re-export so downstream crates (radicle-tauri) can branch on artifact

// kind without depending on radicle-artifact directly.

pub use radicle_artifact::share::cid_utils::ArtifactKind;

/// Outcome of an artifact fetch. `IrohStore` means the bytes are now in

/// the iroh blob store and the caller needs to `export` them to disk;

/// `DiskDirect` means the bytes were written directly to the user's

/// destination (HTTP path) and no export step is required.

pub enum FetchOutcome {

    IrohStore,

    DiskDirect,

}

/// Fetch an artifact's bytes into the iroh blob store from any of the

/// iroh providers reachable through `locations`. Streams `on_progress`

/// events as the download progresses. Bytes are verified against the CID

/// via iroh-blobs' built-in hash check. Returns `Err(NoIrohProviders)`

/// when none of the locations are iroh URLs — callers handle HTTP

/// fallback via [`fetch_http_blob`].

/// Extract every HTTP/HTTPS URL from `locations`, preserving insertion

/// order so the caller can try them in a deterministic sequence.

pub fn http_urls(locations: &BTreeMap<Did, BTreeSet<Url>>) -> Vec<Url> {

    let mut out = Vec::new();

    for urls in locations.values() {

        for url in urls {

            if matches!(url.scheme(), "http" | "https") {

                out.push(url.clone());

            }

        }

    }

    out

}

/// Download a blob artifact via HTTP directly to disk. Writes to a

/// `.partial` sibling first, verifies the CID against the file contents,

/// and only then renames into place — matching the safety pattern in

/// `radicle_artifact::share::fetch::download`. Run on the blocking pool;

/// `ureq` is synchronous.

pub fn fetch_http_blob(url: &Url, expected_cid: &Cid, dest: &Path) -> Result<(), Error> {

    use std::io::{BufWriter, Read, Write};

    let agent = ureq::Agent::new_with_config(

        ureq::Agent::config_builder()

            .timeout_connect(Some(std::time::Duration::from_secs(10)))

            .build(),

    );

    let mut response = agent

        .get(url.as_str())

        .call()

        .map_err(|e| Error::Iroh(format!("http get {url}: {e}")))?;

    let partial = dest.with_extension("partial");

    if let Some(parent) = partial.parent() {

        std::fs::create_dir_all(parent)?;

    }

    {

        let file = std::fs::File::create(&partial)?;

        let mut writer = BufWriter::new(file);

        let mut buf = [0u8; 64 * 1024];

        let mut body = response.body_mut().as_reader();

        loop {

            let n = body.read(&mut buf).map_err(|e| {

                std::fs::remove_file(&partial).ok();

                Error::Iroh(format!("http read {url}: {e}"))

            })?;

            if n == 0 {

                break;

            }

            writer.write_all(&buf[..n]).map_err(|e| {

                std::fs::remove_file(&partial).ok();

                Error::Io(e)

            })?;

        }

        writer.flush().map_err(|e| {

            std::fs::remove_file(&partial).ok();

            Error::Io(e)

        })?;

    }

    if let Err(e) = cid_utils::verify_cid_file(&partial, expected_cid) {

        std::fs::remove_file(&partial).ok();

        return Err(Error::Iroh(format!("cid verification: {e}")));

    }

    std::fs::rename(&partial, dest)?;

    Ok(())

}