supreme_fs/game_storage/online/

upload.rs

//! The unified chunked-upload primitive used for both snapshot and content
//! uploads, plus the server upload-limit query it depends on.

use super::util::compute_chunk_size;
use crate::game_storage::GameStorage;
use crate::{HybridStorageError, SnapshotEvent};
use sha2::{Digest, Sha256};
use std::io;
use std::sync::mpsc::Sender;

impl GameStorage {
    /// Get maximum upload size from server
    pub fn get_max_upload_size(&self) -> Result<usize, HybridStorageError> {
        if let Some(api_url) = &self.api_url {
            let client = self
                .client
                .as_ref()
                .ok_or_else(|| io::Error::other("Online storage not configured"))?;

            let url = format!("{api_url}?action=get_upload_limits");
            if let Ok(response) = client.get(&url).call() {
                #[derive(serde::Deserialize)]
                struct UploadLimits {
                    max_upload_size: usize,
                }

                if let Ok(limits) = response.into_body().read_json::<UploadLimits>() {
                    return Ok(limits.max_upload_size);
                }
            }
        }

        // Default fallback - assume 8MB limit
        Ok(8 * 1024 * 1024)
    }

    /// Unified chunked upload for all files (single chunk for small files, multiple for large)
    pub fn upload_file_unified(
        &self,
        subdirectory: &str,
        data: &[u8],
        file_type: &str, // "snapshot" or "content"
        filename: Option<&str>,
        tx: Option<Sender<SnapshotEvent>>,
    ) -> Result<(), HybridStorageError> {
        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"))?;

        // Calculate Hash of the data (we need this for the final filename)
        let hash = {
            let mut hasher = Sha256::new();
            hasher.update(data);
            hex::encode(hasher.finalize())
        };

        let filename = match filename {
            Some(f) => f.to_string(),
            None => {
                if file_type == "snapshot" {
                    format!("{hash}.json")
                } else {
                    hash.clone()
                }
            }
        };

        // Get server upload limits to determine optimal chunk size
        let max_upload_size = self.get_max_upload_size()?;
        let chunk_size = compute_chunk_size(max_upload_size);

        let total_chunks = data.len().div_ceil(chunk_size);

        // Debug logging
        if let Some(ref sender) = tx {
            let _ = sender.send(SnapshotEvent::Log(format!(
                "Data length: {} bytes, chunk size: {} bytes, total chunks: {}",
                data.len(),
                chunk_size,
                total_chunks
            )));
        }

        // Use SHA256 of the complete file as upload ID (unique and verifiable)
        let upload_id = hash.clone();

        // Send progress init if we have a sender
        if let Some(ref sender) = tx {
            let _ = sender.send(SnapshotEvent::InitProgress(total_chunks));
            let _ = sender.send(SnapshotEvent::Log(format!(
                "Uploading {total_chunks} chunks (chunk size: {chunk_size} bytes)"
            )));
        }

        // Upload each chunk
        for (chunk_index, chunk) in data.chunks(chunk_size).enumerate() {
            // Calculate chunk hash for integrity verification
            let chunk_hash = {
                let mut hasher = Sha256::new();
                hasher.update(chunk);
                hex::encode(hasher.finalize())
            };

            // Send progress update
            if let Some(ref sender) = tx {
                let _ = sender.send(SnapshotEvent::SetStatus(format!(
                    "Uploading chunk {}/{}",
                    chunk_index + 1,
                    total_chunks
                )));
            }

            use super::multipart::{MultipartForm, SendMultipart};

            let part_filename = format!("chunk_{chunk_index}_{chunk_hash}");
            let mut form = MultipartForm::new()
                .bytes(
                    "chunk_file",
                    &part_filename,
                    "application/octet-stream",
                    chunk,
                )
                .text("chunk_index", chunk_index.to_string())
                .text("total_chunks", total_chunks.to_string())
                .text("original_filename", filename.clone())
                .text("upload_id", upload_id.clone())
                .text("chunk_hash", chunk_hash)
                .text("file_type", file_type);

            if file_type == "content" {
                form = form.text("hash", filename.clone());
            }

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

            let response = client.post(api_url).send_multipart(form)?;

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

            // Send progress increment
            if let Some(ref sender) = tx {
                let _ = sender.send(SnapshotEvent::IncrementProgress);
            }

            // Check if this was the last chunk and processing is complete
            #[derive(serde::Deserialize)]
            struct ChunkResponse {
                status: Option<String>,
                missing_files: Option<Vec<String>>,
            }

            if let Ok(response_data) = response.into_body().read_json::<ChunkResponse>()
                && response_data.status.as_deref() != Some("chunk_received")
            {
                // This was the last chunk and processing is complete
                if file_type == "snapshot" {
                    if let Some(missing) = response_data.missing_files {
                        let total_missing = missing.len();

                        // Notify user about missing content files
                        if let Some(ref sender) = tx {
                            let msg = format!(
                                "Uploading {} missing content file{}...",
                                total_missing,
                                if total_missing == 1 { "" } else { "s" }
                            );
                            let _ = sender.send(SnapshotEvent::Log(msg.clone()));
                            let _ = sender.send(SnapshotEvent::SetStatus(msg));
                        }

                        for (index, hash) in missing.into_iter().enumerate() {
                            // Update status for each content file
                            if let Some(ref sender) = tx {
                                let _ = sender.send(SnapshotEvent::SetStatus(format!(
                                    "Uploading content file {}/{}",
                                    index + 1,
                                    total_missing
                                )));
                            }

                            // Upload missing content
                            let content_path_xz = self.contents_path().join(format!("{hash}.xz"));
                            let content_path_raw = self.contents_path().join(&hash);

                            if let Ok(content_data) = std::fs::read(&content_path_xz) {
                                let filename = format!("{hash}.xz");
                                if let Some(ref sender) = tx {
                                    let _ = sender.send(SnapshotEvent::Log(format!(
                                        "Uploading content file: {} ({} bytes)",
                                        filename,
                                        content_data.len()
                                    )));
                                }
                                self.upload_content_file(&filename, &content_data)?;
                            } else if let Ok(content_data) = std::fs::read(&content_path_raw) {
                                if let Some(ref sender) = tx {
                                    let _ = sender.send(SnapshotEvent::Log(format!(
                                        "Uploading content file: {} ({} bytes)",
                                        hash,
                                        content_data.len()
                                    )));
                                }
                                self.upload_content_file(&hash, &content_data)?;
                            }
                        }

                        // Log completion of content file uploads
                        if let Some(ref sender) = tx {
                            let _ = sender.send(SnapshotEvent::Log(format!(
                                "Uploaded {} content file{}",
                                total_missing,
                                if total_missing == 1 { "" } else { "s" }
                            )));
                        }
                    }

                    // Commit the snapshot
                    if let Some(ref sender) = tx {
                        let _ =
                            sender.send(SnapshotEvent::Log("Committing snapshot...".to_string()));
                        let _ = sender.send(SnapshotEvent::SetStatus(
                            "Committing snapshot...".to_string(),
                        ));
                    }
                    self.commit_snapshot_type(subdirectory, &filename)?;

                    // Send completion status
                    if let Some(ref sender) = tx {
                        let _ =
                            sender.send(SnapshotEvent::SetStatus("Upload complete!".to_string()));
                    }
                }

                return Ok(());
            }
        }

        Ok(())
    }
}