get_file_opts(&self, location: &Path, file: &std::fs::File, options: GetOptions) -> Result<()> // Implement it with get
get_file(&self, location: &Path, file: &std::fs::File) -> Result<()> // (which will call get_file_opts with default option)
put_file_opts(&self, location: &Path, file: &std::fs::File, options: PutOptions) -> Result<()>  // Implement it with put and put_multipart depending on the file size
put_file(&self, location: &Path, file: &std::fs::File) -> Result<()> // (which will call put_file_opts with default option)

pub async fn download(
    store: &dyn ObjectStore,
    location: &Path,
    opts: GetOptions,
    file: &mut std::fs::File,
    transfer_opts: Option<&DownloadTransferConfig>,
) -> Result<()> 

pub struct DownloadTransferConfig {
    /// The maximum number of concurrent chunks to download
    pub max_concurrent_chunks: usize,
    /// The maximum number of bytes to buffer in memory
    pub chunk_queue_size: usize,
}

impl Default for DownloadTransferConfig {
    fn default() -> Self {
        Self {
            max_concurrent_chunks: 1,
            chunk_queue_size: 2,
        }
    }
}

pub async fn download(
    store: &dyn ObjectStore,
    location: &Path,
    opts: GetOptions,
    file: &mut std::fs::File,
    transfer_opts: Option<&DownloadTransferConfig>,
) -> Result<()> {
    let result = store.get_opts(&location, opts).await?;
    let transfer_opts = *transfer_opts.unwrap_or(&DownloadTransferConfig::default());
    let (sender, mut receiver) =
        tokio::sync::mpsc::channel::<Bytes>(transfer_opts.chunk_queue_size);

    match result.payload {
        GetResultPayload::Stream(stream) => {
            let sender_task = tokio::spawn(async move {
                let mut buffered_stream = stream
                    .map(|chunk| async move {
                        let chunk = chunk.map_err(crate::Error::from)?;
                        Ok::<Bytes, crate::Error>(chunk)
                    })
                    .buffered(transfer_opts.max_concurrent_chunks);

                while let Some(chunk) = buffered_stream.next().await {
                    let chunk = chunk?;
                    if let Err(e) = sender.send(chunk).await {
                        eprintln!("Error sending the chunk: {:?}", e);
                        break;
                    }
                }
                drop(sender);
                Ok::<(), crate::Error>(())
            });

            while let Some(chunk) = receiver.recv().await {
                file.write_all(&chunk).context(UnableToWriteFileSnafu)?;
            }

            sender_task.await.context(UnableToJoinTaskSnafu)??;
            Ok(())
        }

        GetResultPayload::File(mut source_file, _path) => {
            std::io::copy(&mut source_file, file).context(UnableToWriteFileSnafu)?;
            Ok(())
        }
    }
}