shrupl/src/cachefile.rs

use std::{
    collections::VecDeque,
    fs,
    io::{self, Write},
    path::PathBuf,
};

use log::trace;
use serde::{Deserialize, Serialize};

use crate::{
    cli::Cli,
    file::{self, Chunk, FileTrait},
    sharry::{self, Client, Uri},
};

#[derive(Serialize, Deserialize, Debug)]
pub struct CacheFile {
    #[serde(skip)]
    file_name: PathBuf,

    uri: Uri,
    alias_id: String,
    share_id: String,

    uploading: Option<file::Uploading>,
    files: VecDeque<file::Checked>,
}

impl CacheFile {
    fn cache_dir() -> PathBuf {
        let dir_name = dirs_next::cache_dir()
            .expect("could not determine cache directory")
            .join("shrupl");

        trace!("cachedir: {:?}", dir_name.display());
        dir_name
    }

    fn cache_file(args: &Cli) -> PathBuf {
        let file_name = Self::cache_dir().join(format!("{}.json", args.get_hash()));

        trace!("cachefile: {:?}", file_name.display());
        file_name
    }

    pub fn try_resume(args: &Cli) -> io::Result<Self> {
        let file_name = Self::cache_file(args);

        let state: Self = {
            let file = fs::File::open(&file_name)?;
            let reader = io::BufReader::new(file);
            serde_json::from_reader(reader).map_err(io::Error::other)?
        };

        Ok(Self { file_name, ..state })
    }

    pub fn from_args(args: &Cli, share_id: String) -> Self {
        Self {
            file_name: Self::cache_file(args),
            uri: args.get_uri(),
            alias_id: args.alias.clone(),
            share_id,
            uploading: None,
            files: args.files.clone().into(),
        }
    }

    pub fn file_names(&self) -> Vec<&str> {
        let mut result = vec![];

        if let Some(upl) = self.uploading.as_ref() {
            result.push(upl.get_name());
        }
        self.files.iter().map(|chk| result.push(chk.get_name()));

        result
    }

    pub fn start_upload(&mut self, client: &impl Client) -> sharry::Result<bool> {
        if self.uploading.is_some() {
            return Ok(true);
        }

        if let Some(chk) = self.files.pop_front() {
            self.uploading =
                Some(chk.start_upload(client, &self.uri, &self.alias_id, &self.share_id)?);

            Ok(true)
        } else {
            Ok(false)
        }
    }

    pub fn uploading(&mut self) -> &mut Option<file::Uploading> {
        &mut self.uploading
    }

    pub fn abort_upload(&mut self) {
        let Some(upl) = self.uploading.take() else {
            panic!("abort called while not uploading");
        };

        self.files.push_front(upl.abort());
    }

    pub fn share_notify(&self, client: &impl Client) -> sharry::Result<()> {
        client.share_notify(&self.uri, &self.alias_id, &self.share_id)
    }

    pub fn file_patch(&self, client: &impl Client, chunk: &Chunk) -> sharry::Result<()> {
        client.file_patch(&self.uri, &self.alias_id, &self.share_id, chunk)
    }

    pub fn save(&self) -> io::Result<()> {
        let cache_dir = self.file_name.parent().ok_or_else(|| {
            io::Error::other(format!("orphan file {:?}", self.file_name.display()))
        })?;
        fs::create_dir_all(cache_dir)?;

        let json = serde_json::to_string_pretty(self).map_err(io::Error::other)?;
        let mut file = fs::File::create(&self.file_name)?;
        file.write_all(json.as_bytes())?;

        trace!("updated {:?}", self.file_name.display());
        Ok(())
    }

    pub fn clear(self) -> io::Result<()> {
        fs::remove_file(&self.file_name)?;

        trace!("removed {:?}", self.file_name.display());
        Ok(())
    }
}