rusty-store 0.2.4

use ron::ser::PrettyConfig;
use serde::{Deserialize, Serialize};
use std::fmt::Debug;
use std::fs::{self, File, OpenOptions};
use std::io::{Read, Seek, Write};
use std::path::PathBuf;
use thiserror::Error;

use log::debug;
use log::info;
use log::warn;

use crate::manager::StoreManager;

#[derive(Error, Debug)]
pub enum StoreError {
    #[error("RON parsing error: {0}")]
    RonParse(#[source] ron::error::SpannedError),

    #[error("RON error: {0}")]
    Ron(#[source] ron::error::Error),

    #[error("Failed to open file: {0}")]
    FileOpen(#[source] std::io::Error),

    #[error("Failed to read from file: {0}")]
    Read(#[source] std::io::Error),

    #[error("Failed to create directory: {0}")]
    CreateDir(#[source] std::io::Error),

    #[error("Failed to write to file: {0}")]
    Write(#[source] std::io::Error),
}

/// Represents the different types of storage locations that can be used for storing data.
///
/// The `StoringType` enum provides a way to specify where data should be stored, based on the
/// platform and the type of data. It includes variants for common storage locations such as
/// cache, data, and configuration directories, as well as a custom path option.
///
/// # Variants
///
/// - `Cache`: Path to the user's cache directory.
/// - `Data`: Path to the user's data directory.
/// - `Config`: Path to the user's configuration directory.
/// - `Custom(PathBuf)`: Custom path specified by the user.
#[derive(Debug, Default)]
pub enum StoringType {
    /// Path to the user's cache directory.
    ///
    /// |Platform | Value                               | Example                      |
    /// | ------- | ----------------------------------- | ---------------------------- |
    /// | Linux   | `$XDG_CACHE_HOME` or `$HOME`/.cache | /home/alice/.cache           |
    /// | macOS   | `$HOME`/Library/Caches              | /Users/Alice/Library/Caches  |
    /// | Windows | `{FOLDERID_LocalAppData}`           | C:\Users\Alice\AppData\Local |
    Cache,

    /// Path to the user's data directory.
    ///
    /// |Platform | Value                                    | Example                                  |
    /// | ------- | ---------------------------------------- | ---------------------------------------- |
    /// | Linux   | `$XDG_DATA_HOME` or `$HOME`/.local/share | /home/alice/.local/share                 |
    /// | macOS   | `$HOME`/Library/Application Support      | /Users/Alice/Library/Application Support |
    /// | Windows | `{FOLDERID_RoamingAppData}`              | C:\Users\Alice\AppData\Roaming           |
    #[default]
    Data,

    /// Path to the user's config directory.
    ///
    /// |Platform | Value                                 | Example                                  |
    /// | ------- | ------------------------------------- | ---------------------------------------- |
    /// | Linux   | `$XDG_CONFIG_HOME` or `$HOME`/.config | /home/alice/.config                      |
    /// | macOS   | `$HOME`/Library/Application Support   | /Users/Alice/Library/Application Support |
    /// | Windows | `{FOLDERID_RoamingAppData}`           | C:\Users\Alice\AppData\Roaming           |
    Config,

    /// Custom path of the store save location
    Custom(PathBuf),
}

/// Trait allowing a struct to be managed by `Storage`.
///
/// The `Storing` trait provides a way to specify the type of storage location for a struct.
/// It requires the struct to implement `Serialize`, `Deserialize`, and `Default` traits.
///
/// # Example
///
/// ```
/// use rusty_store::{Storage, StoreHandle, Storing, StoringType};
/// use serde::{Deserialize, Serialize};
///
///
/// #[derive(Serialize, Deserialize, Default)]
/// struct MyStore {
///     pub count: u32,
/// }
///
/// impl Storing for MyStore {
///     fn store_type() -> StoringType {
///         StoringType::Data
///     }
/// }
/// ```
pub trait Storing: Serialize + for<'de> Deserialize<'de> + Default {
    fn store_type() -> StoringType {
        StoringType::default()
    }
}

/// `StoreHandle` acts as a container that holds store data in memory and provides methods to access
/// and modify this data. The `StoreHandle` does not manage storage directly but facilitates the read and
/// write operations by holding the data and its identifier.
#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
pub struct StoreHandle<T> {
    store_id: String,
    store: T,
}

impl<T: Storing> StoreHandle<T> {
    /// Creates a new `StoreHandle` instance with the given `store_id`.
    ///
    /// # Arguments
    ///
    /// * `store_id` - A string slice that holds the identifier for the store.
    ///
    /// # Returns
    ///
    /// A new `StoreHandle` instance with the specified `store_id` and a default store.
    pub fn new(store_id: &str) -> Self {
        Self {
            store: T::default(),
            store_id: store_id.to_owned(),
        }
    }

    /// Sets the store data.
    ///
    /// # Arguments
    ///
    /// * `store` - The store data to be set.
    fn set_store(&mut self, store: T) {
        debug!("Setting store with id: {}", self.store_id);
        self.store = store;
    }

    /// Returns a mutable reference to the stored data.
    ///
    /// # Returns
    ///
    /// A mutable reference to the stored data.
    pub fn get_store_mut(&mut self) -> &mut T {
        &mut self.store
    }

    /// Returns a reference to the stored data.
    ///
    /// # Returns
    ///
    /// A reference to the stored data.
    pub fn get_store(&self) -> &T {
        &self.store
    }

    /// Returns a reference to the store identifier.
    ///
    /// # Returns
    ///
    /// A reference to the store identifier.
    pub fn store_id(&self) -> &str {
        &self.store_id
    }
}

/// Handles file system paths for reading from and writing to data storage.
///
/// The `Storage` struct provides a way to manage file paths used for storing data in different locations.
/// It simplifies the process of accessing and modifying data by providing methods for these operations.
///
/// # Example
///
/// ```
/// use rusty_store::{Storage, StoreHandle, Storing};
/// use serde::{Deserialize, Serialize};
///
/// #[derive(Serialize, Deserialize, Default, Storing)]
/// pub struct MyStore {
///     pub count: u32,
/// }
///
/// impl MyStore {
///     fn increment_count(&mut self) {
///         self.count += 1;
///     }
/// }
///
///
/// // Initialize the Storage with the defaults
/// let storage = Storage::new("APP_ID");
///
/// // Create a handle for managing the store data.
/// let mut handle = StoreHandle::<MyStore>::new("my_store_id");
///
/// // Read existing store from storage
/// storage
///     .read(&mut handle)
///     .expect("Failed to read from storage");
///
/// // Modify the store data
/// let counter = handle.get_store_mut();
///
/// counter.increment_count();
/// counter.increment_count();
/// counter.increment_count();
///
/// // Write changes to disk
/// storage
///     .write(&mut handle)
///     .expect("Failed to write to storage");
///
/// let counter = handle.get_store();
///
/// println!("Count: {}", counter.count);
/// ```
#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
pub struct Storage {
    cache_dir: PathBuf,
    data_dir: PathBuf,
    config_dir: PathBuf,
}

impl Storage {
    /// Creates a new `Storage` instance by obtaining the paths for cache, data, and configuration directories.
    ///
    /// # Panics
    ///
    /// - Panics if the cache directory, data directory, or configuration directory path cannot be determined.
    pub fn new(app_id: &str) -> Self {
        Self {
            data_dir: dirs::data_dir()
                .expect("Failed to determine cache directory path")
                .join(app_id),
            config_dir: dirs::config_dir()
                .expect("Failed to determine data directory path")
                .join(app_id),
            cache_dir: dirs::cache_dir()
                .expect("Failed to determine configuration directory path")
                .join(app_id),
        }
    }

    /// Creates a new `Storage` instance with specific cache, data, and config paths.
    ///
    /// # Arguments
    ///
    /// * `cache_dir` - A `PathBuf` representing the cache directory path.
    /// * `data_dir` - A `PathBuf` representing the data directory path.
    /// * `config_dir` - A `PathBuf` representing the configuration directory path.
    ///
    /// # Returns
    ///
    /// A new `Storage` instance with the specified cache, data, and config paths.
    ///
    /// # Example
    ///
    /// ```
    /// use std::path::PathBuf;
    /// use rusty_store::Storage;
    ///
    /// let cache_dir = PathBuf::from("/path/to/cache");
    /// let data_dir = PathBuf::from("/path/to/data");
    /// let config_dir = PathBuf::from("/path/to/config");
    ///
    /// let storage = Storage::from_dirs(cache_dir, data_dir, config_dir);
    /// ```
    pub fn from_dirs(cache_dir: PathBuf, data_dir: PathBuf, config_dir: PathBuf) -> Self {
        Self {
            cache_dir,
            data_dir,
            config_dir,
        }
    }

    /// Returns a new StoreManager of type `T` with the given `store_id`
    pub fn new_manager<T: Storing>(&self, store_id: &str) -> Result<StoreManager<T>, StoreError> {
        StoreManager::<T>::new(self, store_id)
    }

    /// Returns a new Handle of type `T` with the given `store_id`
    pub fn new_handle<T: Storing>(&self, store_id: &str) -> StoreHandle<T> {
        StoreHandle::<T>::new(store_id)
    }

    /// Reads the store from a file and updates the provided `StoreHandle`.
    /// If the file does not exist, it creates a default store if a default is available.
    ///
    /// # Example
    ///
    /// ```
    /// use rusty_store::{Storage, StoreHandle, Storing};
    /// use serde::{Deserialize, Serialize};
    ///
    /// #[derive(Serialize, Deserialize, Default, Storing)]
    /// pub struct MyStore {
    ///     pub count: u32,
    /// }
    ///
    /// impl MyStore {
    ///     fn increment_count(&mut self) {
    ///         self.count += 1;
    ///     }
    /// }
    ///
    /// let storage = Storage::new("APP_ID");
    /// let mut handle: StoreHandle<MyStore> = StoreHandle::new("my_store_id");
    ///
    /// storage.read(&mut handle).expect("Failed to read store");
    ///
    /// ```
    pub fn read<T: Storing>(&self, handle: &mut StoreHandle<T>) -> Result<(), StoreError> {
        debug!("Reading store with id: {}", handle.store_id());
        self.open_file::<T, _>(
            |file, handle| {
                let store = Self::read_string(file).map_err(StoreError::Read)?;
                let store_data: T = ron::from_str(&store).map_err(StoreError::RonParse)?;

                handle.set_store(store_data);

                info!("Successfully read store with id: {}", handle.store_id());
                Ok(())
            },
            handle,
        )
    }

    /// Writes the current store `T` from the provided `StoreHandle` to a file.
    /// If the file does not exist, it creates a default store if a default is available.
    ///
    /// # Example
    ///
    /// ```
    /// use rusty_store::{Storage, StoreHandle, Storing};
    /// use serde::{Deserialize, Serialize};
    ///
    /// #[derive(Serialize, Deserialize, Default, Storing)]
    /// pub struct MyStore {
    ///     pub count: u32,
    /// }
    ///
    /// impl MyStore {
    ///     fn increment_count(&mut self) {
    ///         self.count += 1;
    ///     }
    /// }
    ///
    /// let storage = Storage::new("APP_ID");
    /// let mut handle: StoreHandle<MyStore> = StoreHandle::new("my_store_id");
    ///
    /// storage.write(&mut handle).expect("Failed to read store");
    ///
    /// ```
    pub fn write<T: Storing>(&self, handle: &mut StoreHandle<T>) -> Result<(), StoreError> {
        debug!("Writing store with id: {}", handle.store_id());
        self.open_file::<T, _>(
            |file: &mut File, handle| {
                let store = handle.get_store_mut();

                // Serialize current store to string
                let str =
                    ron::ser::to_string_pretty(&store, PrettyConfig::new().compact_arrays(true))
                        .map_err(StoreError::Ron)?;

                // Read current file content for comparison
                file.rewind().map_err(StoreError::Write)?;
                let existing = Self::read_string(file).map_err(StoreError::Read)?;

                // Skip writing if identical
                if existing == str {
                    debug!(
                        "Store unchanged, skipping write for id: {}",
                        handle.store_id()
                    );
                    return Ok(());
                }

                // Otherwise, overwrite file
                file.set_len(0).map_err(StoreError::Write)?;
                file.rewind().map_err(StoreError::Write)?;
                file.write_all(str.as_bytes()).map_err(StoreError::Write)?;
                file.flush().map_err(StoreError::Write)?;

                info!("Successfully wrote store with id: {}", handle.store_id());
                Ok(())
            },
            handle,
        )
    }

    /// Opens the file for reading or writing. If the file does not exist, it attempts
    /// to create a default store if a default is provided.
    fn open_file<T, F>(
        &self,
        mut operation: F,
        handle: &mut StoreHandle<T>,
    ) -> Result<(), StoreError>
    where
        T: Storing,
        F: FnMut(&mut File, &mut StoreHandle<T>) -> Result<(), StoreError>,
    {
        let mut dir_path = self.dir_path::<T>();
        dir_path.push(handle.store_id()); // i don't like this

        debug!("Opening file at path: {:?}", dir_path);

        match OpenOptions::new()
            .read(true)
            .write(true)
            .create(false)
            .truncate(false)
            .open(&dir_path)
        {
            Ok(mut config) => {
                debug!("File opened successfully at path: {:?}", dir_path);
                operation(&mut config, handle)
            }
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
                warn!(
                    "File not found at path: {:?}, creating default store",
                    dir_path
                );
                self.store_default::<T>(dir_path)?;
                self.open_file(operation, handle)
            }
            Err(err) => {
                warn!(
                    "Failed to open file at path: {:?}, error: {:?}",
                    dir_path, err
                );
                Err(StoreError::FileOpen(err))
            }
        }
    }

    fn store_default<T: Storing>(&self, path: PathBuf) -> Result<(), StoreError> {
        debug!("Storing default configuration at path: {:?}", path);
        if let Some(parent) = path.parent() {
            fs::create_dir_all(parent).map_err(StoreError::CreateDir)?;
            info!("Created directory for path: {:?}", parent);
        }

        let default_store = T::default();
        let str = ron::ser::to_string_pretty(&default_store, PrettyConfig::new())
            .map_err(StoreError::Ron)?;
        fs::write(&path, str).map_err(StoreError::Write)?;
        info!("Default store written at path: {:?}", &path);

        Ok(())
    }

    fn dir_path<T: Storing>(&self) -> PathBuf {
        let path = match T::store_type() {
            StoringType::Cache => self.cache_dir.clone(),
            StoringType::Data => self.data_dir.clone(),
            StoringType::Config => self.config_dir.clone(),
            StoringType::Custom(path) => path,
        };
        debug!(
            "Resolved directory path for store type: {:?} to path: {:?}",
            T::store_type(),
            path
        );
        path
    }

    fn read_string(mut file: &File) -> Result<String, std::io::Error> {
        let mut buf = String::new();
        file.read_to_string(&mut buf)?;
        debug!("Read string from file, length: {}", buf.len());
        Ok(buf)
    }
}