ommui_data 0.39.0

use crate::ommui::{
    CalibrationDescription, DeviceSettings, LoadableDevice,
    SampleCachedInformation, SamplingSettings, StorableDevice,
};
use crate::{error, file_load_json as load_json, LoadPathPattern, Result};
use arnalisa::Calibration;
use indexmap::{IndexMap, IndexSet};
use snafu::ResultExt;
use std::path::PathBuf;
use uuid::Uuid;

#[derive(Debug)]
pub struct Device {
    inner: crate::filesystem::Device,
}

impl Device {
    pub fn new(inner: crate::filesystem::Device) -> Self {
        Device { inner }
    }

    fn product_id(&self) -> String {
        self.inner.product_id.to_string()
    }

    pub fn device_dir(&self) -> PathBuf {
        self.inner.device_dir().join(self.product_id())
    }

    pub fn config_dir(&self) -> PathBuf {
        self.inner.config_dir().join(self.product_id())
    }

    pub fn cache_dir(&self) -> PathBuf {
        self.inner.cache_dir().join(self.product_id())
    }

    pub fn system_profiles_file(&self) -> PathBuf {
        self.device_dir().join("profiles.json")
    }

    pub fn user_profiles_file(&self) -> PathBuf {
        self.config_dir().join("profiles.json")
    }

    pub fn device_settings_file(&self) -> PathBuf {
        self.config_dir().join("settings.json")
    }

    pub fn description_calibration_dir(
        &self,
        calibration_id: &str,
    ) -> PathBuf {
        self.inner
            .description_calibration_dir(calibration_id)
            .join(self.product_id())
    }

    pub fn calibration_description_file(
        &self,
        calibration_id: &str,
    ) -> PathBuf {
        self.description_calibration_dir(calibration_id)
            .join("calibration.json")
    }

    pub fn sampling_dir(&self, sampling_id: &str) -> PathBuf {
        self.inner.sampling_dir(sampling_id).join(self.product_id())
    }

    pub fn sampling_settings_file(&self, sampling_id: &str) -> PathBuf {
        self.sampling_dir(sampling_id).join("settings.json")
    }

    pub fn calibrations_dir(&self) -> PathBuf {
        self.config_dir().join("calibration")
    }

    pub fn calibration_dir(&self, calibration_id: &str) -> PathBuf {
        self.calibrations_dir().join(calibration_id)
    }

    pub fn calibration_file(&self, calibration_id: &str) -> PathBuf {
        self.calibration_dir(calibration_id)
            .join("calibration.json")
    }

    pub fn sample_cached_information_file(&self) -> PathBuf {
        self.cache_dir().join("sample_cache.json")
    }
}

impl LoadableDevice for Device {
    fn load_system_profile_index(&self) -> Result<IndexSet<Uuid>> {
        load_json(self.system_profiles_file())
    }

    fn load_user_profile_index(&self) -> Result<IndexSet<Uuid>> {
        load_json(self.user_profiles_file())
    }

    fn load_calibration_index(&self) -> Result<IndexSet<String>> {
        IndexSet::load_path_pattern_from_dir(
            self.calibrations_dir(),
            "*/calibration.json",
        )
    }

    fn load_device_settings(&self) -> Result<DeviceSettings> {
        load_json(self.device_settings_file())
    }

    fn load_calibration_description(
        &self,
        calibration_id: &str,
    ) -> Result<CalibrationDescription> {
        load_json(self.calibration_description_file(calibration_id))
    }

    fn load_sampling_settings(
        &self,
        sampling_id: &str,
    ) -> Result<SamplingSettings> {
        load_json(self.sampling_settings_file(sampling_id))
    }

    fn load_calibration(
        &self,
        calibration_id: &str,
    ) -> Result<Calibration> {
        load_json(self.calibration_file(calibration_id))
    }

    fn load_sample_cached_information(
        &self,
    ) -> Result<IndexMap<Uuid, SampleCachedInformation>> {
        load_json(self.sample_cached_information_file())
    }
}

impl StorableDevice for Device {
    fn store_calibration(
        &mut self,
        calibration_id: &str,
        calibration: &Calibration,
    ) -> Result<()> {
        std::fs::create_dir_all(self.calibration_dir(calibration_id))
            .context(error::Io)?;
        let writer =
            std::fs::File::create(self.calibration_file(calibration_id))
                .context(error::Io)?;

        serde_json::to_writer_pretty(writer, calibration)
            .context(error::Serde)?;
        Ok(())
    }

    fn store_device_settings(
        &mut self,
        settings: &DeviceSettings,
    ) -> Result<()> {
        std::fs::create_dir_all(self.config_dir()).context(error::Io)?;
        let writer = std::fs::File::create(self.device_settings_file())
            .context(error::Io)?;

        serde_json::to_writer_pretty(writer, settings)
            .context(error::Serde)?;
        Ok(())
    }

    fn store_sample_cached_information(
        &self,
        cached_information: &IndexMap<Uuid, SampleCachedInformation>,
    ) -> Result<()> {
        std::fs::create_dir_all(self.cache_dir()).context(error::Io)?;
        let writer =
            std::fs::File::create(self.sample_cached_information_file())
                .context(error::Io)?;

        serde_json::to_writer_pretty(writer, cached_information)
            .context(error::Serde)?;
        Ok(())
    }
}