librats 0.7.2 → 0.9.0

package/native-src/src/file_transfer.h

@@ -1,567 +1,286 @@
 #pragma once
 
-#include "socket.h"
+// =============================================================================
+// File / directory transfer for librats
+// =============================================================================
+//
+// A transfer streams one file or a whole directory tree to a connected peer
+// over the reliable (and, when enabled, encrypted) RatsClient connection.
+//
+// Wire protocol (see file_transfer.cpp for the exact framing):
+//   * Control messages travel on the named-message channel as JSON:
+//       ft_offer    sender  -> receiver : manifest of files to be sent
+//       ft_response receiver-> sender   : accepted / rejected
+//       ft_file_end sender  -> receiver : SHA-256 of a file once fully streamed
+//       ft_progress receiver-> sender   : bytes received so far (drives backpressure)
+//       ft_complete receiver-> sender   : transfer finished (success / failure)
+//       ft_control  either  -> either   : pause / resume / cancel
+//   * File data travels on the binary channel as self-describing chunk frames.
+//
+// Design notes:
+//   * The transport is reliable and ordered, so chunks are streamed strictly
+//     sequentially - there is no per-chunk retransmission. Integrity is checked
+//     with a per-chunk CRC32 and a whole-file SHA-256.
+//   * Backpressure: the sender keeps at most `window_bytes` un-acknowledged and
+//     waits for `ft_progress` before sending more, so memory stays bounded.
+//   * Received data is written to a temp file and only moved to its final path
+//     after the SHA-256 matches, so a failed transfer never leaves a bad file.
+//
+// =============================================================================
+
 #include "json.hpp"
-#include <string>
-#include <vector>
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <cstdint>
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <unordered_map>
-#include <atomic>
-#include <chrono>
-#include <thread>
 #include <queue>
-#include <condition_variable>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
 
 namespace librats {
 
-// Forward declaration
 class RatsClient;
+struct Transfer; // internal per-transfer state, defined in file_transfer.cpp
+
+// -----------------------------------------------------------------------------
+// Public enums
+// -----------------------------------------------------------------------------
 
-/**
- * File transfer status codes
- */
 enum class FileTransferStatus {
-    PENDING,        // Transfer queued but not started
-    STARTING,       // Transfer initialization in progress
-    IN_PROGRESS,    // Transfer actively sending/receiving chunks
-    PAUSED,         // Transfer temporarily paused
-    COMPLETED,      // Transfer completed successfully
-    FAILED,         // Transfer failed due to error
-    CANCELLED,      // Transfer cancelled by user
-    RESUMING        // Transfer resuming from interruption
+    PENDING,      // incoming offer awaiting accept/reject, or outgoing offer awaiting response
+    STARTING,     // accepted, about to move data
+    IN_PROGRESS,  // actively transferring
+    PAUSED,       // paused by either side
+    COMPLETED,    // finished successfully
+    FAILED,       // finished with an error
+    CANCELLED,    // cancelled by either side
+    RESUMING      // transient state between PAUSED and IN_PROGRESS
 };
 
-/**
- * File transfer direction
- */
 enum class FileTransferDirection {
-    SENDING,        // We are sending the file
-    RECEIVING       // We are receiving the file
+    SENDING,
+    RECEIVING
 };
 
-// Note: Compression removed as requested - only binary chunks needed
-
-/**
- * File transfer chunk information
- */
-struct FileChunk {
-    std::string transfer_id;        // Unique transfer identifier
-    uint64_t chunk_index;           // Sequential chunk number (0-based)
-    uint64_t total_chunks;          // Total number of chunks in transfer
-    uint64_t chunk_size;            // Size of this specific chunk
-    uint64_t file_offset;           // Offset in the original file
-    std::vector<uint8_t> data;      // Chunk data payload
-    std::string checksum;           // SHA256 checksum of chunk data
-    
-    FileChunk() : chunk_index(0), total_chunks(0), chunk_size(0), 
-                  file_offset(0) {}
-};
+// Human-readable name of a status, e.g. "IN_PROGRESS". Never returns null.
+const char* file_transfer_status_name(FileTransferStatus status);
 
-/**
- * File metadata for transfers
- */
-struct FileMetadata {
-    std::string filename;           // Original filename
-    std::string relative_path;      // Relative path within directory structure
-    uint64_t file_size;             // Total file size in bytes
-    uint64_t last_modified;         // Last modification timestamp
-    std::string mime_type;          // MIME type of the file
-    std::string checksum;           // Full file checksum
-    
-    FileMetadata() : file_size(0), last_modified(0) {}
+// -----------------------------------------------------------------------------
+// Public data structures
+// -----------------------------------------------------------------------------
+
+// One file inside a transfer. A single-file transfer has exactly one entry; a
+// directory transfer has one per regular file.
+struct FileInfo {
+    std::string relative_path; // POSIX-style path relative to the transfer root
+    uint64_t    size = 0;      // file size in bytes
 };
 
-/**
- * Directory transfer metadata
- */
-struct DirectoryMetadata {
-    std::string directory_name;     // Directory name
-    std::string relative_path;      // Relative path
-    std::vector<FileMetadata> files; // Files in this directory level
-    std::vector<DirectoryMetadata> subdirectories; // Nested directories
-    
-    // Calculate total transfer size
-    uint64_t get_total_size() const;
-    
-    // Get total file count
-    size_t get_total_file_count() const;
+// Description of an incoming transfer, delivered to the offer callback so the
+// application can decide whether to accept() or reject() it.
+struct IncomingTransferOffer {
+    std::string transfer_id;
+    std::string peer_id;
+    std::string name;             // file name, or directory name
+    bool        is_directory = false;
+    uint64_t    total_size = 0;   // sum of all file sizes
+    std::vector<FileInfo> files;  // full manifest
 };
 
-/**
- * File transfer progress information
- */
+// Immutable snapshot of a transfer's progress. Returned by queries and passed
+// to the progress callback.
 struct FileTransferProgress {
-    std::string transfer_id;        // Transfer identifier
-    std::string peer_id;            // Peer we're transferring with
-    FileTransferDirection direction; // Send or receive
-    FileTransferStatus status;      // Current status
-    
-    // File information
-    std::string filename;           // File being transferred
-    std::string local_path;         // Local file path
-    uint64_t file_size;             // Total file size
-    
-    // Progress tracking
-    uint64_t bytes_transferred;     // Bytes completed
-    uint64_t total_bytes;           // Total bytes to transfer
-    uint32_t chunks_completed;      // Chunks successfully transferred
-    uint32_t total_chunks;          // Total chunks in transfer
-    
-    // Performance metrics
-    std::chrono::steady_clock::time_point start_time;    // Transfer start time
-    std::chrono::steady_clock::time_point last_update;   // Last progress update
-    double transfer_rate_bps;       // Current transfer rate (bytes/second)
-    double average_rate_bps;        // Average transfer rate since start
-    std::chrono::milliseconds estimated_time_remaining; // ETA
-    
-    // Error information
-    std::string error_message;      // Error details if failed
-    uint32_t retry_count;           // Number of retries attempted
-    
-    FileTransferProgress() : direction(FileTransferDirection::SENDING), 
-                           status(FileTransferStatus::PENDING),
-                           file_size(0), bytes_transferred(0), total_bytes(0),
-                           chunks_completed(0), total_chunks(0),
-                           transfer_rate_bps(0.0), average_rate_bps(0.0),
-                           retry_count(0) {
-        start_time = std::chrono::steady_clock::now();
-        last_update = start_time;
-    }
-    
-    // Calculate completion percentage (0.0 to 100.0)
+    std::string transfer_id;
+    std::string peer_id;
+    FileTransferDirection direction = FileTransferDirection::SENDING;
+    FileTransferStatus    status    = FileTransferStatus::PENDING;
+
+    std::string filename;     // file name, or directory name
+    std::string local_path;   // local source (sending) or destination (receiving)
+    bool        is_directory = false;
+
+    uint64_t bytes_transferred = 0;
+    uint64_t total_bytes       = 0;
+    uint32_t files_completed   = 0;
+    uint32_t total_files       = 0;
+
+    double transfer_rate_bps = 0.0; // recent throughput, bytes/second
+    double average_rate_bps  = 0.0; // average throughput since start
+
+    std::chrono::milliseconds elapsed_time{0};
+    std::chrono::milliseconds estimated_time_remaining{0};
+
+    std::string error_message; // populated when status == FAILED
+
+    // Completion as a percentage in [0, 100].
     double get_completion_percentage() const {
-        if (total_bytes == 0) return 0.0;
-        return (static_cast<double>(bytes_transferred) / total_bytes) * 100.0;
-    }
-    
-    // Calculate elapsed time
-    std::chrono::milliseconds get_elapsed_time() const {
-        return std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::steady_clock::now() - start_time);
+        if (total_bytes == 0) {
+            return status == FileTransferStatus::COMPLETED ? 100.0 : 0.0;
+        }
+        return (static_cast<double>(bytes_transferred) / static_cast<double>(total_bytes)) * 100.0;
     }
-    
-    // Update transfer rate calculations
-    void update_transfer_rates(uint64_t new_bytes_transferred);
+
+    std::chrono::milliseconds get_elapsed_time() const { return elapsed_time; }
 };
 
-/**
- * File transfer configuration
- */
+// -----------------------------------------------------------------------------
+// Configuration
+// -----------------------------------------------------------------------------
+
 struct FileTransferConfig {
-    uint32_t chunk_size;            // Size of each chunk (default: 64KB)
-    uint32_t max_concurrent_chunks; // Max chunks in flight (default: 4)
-    uint32_t max_retries;           // Max retry attempts per chunk (default: 3)
-    uint32_t timeout_seconds;       // Timeout per chunk (default: 30)
-    bool verify_checksums;          // Verify chunk checksums (default: true)
-    bool allow_resume;              // Allow resuming interrupted transfers (default: true)
-    std::string temp_directory;     // Temporary directory for incomplete files
-    
-    FileTransferConfig() 
-        : chunk_size(65536),        // 64KB chunks
-          max_concurrent_chunks(4), 
-          max_retries(3),
-          timeout_seconds(30),
-          verify_checksums(true),
-          allow_resume(true),
-          temp_directory("./temp_transfers") {}
+    uint32_t chunk_size            = 64 * 1024;        // payload bytes per network chunk
+    uint32_t window_bytes          = 4 * 1024 * 1024;  // max un-acknowledged bytes in flight
+    uint32_t progress_interval     = 256 * 1024;       // receiver sends an ack every N bytes
+    uint32_t transfer_timeout_secs = 60;               // abort a transfer idle for this long
+    uint32_t worker_threads        = 4;                // concurrent outgoing transfers
+    bool     verify_integrity      = true;             // per-chunk CRC32 + whole-file SHA-256
+    std::string temp_directory     = "./rats_file_transfers"; // holds in-progress downloads
 };
 
-/**
- * Callback function types for file transfer events
- */
-using FileTransferProgressCallback = std::function<void(const FileTransferProgress&)>;
-using FileTransferCompletedCallback = std::function<void(const std::string& transfer_id, bool success, const std::string& error_message)>;
-using FileTransferRequestCallback = std::function<bool(const std::string& peer_id, const FileMetadata& metadata, const std::string& transfer_id)>;
-using DirectoryTransferProgressCallback = std::function<void(const std::string& transfer_id, const std::string& current_file, uint64_t files_completed, uint64_t total_files, uint64_t bytes_completed, uint64_t total_bytes)>;
-using FileRequestCallback = std::function<bool(const std::string& peer_id, const std::string& file_path, const std::string& transfer_id)>;
-using DirectoryRequestCallback = std::function<bool(const std::string& peer_id, const std::string& directory_path, bool recursive, const std::string& transfer_id)>;
-
-/**
- * File transfer manager class
- * Handles efficient chunked file transfers with resume capability
- */
+// -----------------------------------------------------------------------------
+// Callback types
+// -----------------------------------------------------------------------------
+
+// Invoked when a peer offers a transfer. The handler should eventually call
+// accept()/reject() (it may do so synchronously or later, from any thread).
+// If no offer callback is registered, incoming offers are auto-rejected.
+using TransferOfferCallback = std::function<void(const IncomingTransferOffer&)>;
+
+// Invoked periodically with a progress snapshot, for both directions.
+using TransferProgressCallback = std::function<void(const FileTransferProgress&)>;
+
+// Invoked once when a transfer reaches a terminal state.
+using TransferCompletedCallback =
+    std::function<void(const std::string& transfer_id, bool success, const std::string& error)>;
+
+// -----------------------------------------------------------------------------
+// FileTransferManager
+// -----------------------------------------------------------------------------
+
 class FileTransferManager {
 public:
-    /**
-     * Constructor
-     * @param client Reference to RatsClient for communication
-     * @param config Transfer configuration settings
-     */
-    FileTransferManager(RatsClient& client, const FileTransferConfig& config = FileTransferConfig());
-    
-    /**
-     * Destructor
-     */
+    explicit FileTransferManager(RatsClient& client,
+                                 const FileTransferConfig& config = FileTransferConfig());
     ~FileTransferManager();
-    
-    // Configuration
-    /**
-     * Update transfer configuration
-     * @param config New configuration settings
-     */
+
+    FileTransferManager(const FileTransferManager&) = delete;
+    FileTransferManager& operator=(const FileTransferManager&) = delete;
+
+    // --- configuration ---
     void set_config(const FileTransferConfig& config);
-    
-    /**
-     * Get current configuration
-     * @return Current configuration settings
-     */
-    const FileTransferConfig& get_config() const;
-    
-    /**
-     * Handle binary data that might be file transfer chunks
-     * @param peer_id Source peer ID  
-     * @param binary_data Binary data received
-     * @return true if this was a file transfer chunk, false otherwise
-     */
-    bool handle_binary_data(const std::string& peer_id, const std::vector<uint8_t>& binary_data);
-    
-    // Callback registration
-    /**
-     * Set progress callback for transfer updates
-     * @param callback Function to call with progress updates
-     */
-    void set_progress_callback(FileTransferProgressCallback callback);
-    
-    /**
-     * Set completion callback for transfer completion
-     * @param callback Function to call when transfers complete
-     */
-    void set_completion_callback(FileTransferCompletedCallback callback);
-    
-    /**
-     * Set incoming transfer request callback
-     * @param callback Function to call when receiving transfer requests
-     */
-    void set_request_callback(FileTransferRequestCallback callback);
-    
-    /**
-     * Set directory transfer progress callback
-     * @param callback Function to call with directory transfer progress
-     */
-    void set_directory_progress_callback(DirectoryTransferProgressCallback callback);
-    
-    /**
-     * Set file request callback (called when receiving file requests)
-     * @param callback Function to call when receiving file requests
-     */
-    void set_file_request_callback(FileRequestCallback callback);
-    
-    /**
-     * Set directory request callback (called when receiving directory requests)
-     * @param callback Function to call when receiving directory requests
-     */
-    void set_directory_request_callback(DirectoryRequestCallback callback);
-    
-    // File transfer operations
-    /**
-     * Send a file to a peer
-     * @param peer_id Target peer ID
-     * @param file_path Local file path to send
-     * @param remote_filename Optional remote filename (default: use local name)
-     * @return Transfer ID if successful, empty string if failed
-     */
-    std::string send_file(const std::string& peer_id, const std::string& file_path, 
-                         const std::string& remote_filename = "");
-    
-    /**
-     * Send a file with custom metadata
-     * @param peer_id Target peer ID
-     * @param file_path Local file path to send
-     * @param metadata Custom file metadata
-     * @return Transfer ID if successful, empty string if failed
-     */
-    std::string send_file_with_metadata(const std::string& peer_id, const std::string& file_path,
-                                       const FileMetadata& metadata);
-    
-    /**
-     * Send an entire directory to a peer
-     * @param peer_id Target peer ID
-     * @param directory_path Local directory path to send
-     * @param remote_directory_name Optional remote directory name
-     * @param recursive Whether to include subdirectories (default: true)
-     * @return Transfer ID if successful, empty string if failed
-     */
+    FileTransferConfig get_config() const;
+
+    // --- starting transfers ---
+    // Returns a transfer id, or "" on immediate failure (e.g. missing file).
+    std::string send_file(const std::string& peer_id, const std::string& file_path,
+                          const std::string& remote_name = "");
     std::string send_directory(const std::string& peer_id, const std::string& directory_path,
-                              const std::string& remote_directory_name = "", bool recursive = true);
-    
-    /**
-     * Request a file from a remote peer
-     * @param peer_id Target peer ID
-     * @param remote_file_path Path to file on remote peer
-     * @param local_path Local path where file should be saved
-     * @return Transfer ID if successful, empty string if failed
-     */
-    std::string request_file(const std::string& peer_id, const std::string& remote_file_path,
-                            const std::string& local_path);
-    
-    /**
-     * Request a directory from a remote peer
-     * @param peer_id Target peer ID
-     * @param remote_directory_path Path to directory on remote peer
-     * @param local_directory_path Local path where directory should be saved
-     * @param recursive Whether to include subdirectories (default: true)
-     * @return Transfer ID if successful, empty string if failed
-     */
-    std::string request_directory(const std::string& peer_id, const std::string& remote_directory_path,
-                                 const std::string& local_directory_path, bool recursive = true);
-    
-    /**
-     * Accept an incoming file transfer
-     * @param transfer_id Transfer identifier from request
-     * @param local_path Local path where file should be saved
-     * @return true if accepted successfully
-     */
-    bool accept_file_transfer(const std::string& transfer_id, const std::string& local_path);
-    
-    /**
-     * Reject an incoming file transfer
-     * @param transfer_id Transfer identifier from request
-     * @param reason Optional reason for rejection
-     * @return true if rejected successfully
-     */
-    bool reject_file_transfer(const std::string& transfer_id, const std::string& reason = "");
-    
-    /**
-     * Accept an incoming directory transfer
-     * @param transfer_id Transfer identifier from request
-     * @param local_path Local path where directory should be saved
-     * @return true if accepted successfully
-     */
-    bool accept_directory_transfer(const std::string& transfer_id, const std::string& local_path);
-    
-    /**
-     * Reject an incoming directory transfer
-     * @param transfer_id Transfer identifier from request
-     * @param reason Optional reason for rejection
-     * @return true if rejected successfully
-     */
-    bool reject_directory_transfer(const std::string& transfer_id, const std::string& reason = "");
-    
-    // Transfer control
-    /**
-     * Pause an active transfer
-     * @param transfer_id Transfer to pause
-     * @return true if paused successfully
-     */
-    bool pause_transfer(const std::string& transfer_id);
-    
-    /**
-     * Resume a paused transfer
-     * @param transfer_id Transfer to resume
-     * @return true if resumed successfully
-     */
-    bool resume_transfer(const std::string& transfer_id);
-    
-    /**
-     * Cancel an active or paused transfer
-     * @param transfer_id Transfer to cancel
-     * @return true if cancelled successfully
-     */
-    bool cancel_transfer(const std::string& transfer_id);
-    
-    /**
-     * Retry a failed transfer
-     * @param transfer_id Transfer to retry
-     * @return true if retry initiated successfully
-     */
-    bool retry_transfer(const std::string& transfer_id);
-    
-    // Information and monitoring
-    /**
-     * Get progress information for a transfer
-     * @param transfer_id Transfer to query
-     * @return Progress information or nullptr if not found
-     */
-    std::shared_ptr<FileTransferProgress> get_transfer_progress(const std::string& transfer_id) const;
-    
-    /**
-     * Get all active transfers
-     * @return Vector of transfer progress objects
-     */
+                               const std::string& remote_name = "");
+
+    // --- responding to an incoming offer ---
+    // For a single file, local_path is the destination file path.
+    // For a directory, local_path is the destination directory.
+    bool accept(const std::string& transfer_id, const std::string& local_path);
+    bool reject(const std::string& transfer_id, const std::string& reason = "");
+
+    // --- controlling an active transfer (works from either side) ---
+    bool pause(const std::string& transfer_id);
+    bool resume(const std::string& transfer_id);
+    bool cancel(const std::string& transfer_id);
+
+    // --- queries ---
+    std::shared_ptr<FileTransferProgress> get_progress(const std::string& transfer_id) const;
     std::vector<std::shared_ptr<FileTransferProgress>> get_active_transfers() const;
-    
-    /**
-     * Get transfer history
-     * @param limit Maximum number of entries to return (0 for all)
-     * @return Vector of completed transfer progress objects
-     */
-    std::vector<std::shared_ptr<FileTransferProgress>> get_transfer_history(size_t limit = 0) const;
-    
-    /**
-     * Clear transfer history
-     */
-    void clear_transfer_history();
-    
-    /**
-     * Get statistics about transfers
-     * @return JSON object with transfer statistics
-     */
-    nlohmann::json get_transfer_statistics() const;
-    
-    // Utility functions
-    /**
-     * Calculate file checksum
-     * @param file_path Path to file
-     * @param algorithm Hash algorithm ("md5", "sha256")
-     * @return Checksum string or empty if failed
-     */
-    static std::string calculate_file_checksum(const std::string& file_path, const std::string& algorithm = "sha256");
-    
-    /**
-     * Get file metadata
-     * @param file_path Path to file
-     * @return File metadata structure
-     */
-    static FileMetadata get_file_metadata(const std::string& file_path);
-    
-    /**
-     * Get directory metadata
-     * @param directory_path Path to directory
-     * @param recursive Whether to scan recursively
-     * @return Directory metadata structure
-     */
-    static DirectoryMetadata get_directory_metadata(const std::string& directory_path, bool recursive = true);
-    
-    /**
-     * Validate file path and permissions
-     * @param file_path Path to validate
-     * @param check_write Whether to check write permissions
-     * @return true if valid and accessible
-     */
-    static bool validate_file_path(const std::string& file_path, bool check_write = false);
+    nlohmann::json get_statistics() const;
+
+    // --- callbacks ---
+    void set_offer_callback(TransferOfferCallback callback);
+    void set_progress_callback(TransferProgressCallback callback);
+    void set_completed_callback(TransferCompletedCallback callback);
+
+    // --- hooks invoked by RatsClient (not part of the application API) ---
+    // Returns true if the binary data was a file-transfer chunk frame.
+    bool handle_binary_data(const std::string& peer_id, const std::vector<uint8_t>& data);
+    void on_peer_disconnected(const std::string& peer_id);
+
+    // --- utilities ---
+    // Hex-encoded SHA-256 of a file, or "" if it cannot be read.
+    static std::string compute_file_sha256(const std::string& path);
 
 private:
+    // --- setup / teardown ---
+    void register_handlers();
+    void worker_loop();
+    void maintenance_loop();
+
+    // --- sending ---
+    std::string start_send(const std::string& peer_id, const std::shared_ptr<Transfer>& t,
+                           const std::string& name);
+    void run_send(const std::shared_ptr<Transfer>& t);
+    void queue_send(const std::string& transfer_id);
+
+    // --- control message handlers ---
+    void on_offer(const std::string& peer_id, const nlohmann::json& msg);
+    void on_response(const std::string& peer_id, const nlohmann::json& msg);
+    void on_file_end(const std::string& peer_id, const nlohmann::json& msg);
+    void on_progress(const std::string& peer_id, const nlohmann::json& msg);
+    void on_complete(const std::string& peer_id, const nlohmann::json& msg);
+    void on_control(const std::string& peer_id, const nlohmann::json& msg);
+
+    // --- receiving ---
+    void on_chunk(const std::string& transfer_id, const std::string& peer_id,
+                  uint32_t file_index, uint64_t offset,
+                  const uint8_t* data, uint32_t len, uint32_t crc);
+    void try_finalize_file(const std::shared_ptr<Transfer>& t, size_t file_index);
+
+    // --- shared helpers ---
+    std::shared_ptr<Transfer> find(const std::string& transfer_id) const;
+    void finish(const std::shared_ptr<Transfer>& t, bool success, const std::string& error);
+    void emit_progress(const std::shared_ptr<Transfer>& t);
+    FileTransferProgress snapshot(const std::shared_ptr<Transfer>& t) const; // call with t->mtx held
+    void send_control(const std::shared_ptr<Transfer>& t, const std::string& action);
+    void cleanup_temp_files(const std::shared_ptr<Transfer>& t);
+
     RatsClient& client_;
+
+    mutable std::mutex config_mutex_;
     FileTransferConfig config_;
-    
-    // Transfer tracking
+
+    // All transfers, active and recently finished, keyed by transfer id.
     mutable std::mutex transfers_mutex_;
-    std::unordered_map<std::string, std::shared_ptr<FileTransferProgress>> active_transfers_;
-    std::unordered_map<std::string, std::shared_ptr<FileTransferProgress>> completed_transfers_;
-    
-    // Pending transfers (not yet accepted/rejected)
-    mutable std::mutex pending_mutex_;
-    struct PendingFileTransfer {
-        FileMetadata metadata;
-        std::string peer_id;
-    };
-    struct PendingDirectoryTransfer {
-        DirectoryMetadata metadata;
-        std::string peer_id;
-    };
-    std::unordered_map<std::string, PendingFileTransfer> pending_transfers_;
-    std::unordered_map<std::string, PendingDirectoryTransfer> pending_directory_transfers_;
-    
-    // Active directory transfers
-    mutable std::mutex directory_transfers_mutex_;
-    std::unordered_map<std::string, DirectoryMetadata> active_directory_transfers_;
-    
-    // Chunk management
-    mutable std::mutex chunks_mutex_;
-    std::unordered_map<std::string, std::queue<FileChunk>> outgoing_chunks_;
-    std::unordered_map<std::string, std::unordered_map<uint64_t, FileChunk>> received_chunks_;
-    
-    // Active chunk transfers waiting for binary data
-    struct PendingChunk {
-        std::string transfer_id;
-        uint64_t chunk_index;
-        uint64_t total_chunks;
-        uint64_t chunk_size;
-        uint64_t file_offset;
-        std::string checksum;
-        std::chrono::steady_clock::time_point created_at;
-    };
-    std::unordered_map<std::string, PendingChunk> pending_chunks_; // key: peer_id
-    
-    // Worker threads
-    std::vector<std::thread> worker_threads_;
-    std::atomic<bool> running_;
-    std::condition_variable work_condition_;
-    std::mutex work_mutex_;
-    std::queue<std::string> work_queue_; // Transfer IDs that need processing
-    
-    // Cleanup thread synchronization
-    std::condition_variable cleanup_condition_;
-    std::mutex cleanup_mutex_;
-    
-    // Throttling synchronization
-    std::condition_variable throttle_condition_;
-    std::mutex throttle_mutex_;
-    
-    // Callbacks
-    FileTransferProgressCallback progress_callback_;
-    FileTransferCompletedCallback completion_callback_;
-    FileTransferRequestCallback request_callback_;
-    DirectoryTransferProgressCallback directory_progress_callback_;
-    FileRequestCallback file_request_callback_;
-    DirectoryRequestCallback directory_request_callback_;
-    
-    // Statistics
+    std::unordered_map<std::string, std::shared_ptr<Transfer>> transfers_;
+
+    // Outgoing transfers ready to be streamed by a worker thread.
+    std::mutex queue_mutex_;
+    std::condition_variable queue_cv_;
+    std::queue<std::string> send_queue_;
+
+    std::vector<std::thread> workers_;
+    std::thread maintenance_thread_;
+    std::mutex maintenance_mutex_;
+    std::condition_variable maintenance_cv_;
+    std::atomic<bool> running_{true};
+
+    mutable std::mutex callbacks_mutex_;
+    TransferOfferCallback offer_callback_;
+    TransferProgressCallback progress_callback_;
+    TransferCompletedCallback completed_callback_;
+
+    // Aggregate statistics.
     mutable std::mutex stats_mutex_;
-    uint64_t total_bytes_sent_;
-    uint64_t total_bytes_received_;
-    uint64_t total_files_sent_;
-    uint64_t total_files_received_;
-    std::chrono::steady_clock::time_point start_time_;
-    
-    // Private methods
-    void initialize();
-    void shutdown();
-    void worker_thread_loop();
-    void cleanup_thread_loop();
-    void process_transfer(const std::string& transfer_id);
-    
-    // Transfer management
-    std::string generate_transfer_id() const;
-    void start_file_send(const std::string& transfer_id);
-    void start_file_receive(const std::string& transfer_id);
-    void start_directory_send(const std::string& transfer_id);
-    void start_directory_receive(const std::string& transfer_id);
-    void handle_chunk_received(const FileChunk& chunk);
-    void handle_chunk_ack(const std::string& transfer_id, uint64_t chunk_index, bool success);
-    
-    // File operations
-    bool create_temp_file(const std::string& transfer_id, uint64_t file_size);
-    bool finalize_received_file(const std::string& transfer_id, const std::string& final_path);
-    
-    // Checksum validation
-    bool verify_chunk_checksum(const FileChunk& chunk);
-    std::string calculate_chunk_checksum(const std::vector<uint8_t>& data);
-    
-    // Network message handling
-    void handle_transfer_request(const std::string& peer_id, const nlohmann::json& message);
-    void handle_transfer_response(const std::string& peer_id, const nlohmann::json& message);
-    void handle_chunk_metadata_message(const std::string& peer_id, const nlohmann::json& message);
-    void handle_chunk_binary_message(const std::string& peer_id, const std::vector<uint8_t>& binary_data);
-    void handle_chunk_ack_message(const std::string& peer_id, const nlohmann::json& message);
-    void handle_transfer_control(const std::string& peer_id, const nlohmann::json& message);
-    void handle_file_request(const std::string& peer_id, const nlohmann::json& message);
-    void handle_directory_request(const std::string& peer_id, const nlohmann::json& message);
-    
-    // Message creation
-    nlohmann::json create_transfer_request_message(const FileMetadata& metadata, const std::string& transfer_id);
-    nlohmann::json create_transfer_response_message(const std::string& transfer_id, bool accepted, const std::string& reason = "");
-    std::vector<uint8_t> create_chunk_binary_message(const FileChunk& chunk);
-    nlohmann::json create_chunk_metadata_message(const FileChunk& chunk);
-    nlohmann::json create_chunk_ack_message(const std::string& transfer_id, uint64_t chunk_index, bool success, const std::string& error = "");
-    nlohmann::json create_control_message(const std::string& transfer_id, const std::string& action, const nlohmann::json& data = nlohmann::json::object());
-    
-    // Progress tracking
-    void update_transfer_progress(const std::string& transfer_id, uint64_t bytes_delta = 0);
-    void complete_transfer(const std::string& transfer_id, bool success, const std::string& error_message = "");
-    void move_to_completed(const std::string& transfer_id);
-    
-    // File system utilities
-    static bool ensure_directory_exists(const std::string& directory_path);
-    static std::string get_temp_file_path(const std::string& transfer_id, const std::string& temp_dir);
-    static std::string extract_filename(const std::string& file_path);
-    static std::string get_mime_type(const std::string& file_path);
-    
-    // Binary chunk transmission helper
-    bool parse_chunk_binary_header(const std::vector<uint8_t>& binary_data, FileChunk& chunk);
+    uint64_t stat_bytes_sent_ = 0;
+    uint64_t stat_bytes_received_ = 0;
+    uint64_t stat_files_sent_ = 0;
+    uint64_t stat_files_received_ = 0;
+    uint64_t stat_completed_ = 0;
+    uint64_t stat_failed_ = 0;
+    std::chrono::steady_clock::time_point started_at_;
 };
 
 } // namespace librats
-