use log::debug;

use log::{debug, error};

}
async fn download_change(
    client: reqwest::Client,
    url: String,
    mut path: PathBuf,
    c: libpijul::pristine::Hash,
) -> Result<(), anyhow::Error> {
    libpijul::changestore::filesystem::push_filename(&mut path, &c);
    std::fs::create_dir_all(&path.parent().unwrap())?;
    let path_ = path.with_extension("tmp");
    let mut f = std::fs::File::create(&path_)?;
    libpijul::changestore::filesystem::pop_filename(&mut path);
    let c32 = c.to_base32();
    let url = format!("{}/{}", url, super::DOT_DIR);
    let mut delay = 1f64;
    let mut res = loop {
        let res = if let Ok(res) = client.get(&url).query(&[("change", &c32)]).send().await {
            res
        } else {
            error!("HTTP error, retrying in {} seconds", delay.round());
            tokio::time::delay_for(std::time::Duration::from_secs_f64(delay)).await;
            delay *= 2.;
            continue;
        };
        debug!("response {:?}", res);
        if res.status().is_success() {
            break res;
        } else {
            return Err((crate::Error::Http {
                status: res.status(),
            })
            .into());
        }
    };
    while let Some(chunk) = res.chunk().await? {
        debug!("writing {:?}", chunk.len());
        f.write_all(&chunk)?;
    }
    std::fs::rename(&path_, &path_.with_extension("change"))?;
    Ok(())

const POOL_SIZE: usize = 20;

        path: &mut PathBuf,

        path: &PathBuf,

        let mut pool = <[_; POOL_SIZE]>::default();
        let mut cur = 0;

            libpijul::changestore::filesystem::push_filename(path, c);
            std::fs::create_dir_all(&path.parent().unwrap())?;
            let path_ = path.with_extension("tmp");
            let mut f = std::fs::File::create(&path_)?;
            libpijul::changestore::filesystem::pop_filename(path);
            let c32 = c.to_base32();
            let url = format!("{}/{}", self.url, super::DOT_DIR);
            let mut res = self
                .client
                .get(&url)
                .query(&[("change", c32)])
                .send()
                .await?;
            debug!("response {:?}", res);
            if !res.status().is_success() {
                return Err((crate::Error::Http {
                    status: res.status(),
                })
                .into());
            }
            while let Some(chunk) = res.chunk().await? {
                debug!("writing {:?}", chunk.len());
                f.write_all(&chunk)?;
            }
            std::fs::rename(&path_, &path_.with_extension("change"))?;

            if send.send(*c).await.is_err() {
                debug!("err for {:?}", c);
                progress.abandon();
                break;

            let t = std::mem::replace(
                &mut pool[cur],
                Some(tokio::spawn(download_change(
                    self.client.clone(),
                    self.url.clone(),
                    path.clone(),
                    *c,
                ))),
            );
            if let Some(t) = t {
                t.await??;
                if send.send(*c).await.is_err() {
                    debug!("err for {:?}", c);
                    progress.abandon();
                    break;
                }

            cur = (cur + 1) % POOL_SIZE;