storage_manager.hpp

/**
 * @file storage_manager.hpp
 * @brief Storage Manager for persistent database files
 */

#ifndef CLOUDSQL_STORAGE_STORAGE_MANAGER_HPP
#define CLOUDSQL_STORAGE_STORAGE_MANAGER_HPP

#include <atomic>
#include <fstream>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>

namespace cloudsql::storage {

/**
 * @brief Manages low-level disk I/O and page-level access
 * @note StorageManager is not thread-safe for concurrent file operations.
 *       The atomics in Stats are for aggregation of counters, not concurrent
 *       file access. Use external synchronization (e.g., a lock) if multiple
 *       threads will access the same StorageManager instance.
 */
class StorageManager {
   public:
    static constexpr uint32_t PAGE_SIZE = 4096;
    static constexpr int DEFAULT_DIR_MODE = 0755;

    struct Stats {
        std::atomic<uint64_t> pages_read{0};
        std::atomic<uint64_t> pages_written{0};
        std::atomic<uint64_t> bytes_read{0};
        std::atomic<uint64_t> bytes_written{0};
        std::atomic<uint32_t> files_opened{0};
    };

    explicit StorageManager(std::string data_dir);
    ~StorageManager();

    // Disable copy/move for storage manager (due to atomic stats)
    StorageManager(const StorageManager&) = delete;
    StorageManager& operator=(const StorageManager&) = delete;
    StorageManager(StorageManager&&) = delete;
    StorageManager& operator=(StorageManager&&) = delete;

    /**
     * @brief Get storage statistics
     */
    [[nodiscard]] const Stats& get_stats() const { return stats_; }

    /**
     * @brief Open a database file
     */
    bool open_file(const std::string& filename);

    /**
     * @brief Close a database file
     */
    bool close_file(const std::string& filename);

    /**
     * @brief Read a page from disk into buffer
     * @param filename Name of the database file
     * @param page_num Page index
     * @param buffer Pre-allocated buffer of at least PAGE_SIZE
     * @return true on success
     */
    bool read_page(const std::string& filename, uint32_t page_num, char* buffer);

    /**
     * @brief Write a page from buffer to disk
     * @param filename Name of the database file
     * @param page_num Page index
     * @param buffer Buffer containing data to write
     * @return true on success
     */
    bool write_page(const std::string& filename, uint32_t page_num, const char* buffer);

    /**
     * @brief Allocate a new page in the database file
     * @param filename Name of the database file
     * @return index of the newly allocated page
     */
    uint32_t allocate_page(const std::string& filename);

    /**
     * @brief Deallocate a page (stub for future use)
     */
    static void deallocate_page(const std::string& filename, uint32_t page_num);

    /**
     * @brief Resolves the full filesystem path for a given filename within the storage directory.
     * @param filename The relative name of the file.
     * @return The absolute or relative path from the process root.
     */
    [[nodiscard]] std::string get_full_path(const std::string& filename) const;

    /**
     * @brief Check if a file exists
     */
    [[nodiscard]] bool file_exists(const std::string& filename) const;

    /**
     * @brief Create data directory if not exists
     */
    bool create_dir_if_not_exists();

    /**
     * @brief Delete a file from storage
     * @param filename The relative name of the file
     * @return true if deleted, false otherwise
     */
    bool delete_file(const std::string& filename);

   private:
    std::string data_dir_;
    std::unordered_map<std::string, std::fstream*> open_files_;
    std::unordered_map<std::string, std::streamoff> file_sizes_;
    std::mutex file_sizes_mutex_;
    Stats stats_;
};

}  // namespace cloudsql::storage

#endif  // CLOUDSQL_STORAGE_STORAGE_MANAGER_HPP