shrupl/src/appstate.rs

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

use console::style;
use indicatif::{ProgressBar, ProgressStyle};
use log::{debug, trace};
use serde::{Deserialize, Serialize};

use super::{
    cli::Cli,
    sharry::{Alias, ChunkState, FileChecked, FileUploading, Share, UploadError},
};

#[derive(Serialize, Deserialize, Debug)]
pub struct AppState {
    #[serde(skip)]
    file_name: PathBuf,
    #[serde(skip)]
    progress: Option<ProgressBar>,

    alias: Alias,
    share: Share,
    files: VecDeque<FileState>,
}

#[derive(Serialize, Deserialize, Debug)]
enum FileState {
    C(FileChecked),
    U(FileUploading),
}

impl FileState {
    fn file_name(&self) -> &str {
        match self {
            FileState::C(checked) => checked.file_name(),
            FileState::U(uploading) => uploading.file_name(),
        }
    }
}

impl AppState {
    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
    }

    fn load(file_name: impl AsRef<Path>) -> io::Result<Self> {
        let content = fs::read_to_string(file_name)?;
        serde_json::from_str(&content).map_err(io::Error::other)
    }

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

        Self::load(&file_name)
            .inspect_err(|e| debug!("could not resume from {:?}: {e}", file_name.display()))
            .map(|state| {
                debug!("successfully loaded AppState");

                Self {
                    file_name,
                    progress: None,
                    alias: state.alias,
                    share: state.share,
                    files: state.files,
                }
            })
            .ok()
    }

    pub fn from_args(args: &Cli, http: &ureq::Agent) -> Result<Self, ureq::Error> {
        let file_name = Self::cache_file(args);
        let alias = args.get_alias();

        let share = Share::create(http, &alias, args.get_share_request())?;

        let files: VecDeque<_> = args.files.clone().into_iter().map(FileState::C).collect();

        Ok(Self {
            file_name,
            progress: None,
            alias,
            share,
            files,
        })
    }

    pub fn file_names(&self) -> Vec<&str> {
        self.files.iter().map(FileState::file_name).collect()
    }

    pub fn upload_chunk(
        &mut self,
        http: &ureq::Agent,
        chunk_size: usize,
    ) -> Result<Option<()>, UploadError> {
        let uploading = match self.files.pop_front() {
            Some(FileState::C(checked)) => checked
                .start_upload(http, &self.alias, &self.share)
                .unwrap(),
            Some(FileState::U(uploading)) => uploading,
            None => return Ok(None),
        };

        debug!("{uploading} chunk {chunk_size}");

        let pb = match self.progress {
            Some(ref pb) => pb,
            None => {
                self.progress = Some({
                    let pb = {
                        let ps = ProgressStyle::with_template(&format!(
                            "{{msg:.yellow}}: {{bar:50.cyan/blue}} {{binary_bytes:.magenta}}{}{{binary_total_bytes:.magenta}} ({{elapsed}})",
                            style("/").magenta(),
                        ))
                        .unwrap();

                        ProgressBar::new(uploading.size())
                            .with_style(ps)
                            .with_message(uploading.file_name().to_owned())
                            .with_position(uploading.offset())
                    };
                    pb.tick();

                    pb
                });
                self.progress.as_ref().unwrap()
            }
        };
        pb.tick();

        match uploading.upload_chunk(http, &self.alias, chunk_size) {
            ChunkState::Ok(upl) => {
                pb.set_position(upl.offset());
                self.files.push_front(FileState::U(upl));
                Ok(Some(()))
            }
            ChunkState::Err(upl, e) => {
                self.files.push_front(FileState::U(upl));
                Err(e)
            }
            ChunkState::Finished(path) => {
                debug!("Finished {:?}!", path.display());
                pb.finish();
                self.progress = None;
                self.share.notify(http, &self.alias).unwrap();

                Ok(self.files.front().map(drop))
            }
        }
    }

    pub fn save(&self) -> io::Result<()> {
        fs::create_dir_all(Self::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(())
    }
}