use ::std::fmt::Write as _;
use ::std::fs;
use ::std::io;
use ::std::path::{Path, PathBuf};
use ::std::sync::atomic::{AtomicBool, Ordering};
use ::std::sync::{Arc, Mutex, PoisonError};
use ::anyhow::{Context as _, Result};
use crate::param::Param;
pub fn dir() -> Option<PathBuf> {
let state = ::std::env::var_os("XDG_STATE_HOME")
.filter(|dir| !dir.is_empty())
.map(PathBuf::from)
.or_else(|| ::std::env::var_os("HOME").map(|home| Path::new(&home).join(".local/state")))?;
Some(state.join("voice-filter"))
}
const INPUT: &str = "input";
const OUTPUT: &str = "output";
const CHAIN: &str = "chain";
const LISTEN: &str = "listen";
const LISTEN_VOLUME: &str = "listen-volume";
const ENABLED: &str = "enabled";
pub fn load_enabled(dir: &Path) -> Result<bool> {
match load(dir, ENABLED)?.as_deref() {
None | Some("on") => Ok(true),
Some("off") => Ok(false),
Some(value) => Err(::anyhow::anyhow!("{value} isn't on or off")),
}
}
pub fn save_enabled(dir: &Path, on: bool) -> Result<()> {
if on {
remove(dir, ENABLED)
} else {
save(dir, ENABLED, "off")
}
}
pub fn load_input(dir: &Path) -> Result<Option<String>> {
load(dir, INPUT)
}
pub fn save_input(dir: &Path, name: &str) -> Result<()> {
save(dir, INPUT, name)
}
pub fn load_output(dir: &Path) -> Result<Option<String>> {
load(dir, OUTPUT)
}
pub fn save_output(dir: &Path, name: &str) -> Result<()> {
save(dir, OUTPUT, name)
}
pub fn load_listen(dir: &Path) -> Result<Option<bool>> {
Ok(load(dir, LISTEN)?.map(|listen| listen == "on"))
}
pub fn save_listen(dir: &Path, on: Option<bool>) -> Result<()> {
match on {
Some(on) => save(dir, LISTEN, if on { "on" } else { "off" }),
None => remove(dir, LISTEN),
}
}
pub fn load_listen_volume(dir: &Path) -> Result<Option<f32>> {
load(dir, LISTEN_VOLUME)?
.map(|volume| {
volume
.parse()
.with_context(|| format!("{volume} isn't a number"))
})
.transpose()
}
pub fn save_listen_volume(dir: &Path, db: f32) -> Result<()> {
save(dir, LISTEN_VOLUME, &db.to_string())
}
pub fn save_chain(
dir: &Path,
switches: &[(&'static str, Arc<AtomicBool>)],
params: &[(&'static str, Param)],
) -> Result<()> {
let mut chain = String::new();
for (stage, enabled) in switches {
if !enabled.load(Ordering::Relaxed) {
writeln!(chain, "{stage} off")?;
}
}
for (stage, param) in params {
let value = param.get();
if value != param.default {
writeln!(chain, "{stage}.{} {value}", param.name)?;
}
}
save(dir, CHAIN, chain.trim_end())
}
pub fn restore_chain(
dir: &Path,
switches: &[(&'static str, Arc<AtomicBool>)],
params: &[(&'static str, Param)],
) -> Result<Vec<String>> {
let Some(chain) = load(dir, CHAIN)? else {
return Ok(Vec::new());
};
let mut warnings = Vec::new();
for line in chain.lines().map(str::trim).filter(|line| !line.is_empty()) {
if let Err(warning) = restore_line(line, switches, params) {
warnings.push(format!("Skipped “{line}” of the saved settings: {warning}"));
}
}
Ok(warnings)
}
fn restore_line(
line: &str,
switches: &[(&'static str, Arc<AtomicBool>)],
params: &[(&'static str, Param)],
) -> Result<(), String> {
let Some((key, value)) = line.split_once(char::is_whitespace) else {
return Err("no value".to_owned());
};
let value = value.trim();
match key.split_once('.') {
Some((stage, name)) => {
let param = Param::find(params, stage, name)
.ok_or_else(|| format!("no parameter {name} of {stage}"))?;
let value = value
.parse()
.map_err(|_| format!("{value} isn't a number"))?;
param.set(value).map_err(|err| err.to_string())
}
None => {
let (_, enabled) = switches
.iter()
.find(|(stage, _)| *stage == key)
.ok_or_else(|| format!("no stage {key}"))?;
let on = match value {
"on" => true,
"off" => false,
_ => return Err(format!("{value} isn't on or off")),
};
enabled.store(on, Ordering::Relaxed);
Ok(())
}
}
}
fn load(dir: &Path, name: &str) -> Result<Option<String>> {
let path = dir.join(name);
match fs::read_to_string(&path) {
Ok(name) => Ok(Some(name.trim().to_owned()).filter(|name| !name.is_empty())),
Err(err) if err.kind() == io::ErrorKind::NotFound => Ok(None),
Err(err) => Err(err).with_context(|| format!("Could not read {}", path.display())),
}
}
fn remove(dir: &Path, name: &str) -> Result<()> {
let path = dir.join(name);
match fs::remove_file(&path) {
Err(err) if err.kind() != io::ErrorKind::NotFound => {
Err(err).with_context(|| format!("Could not remove {}", path.display()))
}
_ => Ok(()),
}
}
fn save(dir: &Path, name: &str, value: &str) -> Result<()> {
static SAVING: Mutex<()> = Mutex::new(());
let _saving = SAVING.lock().unwrap_or_else(PoisonError::into_inner);
fs::create_dir_all(dir).with_context(|| format!("Could not create {}", dir.display()))?;
let path = dir.join(name);
let temporary = dir.join(format!(".{name}.tmp"));
fs::write(&temporary, format!("{value}\n"))
.with_context(|| format!("Could not write {}", temporary.display()))?;
fs::rename(&temporary, &path).with_context(|| format!("Could not write {}", path.display()))
}