supreme_fs/game_storage/online/

transfer.rs

//! Uploading, committing, and fetching whole snapshot files (profiles and
//! replays), including local `.supreme/<subdirectory>/` caching.

use super::util::ensure_json_extension;
use crate::game_storage::GameStorage;
use crate::{HybridStorageError, OnlineStorageError, SnapshotEvent};
use std::fs;
use std::io;
use std::sync::mpsc::Sender;

impl GameStorage {
    pub fn upload_profile(
        &self,
        profile_name: &str,
        data: &[u8],
        tx: Option<Sender<SnapshotEvent>>,
    ) -> Result<(), HybridStorageError> {
        self.save_and_upload_snapshot("profiles", profile_name, data, tx)
    }

    /// Upload a replay snapshot (json file) to the backend.
    pub fn upload_replay(
        &self,
        snapshot_name: &str,
        data: &[u8],
        tx: Option<Sender<SnapshotEvent>>,
    ) -> Result<(), HybridStorageError> {
        self.save_and_upload_snapshot("replays", snapshot_name, data, tx)
    }

    fn save_and_upload_snapshot(
        &self,
        subdirectory: &str,
        name: &str,
        data: &[u8],
        tx: Option<Sender<SnapshotEvent>>,
    ) -> Result<(), HybridStorageError> {
        let filename = ensure_json_extension(name);

        // Standardize path: .supreme/<subdirectory>/<filename>
        let local_path = self
            .root_path
            .join(".supreme")
            .join(subdirectory)
            .join(&filename);

        fs::create_dir_all(
            local_path
                .parent()
                .ok_or_else(|| io::Error::other("Local path has no parent directory"))?,
        )?;
        fs::write(&local_path, data)?;

        if self.api_url.is_some() {
            self.upload_snapshot_generic(subdirectory, name, data, tx)?;
        }

        Ok(())
    }

    fn upload_snapshot_generic(
        &self,
        subdirectory: &str,
        _name: &str,
        data: &[u8],
        tx: Option<Sender<SnapshotEvent>>,
    ) -> Result<(), HybridStorageError> {
        if self.api_url.is_some() {
            // Use unified chunked upload for all files
            return self.upload_file_unified(subdirectory, data, "snapshot", None, tx);
        }

        Ok(())
    }

    /// Commit a staged snapshot.
    pub fn commit_snapshot(&self, snapshot_name: &str) -> Result<(), HybridStorageError> {
        self.commit_snapshot_type("replays", snapshot_name)
    }

    pub fn commit_snapshot_type(
        &self,
        subdirectory: &str,
        snapshot_filename_with_ext: &str,
    ) -> Result<(), HybridStorageError> {
        use super::multipart::{MultipartForm, SendMultipart};
        let client = self
            .client
            .as_ref()
            .ok_or_else(|| io::Error::other("Online storage not configured"))?;
        let api_url = self
            .api_url
            .as_ref()
            .ok_or_else(|| io::Error::other("Online storage not configured"))?;

        let mut form = MultipartForm::new()
            .text("action", "commit_snapshot")
            .text("name", snapshot_filename_with_ext)
            .text("type", subdirectory);

        if let Some(token) = &self.token {
            form = form.text("api_token", token.clone());
        }

        let mut request = client.post(api_url);
        if let Some(ref token) = self.token {
            request = request.header("X-SSBZ-Token", token);
        }
        let response = request.send_multipart(form)?;

        if !response.status().is_success() {
            return Err(HybridStorageError::UploadFailed(
                self.extract_error_message(response),
            ));
        }
        Ok(())
    }

    /// Fetch a replay snapshot JSON by name.
    /// Tries local .supreme/replays first, then online at /replays/.
    pub fn fetch_replay(&self, snapshot_name: &str) -> Result<Vec<u8>, HybridStorageError> {
        self.fetch_and_cache_snapshot("replays", snapshot_name)
    }

    pub(crate) fn fetch_and_cache_snapshot(
        &self,
        subdirectory: &str,
        name: &str,
    ) -> Result<Vec<u8>, HybridStorageError> {
        let filename = ensure_json_extension(name);

        // Standardize path: .supreme/<subdirectory>/<filename>
        let local_path = self
            .root_path
            .join(".supreme")
            .join(subdirectory)
            .join(&filename);

        if local_path.exists() {
            return Ok(fs::read(&local_path)?);
        }

        if self.api_url.is_some() {
            let data = self.fetch_snapshot(subdirectory, &filename)?;
            // Cache locally
            fs::create_dir_all(
                local_path
                    .parent()
                    .ok_or_else(|| io::Error::other("Local path has no parent directory"))?,
            )?;
            fs::write(&local_path, &data)?;
            Ok(data)
        } else {
            Err(HybridStorageError::NotFound(filename))
        }
    }

    fn fetch_snapshot(
        &self,
        subdirectory: &str,
        filename: &str,
    ) -> Result<Vec<u8>, HybridStorageError> {
        let client = self
            .client
            .as_ref()
            .ok_or_else(|| io::Error::other("Online storage not configured"))?;
        let base_url = self
            .api_url
            .as_ref()
            .ok_or_else(|| io::Error::other("Online storage not configured"))?
            .trim_end_matches('/');

        let filename_json = ensure_json_extension(filename);
        let url = format!("{base_url}/{subdirectory}/{filename_json}");

        let response = client.get(&url).call()?;
        if response.status().is_success() {
            let mut bytes = Vec::new();
            use std::io::Read;
            response.into_body().into_reader().read_to_end(&mut bytes)?;
            Ok(bytes)
        } else {
            Err(OnlineStorageError::NotFound(format!("URL: {subdirectory}/{filename_json}")).into())
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::tempdir;

    #[test]
    fn fetch_and_cache_snapshot_reads_from_local_cache_first() {
        let dir = tempdir().unwrap();
        let storage = GameStorage::new(dir.path());
        let cache_dir = dir.path().join(".supreme").join("replays");
        fs::create_dir_all(&cache_dir).unwrap();
        fs::write(cache_dir.join("my_replay.json"), b"cached data").unwrap();

        let data = storage
            .fetch_and_cache_snapshot("replays", "my_replay")
            .expect("fetch_and_cache_snapshot");
        assert_eq!(data, b"cached data");
    }

    #[test]
    fn fetch_and_cache_snapshot_returns_not_found_when_offline_and_uncached() {
        let dir = tempdir().unwrap();
        let storage = GameStorage::new(dir.path());
        let result = storage.fetch_and_cache_snapshot("replays", "missing");
        assert!(matches!(result, Err(HybridStorageError::NotFound(_))));
    }

    #[test]
    fn save_and_upload_snapshot_writes_local_cache_even_when_offline() {
        let dir = tempdir().unwrap();
        let storage = GameStorage::new(dir.path());

        storage
            .upload_profile("my_profile", b"profile-bytes", None)
            .expect("upload_profile should succeed locally when offline");

        let cached = dir
            .path()
            .join(".supreme")
            .join("profiles")
            .join("my_profile.json");
        assert!(cached.exists());
        assert_eq!(fs::read(cached).unwrap(), b"profile-bytes");
    }
}