koan_core/audio/dsp/

profiles.rs

//! The profiles in `config.local.toml`, as every front end changes them.
//!
//! Imported responses are kept under `dsp/<profile>/` beside the config, one
//! 32-bit float WAV per rate, or a `.cfg` with it where routes mix or delay
//! channels. Whatever they were imported from — a Roon zip, a CamillaDSP
//! setup, a share from another app — is read once and not needed again.

use std::path::{Path, PathBuf};

use super::import::Imported;
use super::{Setup, convolver, raw};
use crate::config::{self, Config, DspEar, DspMeasurement, DspProfile, DspRole, DspScope};

#[derive(Debug, Clone, PartialEq)]
pub struct Summary {
    pub name: String,
    pub devices: Vec<String>,
    pub bands: usize,
    /// Profiles it plays first, for a stack.
    pub layers: usize,
    /// Rates there are responses for.
    pub rates: Vec<u32>,
    /// Why the profile would not load, if it would not.
    pub problem: Option<String>,
    pub role: DspRole,
    /// Built from a measurement.
    pub measured: bool,
    /// For a group: its members, in order, and the one playing.
    pub members: Vec<String>,
    pub playing: Option<String>,
    /// A preset: a correction and its tuning saved together.
    pub preset: bool,
    /// Changed since it was imported, so it can go back.
    pub edited: bool,
    /// The devices it is chosen for: as their correction, in their tuning,
    /// or as the preset they were set from.
    pub used_on: Vec<String>,
    /// Kept on every device of the account.
    pub everywhere: bool,
    /// The presets and groups that hold it.
    pub held_by: Vec<String>,
    /// Why it cannot move to the other scope, while it cannot.
    pub scope_locked: Option<String>,
    /// The graphic curves among `bands`, and their points in all.
    pub graphics: usize,
    pub points: usize,
    /// The target it was made against, by name.
    pub made_for: Option<String>,
    /// How it would meet the overview device's correction, as `joins` says
    /// of an EQ in that device's tuning.
    pub join: Option<Join>,
}

/// What a device plays, as the apps' EQ page shows it: for a front end
/// without one, such as the CLI and an assistant driving it.
#[derive(Debug, Clone, PartialEq, serde::Serialize)]
pub struct ChainView {
    pub device: String,
    pub correction: Option<String>,
    /// The target the correction aims at, by name.
    pub target: Option<String>,
    pub tuning: Vec<TuningView>,
    pub preset: Option<String>,
    /// Changed since it was set from `preset`.
    pub edited: bool,
    /// The tuning's EQs that do not play, by name; `notes` says why.
    pub left_out: Vec<String>,
    pub notes: Option<String>,
    /// No correction and no tuning: it plays untouched.
    pub flat: bool,
    /// The chain in words, as the EQ page says it.
    pub sentence: String,
}

#[derive(Debug, Clone, PartialEq, serde::Serialize)]
pub struct TuningView {
    pub name: String,
    pub on: bool,
    /// The target it was made against, by name.
    pub made_for: Option<String>,
    /// Made against the target the correction aims at. False where it was
    /// made against another, or where that is not known; none where there
    /// is nothing to compare.
    pub matched: Option<bool>,
    pub join: Option<Join>,
    /// What of it does not play as chosen, and why.
    pub note: Option<String>,
}

/// How an EQ of the tuning meets the correction ahead of it.
#[derive(Debug, Clone, PartialEq, serde::Serialize)]
#[serde(rename_all = "snake_case", tag = "state")]
pub enum Join {
    /// Made against the target the correction aims at: nothing to convert.
    Matched,
    /// Made against another target: the difference from the correction's
    /// target to that one plays first. Names, not ids.
    Converted { from: String, to: String },
    /// Made against another target, under a correction fitted to a
    /// measurement: the correction is fitted to that target in place of
    /// `from`, so nothing is converted.
    Refitted { from: String, to: String },
    /// Made against a target not said, so nothing converts: a target the EQ
    /// already includes may be applied twice.
    Unknown,
}

/// One EQ of a device's tuning, as it meets the correction.
#[derive(Debug, Clone, Default, PartialEq)]
pub struct EqJoin {
    /// The target it was made against, by name.
    pub made_for: Option<String>,
    /// None where nothing is compared: no correction, one whose target is
    /// not known, a headphone of another kind, or an EQ that does not play.
    pub join: Option<Join>,
    pub note: Option<String>,
    /// For a converted join, the target difference that plays, in dB on
    /// `targets::grid()`.
    pub step: Vec<f64>,
    /// For an unknown join, the target it looks made against, by id and
    /// name: see [`suggest_made_against`].
    pub suggestion: Option<(String, String)>,
}

/// How each EQ of `device`'s tuning meets its correction, in order. `notes`
/// are the chain's, by EQ, and `dropped` the EQs it leaves out.
fn joins(
    dsp: &crate::config::DspConfig,
    device: &str,
    notes: &[(String, String)],
    dropped: &[String],
    refit: Option<&str>,
) -> Vec<EqJoin> {
    use super::targets;
    let all = &dsp.profiles;
    let own = dsp.profile_for(device).and_then(|c| aims_at(c, all));
    let aim = refit.map(str::to_owned).or_else(|| own.clone());
    tunings_for(device)
        .into_iter()
        .map(|(name, on)| {
            let made = all
                .iter()
                .find(|p| p.name == name)
                .and_then(|p| super::made_against(p, all, 0));
            let plays = dsp.enabled && on && !dropped.contains(&name);
            let join = plays
                .then(|| match (refit, made.as_deref(), own.as_deref()) {
                    (Some(r), Some(m), Some(o)) if r == m => Some(Join::Refitted {
                        from: target_name(o),
                        to: target_name(r),
                    }),
                    _ => meets(aim.as_deref(), made.as_deref()),
                })
                .flatten();
            let said: Vec<&str> = notes
                .iter()
                .filter(|(eq, _)| *eq == name)
                .map(|(_, n)| n.as_str())
                .collect();
            let step = match (&join, &aim, &made, dsp.profile_for(device)) {
                (Some(Join::Converted { .. }), Some(a), Some(m), Some(c)) => {
                    targets::choice_curve(a)
                        .zip(targets::choice_curve(m))
                        .map(|(from, to)| targets::on_grid_db(&target_step(c, all, &from, &to)))
                        .unwrap_or_default()
                }
                _ => Vec::new(),
            };
            let suggestion = match (&join, &aim) {
                (Some(Join::Unknown), Some(a)) => guess(&name, all, a),
                _ => None,
            };
            EqJoin {
                made_for: made.as_deref().map(target_name),
                join,
                note: (!said.is_empty()).then(|| said.join(" ")),
                step,
                suggestion,
            }
        })
        .collect()
}

/// How an EQ made against `made` meets a correction aiming at `aim`, both
/// target ids. None where nothing compares: no correction target, or one
/// for another kind of headphone.
fn meets(aim: Option<&str>, made: Option<&str>) -> Option<Join> {
    match (aim, made) {
        (Some(a), Some(m)) if a == m => Some(Join::Matched),
        (Some(a), Some(m)) if super::targets::same_ear(a, m) => Some(Join::Converted {
            from: target_name(a),
            to: target_name(m),
        }),
        (Some(_), None) => Some(Join::Unknown),
        _ => None,
    }
}

/// What `device` plays.
pub fn chain_view(device: &str) -> ChainView {
    let o = overview_for(Some(device.to_owned()));
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let chosen = cfg.dsp.profile_for(device);
    let target = o.aim.clone();
    let includes = chosen.is_some_and(|c| shown_role(c, all) == DspRole::Baked);
    let playing: Vec<&str> = if includes {
        Vec::new()
    } else {
        o.chain
            .iter()
            .filter(|(name, on)| *on && !o.left_out_eqs.contains(name))
            .map(|(name, _)| name.as_str())
            .collect()
    };
    let meets = o
        .chain
        .iter()
        .zip(&o.joins)
        .filter(|((name, _), _)| playing.contains(&name.as_str()))
        .filter_map(|((name, _), j)| Some(joined(name, j.join.as_ref()?, target.as_deref()?)))
        .collect::<Vec<_>>();
    let sentence = match (&o.active, playing.is_empty()) {
        (None, true) => format!("{device} is flat: the music plays untouched."),
        (active, _) => {
            let mut parts = Vec::new();
            if let Some(c) = active {
                parts.push(match &target {
                    Some(t) => format!("corrected by {c} to {t}"),
                    None => format!("corrected by {c}"),
                });
            }
            if !playing.is_empty() {
                parts.push(format!("tuned with {}", and_list(&playing)));
            }
            let mut said = format!("Music to {device}, {}.", parts.join(", then "));
            for j in meets {
                said.push(' ');
                said.push_str(&j);
            }
            // The tuning stays the device's under a correction that
            // includes one, and plays again once that correction goes.
            let skipped: Vec<&str> = o
                .chain
                .iter()
                .filter(|(_, on)| includes && *on)
                .map(|(name, _)| name.as_str())
                .collect();
            if let (Some(c), false) = (active, skipped.is_empty()) {
                said.push_str(&format!(
                    " Its tuning, {}, is skipped: {c} already includes one.",
                    and_list(&skipped)
                ));
            }
            said
        }
    };
    ChainView {
        device: device.to_owned(),
        flat: o.active.is_none() && o.chain.is_empty(),
        correction: o.active,
        target,
        tuning: o
            .chain
            .into_iter()
            .zip(o.joins)
            .map(|((name, on), j)| TuningView {
                name,
                on,
                matched: j.join.as_ref().map(|j| *j == Join::Matched),
                made_for: j.made_for,
                join: j.join,
                note: j.note,
            })
            .collect(),
        edited: o.preset.as_ref().is_some_and(|(_, e)| *e),
        preset: o.preset.map(|(name, _)| name),
        left_out: o.left_out_eqs,
        notes: o.left_out,
        sentence,
    }
}

/// What the tuning `name` looks made against, as an id and a name, played on
/// a correction aiming at `aim`: see [`targets::guess_made_against`].
fn guess(name: &str, all: &[DspProfile], aim: &str) -> Option<(String, String)> {
    let ear = super::targets::shipped(aim)?.ear;
    let p = all.iter().find(|p| p.name == name)?;
    // A group's Made against is every member's that does not say, and a
    // guess from the member playing is no guess at the others.
    if p.group {
        return None;
    }
    let eq = response_of(p, all, 48_000)?.total;
    super::targets::guess_made_against(&eq, ear, aim).map(|t| (t.id.to_owned(), t.name.to_owned()))
}

/// What the tuning `name` looks made against, on `device`, where it does not
/// say: worked out from its curve against the target `device`'s correction
/// aims at, for the person to accept or not. Never set without asking.
pub fn suggest_made_against(name: &str, device: &str) -> Option<(String, String)> {
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let p = all.iter().find(|p| p.name == name)?;
    if shown_role(p, all) != DspRole::Tuning || super::made_against(p, all, 0).is_some() {
        return None;
    }
    let aim = cfg.dsp.profile_for(device).and_then(|c| aims_at(c, all))?;
    guess(name, all, &aim)
}

/// What the tuning `name` adds on `device`'s correction for each target it
/// could say it was made against, in dB on `targets::grid()`: itself, with
/// the target difference ahead of it where the target is another of the
/// same kind of headphone. `None` is not saying, which plays it as it is.
/// A wrong choice shows as a preference applied twice or taken out. Empty
/// where the correction's target is not known.
pub fn made_against_previews(name: &str, device: &str) -> Vec<(Option<String>, Vec<f64>)> {
    use super::targets;
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let Some(correction) = cfg.dsp.profile_for(device) else {
        return Vec::new();
    };
    let Some(aim) = aims_at(correction, all) else {
        return Vec::new();
    };
    let Some(eq) = all
        .iter()
        .find(|p| p.name == name)
        .and_then(|p| response_of(p, all, 48_000))
        .map(|r| r.total)
    else {
        return Vec::new();
    };
    let Some(from) = targets::choice_curve(&aim) else {
        return Vec::new();
    };
    let ids = targets::TARGETS
        .iter()
        .map(|t| t.id.to_owned())
        .chain(targets::added().into_iter().map(|a| a.id));
    // A correction built from a measurement is fitted again to the target
    // chosen, which moves it from the bands it plays, its own and for one
    // saved before kōan fitted bands the fit made as it plays, to the refit.
    let member = super::member_playing(correction, all);
    let fits = member.measured().map(|m| {
        let mut own = member.sanitized().filters;
        if member.fitted.is_none() {
            own.extend(fitted_to(member, &m.target).unwrap_or_default());
        }
        own
    });
    let grid = targets::grid();
    std::iter::once((None, eq.clone()))
        .chain(ids.filter_map(|id| {
            let refit = fits
                .as_ref()
                .filter(|_| id != aim && targets::same_ear(&aim, &id))
                .and_then(|own| Some((own, fitted_to(member, &id)?)));
            let plays = if let Some((own, refit)) = refit {
                let (own, refit) = (
                    super::response(own, &grid, 48_000),
                    super::response(&refit, &grid, 48_000),
                );
                eq.iter()
                    .zip(own.iter().zip(&refit))
                    .map(|(e, (o, r))| e + r - o)
                    .collect()
            } else if id == aim || !targets::same_ear(&aim, &id) {
                eq.clone()
            } else {
                let step = targets::on_grid_db(&target_step(
                    correction,
                    all,
                    &from,
                    &targets::choice_curve(&id)?,
                ));
                eq.iter().zip(&step).map(|(e, s)| e + s).collect()
            };
            Some((Some(id), plays))
        }))
        .collect()
}

/// How `eq` meets a correction aiming at `aim`, as a sentence: what the EQ
/// page's chain reads to VoiceOver after the chain itself.
pub fn joined(eq: &str, join: &Join, aim: &str) -> String {
    match join {
        Join::Matched => format!("{eq} was made for {aim}: matched."),
        Join::Converted { from, to } => {
            format!("{eq} was made for {to}, so the difference from {from} to {to} plays first.")
        }
        Join::Refitted { to, .. } => {
            format!("{eq} was made for {to}, so the correction is fitted to {to} for it.")
        }
        Join::Unknown => {
            format!("What {eq} was made against is not set.")
        }
    }
}

/// "A", "A and B", "A, B and C".
fn and_list(items: &[&str]) -> String {
    match items {
        [] => String::new(),
        [one] => (*one).to_owned(),
        [rest @ .., last] => format!("{} and {last}", rest.join(", ")),
    }
}

/// Set `device`'s whole chain: its correction (`Some(None)` for none), its
/// tuning's EQs in order, all on. What is not given is left as it is, and
/// giving the same twice changes nothing. Refused, naming the choices, for
/// a correction or EQ that is not one.
pub fn set_chain(
    device: &str,
    correction: Option<Option<&str>>,
    tuning: Option<&[String]>,
) -> Result<(), String> {
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let choices = |names: Vec<&str>| {
        if names.is_empty() {
            "none yet".to_owned()
        } else {
            names.join(", ")
        }
    };
    if let Some(Some(name)) = correction {
        let corrections: Vec<&str> = all
            .iter()
            .filter(|p| !p.preset && shown_role(p, all).corrects())
            .map(|p| p.name.as_str())
            .collect();
        if all.iter().any(|p| p.name == name && p.preset) {
            return Err(format!(
                "{name} is a preset, not a correction: set it with `koan dsp preset use {name:?}`"
            ));
        }
        if !corrections.contains(&name) {
            return Err(format!(
                "No correction called {name}. Corrections: {}",
                choices(corrections)
            ));
        }
    }
    if let Some(eqs) = tuning {
        let valid: Vec<&str> = all
            .iter()
            .filter(|p| !p.preset && check_tuning(&p.name, all).is_ok())
            .map(|p| p.name.as_str())
            .collect();
        for (i, eq) in eqs.iter().enumerate() {
            if !all.iter().any(|p| &p.name == eq) {
                return Err(format!("No EQ called {eq}. EQs: {}", choices(valid)));
            }
            check_tuning(eq, all)?;
            if eqs[..i].contains(eq) {
                return Err(format!("{eq} is in the tuning twice"));
            }
        }
        // Checked before anything is set, so a refusal changes nothing.
        let then = match correction {
            Some(c) => c.and_then(|c| all.iter().find(|p| p.name == c)),
            None => cfg.dsp.profile_for(device),
        };
        if let Some(c) = then
            && !eqs.is_empty()
            && shown_role(c, all) == DspRole::Baked
        {
            return Err(baked_already(&c.name));
        }
    }
    // One write, so the two never half-apply. What is not given stays, and
    // so does the preset the device was set from, which then reads as edited.
    let correction: Option<String> = match correction {
        Some(c) => c.map(str::to_owned),
        None => cfg.dsp.profile_for(device).map(|p| p.name.clone()),
    };
    let entries: Vec<(String, bool)> = match tuning {
        Some(eqs) => eqs.iter().map(|e| (e.clone(), true)).collect(),
        None => tunings_for(device),
    };
    let preset = preset_for(device).map(|(name, _)| name);
    persist(|cfg| {
        set_output(
            cfg,
            device,
            correction.as_deref(),
            &entries,
            preset.as_deref(),
        )
    })
}

/// What a device is set to, for a menu of presets.
#[derive(Debug, Clone, PartialEq)]
pub struct OutputState {
    pub device: String,
    /// The preset it was set from, and whether it was changed since.
    pub preset: Option<(String, bool)>,
    /// No correction and no tuning: it plays untouched.
    pub flat: bool,
}

#[derive(Debug, Clone, PartialEq)]
pub struct Overview {
    pub enabled: bool,
    /// The output device playback goes to.
    pub device: Option<String>,
    /// The profile for that device: its correction.
    pub active: Option<String>,
    /// The tuning it plays on top.
    pub tuning: Option<String>,
    /// Whether that tuning plays: not on a baked correction, nor where the
    /// chain cannot hold it.
    pub tuning_plays: bool,
    /// What of that device's choices does not play, and why.
    pub left_out: Option<String>,
    /// The EQs of its tuning left out entirely.
    pub left_out_eqs: Vec<String>,
    /// Every output's tuning, by device: its first EQ.
    pub tunings: Vec<(String, String)>,
    /// That device's tuning: its EQs in order, each on or off.
    pub chain: Vec<(String, bool)>,
    /// How each EQ of `chain` meets the correction, in the same order.
    pub joins: Vec<EqJoin>,
    /// The target that device's correction aims at, by name.
    pub aim: Option<String>,
    /// Whether that target is for in-ears; none where it is not known.
    pub in_ear: Option<bool>,
    /// The preset that device was set from, and whether it was changed
    /// since.
    pub preset: Option<(String, bool)>,
    pub profiles: Vec<Summary>,
    /// Every device the EQ names, and what each is set to.
    pub outputs: Vec<OutputState>,
    /// That device plays filters alone, with no correction.
    pub filters_only: bool,
}

/// The device the player resolves to: the configured one if it is there, or
/// the system's.
pub fn current_device() -> Option<String> {
    let cfg = Config::cached();
    if let Some(name) = &cfg.playback.output_device
        && crate::audio::list_output_devices()
            .is_ok_and(|devices| devices.iter().any(|d| &d.name == name))
    {
        return Some(name.clone());
    }
    crate::audio::default_output_device().ok().map(|d| d.name)
}

pub fn overview() -> Overview {
    overview_for(current_device())
}

/// The profiles, and which `device` plays through. A front end that knows
/// a renderer is the output names it by its UDN here.
pub fn overview_for(device: Option<String>) -> Overview {
    let cfg = Config::cached();
    let base = config::config_dir();
    let chain = device
        .as_deref()
        .and_then(|d| super::output_chain(&cfg.dsp, d));
    let aim = device
        .as_deref()
        .and_then(|d| cfg.dsp.profile_for(d))
        .and_then(|c| aims_at(c, &cfg.dsp.profiles));
    Overview {
        enabled: cfg.dsp.enabled,
        filters_only: device
            .as_deref()
            .is_some_and(|d| cfg.dsp.filters_only.iter().any(|f| f == d)),
        active: device
            .as_deref()
            .and_then(|d| cfg.dsp.profile_for(d))
            .map(|p| p.name.clone()),
        tuning_plays: chain.as_ref().is_some_and(|c| c.tuning_plays),
        left_out_eqs: chain
            .as_ref()
            .map(|c| c.left_out_eqs.clone())
            .unwrap_or_default(),
        joins: match (&device, &chain) {
            (Some(d), Some(c)) => joins(
                &cfg.dsp,
                d,
                &c.eq_notes,
                &c.left_out_eqs,
                c.refit.as_ref().map(|(to, _)| to.as_str()),
            ),
            (Some(d), None) => joins(&cfg.dsp, d, &[], &[], None),
            (None, _) => Vec::new(),
        },
        in_ear: aim
            .as_deref()
            .and_then(super::targets::shipped)
            .and_then(|t| match t.ear {
                super::targets::Ear::In => Some(true),
                super::targets::Ear::Over => Some(false),
                super::targets::Ear::Speaker => None,
            }),
        aim: aim.as_deref().map(target_name),
        left_out: chain.and_then(|c| c.left_out),
        outputs: outputs(&cfg.dsp),
        tunings: cfg.dsp.tunings.iter().fold(Vec::new(), |mut first, t| {
            if !first.iter().any(|(d, _): &(String, String)| d == &t.device) {
                first.push((t.device.clone(), t.tuning.clone()));
            }
            first
        }),
        tuning: device.as_deref().and_then(tuning_for),
        chain: device.as_deref().map(tunings_for).unwrap_or_default(),
        preset: device.as_deref().and_then(preset_for),
        device,
        profiles: cfg
            .dsp
            .profiles
            .iter()
            .map(|p| {
                let graphics: Vec<_> = p
                    .filters
                    .iter()
                    .filter_map(|f| match f {
                        config::DspFilter::Graphic(g) => Some(g),
                        _ => None,
                    })
                    .collect();
                let made = super::made_against(p, &cfg.dsp.profiles, 0);
                let (rates, problem) = match Setup::load(p, &cfg.dsp.profiles, &base) {
                    Ok(setup) => (setup.map(|s| s.rates()).unwrap_or_default(), None),
                    Err(e) => (Vec::new(), Some(e.to_string())),
                };
                Summary {
                    name: p.name.clone(),
                    devices: p.devices.clone(),
                    bands: p.filters.len(),
                    layers: p.layers.len(),
                    rates,
                    problem,
                    role: shown_role(p, &cfg.dsp.profiles),
                    measured: p.measured().is_some(),
                    members: if p.group {
                        p.layers.iter().map(|l| l.profile.clone()).collect()
                    } else {
                        Vec::new()
                    },
                    playing: p
                        .group
                        .then(|| p.layers.iter().find(|l| l.on).map(|l| l.profile.clone()))
                        .flatten(),
                    preset: p.preset,
                    edited: edited(p),
                    used_on: used_on(&cfg.dsp, &p.name),
                    held_by: cfg
                        .dsp
                        .profiles
                        .iter()
                        .filter(|q| {
                            (q.preset || q.group) && q.layers.iter().any(|l| l.profile == p.name)
                        })
                        .map(|q| q.name.clone())
                        .collect(),
                    everywhere: scope(p, &cfg.dsp.profiles) == DspScope::Everywhere,
                    scope_locked: scope_locked(p, &cfg.dsp.profiles),
                    graphics: graphics.len(),
                    points: graphics.iter().map(|g| g.points.len()).sum(),
                    made_for: made.as_deref().map(target_name),
                    join: meets(aim.as_deref(), made.as_deref()),
                }
            })
            .collect(),
    }
}

/// Every device the EQ names, in the order first named, and what each is
/// set to.
fn outputs(dsp: &crate::config::DspConfig) -> Vec<OutputState> {
    let mut devices: Vec<&str> = Vec::new();
    for d in dsp
        .profiles
        .iter()
        .filter(|p| !p.preset)
        .flat_map(|p| p.devices.iter())
        .chain(dsp.tunings.iter().map(|t| &t.device))
        .chain(dsp.presets.iter().map(|p| &p.device))
    {
        if !devices.contains(&d.as_str()) {
            devices.push(d);
        }
    }
    devices
        .into_iter()
        .map(|d| OutputState {
            device: d.to_owned(),
            preset: preset_for(d),
            flat: dsp.profile_for(d).is_none() && !dsp.tunings.iter().any(|t| t.device == d),
        })
        .collect()
}

/// The devices `name` is chosen for: as their correction, in their tuning,
/// or as the preset they were set from.
fn used_on(dsp: &crate::config::DspConfig, name: &str) -> Vec<String> {
    let mut on: Vec<String> = Vec::new();
    let correcting = dsp
        .profiles
        .iter()
        .filter(|p| p.name == name && !p.preset)
        .flat_map(|p| p.devices.iter());
    let tuning = dsp
        .tunings
        .iter()
        .filter(|t| t.tuning == name)
        .map(|t| &t.device);
    let preset = dsp
        .presets
        .iter()
        .filter(|p| p.preset == name)
        .map(|p| &p.device);
    for d in correcting.chain(tuning).chain(preset) {
        if !on.contains(d) {
            on.push(d.clone());
        }
    }
    on
}

/// Save an import as the profile `name`, or the name it came with. An existing
/// profile of that name keeps its devices, and whichever of its filters and
/// responses the import does not replace — so a room's responses and a
/// headphone EQ can be imported into one profile in turn.
pub fn save(imported: Imported, name: Option<&str>) -> Result<String, String> {
    let name = name
        .map(str::trim)
        .filter(|n| !n.is_empty())
        .unwrap_or(&imported.name)
        .to_string();
    let impulses = if imported.impulses.is_empty() {
        None
    } else {
        Some(write_impulses(&name, &imported)?)
    };
    let filters = (!imported.filters.is_empty()).then_some(imported.filters);
    let source = imported.source;
    persist(|cfg| {
        let profile = profile_mut(&mut cfg.dsp.profiles, &name);
        for s in source {
            if !profile.source.contains(&s) {
                profile.source.push(s);
            }
        }
        if let Some(filters) = filters {
            profile.filters = filters;
            // Derived from the filters, which now include these.
            profile.preamp_db = None;
            // Kept, so an edit can be undone.
            profile.original = Some(crate::config::DspOriginal {
                filters: profile.filters.clone(),
                preamp_db: None,
            });
        }
        if let Some(impulses) = impulses {
            profile.impulses = impulses;
        }
    })
    .map_err(|e| e.to_string())?;
    Ok(name)
}

fn write_impulses(name: &str, imported: &Imported) -> Result<Vec<PathBuf>, String> {
    let rel = Path::new("dsp").join(slug(name));
    let dir = config::config_dir().join(&rel);
    let _ = std::fs::remove_dir_all(&dir);
    std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
    let mut paths = Vec::new();
    for ir in &imported.impulses {
        let shared_rate = imported
            .impulses
            .iter()
            .filter(|i| i.rate == ir.rate)
            .count()
            > 1;
        let stem = match (shared_rate, ir.channels) {
            (true, Some(n)) => format!("{}-{n}ch", ir.rate),
            _ => ir.rate.to_string(),
        };
        let file = match ir.as_channels() {
            Some(channels) => {
                let channels: Vec<Vec<f32>> = channels.into_iter().map(<[f32]>::to_vec).collect();
                let file = format!("{stem}.wav");
                raw::write_wav(&dir.join(&file), ir.rate, &channels).map_err(|e| e.to_string())?;
                file
            }
            None => convolver::write(&dir, &stem, ir)?
                .file_name()
                .map(|f| f.to_string_lossy().into_owned())
                .unwrap_or_default(),
        };
        paths.push(rel.join(file));
    }
    Ok(paths)
}

/// One impulse-response file in a profile, as the detail page shows it.
#[derive(Debug, Clone, PartialEq)]
pub struct ImpulseDetail {
    pub file: String,
    pub rate: u32,
    /// `None` for one response applied to every channel.
    pub channels: Option<usize>,
    pub taps: usize,
    pub routes: usize,
    /// Routes mix channels into others, as crossfeed does, rather than each
    /// channel being convolved on its own.
    pub mixes: bool,
    /// Channels delayed against each other.
    pub delayed: bool,
    /// Where the response peaks: the delay trimmed from playback.
    pub peak_ms: f64,
}

#[derive(Debug, Clone, PartialEq)]
pub struct Detail {
    pub name: String,
    pub devices: Vec<String>,
    pub source: Vec<String>,
    pub filters: Vec<crate::config::DspFilter>,
    pub impulses: Vec<ImpulseDetail>,
    /// The gain applied ahead of the filters, at `preamp_rate`.
    pub preamp_db: f64,
    pub preamp_rate: u32,
    /// Set by hand rather than derived.
    pub preamp_set: bool,
    pub problem: Option<String>,
    /// Profiles it plays first, for a stack.
    pub layers: Vec<crate::config::DspLayer>,
    /// A group: one of `layers` plays, the one switched on.
    pub group: bool,
    /// Kept on every device of the account, rather than this one alone.
    pub everywhere: bool,
    /// Where it is kept was chosen, rather than following from what it is.
    pub scope_set: bool,
    pub role: DspRole,
    pub role_set: bool,
    /// A chain correcting twice, made before that was refused: which, and
    /// what to do.
    pub corrects_twice: Option<String>,
    /// The chain in a line each: see [`summary`].
    pub corrects: Option<String>,
    pub corrects_baked: bool,
    pub tunings: Vec<String>,
    /// For each of `layers`, what it is for; `None` where it is missing.
    pub layer_roles: Vec<Option<DspRole>>,
    pub measured: bool,
    pub made_for: Option<String>,
    /// For a tuning: the target it was made against.
    pub tuned_for: Option<String>,
    /// A preset: a correction and its tuning saved together.
    pub preset: bool,
    /// Changed since it was imported.
    pub edited: bool,
    /// Imported, so it can go back to how it was.
    pub can_revert: bool,
    /// A correction, which plays as made: its bands are not edited.
    pub read_only: bool,
    /// For an EQ of bands alone: one list for both channels, or one each.
    pub channels: Option<ChannelLayout>,
}

/// Everything in the profile `name`.
pub fn detail(name: &str) -> Option<Detail> {
    let cfg = Config::cached();
    let profile = cfg.dsp.profiles.iter().find(|p| p.name == name)?;
    let base = config::config_dir();
    let mut problem = None;
    let mut impulses = Vec::new();
    for path in &profile.impulses {
        match super::load_impulses(path, &base) {
            Ok(irs) => impulses.extend(irs.into_iter().map(|ir| {
                ImpulseDetail {
                    file: path
                        .file_name()
                        .map(|f| f.to_string_lossy().into_owned())
                        .unwrap_or_default(),
                    rate: ir.rate,
                    channels: ir.channels,
                    taps: ir.taps(),
                    routes: ir.routes.len(),
                    mixes: ir.mixes(),
                    delayed: ir.in_delays.iter().chain(&ir.out_delays).any(|&d| d > 0),
                    peak_ms: ir.delay() as f64 * 1000.0 / ir.rate as f64,
                }
            })),
            Err(e) => problem = Some(e.to_string()),
        }
    }
    impulses.sort_by_key(|i| i.rate);
    let preamp_rate = impulses
        .iter()
        .map(|i| i.rate)
        .find(|&r| r == 48000)
        .or(impulses.first().map(|i| i.rate))
        .unwrap_or(48000);
    // What it plays is adjusted to stay within bounds: say how.
    let mut adjusted = profile.clone().sanitize();
    match super::chain_noted(profile, &cfg.dsp.profiles, &mut Vec::new()) {
        Ok((_, notes)) => {
            for n in notes {
                if !adjusted.contains(&n) {
                    adjusted.push(n);
                }
            }
        }
        Err(e) => problem = Some(e.to_string()),
    }
    let setup = Setup::load(profile, &cfg.dsp.profiles, &base)
        .ok()
        .flatten();
    if let Some(cut) = setup.as_ref().and_then(|s| s.headroom_cut(preamp_rate, 2)) {
        adjusted.push(format!("preamp −{cut:.1} dB for headroom"));
    }
    if !adjusted.is_empty() {
        let note = format!("Adjusted: {}", adjusted.join("; "));
        problem = Some(problem.map_or(note.clone(), |p| format!("{p}. {note}")));
    }
    let preamp_db = setup.map_or(0.0, |s| s.preamp_db(preamp_rate, 2));
    let chain_summary = summary(name).unwrap_or_default();
    Some(Detail {
        name: profile.name.clone(),
        devices: profile.devices.clone(),
        source: profile.source.clone(),
        filters: profile.filters.clone(),
        impulses,
        preamp_db,
        preamp_rate,
        preamp_set: profile.preamp_db.is_some(),
        layers: profile.layers.clone(),
        group: profile.group,
        problem,
        everywhere: scope(profile, &cfg.dsp.profiles) == DspScope::Everywhere,
        scope_set: profile.scope.is_some(),
        role: shown_role(profile, &cfg.dsp.profiles),
        role_set: profile.role.is_some(),
        corrects_twice: corrects_twice(profile, &cfg.dsp.profiles),
        corrects: chain_summary.correction,
        corrects_baked: chain_summary.baked,
        tunings: chain_summary.tunings,
        layer_roles: profile
            .layers
            .iter()
            .map(|l| {
                cfg.dsp
                    .profiles
                    .iter()
                    .find(|p| p.name == l.profile)
                    .map(role)
            })
            .collect(),
        measured: profile.measured().is_some(),
        made_for: profile.target.as_ref().map(|t| t.made_for.clone()),
        tuned_for: profile.tuned_for.clone(),
        preset: profile.preset,
        edited: edited(profile),
        can_revert: profile.original.is_some(),
        read_only: editable(profile, &cfg.dsp.profiles).is_err(),
        channels: if profile.layers.is_empty() && profile.impulses.is_empty() {
            channel_layout(&profile.filters)
        } else {
            None
        },
    })
}

/// Rename a profile, moving the responses koan keeps for it.
pub fn rename(old: &str, new: &str) -> Result<(), String> {
    let new = new.trim();
    if new.is_empty() {
        return Err("It needs a name".into());
    }
    if new == old {
        return Ok(());
    }
    let cfg = Config::cached();
    if cfg.dsp.profiles.iter().any(|p| p.name == new) {
        return Err(format!("There is already an EQ called {new}"));
    }
    if !cfg.dsp.profiles.iter().any(|p| p.name == old) {
        return Err(format!("No EQ called {old}"));
    }
    let (from, to) = (
        Path::new("dsp").join(slug(old)),
        Path::new("dsp").join(slug(new)),
    );
    let base = config::config_dir();
    let moved = from != to && base.join(&from).exists();
    if moved {
        if base.join(&to).exists() {
            return Err(format!("{} is in the way", to.display()));
        }
        std::fs::rename(base.join(&from), base.join(&to)).map_err(|e| e.to_string())?;
    }
    persist(|cfg| {
        // The stacks that play it follow the new name.
        for l in cfg
            .dsp
            .profiles
            .iter_mut()
            .flat_map(|p| p.layers.iter_mut())
        {
            if l.profile == old {
                l.profile = new.to_string();
            }
        }
        // So do the outputs that play it as their tuning, or were set from it.
        for t in &mut cfg.dsp.tunings {
            if t.tuning == old {
                t.tuning = new.to_string();
            }
        }
        for p in &mut cfg.dsp.presets {
            if p.preset == old {
                p.preset = new.to_string();
            }
        }
        if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == old) {
            p.name = new.to_string();
            if moved {
                for path in &mut p.impulses {
                    if let Ok(rest) = path.strip_prefix(&from) {
                        *path = to.join(rest);
                    }
                }
            }
        }
    })
    .map_err(|e| e.to_string())
}

/// Write the profiles, and say so: what each output plays through is shown
/// on every device that can choose it, here and on the devices controlling
/// this one.
fn persist(mutate: impl FnOnce(&mut crate::config::Config)) -> Result<(), String> {
    Config::persist(mutate).map_err(|e| e.to_string())?;
    crate::signal::engine_changed().bump();
    crate::remote::dsp_sync::changed();
    Ok(())
}

/// Where `name` keeps its files: responses, and an AutoEQ result's CSV.
pub fn dir(name: &str) -> PathBuf {
    config::config_dir().join("dsp").join(slug(name))
}

/// Record the target `name`'s correction was made for: one that ships,
/// since a move is worked out against it. A target chosen in its place is
/// kept where it is for the same kind of headphone. Refused for a
/// correction built from a measurement, which is made for the target it is
/// corrected to.
pub fn set_made_for(name: &str, made_for: Option<&str>) -> Result<(), String> {
    use super::targets;
    let cfg = Config::cached();
    let p = cfg
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == name)
        .ok_or_else(|| format!("No EQ called {name}"))?;
    if p.measured().is_some() {
        return Err(format!(
            "{name} is built from a measurement: choose the target it is corrected to instead"
        ));
    }
    let made = match made_for {
        Some(id) => Some(targets::shipped(id).ok_or_else(|| format!("No target called {id}"))?),
        None => None,
    };
    let chosen = p
        .target
        .as_ref()
        .and_then(|t| t.chosen.clone())
        .filter(|c| made.is_some_and(|m| targets::shipped(c).is_none_or(|t| t.ear == m.ear)));
    persist(|cfg| {
        if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == name) {
            p.target = made.map(|m| crate::config::DspTarget {
                made_for: m.id.to_owned(),
                chosen,
            });
        }
    })
}

/// The headphone `p` corrects, as measured, and the target it is corrected
/// to, for drawing: an AutoEQ result's own two curves, its target moved as a
/// chosen target moves it; or a measurement and its target, levelled at
/// 1 kHz so they are drawn against each other.
fn headphone(p: &DspProfile) -> Option<(super::targets::Curve, super::targets::Curve)> {
    use super::targets;
    let folder = dir(&p.name);
    if let Some(m) = p.measured() {
        let level = |c: targets::Curve| {
            let k = targets::at(&c, 1000.0);
            c.into_iter()
                .map(|(hz, db)| (hz, db - k))
                .collect::<targets::Curve>()
        };
        return Some((
            level(targets::measurement(&folder)?),
            level(targets::choice_curve(&m.target)?),
        ));
    }
    let (raw, made_for) = targets::autoeq_measurement(&folder)?;
    let moved = p
        .target
        .as_ref()
        .and_then(|t| Some((t.chosen.as_ref()?, &t.made_for)))
        .and_then(|(to, from)| {
            Some(targets::difference(
                &targets::choice_curve(from)?,
                &targets::choice_curve(to)?,
            ))
        });
    Some((
        raw,
        match moved {
            Some(step) => targets::moved(&made_for, &step),
            None => made_for,
        },
    ))
}

/// What `name` offers to move its correction to.
#[derive(Debug, Clone, PartialEq)]
pub struct TargetChoices {
    /// The target an AutoEQ correction or a ready-made EQ was made for;
    /// none for one built from a measurement, which is made for `chosen`.
    pub made_for: Option<&'static super::targets::Target>,
    pub chosen: Option<String>,
    /// The shipped targets for the same kind of headphone, then those added.
    pub choices: Vec<TargetChoice>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct TargetChoice {
    pub id: String,
    pub name: String,
    /// What it does, in a few plain words; empty for one added.
    pub does: String,
    /// What it sounds like; empty for one added.
    pub character: String,
}

/// The targets `name` can move to, for a correction installed from AutoEQ
/// whose target is known.
pub fn target_choices(name: &str) -> Option<TargetChoices> {
    use super::targets;
    let cfg = Config::cached();
    let p = cfg.dsp.profiles.iter().find(|p| p.name == name)?;
    let (made_for, chosen, ear) = match (p.measured(), &p.target) {
        (Some(m), _) => (
            None,
            Some(m.target.clone()),
            match m.ear {
                DspEar::In => targets::Ear::In,
                DspEar::Over => targets::Ear::Over,
                DspEar::Speaker => targets::Ear::Speaker,
            },
        ),
        (None, Some(t)) => {
            let made_for = targets::shipped(&t.made_for)?;
            (Some(made_for), t.chosen.clone(), made_for.ear)
        }
        (None, None) => return None,
    };
    let mut choices: Vec<TargetChoice> = targets::TARGETS
        .iter()
        .filter(|c| c.ear == ear)
        .map(|c| TargetChoice {
            id: c.id.into(),
            name: c.name.into(),
            does: c.does.into(),
            character: c.character.into(),
        })
        .collect();
    choices.extend(targets::added().into_iter().map(|a| TargetChoice {
        id: a.id,
        name: a.name,
        does: String::new(),
        character: String::new(),
    }));
    Some(TargetChoices {
        made_for,
        chosen,
        choices,
    })
}

/// Move `name`'s correction to `chosen`, or with `None` back to the target it
/// was made for.
pub fn choose_target(name: &str, chosen: Option<&str>) -> Result<(), String> {
    let choices =
        target_choices(name).ok_or_else(|| format!("{name} has no target to move from"))?;
    if let Some(c) = chosen
        && !choices.choices.iter().any(|x| x.id == c)
    {
        return Err(format!("No target {c} for {name}"));
    }
    // Built from a measurement: its bands are fitted again to the target
    // chosen.
    let measured = Config::cached()
        .dsp
        .profiles
        .iter()
        .any(|p| p.name == name && p.measured().is_some());
    let refit = match chosen {
        Some(c) if measured => {
            let curve = super::targets::measurement(&dir(name))
                .ok_or_else(|| format!("{name}'s measurement is missing"))?;
            let aim = super::targets::choice_curve(c).ok_or_else(|| format!("No target {c}"))?;
            Some(squig_fit(&curve, &aim))
        }
        _ => None,
    };
    persist(|cfg| {
        let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == name) else {
            return;
        };
        if let Some(m) = p.fitted.as_mut().or(p.measurement.as_mut()) {
            // Built from a measurement: it is made for the target chosen,
            // and fitted to it, one saved before kōan fitted bands too.
            if let Some(c) = chosen {
                m.target = c.to_owned();
            }
            if let Some((filters, preamp)) = refit {
                let legacy = p.measurement.take();
                p.fitted = p.fitted.take().or(legacy);
                p.filters = filters;
                p.preamp_db = Some(preamp);
            }
        } else if let Some(t) = p.target.as_mut() {
            t.chosen = chosen.filter(|c| *c != t.made_for).map(str::to_owned);
        }
    })
    .map_err(|e| e.to_string())
}

/// Play `device` through `name`, or untouched with `None`.
pub fn assign(name: Option<&str>, device: &str) -> Result<(), String> {
    if let Some(name) = name {
        let cfg = Config::cached();
        let Some(p) = cfg.dsp.profiles.iter().find(|p| p.name == name) else {
            return Err(format!("No EQ called {name}"));
        };
        // A preset is never an output's correction: it sets one.
        if p.preset {
            return apply_preset(device, Some(name));
        }
    }
    persist(|cfg| {
        for p in &mut cfg.dsp.profiles {
            p.devices.retain(|d| d != device);
            if Some(p.name.as_str()) == name {
                p.devices.push(device.to_string());
            }
        }
        // A correction chosen is the output correcting again.
        let all = cfg.dsp.profiles.clone();
        if all
            .iter()
            .any(|p| Some(p.name.as_str()) == name && shown_role(p, &all).corrects())
        {
            cfg.dsp.filters_only.retain(|d| d != device);
        }
    })
    .map_err(|e| e.to_string())
}

/// The ranges a band edited by hand is held to: the audible band, what a
/// correction plausibly asks, and Q from very broad to very narrow.
const BAND_HZ: std::ops::RangeInclusive<f64> = 10.0..=22_000.0;
const BAND_DB: std::ops::RangeInclusive<f64> = -30.0..=30.0;
const BAND_Q: std::ops::RangeInclusive<f64> = 0.1..=20.0;

fn clamp(v: f64, r: &std::ops::RangeInclusive<f64>) -> Result<f64, String> {
    if !v.is_finite() {
        return Err("Not a number".into());
    }
    Ok(v.clamp(*r.start(), *r.end()))
}

/// Refused unless `name` is there and can be edited: not a correction.
fn may_edit(name: &str) -> Result<(), String> {
    let cfg = Config::cached();
    let p = cfg
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == name)
        .ok_or_else(|| format!("No EQ called {name}"))?;
    editable(p, &cfg.dsp.profiles)
}

/// A band's type by its config name, and its figures held within the
/// ranges a band may have.
fn band_values(
    kind: &str,
    freq: f64,
    gain_db: f64,
    q: f64,
) -> Result<(crate::config::EqFilterKind, f64, f64, f64), String> {
    let kind = serde_json::from_value(serde_json::Value::String(kind.into()))
        .map_err(|_| format!("No band type called {kind}"))?;
    Ok((
        kind,
        clamp(freq, &BAND_HZ)?,
        clamp(gain_db, &BAND_DB)?,
        clamp(q, &BAND_Q)?,
    ))
}

/// A curve's points held within a band's ranges, in order of frequency.
fn curve_points(points: &[(f64, f64)]) -> Result<Vec<(f64, f64)>, String> {
    if points.is_empty() {
        return Err("A curve needs a point".into());
    }
    let most = crate::config::dsp_bounds::GRAPHIC_POINTS;
    if points.len() > most {
        return Err(format!("A curve has at most {most} points"));
    }
    let mut points = points
        .iter()
        .map(|&(hz, db)| Ok((clamp(hz, &BAND_HZ)?, clamp(db, &BAND_DB)?)))
        .collect::<Result<Vec<_>, String>>()?;
    points.sort_by(|a, b| a.0.total_cmp(&b.0));
    Ok(points)
}

/// What `name` would draw with filter `index` changed by `edit`, nothing
/// saved: the graph follows a drag with this, and the edit is saved when
/// the drag settles. None where the filter is not of the kind `edit` takes,
/// or `name` is a correction, which is not edited.
fn preview(
    name: &str,
    index: usize,
    rate: u32,
    edit: impl FnOnce(&mut crate::config::DspFilter) -> bool,
) -> Option<Response> {
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let mut p = all.iter().find(|p| p.name == name)?.clone();
    editable(&p, all).ok()?;
    if !edit(p.filters.get_mut(index)?) {
        return None;
    }
    response_of(&p, all, rate)
}

/// What `name` would draw with band `index` set so, at `rate`.
pub fn preview_band(
    name: &str,
    index: usize,
    kind: &str,
    freq: f64,
    gain_db: f64,
    q: f64,
    rate: u32,
) -> Option<Response> {
    let (kind, freq, gain_db, q) = band_values(kind, freq, gain_db, q).ok()?;
    preview(name, index, rate, |f| match f {
        crate::config::DspFilter::Band(b) => {
            (b.kind, b.freq, b.gain_db, b.q) = (kind, freq, gain_db, q);
            true
        }
        _ => false,
    })
}

/// What `name` would draw with curve `index` set to `points`, at `rate`.
pub fn preview_curve(
    name: &str,
    index: usize,
    points: &[(f64, f64)],
    rate: u32,
) -> Option<Response> {
    let points = curve_points(points).ok()?;
    preview(name, index, rate, |f| match f {
        crate::config::DspFilter::Graphic(g) => {
            g.points = points;
            true
        }
        _ => false,
    })
}

/// Set filter `index` of `name`, a parametric band, to `kind` at `freq`,
/// `gain_db` and `q`, held within the ranges a band may have. Its channels
/// are kept. Delays, mixes and graphic curves are not edited this way.
/// Refused for a correction, which plays as made.
pub fn set_band(
    name: &str,
    index: usize,
    kind: &str,
    freq: f64,
    gain_db: f64,
    q: f64,
) -> Result<(), String> {
    use crate::config::DspFilter;
    let (kind, freq, gain_db, q) = band_values(kind, freq, gain_db, q)?;
    may_edit(name)?;
    let mut found = Err(format!("{name} has no band {}", index + 1));
    persist(|cfg| {
        if let Some(DspFilter::Band(b)) = cfg
            .dsp
            .profiles
            .iter_mut()
            .find(|p| p.name == name)
            .and_then(|p| p.filters.get_mut(index))
        {
            (b.kind, b.freq, b.gain_db, b.q) = (kind, freq, gain_db, q);
            found = Ok(());
        }
    })
    .map_err(|e| e.to_string())?;
    found
}

/// Set the points of filter `index` of `name`, a graphic curve, each held
/// within the ranges a band may have and put in order of frequency. Its
/// channels are kept. Refused for a correction, which plays as made.
pub fn set_curve(name: &str, index: usize, points: &[(f64, f64)]) -> Result<(), String> {
    use crate::config::DspFilter;
    let points = curve_points(points)?;
    may_edit(name)?;
    let mut found = Err(format!("{name} has no curve {}", index + 1));
    persist(|cfg| {
        if let Some(DspFilter::Graphic(g)) = cfg
            .dsp
            .profiles
            .iter_mut()
            .find(|p| p.name == name)
            .and_then(|p| p.filters.get_mut(index))
        {
            g.points = points;
            found = Ok(());
        }
    })
    .map_err(|e| e.to_string())?;
    found
}

/// Add a flat peaking band at 1 kHz to the end of `name`'s filters, on
/// `channel` alone or, with none, on every channel. Returns its index.
pub fn add_band(name: &str, channel: Option<u16>) -> Result<usize, String> {
    use crate::config::{DspFilter, EqFilter, EqFilterKind};
    may_edit(name)?;
    let mut index = 0;
    persist(|cfg| {
        let p = profile_mut(&mut cfg.dsp.profiles, name);
        p.filters.push(DspFilter::Band(EqFilter {
            kind: EqFilterKind::Peaking,
            freq: 1000.0,
            gain_db: 0.0,
            q: 1.0,
            channels: channel.into_iter().collect(),
        }));
        index = p.filters.len() - 1;
    })
    .map_err(|e| e.to_string())?;
    Ok(index)
}

/// Where a new EQ of bands starts: flat, or tilted the way most people
/// first reach for.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Starter {
    Flat,
    BassBoost,
    Warm,
    Bright,
}

/// Eight bands spread across the range, as a parametric EQ opens: a low
/// shelf, six peaks an octave apart and a high shelf, at `starter`'s gains.
pub fn starter_bands(starter: Starter) -> Vec<crate::config::DspFilter> {
    use crate::config::{DspFilter, EqFilter, EqFilterKind};
    let (low, high, presence) = match starter {
        Starter::Flat => (0.0, 0.0, 0.0),
        Starter::BassBoost => (4.0, 0.0, 0.0),
        Starter::Warm => (2.0, -2.0, 0.0),
        Starter::Bright => (0.0, 2.5, 1.0),
    };
    let band = |kind, freq, gain_db, q| {
        DspFilter::Band(EqFilter {
            kind,
            freq,
            gain_db,
            q,
            channels: vec![],
        })
    };
    let mut bands = vec![band(
        EqFilterKind::LowShelf,
        100.0,
        low,
        std::f64::consts::FRAC_1_SQRT_2,
    )];
    for freq in [200.0, 400.0, 800.0, 1600.0, 3200.0, 6400.0] {
        let gain = if freq == 3200.0 { presence } else { 0.0 };
        bands.push(band(EqFilterKind::Peaking, freq, gain, 1.0));
    }
    bands.push(band(
        EqFilterKind::HighShelf,
        10_000.0,
        high,
        std::f64::consts::FRAC_1_SQRT_2,
    ));
    bands
}

/// Make the EQ `name`: `starter`'s bands, on every channel, to edit.
pub fn create_eq(name: &str, starter: Starter) -> Result<(), String> {
    let name = name.trim();
    if name.is_empty() {
        return Err("It needs a name".into());
    }
    if Config::cached().dsp.profiles.iter().any(|p| p.name == name) {
        return Err(format!("There is already an EQ called {name}"));
    }
    persist(|cfg| {
        cfg.dsp.profiles.push(DspProfile {
            name: name.to_owned(),
            filters: starter_bands(starter),
            role: Some(DspRole::Tuning),
            ..Default::default()
        });
    })
    .map_err(|e| e.to_string())
}

/// How an EQ of bands lays them over the two channels: one list for both,
/// or one for each, and whether the two lists say different things.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ChannelLayout {
    pub stereo: bool,
    pub differ: bool,
}

/// `filters`' layout, where they are bands alone, each on every channel or
/// on the left or right alone. `None` for anything else: delays, mixes,
/// curves, or bands over more channels than two.
pub fn channel_layout(filters: &[crate::config::DspFilter]) -> Option<ChannelLayout> {
    use crate::config::DspFilter;
    let mut stereo = false;
    for f in filters {
        let DspFilter::Band(b) = f else { return None };
        match b.channels.as_slice() {
            [] => {}
            [0] | [1] => stereo = true,
            _ => return None,
        }
    }
    let on = |c: u16| -> Vec<(crate::config::EqFilterKind, u64, u64, u64)> {
        filters
            .iter()
            .filter_map(|f| match f {
                DspFilter::Band(b) if b.channels.is_empty() || b.channels.contains(&c) => {
                    Some((b.kind, b.freq.to_bits(), b.gain_db.to_bits(), b.q.to_bits()))
                }
                _ => None,
            })
            .collect()
    };
    Some(ChannelLayout {
        stereo,
        differ: stereo && on(0) != on(1),
    })
}

/// Give `name` a list of bands for each channel, each starting as the one
/// list it had, or one list for both: the bands of channel `keep`, the
/// other's dropped.
pub fn set_stereo(name: &str, stereo: bool, keep: u16) -> Result<(), String> {
    use crate::config::DspFilter;
    may_edit(name)?;
    if keep > 1 {
        return Err("Keep the left channel (0) or the right (1)".into());
    }
    let cfg = Config::cached();
    let p = cfg
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == name)
        .ok_or_else(|| format!("No EQ called {name}"))?;
    if !p.layers.is_empty() || !p.impulses.is_empty() || channel_layout(&p.filters).is_none() {
        return Err(format!(
            "{name} is not bands alone, so it has no channels to set"
        ));
    }
    let on = |c: u16| -> Vec<DspFilter> {
        p.filters
            .iter()
            .filter(|f| {
                let ch = f.channels();
                ch.is_empty() || ch.contains(&c)
            })
            .cloned()
            .map(|mut f| {
                if let Some(ch) = f.channels_mut() {
                    *ch = if stereo { vec![c] } else { vec![] };
                }
                f
            })
            .collect()
    };
    let filters = if stereo {
        let mut both = on(0);
        both.extend(on(1));
        both
    } else {
        on(keep)
    };
    persist(|cfg| profile_mut(&mut cfg.dsp.profiles, name).filters = filters)
        .map_err(|e| e.to_string())
}

/// Take filter `index` out of `name`.
pub fn remove_filter(name: &str, index: usize) -> Result<(), String> {
    may_edit(name)?;
    let mut found = Err(format!("{name} has no filter {}", index + 1));
    persist(|cfg| {
        if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == name)
            && index < p.filters.len()
        {
            p.filters.remove(index);
            found = Ok(());
        }
    })
    .map_err(|e| e.to_string())?;
    found
}

/// What a profile does to the sound, for drawing: every curve on AutoEQ's
/// grid, in dB.
#[derive(Debug, Clone, PartialEq)]
pub struct Response {
    pub freqs: Vec<f64>,
    /// Everything it plays, layers, target step and impulse responses
    /// included, on the first channel. The preamp is left out, so the
    /// curve lines up with the bands' own gains; it is `preamp_db`.
    pub total: Vec<f64>,
    /// Each of its own parametric bands alone, in order; a flat gain is
    /// `gain_db`.
    pub bands: Vec<Vec<f64>>,
    /// Each layer as it plays alone, for a stack.
    pub layers: Vec<LayerResponse>,
    /// For a correction from AutoEQ (or a stack with one among its layers):
    /// the headphone as measured, the target it plays to, and the measurement
    /// with everything here applied.
    pub measurement: Option<Vec<f64>>,
    pub target: Option<Vec<f64>>,
    pub predicted: Option<Vec<f64>>,
    /// The gain ahead of it all at `rate`.
    pub preamp_db: f64,
    /// The flat gain among its filters on the first channel, which `total`
    /// includes. With `preamp_db`, the level the curve sits at, however the
    /// profile states its gain.
    pub gain_db: f64,
    /// For a chain with both a correction and tuning: what the correction
    /// does, and what the tuning on top does, so each can be drawn as its
    /// own. `total` is the two together.
    pub correction: Option<Vec<f64>>,
    pub tuning: Option<Vec<f64>>,
    /// For a split's preview: the baked EQ it comes from, which `total`
    /// plays the same as.
    pub original: Option<Vec<f64>>,
    /// For an EQ with a list of bands for each channel: the right channel,
    /// where `total` is the left.
    pub right: Option<Vec<f64>>,
    /// `gain_db` on the right channel, which `right` includes.
    pub right_gain_db: f64,
}

#[derive(Debug, Clone, PartialEq)]
pub struct LayerResponse {
    pub name: String,
    pub on: bool,
    pub db: Vec<f64>,
}

/// What `name` does to the sound at `rate`, from the filters the DSP runs.
/// `None` for a profile that is not there or would not play.
pub fn response(name: &str, rate: u32) -> Option<Response> {
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    response_of(all.iter().find(|p| p.name == name)?, all, rate)
}

/// What the output `device` plays at `rate`: its correction and the tuning
/// on top, as the player builds them.
pub fn output_response(device: &str, rate: u32) -> Option<Response> {
    let chain = super::output_chain(&Config::cached().dsp, device)?;
    response_of(&chain.profile, &chain.all, rate)
}

fn response_of(profile: &DspProfile, all: &[DspProfile], rate: u32) -> Option<Response> {
    use super::targets;
    let freqs = targets::grid();
    let curve = |filters: &[crate::config::DspFilter]| super::response(filters, &freqs, rate);
    let setup = Setup::load(profile, all, &config::config_dir()).ok()?;
    let total = setup
        .as_ref()
        .map_or_else(|| vec![0.0; freqs.len()], |s| s.response(&freqs, rate));
    let bands = profile
        .filters
        .iter()
        .filter(|f| matches!(f, crate::config::DspFilter::Band(b) if b.kind != crate::config::EqFilterKind::Gain))
        .map(|f| curve(std::slice::from_ref(f)))
        .collect();
    // The correction alone, where the chain has tuning besides.
    let corrector = corrections_in(profile, all)
        .first()
        .and_then(|c| all.iter().find(|p| &p.name == c))
        .filter(|c| c.name != profile.name || !profile.layers.is_empty());
    // An output's chain is its correction with the tuning as layers, and
    // the correction as it plays there, fitted again for the tuning.
    let correction = corrector.and_then(|c| {
        let c = if c.name == profile.name { profile } else { c };
        let alone = DspProfile {
            layers: Vec::new(),
            ..c.clone()
        };
        Setup::load(&alone, all, &config::config_dir())
            .ok()
            .flatten()
            .map(|s| s.response(&freqs, rate))
    });
    let tuning = correction
        .as_ref()
        .map(|c| {
            total
                .iter()
                .zip(c)
                .map(|(t, c)| t - c)
                .collect::<Vec<f64>>()
        })
        .filter(|t| t.iter().any(|db| db.abs() > 0.05));
    let correction = correction.filter(|_| tuning.is_some());
    let layers = profile
        .layers
        .iter()
        .filter_map(|l| {
            let p = all.iter().find(|p| p.name == l.profile)?;
            let filters = super::chain(p, all, &mut Vec::new()).ok()?;
            Some(LayerResponse {
                // An output's tuning is resolved under a name of its own.
                name: l
                    .profile
                    .rsplit('\u{1}')
                    .next()
                    .unwrap_or_default()
                    .to_owned(),
                on: l.on,
                db: curve(&filters),
            })
        })
        .collect();

    // The headphone this chain corrects, as measured, and the target it is
    // corrected to: this profile's, or the first of its layers that has one.
    let measured = std::iter::once(profile)
        .chain(
            profile
                .layers
                .iter()
                .filter(|l| l.on)
                .filter_map(|l| all.iter().find(|p| p.name == l.profile)),
        )
        .find_map(headphone);
    let (measurement, target, predicted) = match measured {
        Some((raw, aim)) => {
            let raw: Vec<f64> = freqs.iter().map(|&hz| targets::at(&raw, hz)).collect();
            let aim: Vec<f64> = freqs.iter().map(|&hz| targets::at(&aim, hz)).collect();
            let predicted = raw.iter().zip(&total).map(|(r, t)| r + t).collect();
            (Some(raw), Some(aim), Some(predicted))
        }
        None => (None, None, None),
    };
    let preamp_db = setup
        .as_ref()
        .map_or(0.0, |s| s.preamp_db(s.output_rate(rate), 2));
    let gain_db = setup.as_ref().map_or(0.0, |s| s.gain_db_on(0));
    let right_gain_db = setup.as_ref().map_or(0.0, |s| s.gain_db_on(1));
    let right = right_channel(profile, all, &freqs, rate);
    Some(Response {
        freqs,
        total,
        bands,
        layers,
        measurement,
        target,
        predicted,
        preamp_db,
        gain_db,
        correction,
        tuning,
        original: None,
        right,
        right_gain_db,
    })
}

/// The right channel of what `profile` plays, where it differs from the
/// left: one or more of its EQs has a list of bands for each channel. Not
/// drawn for impulse responses, whose channels are their own.
fn right_channel(
    profile: &DspProfile,
    all: &[DspProfile],
    freqs: &[f64],
    rate: u32,
) -> Option<Vec<f64>> {
    if !super::responses(profile, all).is_empty() {
        return None;
    }
    let filters = super::chain(profile, all, &mut Vec::new()).ok()?;
    if filters.iter().all(|f| f.channels().is_empty()) {
        return None;
    }
    let left = super::response_on(&filters, freqs, rate, 0);
    let right = super::response_on(&filters, freqs, rate, 1);
    left.iter()
        .zip(&right)
        .any(|(l, r)| (l - r).abs() > 0.01)
        .then_some(right)
}

/// Play `member` of the group `group`, and none of the others.
pub fn select(group: &str, member: &str) -> Result<(), String> {
    let cfg = Config::cached();
    let g = cfg
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == group)
        .ok_or_else(|| format!("No EQ called {group}"))?;
    if !g.group {
        return Err(format!("{group} is not a group"));
    }
    if !g.layers.iter().any(|l| l.profile == member) {
        return Err(format!("{member} is not in {group}"));
    }
    persist(|cfg| {
        if let Some(g) = cfg.dsp.profiles.iter_mut().find(|p| p.name == group) {
            for l in &mut g.layers {
                l.on = l.profile == member;
            }
        }
    })
    .map_err(|e| e.to_string())
}

/// Make `name` a group, where one of its layers plays, or a stack, where
/// each is switched on or off. Made a group, the first layer switched on
/// is the one that plays.
pub fn set_group(name: &str, group: bool) -> Result<(), String> {
    persist(|cfg| {
        if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == name) {
            p.group = group;
            if group {
                let first = p.layers.iter().position(|l| l.on).unwrap_or(0);
                for (i, l) in p.layers.iter_mut().enumerate() {
                    l.on = i == first;
                }
            }
        }
    })
    .map_err(|e| e.to_string())
}

/// `name`, or numbered where it or the folder its files would go in is
/// taken, so nothing already here is written over.
pub fn free_name(name: &str) -> String {
    let cfg = Config::cached();
    let taken = |n: &str| {
        let folder = dir(n);
        cfg.dsp
            .profiles
            .iter()
            .any(|p| p.name == n || dir(&p.name) == folder)
            || folder.exists()
    };
    std::iter::once(name.to_owned())
        .chain((2..).map(|n| format!("{name} {n}")))
        .find(|n| !taken(n))
        .expect("some number is free")
}

/// Make `name` a group of `members`, in order, the first playing. Refused
/// over a profile of that name.
pub fn make_group(name: &str, members: &[String]) -> Result<(), String> {
    let name = name.trim();
    if name.is_empty() {
        return Err("A group needs a name".into());
    }
    if Config::cached().dsp.profiles.iter().any(|p| p.name == name) {
        return Err(format!("There is already an EQ called {name}"));
    }
    let group = DspProfile {
        name: name.to_owned(),
        layers: members
            .iter()
            .enumerate()
            .map(|(i, m)| crate::config::DspLayer {
                profile: m.clone(),
                on: i == 0,
            })
            .collect(),
        group: true,
        ..Default::default()
    };
    // Each member as it would play, so a group that cannot is never kept.
    let mut all = Config::cached().dsp.profiles.clone();
    all.push(group.clone());
    for m in members {
        let mut check = group.clone();
        for l in &mut check.layers {
            l.on = &l.profile == m;
        }
        super::chain(&check, &all, &mut Vec::new()).map_err(|e| e.to_string())?;
    }
    persist(|cfg| cfg.dsp.profiles.push(group)).map_err(|e| e.to_string())
}

/// Where `profile` is kept: as set, or as follows from what it is. A room
/// or speaker correction, with impulse responses, or one for an output that
/// stays put (built in, or an amplifier on the network) is this device's; a
/// headphone correction from AutoEQ is the account's, since headphones move
/// between devices; a stack is the account's when every layer is.
pub fn scope(profile: &DspProfile, all: &[DspProfile]) -> DspScope {
    scope_in(profile, all, &mut Vec::new())
}

fn scope_in(profile: &DspProfile, all: &[DspProfile], seen: &mut Vec<String>) -> DspScope {
    if let Some(scope) = profile.scope {
        return scope;
    }
    if !profile.impulses.is_empty() {
        return DspScope::Device;
    }
    if profile.target.is_some() || profile.measured().is_some() {
        return DspScope::Everywhere;
    }
    if !profile.layers.is_empty() {
        if seen.contains(&profile.name) {
            return DspScope::Device;
        }
        seen.push(profile.name.clone());
        let everywhere = profile.layers.iter().all(|l| {
            all.iter()
                .find(|p| p.name == l.profile)
                .is_some_and(|p| scope_in(p, all, seen) == DspScope::Everywhere)
        });
        return if everywhere {
            DspScope::Everywhere
        } else {
            DspScope::Device
        };
    }
    if profile.devices.iter().any(|d| stays_put(d)) {
        return DspScope::Device;
    }
    DspScope::Everywhere
}

/// An output that does not travel: built in, an amplifier on the network
/// (named by its UDN), or a phone's own speaker.
fn stays_put(device: &str) -> bool {
    device.starts_with("uuid:")
        || device == "Speaker"
        || crate::audio::list_output_devices().is_ok_and(|devices| {
            devices
                .iter()
                .any(|d| d.name == device && d.kind == crate::audio::backend::OutputKind::BuiltIn)
        })
}

/// The first of `layers` kept on this device alone, which a stack kept
/// everywhere cannot play on the account's other devices.
fn local_layer<'a>(layers: &'a [crate::config::DspLayer], all: &[DspProfile]) -> Option<&'a str> {
    layers
        .iter()
        .find(|l| {
            all.iter()
                .find(|p| p.name == l.profile)
                .is_some_and(|p| scope(p, all) == DspScope::Device)
        })
        .map(|l| l.profile.as_str())
}

/// The stack kept everywhere that plays `name`, if one does.
fn shared_stack<'a>(name: &str, all: &'a [DspProfile]) -> Option<&'a DspProfile> {
    all.iter().find(|p| {
        p.layers.iter().any(|l| l.profile == name) && scope(p, all) == DspScope::Everywhere
    })
}

/// Why `profile` cannot move to the scope it is not in, in a few words.
fn scope_locked(profile: &DspProfile, all: &[DspProfile]) -> Option<String> {
    if scope(profile, all) == DspScope::Everywhere {
        shared_stack(&profile.name, all).map(|s| format!("{} plays it on every device", s.name))
    } else {
        local_layer(&profile.layers, all).map(|l| format!("plays {l}, kept on this device"))
    }
}

fn kept_here(stack: &str, layer: &str) -> String {
    format!(
        "{layer} is kept on this device, so {stack}, which is kept everywhere, \
         could not play it on your other devices. Keep {layer} everywhere, or {stack} on this device"
    )
}

/// Keep `name` everywhere or on this device alone. A stack kept everywhere
/// cannot have a layer kept here: refused either way round.
pub fn set_scope(name: &str, to: DspScope) -> Result<(), String> {
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let profile = all
        .iter()
        .find(|p| p.name == name)
        .ok_or_else(|| format!("No EQ called {name}"))?;
    match to {
        DspScope::Everywhere => {
            if let Some(layer) = local_layer(&profile.layers, all) {
                return Err(kept_here(name, layer));
            }
        }
        DspScope::Device => {
            if let Some(stack) = shared_stack(name, all) {
                return Err(format!(
                    "{name} is played by {}, which is kept everywhere and would lose it on \
                     your other devices. Keep {} on this device first",
                    stack.name, stack.name
                ));
            }
        }
    }
    persist(|cfg| {
        if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == name) {
            p.scope = Some(to);
        }
    })
    .map_err(|e| e.to_string())
}

/// What `profile` is for: as set, or a correction where it was installed
/// from AutoEQ, built from a measurement or said to be made for a target,
/// and a tuning otherwise.
pub fn role(profile: &DspProfile) -> DspRole {
    // Impulse responses correct a room or a device: never a tuning.
    profile.role.unwrap_or(
        if profile.target.is_some() || profile.measured().is_some() || !profile.impulses.is_empty()
        {
            DspRole::Correction
        } else {
            DspRole::Tuning
        },
    )
}

/// What `profile` is for, as shown: a stack with nothing of its own is what
/// it plays, a correction where it holds one, as that correction is.
pub fn shown_role(profile: &DspProfile, all: &[DspProfile]) -> DspRole {
    let own = !profile.filters.is_empty() || !profile.impulses.is_empty();
    if profile.role.is_some() || own || profile.layers.is_empty() {
        return role(profile);
    }
    corrections_in(profile, all)
        .first()
        .and_then(|c| all.iter().find(|p| &p.name == c))
        .map_or(DspRole::Tuning, role)
}

/// The target the chain `profile` corrects to: its correction's chosen
/// target, or the one it was made for or is built from a measurement to.
/// None for a correction with a tuning baked in, whose target is not only a
/// target, or one whose target is not known.
pub fn aims_at(profile: &DspProfile, all: &[DspProfile]) -> Option<String> {
    let first = corrections_in(profile, all).into_iter().next()?;
    let c = all.iter().find(|p| p.name == first)?;
    if role(c) != DspRole::Correction {
        return None;
    }
    c.measured().map(|m| m.target.clone()).or_else(|| {
        c.target
            .as_ref()
            .map(|t| t.chosen.clone().unwrap_or_else(|| t.made_for.clone()))
    })
}

/// The target difference a tuning made against `made` plays on the
/// correction of `profile`'s chain, which aims at `aim`. Tapered where the
/// correction is built from a measurement, as that correction is, so the two
/// sum to the tuning's target, tapered, minus the measurement.
pub fn target_step(
    profile: &DspProfile,
    all: &[DspProfile],
    aim: &[(f64, f64)],
    made: &[(f64, f64)],
) -> crate::config::GraphicEq {
    use super::targets;
    let measured = corrections_in(profile, all)
        .into_iter()
        .next()
        .and_then(|first| all.iter().find(|p| p.name == first))
        .is_some_and(|c| {
            c.measured().is_some()
                || c.target
                    .as_ref()
                    .is_some_and(|t| t.chosen.as_ref().is_some_and(|to| *to != t.made_for))
                    && targets::autoeq_measurement(&dir(&c.name)).is_some()
        });
    if measured {
        targets::tapered_difference(aim, made)
    } else {
        targets::difference(aim, made)
    }
}

/// What `device`'s chain plays, in dB on `targets::grid()` at `rate`: its
/// correction, any target difference and its tuning, as one curve, preamp
/// aside. With `correction` or `tuning` given, those stand in for the
/// device's own, in this call only; nothing is saved. What an independent
/// check compares with another tool's curves.
pub fn chain_response(
    device: &str,
    correction: Option<&str>,
    tuning: Option<&[String]>,
    rate: u32,
) -> Result<Vec<(f64, f64)>, String> {
    let mut dsp = Config::cached().dsp.clone();
    let named = |dsp: &crate::config::DspConfig, name: &str| -> Result<(), String> {
        dsp.profiles
            .iter()
            .any(|p| p.name == name)
            .then_some(())
            .ok_or_else(|| format!("No EQ called {name}"))
    };
    if let Some(c) = correction {
        named(&dsp, c)?;
        for p in &mut dsp.profiles {
            p.devices.retain(|d| d != device);
            if p.name == c {
                p.devices.push(device.to_owned());
            }
        }
    }
    if let Some(t) = tuning {
        for name in t {
            named(&dsp, name)?;
        }
        dsp.tunings.retain(|t| t.device != device);
        dsp.tunings
            .extend(t.iter().map(|name| crate::config::DspOutputTuning {
                device: device.to_owned(),
                tuning: name.clone(),
                on: true,
            }));
    }
    let freqs = super::targets::grid();
    let filters = match super::output_chain(&dsp, device) {
        Some(chain) => {
            super::chain(&chain.profile, &chain.all, &mut Vec::new()).map_err(|e| e.to_string())?
        }
        None => Vec::new(),
    };
    let total = super::response(&filters, &freqs, rate);
    Ok(freqs.into_iter().zip(total).collect())
}

/// The first EQ of `device`'s tuning: what an app showing one shows.
pub fn tuning_for(device: &str) -> Option<String> {
    tunings_for(device).into_iter().next().map(|(name, _)| name)
}

/// `device`'s tuning: its EQs in the order they play, each on or off.
pub fn tunings_for(device: &str) -> Vec<(String, bool)> {
    Config::cached()
        .dsp
        .tunings
        .iter()
        .filter(|t| t.device == device)
        .map(|t| (t.tuning.clone(), t.on))
        .collect()
}

/// Play `tuning` alone on top of `device`'s correction, or none.
pub fn set_tuning(device: &str, tuning: Option<&str>) -> Result<(), String> {
    let list: Vec<(String, bool)> = tuning.map(|t| (t.to_owned(), true)).into_iter().collect();
    set_tunings(device, &list)
}

/// Make `device`'s tuning `tunings`, EQs in the order they play, each on or
/// off. Only EQs, each once, none with impulse responses; and none on over
/// a correction with a tuning baked in, which would add taste twice.
pub fn set_tunings(device: &str, tunings: &[(String, bool)]) -> Result<(), String> {
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    for (i, (name, _)) in tunings.iter().enumerate() {
        check_tuning(name, all)?;
        if tunings[..i].iter().any(|(n, _)| n == name) {
            return Err(format!("{name} is in the tuning twice"));
        }
    }
    if tunings.iter().any(|(_, on)| *on)
        && let Some(c) = cfg.dsp.profile_for(device)
        && shown_role(c, all) == DspRole::Baked
    {
        return Err(baked_already(&c.name));
    }
    persist(|cfg| {
        cfg.dsp.tunings.retain(|t| t.device != device);
        cfg.dsp.tunings.extend(
            tunings
                .iter()
                .map(|(name, on)| crate::config::DspOutputTuning {
                    device: device.to_owned(),
                    tuning: name.clone(),
                    on: *on,
                }),
        );
    })
}

/// Whether `name` can be an EQ of a tuning, and why not.
fn check_tuning(name: &str, all: &[DspProfile]) -> Result<(), String> {
    let t = all
        .iter()
        .find(|p| p.name == name)
        .ok_or_else(|| format!("No EQ called {name}"))?;
    if !super::responses(t, all).is_empty() {
        return Err(format!(
            "{name} has impulse responses, which correct a room or speakers: choose it as the correction instead"
        ));
    }
    if shown_role(t, all) != DspRole::Tuning {
        return Err(format!(
            "{name} corrects headphones: choose it as the correction instead"
        ));
    }
    Ok(())
}

/// Why a correction's bands are not edited.
pub fn read_only(name: &str) -> String {
    format!(
        "{name} is a correction, which plays as made: add a tuning on top to change the sound, or make it a tuning on its page to edit it"
    )
}

/// Refused for a correction, which plays as made, and for anything fitted
/// to a measurement whatever it is said to be: its bands are fitted again to
/// each new target, and an edit would be lost.
fn editable(profile: &DspProfile, all: &[DspProfile]) -> Result<(), String> {
    if profile.fitted.is_some() {
        return Err(format!(
            "{} is fitted to a measurement, and fitted again for each target, so an edit would be lost: add a tuning on top to change the sound",
            profile.name
        ));
    }
    if shown_role(profile, all).corrects() {
        return Err(read_only(&profile.name));
    }
    Ok(())
}

/// Whether `profile` was changed since it was imported.
pub fn edited(profile: &DspProfile) -> bool {
    profile
        .original
        .as_ref()
        .is_some_and(|o| o.filters != profile.filters || o.preamp_db != profile.preamp_db)
}

/// Put `name` back as it was imported.
pub fn revert(name: &str) -> Result<(), String> {
    let cfg = Config::cached();
    let p = cfg
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == name)
        .ok_or_else(|| format!("No EQ called {name}"))?;
    let Some(original) = p.original.clone() else {
        return Err(format!(
            "{name} was not imported, so there is nothing to go back to"
        ));
    };
    persist(|cfg| {
        if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == name) {
            p.filters = original.filters;
            p.preamp_db = original.preamp_db;
        }
    })
}

/// A copy of `name` as it is now, under `new` or "<name> copy": its filters,
/// files, role, targets and where it is kept, used by no output. Its own,
/// with nothing to revert to. The copy's name.
pub fn duplicate(name: &str, new: Option<&str>) -> Result<String, String> {
    let cfg = Config::cached();
    let p = cfg
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == name)
        .ok_or_else(|| format!("No EQ called {name}"))?;
    let new = match new.map(str::trim).filter(|n| !n.is_empty()) {
        Some(n) if free_name(n) != n => {
            return Err(format!("There is already an EQ called {n}"));
        }
        Some(n) => n.to_owned(),
        None => free_name(&format!("{name} copy")),
    };
    let (from, to) = (dir(name), dir(&new));
    if from.is_dir() {
        copy_dir(&from, &to).map_err(|e| e.to_string())?;
    }
    let mut copy = p.clone();
    let rel = |d: &Path| Path::new("dsp").join(d.file_name().unwrap_or_default());
    copy.impulses = copy
        .impulses
        .iter()
        .map(|i| match i.strip_prefix(rel(&from)) {
            Ok(rest) => rel(&to).join(rest),
            Err(_) => i.clone(),
        })
        .collect();
    copy.name = new.clone();
    copy.devices.clear();
    copy.uid = None;
    copy.origin = None;
    copy.original = None;
    copy.source.clear();
    persist(|cfg| cfg.dsp.profiles.push(copy))?;
    Ok(new)
}

/// `name`'s filters and headroom as they are, to put back with
/// `save_as_copy`. Opaque to callers.
pub fn snapshot(name: &str) -> Option<String> {
    let cfg = Config::cached();
    let p = cfg.dsp.profiles.iter().find(|p| p.name == name)?;
    serde_json::to_string(&crate::config::DspOriginal {
        filters: p.filters.clone(),
        preamp_db: p.preamp_db,
    })
    .ok()
}

/// A copy saved by `save_as_copy`: its name, and whether it took the
/// original's place in the device's tuning, which it does only where the
/// tuning names the original itself.
#[derive(Debug, Clone, PartialEq)]
pub struct SavedCopy {
    pub name: String,
    pub placed: bool,
}

/// Keep `name` as it is now as a copy, under `new` or "<name> copy", and put
/// `name` back: to `before`, a `snapshot` taken before the edit, where it
/// differs, or else to its file, where it was imported and has been edited.
/// On `device`, the copy takes `name`'s place in the tuning. Refused for a
/// correction, which is not edited.
pub fn save_as_copy(
    name: &str,
    new: Option<&str>,
    before: Option<&str>,
    device: Option<&str>,
) -> Result<SavedCopy, String> {
    use crate::config::DspOriginal;
    may_edit(name)?;
    let before: Option<DspOriginal> = before
        .map(serde_json::from_str)
        .transpose()
        .map_err(|e| format!("Not a snapshot: {e}"))?;
    // Whatever would refuse the swap is found before anything is written:
    // the copy is the original under another name, so it may be a tuning's
    // EQ exactly where the original may.
    let tunings = device.map(tunings_for).unwrap_or_default();
    let placed = tunings.iter().any(|(n, _)| n == name);
    if placed {
        check_tuning(name, &Config::cached().dsp.profiles)?;
    }
    let copy = duplicate(name, new)?;
    let cfg = Config::cached();
    let p = cfg
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == name)
        .ok_or_else(|| format!("No EQ called {name}"))?;
    match before {
        Some(b) if b.filters != p.filters || b.preamp_db != p.preamp_db => persist(|cfg| {
            if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == name) {
                p.filters = b.filters;
                p.preamp_db = b.preamp_db;
            }
        })?,
        _ if edited(p) => revert(name)?,
        _ => {}
    }
    if let Some(device) = device.filter(|_| placed) {
        let swapped: Vec<(String, bool)> = tunings
            .into_iter()
            .map(|(n, on)| {
                if n == name {
                    (copy.clone(), on)
                } else {
                    (n, on)
                }
            })
            .collect();
        set_tunings(device, &swapped)?;
    }
    Ok(SavedCopy { name: copy, placed })
}

fn copy_dir(from: &Path, to: &Path) -> std::io::Result<()> {
    std::fs::create_dir_all(to)?;
    for entry in std::fs::read_dir(from)? {
        let entry = entry?;
        let target = to.join(entry.file_name());
        if entry.file_type()?.is_dir() {
            copy_dir(&entry.path(), &target)?;
        } else {
            std::fs::copy(entry.path(), target)?;
        }
    }
    Ok(())
}

/// The preset `device` was last set from, and whether its correction or
/// tuning has been changed since.
pub fn preset_for(device: &str) -> Option<(String, bool)> {
    let cfg = Config::cached();
    let name = cfg
        .dsp
        .presets
        .iter()
        .find(|p| p.device == device)?
        .preset
        .clone();
    let preset = cfg
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == name && p.preset)?;
    let now = chain_of(&cfg.dsp, device);
    let only = cfg.dsp.filters_only.iter().any(|d| d == device);
    Some((name, now != preset.layers || only != preset.filters_only))
}

/// Whether `device` plays filters alone, with no correction.
pub fn filters_only(device: &str) -> bool {
    Config::cached()
        .dsp
        .filters_only
        .iter()
        .any(|d| d == device)
}

/// Have `device` play filters alone, or correct for a headphone again. Alone,
/// a correction it had is taken off it, and kept; an EQ chosen for it that
/// does not correct stays.
pub fn set_filters_only(device: &str, only: bool) -> Result<(), String> {
    persist(|cfg| {
        cfg.dsp.filters_only.retain(|d| d != device);
        if only {
            cfg.dsp.filters_only.push(device.to_owned());
            let all = cfg.dsp.profiles.clone();
            for p in cfg.dsp.profiles.iter_mut() {
                let corrects = all
                    .iter()
                    .find(|q| q.name == p.name)
                    .is_some_and(|q| !q.preset && shown_role(q, &all).corrects());
                if corrects {
                    p.devices.retain(|d| d != device);
                }
            }
        }
    })
    .map_err(|e| e.to_string())
}

/// `device`'s correction and tuning as a preset's layers: the correction,
/// then the tuning's EQs.
fn chain_of(dsp: &crate::config::DspConfig, device: &str) -> Vec<crate::config::DspLayer> {
    let correction = dsp
        .profiles
        .iter()
        .find(|p| !p.preset && p.devices.iter().any(|d| d == device));
    correction
        .map(|c| crate::config::DspLayer {
            profile: c.name.clone(),
            on: true,
        })
        .into_iter()
        .chain(
            dsp.tunings
                .iter()
                .filter(|t| t.device == device)
                .map(|t| crate::config::DspLayer {
                    profile: t.tuning.clone(),
                    on: t.on,
                }),
        )
        .collect()
}

/// Save `device`'s correction and tuning as the preset `name`, over one of
/// that name, and say the output is set from it.
pub fn save_preset(device: &str, name: &str) -> Result<String, String> {
    let name = name.trim();
    if name.is_empty() {
        return Err("A preset needs a name".into());
    }
    let cfg = Config::cached();
    if cfg.dsp.profiles.iter().any(|p| p.name == name && !p.preset) {
        return Err(format!("There is already an EQ called {name}"));
    }
    let layers = chain_of(&cfg.dsp, device);
    let unsaid = unsaid_correction(&cfg.dsp, device);
    let only = cfg.dsp.filters_only.iter().any(|d| d == device);
    persist(|cfg| {
        say_corrects(cfg, unsaid.as_deref());
        match cfg.dsp.profiles.iter_mut().find(|p| p.name == name) {
            Some(p) => {
                p.layers = layers;
                p.filters_only = only;
            }
            None => cfg.dsp.profiles.push(DspProfile {
                name: name.to_owned(),
                preset: true,
                layers,
                filters_only: only,
                ..Default::default()
            }),
        }
        cfg.dsp.presets.retain(|p| p.device != device);
        cfg.dsp.presets.push(crate::config::DspOutputPreset {
            device: device.to_owned(),
            preset: name.to_owned(),
        });
    })?;
    Ok(name.to_owned())
}

/// `device`'s correction where nothing says it is one: a profile with no
/// role that would read as a tuning, chosen as a correction before roles
/// were asked. A preset saved from it must still put it back as one.
fn unsaid_correction(dsp: &crate::config::DspConfig, device: &str) -> Option<String> {
    dsp.profiles
        .iter()
        .find(|p| !p.preset && p.devices.iter().any(|d| d == device))
        .filter(|p| p.role.is_none() && !shown_role(p, &dsp.profiles).corrects())
        .map(|p| p.name.clone())
}

/// Say that `name` corrects, as the output it is chosen for uses it.
fn say_corrects(cfg: &mut Config, name: Option<&str>) {
    if let Some(p) = cfg
        .dsp
        .profiles
        .iter_mut()
        .find(|p| Some(p.name.as_str()) == name)
    {
        p.role = Some(DspRole::Correction);
    }
}

/// What a preset's layers set an output to: its correction, where the first
/// layer is one and on, and its tuning's EQs in order. A correction switched
/// off is no correction, as it played in a stack.
fn preset_parts(
    layers: &[crate::config::DspLayer],
    all: &[DspProfile],
) -> (Option<String>, Vec<(String, bool)>) {
    let mut layers = layers.iter().peekable();
    let correction = layers
        .next_if(|l| {
            all.iter()
                .any(|q| q.name == l.profile && shown_role(q, all).corrects())
        })
        .filter(|l| l.on)
        .map(|l| l.profile.clone());
    (
        correction,
        layers.map(|l| (l.profile.clone(), l.on)).collect(),
    )
}

/// Set `device` to play `correction` and `tunings`, set from `preset`.
fn set_output(
    cfg: &mut Config,
    device: &str,
    correction: Option<&str>,
    tunings: &[(String, bool)],
    preset: Option<&str>,
) {
    for p in &mut cfg.dsp.profiles {
        p.devices.retain(|d| d != device);
        if Some(p.name.as_str()) == correction {
            p.devices.push(device.to_owned());
        }
    }
    cfg.dsp.tunings.retain(|t| t.device != device);
    cfg.dsp.tunings.extend(
        tunings
            .iter()
            .map(|(t, on)| crate::config::DspOutputTuning {
                device: device.to_owned(),
                tuning: t.clone(),
                on: *on,
            }),
    );
    cfg.dsp.presets.retain(|p| p.device != device);
    if let Some(preset) = preset {
        cfg.dsp.presets.push(crate::config::DspOutputPreset {
            device: device.to_owned(),
            preset: preset.to_owned(),
        });
    }
}

/// Set `device` from the preset `name`: its correction, and its tuning's
/// EQs in order, on and off as saved. With `None`, flat: no correction and
/// no tuning, which plays untouched.
pub fn apply_preset(device: &str, name: Option<&str>) -> Result<(), String> {
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let mut only = None;
    let (correction, tunings) = match name {
        None => (None, Vec::new()),
        Some(name) => {
            let p = all
                .iter()
                .find(|p| p.name == name && p.preset)
                .ok_or_else(|| {
                    let presets: Vec<&str> = all
                        .iter()
                        .filter(|p| p.preset)
                        .map(|p| p.name.as_str())
                        .collect();
                    format!(
                        "No preset called {name}. Presets: {}",
                        if presets.is_empty() {
                            "none yet".to_owned()
                        } else {
                            presets.join(", ")
                        }
                    )
                })?;
            let parts = preset_parts(&p.layers, all);
            for (t, _) in &parts.1 {
                check_tuning(t, all)?;
            }
            only = Some(p.filters_only);
            // Filters alone: a correction the preset somehow holds is not
            // set.
            if p.filters_only {
                (None, parts.1)
            } else {
                parts
            }
        }
    };
    persist(|cfg| {
        set_output(cfg, device, correction.as_deref(), &tunings, name);
        if let Some(only) = only {
            cfg.dsp.filters_only.retain(|d| d != device);
            if only {
                cfg.dsp.filters_only.push(device.to_owned());
            }
        }
    })
}

/// An output set from a preset by `migrate`: the device, its correction,
/// its tuning and the preset.
type Setting = (String, Option<String>, Vec<(String, bool)>, String);

/// Bring configs from before presets and tunings of several EQs up to
/// them, once at start, and again harmlessly after:
/// - a stack that is a correction with EQs on top is a preset, and an output
///   that played it plays its correction and EQs, set from it, then the
///   tuning it had on top; a correction switched off in the stack is none;
/// - an output a preset is assigned to as its correction, as the apps
///   before this could and a synced preset can, is set from it the same way;
/// - an output whose correction is a group, of which one member plays, has
///   that member; a group in a tuning becomes its member playing;
/// - with processing switched off, which is no longer a thing, every output
///   is flat, its correction and tuning kept as a preset to go back to.
pub fn migrate() -> Result<(), String> {
    migrate_presets()?;
    flatten_off()
}

/// Processing switched off becomes every output flat. What an output played
/// is kept as a preset named for it, unless it was set from one and not
/// changed since.
fn flatten_off() -> Result<(), String> {
    let cfg = Config::cached();
    if cfg.dsp.enabled {
        return Ok(());
    }
    let mut devices: Vec<&str> = Vec::new();
    for d in cfg
        .dsp
        .profiles
        .iter()
        .filter(|p| !p.preset)
        .flat_map(|p| p.devices.iter())
        .chain(cfg.dsp.tunings.iter().map(|t| &t.device))
    {
        if !devices.contains(&d.as_str()) {
            devices.push(d);
        }
    }
    let mut taken: Vec<String> = cfg.dsp.profiles.iter().map(|p| p.name.clone()).collect();
    let mut kept: Vec<(String, Vec<crate::config::DspLayer>)> = Vec::new();
    let mut unsaid: Vec<String> = Vec::new();
    for device in &devices {
        if preset_for(device).is_some_and(|(_, edited)| !edited) {
            continue;
        }
        let layers = chain_of(&cfg.dsp, device);
        if layers.is_empty() {
            continue;
        }
        unsaid.extend(unsaid_correction(&cfg.dsp, device));
        let name = (1..)
            .map(|n| match n {
                1 => (*device).to_owned(),
                n => format!("{device} {n}"),
            })
            .find(|n| !taken.contains(n))
            .expect("a name is free");
        taken.push(name.clone());
        kept.push((name, layers));
    }
    persist(|cfg| {
        for name in &unsaid {
            say_corrects(cfg, Some(name));
        }
        for (name, layers) in &kept {
            cfg.dsp.profiles.push(DspProfile {
                name: name.clone(),
                preset: true,
                layers: layers.clone(),
                ..Default::default()
            });
        }
        for device in &devices {
            set_output(cfg, device, None, &[], None);
        }
        cfg.dsp.enabled = true;
    })
}

fn migrate_presets() -> Result<(), String> {
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let used_as_layer = |name: &str| {
        all.iter()
            .any(|p| p.layers.iter().any(|l| l.profile == name))
    };
    let corrects = |name: &str| {
        all.iter()
            .any(|q| q.name == name && shown_role(q, all).corrects())
    };
    let is_eq = |name: &str| check_tuning(name, all).is_ok();
    // Each stack becoming a preset, or preset assigned to an output: its
    // name, the layers it keeps as a preset, and the outputs it set.
    let presets: Vec<(String, Vec<crate::config::DspLayer>, Vec<String>)> = all
        .iter()
        .filter(|p| {
            (p.preset && !p.devices.is_empty())
                || (!p.preset
                    && !p.group
                    && p.filters.is_empty()
                    && p.impulses.is_empty()
                    && p.target.is_none()
                    && p.measured().is_none()
                    && !used_as_layer(&p.name)
                    && p.layers.first().is_some_and(|l| corrects(&l.profile))
                    && p.layers.iter().skip(1).all(|l| is_eq(&l.profile)))
        })
        .map(|p| {
            let mut layers = p.layers.clone();
            if layers
                .first()
                .is_some_and(|l| !l.on && corrects(&l.profile))
            {
                layers.remove(0);
            }
            (p.name.clone(), layers, p.devices.clone())
        })
        .collect();
    // Each output those set: its correction, and its tuning, the preset's
    // EQs then those it had on top.
    let mut set: Vec<Setting> = Vec::new();
    for (name, layers, devices) in &presets {
        let (correction, eqs) = preset_parts(layers, all);
        for device in devices {
            let mut tunings = eqs.clone();
            for t in cfg.dsp.tunings.iter().filter(|t| &t.device == device) {
                if !tunings.iter().any(|(n, _)| n == &t.tuning) {
                    tunings.push((t.tuning.clone(), t.on));
                }
            }
            set.push((device.clone(), correction.clone(), tunings, name.clone()));
        }
    }
    let playing = |p: &DspProfile| super::playing(p, all).map(|m| m.name.clone());
    let groups: Vec<(String, String)> = all
        .iter()
        .filter(|p| p.group)
        .filter_map(|g| playing(g).map(|m| (g.name.clone(), m)))
        .collect();
    let groups_in_use = groups.iter().any(|(g, _)| {
        all.iter().any(|p| &p.name == g && !p.devices.is_empty())
            || cfg.dsp.tunings.iter().any(|t| &t.tuning == g)
    });
    if presets.is_empty() && !groups_in_use {
        return Ok(());
    }
    persist(|cfg| {
        for (device, correction, tunings, preset) in &set {
            set_output(cfg, device, correction.as_deref(), tunings, Some(preset));
        }
        for (name, layers, _) in &presets {
            if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| &p.name == name) {
                p.preset = true;
                p.layers = layers.clone();
                p.devices.clear();
            }
        }
        for (group, member) in &groups {
            let devices: Vec<String> = cfg
                .dsp
                .profiles
                .iter()
                .find(|p| &p.name == group)
                .map(|p| p.devices.clone())
                .unwrap_or_default();
            for p in &mut cfg.dsp.profiles {
                if &p.name == group {
                    p.devices.clear();
                } else if &p.name == member {
                    for d in &devices {
                        if !p.devices.contains(d) {
                            p.devices.push(d.clone());
                        }
                    }
                }
            }
            for t in &mut cfg.dsp.tunings {
                if &t.tuning == group {
                    t.tuning = member.clone();
                }
            }
        }
    })
}

/// Why no tuning goes on top of `correction`.
pub fn baked_already(correction: &str) -> String {
    format!(
        "{correction} already includes a tuning. Split it into a correction and an EQ to change the tuning."
    )
}

/// Say which target the tuning `name` was made against, or that it is not
/// known: a target that ships or one added.
pub fn set_tuned_for(name: &str, target: Option<&str>) -> Result<(), String> {
    if !Config::cached().dsp.profiles.iter().any(|p| p.name == name) {
        return Err(format!("No EQ called {name}"));
    }
    if let Some(t) = target
        && super::targets::choice_curve(t).is_none()
    {
        return Err(format!("No target called {t}"));
    }
    persist(|cfg| {
        if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == name) {
            p.tuned_for = target.map(str::to_owned);
        }
    })
}

/// The corrections a chain plays, `profile` and its layers switched on, in
/// the order they play.
pub fn corrections_in(profile: &DspProfile, all: &[DspProfile]) -> Vec<String> {
    fn walk(p: &DspProfile, all: &[DspProfile], seen: &mut Vec<String>, out: &mut Vec<String>) {
        if seen.contains(&p.name) || seen.len() > 64 {
            return;
        }
        seen.push(p.name.clone());
        // A group plays one member, so only it counts.
        let played: Vec<&DspProfile> = if p.group {
            super::playing(p, all).into_iter().collect()
        } else {
            p.layers
                .iter()
                .filter(|l| l.on)
                .filter_map(|l| all.iter().find(|q| q.name == l.profile))
                .collect()
        };
        for q in played {
            walk(q, all, seen, out);
        }
        if role(p).corrects() && !out.contains(&p.name) {
            out.push(p.name.clone());
        }
    }
    let mut out = Vec::new();
    walk(profile, all, &mut Vec::new(), &mut out);
    out
}

/// A correction by name and kind, as a warning names it: "Cantor (AutoEQ)".
fn correction_label(p: &DspProfile) -> String {
    let kind = if role(p) == DspRole::Baked {
        "includes a tuning"
    } else if p.measured().is_some() {
        "measured"
    } else if super::targets::autoeq_measurement(&dir(&p.name)).is_some() {
        "AutoEQ"
    } else if p.target.is_some() {
        "ready-made"
    } else {
        "correction"
    };
    if p.name.to_lowercase().contains(&kind.to_lowercase()) {
        p.name.clone()
    } else {
        format!("{} ({kind})", p.name)
    }
}

/// What a chain correcting more than once says: each undoes the same
/// headphone, so it plays twice the correction. Stacks made before that was
/// refused still play, and say so.
pub fn corrects_twice(profile: &DspProfile, all: &[DspProfile]) -> Option<String> {
    let c = corrections_in(profile, all);
    if c.len() < 2 {
        return None;
    }
    let labels: Vec<String> = c
        .iter()
        .filter_map(|n| all.iter().find(|p| &p.name == n))
        .map(correction_label)
        .collect();
    let (last, rest) = labels.split_last()?;
    Some(format!(
        "This EQ corrects twice: {} and {last}. Keep one.",
        rest.join(", ")
    ))
}

/// Why a chain with more than one correction is refused.
pub fn two_corrections(corrections: &[String]) -> String {
    format!(
        "This EQ already plays the correction {}. Take that out first, or add {} to a device's tuning instead.",
        corrections[0],
        corrections.get(1).map_or("this", String::as_str)
    )
}

/// Say what `name` is for. Always taken, since it is what the profile is:
/// a stack it makes correct twice says so on its page (`corrects_twice`),
/// and gains no further correction.
pub fn set_role(name: &str, to: DspRole) -> Result<(), String> {
    if !Config::cached().dsp.profiles.iter().any(|p| p.name == name) {
        return Err(format!("No EQ called {name}"));
    }
    persist(|cfg| {
        if let Some(p) = cfg.dsp.profiles.iter_mut().find(|p| p.name == name) {
            p.role = Some(to);
        }
    })
}

/// A target's name, by id: one that ships, one added, or the id itself.
pub fn target_name(id: &str) -> String {
    use super::targets;
    targets::shipped(id).map_or_else(
        || {
            targets::added()
                .into_iter()
                .find(|a| a.id == id)
                .map_or_else(|| id.to_owned(), |a| a.name)
        },
        |t| t.name.to_owned(),
    )
}

/// What a chain does, in a line each: the headphone it corrects and how,
/// and the tunings on top.
#[derive(Debug, Clone, Default, PartialEq)]
pub struct ChainSummary {
    pub correction: Option<String>,
    /// The correction has a tuning baked in.
    pub baked: bool,
    pub tunings: Vec<String>,
}

pub fn summary(name: &str) -> Option<ChainSummary> {
    use super::targets;
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let profile = all.iter().find(|p| p.name == name)?;
    let mut chain: Vec<&DspProfile> = profile
        .layers
        .iter()
        .filter(|l| l.on)
        .filter_map(|l| all.iter().find(|p| p.name == l.profile))
        .collect();
    chain.push(profile);
    let mut out = ChainSummary::default();
    for p in chain {
        match role(p) {
            DspRole::Tuning => {
                if !p.filters.is_empty() || !p.impulses.is_empty() {
                    out.tunings.push(p.name.clone());
                }
                continue;
            }
            DspRole::Baked => {
                if out.correction.is_none() {
                    out.correction = Some(format!("{} (correction + tuning in one)", p.name));
                    out.baked = true;
                }
                continue;
            }
            DspRole::Correction => {}
        }
        let line = if let Some(m) = p.measured() {
            format!("{} → {} (from measurement)", p.name, target_name(&m.target))
        } else if let Some(t) = &p.target {
            let autoeq = targets::autoeq_measurement(&dir(&p.name)).is_some();
            match (&t.chosen, autoeq) {
                (Some(c), true) => format!(
                    "{} → {} (rebuilt from AutoEQ's measurement)",
                    p.name,
                    target_name(c)
                ),
                (Some(c), false) => format!("{} → {}", p.name, target_name(c)),
                (None, true) => format!("{} → {}", p.name, target_name(&t.made_for)),
                (None, false) => format!(
                    "{}: ready-made EQ (made for {})",
                    p.name,
                    target_name(&t.made_for)
                ),
            }
        } else {
            format!("{}: ready-made EQ (made for an unknown target)", p.name)
        };
        out.correction.get_or_insert(line);
    }
    Some(out)
}

/// A measurement, checked: frequency and level pairs covering the audible
/// band, as squig.link and REW export them, or a speaker's Klippel export.
pub fn read_measurement(text: &str) -> Result<super::targets::Curve, String> {
    reading(text).map(|(curve, _)| curve)
}

/// What a measurement is read as.
#[derive(Debug, Clone, PartialEq)]
pub struct MeasurementReading {
    /// Said to the person before they go on: for a speaker's Klippel export,
    /// which of its curves.
    pub note: String,
    /// A speaker's, corrected to Flat; otherwise a headphone's.
    pub speaker: bool,
}

pub fn describe_measurement(text: &str) -> Result<MeasurementReading, String> {
    let (curve, used) = reading(text)?;
    Ok(match used {
        Some(used) => MeasurementReading {
            note: used.describe(),
            speaker: true,
        },
        None => MeasurementReading {
            note: format!(
                "{} points, from {:.0} Hz to {:.1} kHz.",
                curve.len(),
                curve.first().map_or(0.0, |p| p.0),
                curve.last().map_or(0.0, |p| p.0) / 1000.0
            ),
            speaker: false,
        },
    })
}

/// Whether a measurement for `ear` may be corrected to `target`: a speaker
/// to the speaker target, a headphone to a headphone's. One added by hand
/// is taken at its word.
fn suits(ear: super::targets::Ear, target: &str) -> Result<(), String> {
    use super::targets::{Ear, shipped};
    match shipped(target) {
        Some(t) if t.ear == Ear::Speaker && ear != Ear::Speaker => Err(format!(
            "{} is a speaker target; a headphone is corrected to a headphone target",
            t.name
        )),
        Some(t) if ear == Ear::Speaker && t.ear != Ear::Speaker => Err(format!(
            "{} is a headphone target; a speaker is corrected to Flat",
            t.name
        )),
        _ => Ok(()),
    }
}

fn reading(text: &str) -> Result<(super::targets::Curve, Option<super::klippel::Used>), String> {
    use super::{klippel, targets};
    if !klippel::is_export(text) {
        return targets::covering(text, "A measurement").map(|c| (c, None));
    }
    let (curve, used) = klippel::read(text)?;
    let curve = targets::covers(curve, "A measurement")
        .map_err(|why| format!("{why}, in its Klippel export"))?;
    Ok((curve, Some(used)))
}

/// What a measurement corrected to a target would do, before anything is
/// saved: the curves the Headphone view draws, and the EQ's own.
pub fn preview_measurement(text: &str, target: &str, rate: u32) -> Result<Response, String> {
    use super::targets;
    let (measured, used) = reading(text)?;
    if used.is_some() {
        suits(targets::Ear::Speaker, target)?;
    }
    let aim = targets::choice_curve(target).ok_or_else(|| format!("No target {target}"))?;
    let freqs = targets::grid();
    let (filters, preamp_db) = squig_fit(&measured, &aim);
    let total = super::response(&filters, &freqs, rate);
    let level = |c: &targets::Curve| {
        let k = targets::at(c, 1000.0);
        freqs
            .iter()
            .map(|&hz| targets::at(c, hz) - k)
            .collect::<Vec<f64>>()
    };
    let raw = level(&measured);
    let predicted = raw.iter().zip(&total).map(|(r, t)| r + t).collect();
    Ok(Response {
        bands: Vec::new(),
        layers: Vec::new(),
        measurement: Some(raw),
        target: Some(level(&aim)),
        predicted: Some(predicted),
        preamp_db,
        gain_db: 0.0,
        correction: None,
        tuning: None,
        original: None,
        right: None,
        right_gain_db: 0.0,
        total,
        freqs,
    })
}

/// A baked EQ taken apart, given the headphones' measurement and the target
/// that counts as neutral: the correction, target − measurement, and what
/// the EQ does beyond it, its taste, as a curve. The reverse of what
/// squig.link does to make one.
struct Split {
    taste: crate::config::GraphicEq,
    freqs: Vec<f64>,
    original: Vec<f64>,
    correction: Vec<f64>,
    tuning: Vec<f64>,
}

fn split(name: &str, text: &str, target: &str, rate: u32) -> Result<Split, String> {
    use super::targets;
    use crate::config::DspFilter;
    let cfg = Config::cached();
    let all = &cfg.dsp.profiles;
    let p = all
        .iter()
        .find(|p| p.name == name)
        .ok_or_else(|| format!("No EQ called {name}"))?;
    if !super::responses(p, all).is_empty() {
        return Err(format!(
            "{name} has impulse responses: only an EQ splits into a correction and a tuning"
        ));
    }
    // What is split is one EQ, the same on every channel: a stack or group
    // would lose its layers, and a mix, a delay or one side's bands would be
    // folded into a curve for both.
    if !p.layers.is_empty() || p.group {
        return Err(format!(
            "{name} plays other EQs: split the one among them that includes a tuning instead"
        ));
    }
    if p.filters.iter().any(|f| match f {
        DspFilter::Band(b) => !b.channels.is_empty(),
        DspFilter::Graphic(g) => !g.channels.is_empty(),
        DspFilter::Mix(_) | DspFilter::Delay(_) => true,
    }) {
        return Err(format!(
            "{name} treats its channels differently: only an EQ the same on every channel splits"
        ));
    }
    let measured = read_measurement(text)?;
    let aim = targets::choice_curve(target).ok_or_else(|| format!("No target {target}"))?;
    let freqs = targets::grid();
    let filters = super::chain(p, all, &mut Vec::new()).map_err(|e| e.to_string())?;
    let original = super::response(&filters, &freqs, rate);
    let correction = super::response(&squig_fit(&measured, &aim).0, &freqs, rate);
    let curve =
        |db: &[f64]| -> targets::Curve { freqs.iter().copied().zip(db.iter().copied()).collect() };
    // The taste is what the EQ does beyond the correction it was baked from.
    // That is target minus measurement whole when the EQ is a graphic
    // export, and the fitted bands, whose treble is held back, when it is a
    // squig.link preset. Taken from the wrong one, the taste carries this
    // measurement's treble peaks and notches, inverted, to every headphone it
    // plays on. A taste is broad, so the right one is the one leaving the
    // least in the treble.
    let neutral = super::response(
        &[DspFilter::Graphic(targets::difference(&measured, &aim))],
        &freqs,
        rate,
    );
    let treble = |base: &[f64]| -> f64 {
        let (sum, n) = freqs
            .iter()
            .zip(original.iter().zip(base))
            .filter(|(hz, _)| **hz >= 2000.0)
            .fold((0.0, 0), |(sum, n), (_, (o, b))| {
                (sum + (o - b).powi(2), n + 1)
            });
        sum / n.max(1) as f64
    };
    let base = if treble(&correction) < treble(&neutral) {
        &correction
    } else {
        &neutral
    };
    let taste = targets::difference(&curve(base), &curve(&original));
    let tuning = super::response(&[DspFilter::Graphic(taste.clone())], &freqs, rate);
    Ok(Split {
        taste,
        freqs,
        original,
        correction,
        tuning,
    })
}

/// What splitting the baked EQ `name` would give, before anything is saved:
/// the correction and the tuning, their sum as `total`, and the EQ itself as
/// `original`, which the sum follows but for the treble a correction holds
/// back.
pub fn preview_split(name: &str, text: &str, target: &str, rate: u32) -> Result<Response, String> {
    let s = split(name, text, target, rate)?;
    let total = s
        .correction
        .iter()
        .zip(&s.tuning)
        .map(|(c, t)| c + t)
        .collect();
    Ok(Response {
        bands: Vec::new(),
        layers: Vec::new(),
        measurement: None,
        target: None,
        predicted: None,
        preamp_db: 0.0,
        gain_db: 0.0,
        correction: Some(s.correction),
        tuning: Some(s.tuning),
        original: Some(s.original),
        right: None,
        right_gain_db: 0.0,
        total,
        freqs: s.freqs,
    })
}

/// Split the baked EQ `name` into a correction built from the headphones'
/// measurement, to `target`, and a tuning holding the rest, made against
/// `target` so it carries to other headphones. Every output that played
/// `name` plays the two instead; `name` itself is kept. The new profiles'
/// names, correction then tuning.
pub fn split_baked(
    name: &str,
    text: &str,
    ear: DspEar,
    target: &str,
) -> Result<(String, String), String> {
    let s = split(name, text, target, 48_000)?;
    let devices = Config::cached()
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == name)
        .map(|p| p.devices.clone())
        .unwrap_or_default();
    let mut correction =
        measured_profile(&free_name(&format!("{name} correction")), text, ear, target)?;
    let tuning = free_name(&format!("{name} tuning"));
    let made = (correction.name.clone(), tuning.clone());
    // One write: both profiles, and every output moved to them, or nothing.
    correction.devices = devices.clone();
    let written = persist(|cfg| {
        for p in &mut cfg.dsp.profiles {
            p.devices.retain(|d| !devices.contains(d));
        }
        cfg.dsp.tunings.retain(|t| !devices.contains(&t.device));
        cfg.dsp
            .tunings
            .extend(devices.iter().map(|d| crate::config::DspOutputTuning {
                device: d.clone(),
                tuning: tuning.clone(),
                on: true,
            }));
        cfg.dsp.profiles.push(correction);
        cfg.dsp.profiles.push(DspProfile {
            name: tuning.clone(),
            filters: vec![crate::config::DspFilter::Graphic(s.taste)],
            role: Some(DspRole::Tuning),
            tuned_for: Some(target.to_owned()),
            ..Default::default()
        });
    });
    if written.is_err() {
        let _ = std::fs::remove_dir_all(dir(&made.0));
    }
    written.map(|()| made)
}

/// Save a correction built from a measurement: the headphone `name`,
/// measured as `text`, corrected to `target`. A correction, kept everywhere
/// like any headphone's.
pub fn save_measured(name: &str, text: &str, ear: DspEar, target: &str) -> Result<String, String> {
    save_measured_from(name, text, ear, target, None)
}

/// [`save_measured`], saying where the measurement came from, as an import
/// says its files: one found on squig.link credits the site it was
/// measured for.
pub fn save_measured_from(
    name: &str,
    text: &str,
    ear: DspEar,
    target: &str,
    source: Option<&str>,
) -> Result<String, String> {
    let mut profile = measured_profile(name, text, ear, target)?;
    profile.source = source.into_iter().map(str::to_owned).collect();
    let name = profile.name.clone();
    persist(|cfg| cfg.dsp.profiles.push(profile))?;
    Ok(name)
}

/// The profile `save_measured` keeps, its measurement written to its folder
/// and the profile itself not yet.
fn measured_profile(
    name: &str,
    text: &str,
    ear: DspEar,
    target: &str,
) -> Result<DspProfile, String> {
    use super::targets;
    let name = name.trim();
    if name.is_empty() {
        return Err("It needs a name".into());
    }
    if Config::cached().dsp.profiles.iter().any(|p| p.name == name) {
        return Err(format!("There is already an EQ called {name}"));
    }
    let (measured, used) = reading(text)?;
    if used.is_some() && ear != DspEar::Speaker {
        return Err(
            "This is a speaker's measurement: it is corrected as a speaker, to Flat".into(),
        );
    }
    suits(
        match ear {
            DspEar::In => targets::Ear::In,
            DspEar::Over => targets::Ear::Over,
            DspEar::Speaker => targets::Ear::Speaker,
        },
        target,
    )?;
    let aim = targets::choice_curve(target).ok_or_else(|| format!("No target {target}"))?;
    // Kept at its own points and in full, and fitted as kept: a new target
    // fits again from the same curve, here or on another device.
    let kept: String = std::iter::once("frequency,raw\n".to_owned())
        .chain(measured.iter().map(|(hz, db)| format!("{hz},{db}\n")))
        .collect();
    let (filters, preamp_db) = squig_fit(&targets::parse(&kept), &aim);
    let folder = dir(name);
    if folder.exists() {
        return Err(format!("{} is in the way", folder.display()));
    }
    std::fs::create_dir_all(&folder).map_err(|e| e.to_string())?;
    std::fs::write(targets::measurement_path(&folder), &kept).map_err(|e| e.to_string())?;
    Ok(DspProfile {
        name: name.to_owned(),
        role: Some(DspRole::Correction),
        fitted: Some(DspMeasurement {
            ear,
            target: target.to_owned(),
        }),
        filters,
        preamp_db: Some(preamp_db),
        ..Default::default()
    })
}

/// The bands `correction` plays fitted to `target` instead of its own
/// target, from the measurement it was built from. None for a correction
/// not built from a measurement, or whose measurement is missing.
pub(super) fn fitted_to(correction: &DspProfile, target: &str) -> Option<Vec<config::DspFilter>> {
    use super::targets;
    correction.measured()?;
    let measured = targets::measurement(&dir(&correction.name))?;
    Some(squig_fit(&measured, &targets::choice_curve(target)?).0)
}

/// The bands squig.link's auto-EQ fits to bring `measured` to `target`, and
/// its preamp to the hundredth of a decibel. A fit takes a good part of a
/// second, so recent ones are kept, by measurement and target, least
/// recently used first out. Those the player asked for while loading its
/// chain are kept apart, so pages fitting previews never push out what is
/// playing and the next load of it does not stall on a refit.
pub(super) fn squig_fit(
    measured: &[(f64, f64)],
    target: &[(f64, f64)],
) -> (Vec<config::DspFilter>, f64) {
    let key = fit_key(measured, target);
    let playing = PLAYING_SCOPE.get();
    {
        let mut fits = FITS.lock();
        let hit = match fits.playing.take(key) {
            Some(hit) => Some((hit, true)),
            None => fits.recent.take(key).map(|hit| (hit, playing)),
        };
        if let Some((hit, playing)) = hit {
            fits.keep(key, hit.clone(), playing);
            return hit;
        }
    }
    let fit = super::autoeq_squig::fit(measured, target);
    let made = (
        fit.filters
            .into_iter()
            .map(config::DspFilter::Band)
            .collect::<Vec<_>>(),
        (fit.preamp_db * 100.0).round() / 100.0,
    );
    FITS.lock().keep(key, made.clone(), playing);
    made
}

fn fit_key(measured: &[(f64, f64)], target: &[(f64, f64)]) -> u64 {
    use std::hash::{Hash, Hasher};
    let mut h = std::collections::hash_map::DefaultHasher::new();
    for (hz, db) in measured.iter().chain([(0.0, 0.0)].iter()).chain(target) {
        hz.to_bits().hash(&mut h);
        db.to_bits().hash(&mut h);
    }
    h.finish()
}

type Fitted = (Vec<config::DspFilter>, f64);

/// Fits most recently used last, at most `cap` of them.
struct Lru {
    cap: usize,
    entries: Vec<(u64, Fitted)>,
}

impl Lru {
    const fn new(cap: usize) -> Self {
        Self {
            cap,
            entries: Vec::new(),
        }
    }

    fn take(&mut self, key: u64) -> Option<Fitted> {
        let at = self.entries.iter().position(|(k, _)| *k == key)?;
        Some(self.entries.remove(at).1)
    }

    fn put(&mut self, key: u64, fit: Fitted) {
        self.take(key);
        if self.entries.len() >= self.cap {
            self.entries.remove(0);
        }
        self.entries.push((key, fit));
    }
}

struct Fits {
    /// What the player's chain was fitted with: a device or two, each with
    /// its target and maybe a tuning's.
    playing: Lru,
    /// Everything else: previews, imports, pages.
    recent: Lru,
}

impl Fits {
    fn keep(&mut self, key: u64, fit: Fitted, playing: bool) {
        if playing {
            self.playing.put(key, fit);
        } else {
            self.recent.put(key, fit);
        }
    }
}

static FITS: parking_lot::Mutex<Fits> = parking_lot::Mutex::new(Fits {
    playing: Lru::new(4),
    recent: Lru::new(32),
});

thread_local! {
    static PLAYING_SCOPE: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}

/// Runs `f` as the player loading its chain: the fits it makes or uses are
/// kept apart from the ones previews make.
pub fn for_playing<T>(f: impl FnOnce() -> T) -> T {
    struct Restore(bool);
    impl Drop for Restore {
        fn drop(&mut self) {
            PLAYING_SCOPE.set(self.0);
        }
    }
    let _restore = Restore(PLAYING_SCOPE.replace(true));
    f()
}

/// Make `name` a stack of `layers`, in order, creating it if there is none.
/// Refused where it could not play: a layer missing, a layer of itself, one
/// with impulse responses, one kept on this device under a stack kept
/// everywhere.
pub fn set_layers(name: &str, layers: Vec<crate::config::DspLayer>) -> Result<(), String> {
    let name = name.trim();
    if name.is_empty() {
        return Err("It needs a name".into());
    }
    if let Some(twice) = layers
        .iter()
        .enumerate()
        .find(|(i, l)| layers[..*i].iter().any(|e| e.profile == l.profile))
        .map(|(_, l)| &l.profile)
    {
        return Err(format!("{twice} is in {name} twice; each plays once"));
    }
    let cfg = Config::cached();
    let mut all = cfg.dsp.profiles.clone();
    let probe = profile_mut(&mut all, name);
    probe.layers = layers.clone();
    // Every layer, on or off: one switched off now is one switched on later.
    // A group's members are alternatives, one playing whichever is picked.
    let mut check = probe.clone();
    if !check.group {
        for l in &mut check.layers {
            l.on = true;
        }
    }
    let corrections = corrections_in(&check, &all);
    // Every correction it had, on or off: a stack that already corrects
    // twice can still be edited, but gains no other.
    let before = cfg
        .dsp
        .profiles
        .iter()
        .find(|p| p.name == name)
        .map(|p| {
            let mut p = p.clone();
            if !p.group {
                for l in &mut p.layers {
                    l.on = true;
                }
            }
            corrections_in(&p, &cfg.dsp.profiles)
        })
        .unwrap_or_default();
    if corrections.len() > 1 && corrections.iter().any(|c| !before.contains(c)) {
        // The one it had first, then the one being added.
        let mut named: Vec<String> = before
            .iter()
            .filter(|c| corrections.contains(c))
            .cloned()
            .collect();
        named.extend(corrections.iter().filter(|c| !before.contains(c)).cloned());
        return Err(two_corrections(&named));
    }
    super::chain(&check, &all, &mut Vec::new()).map_err(|e| e.to_string())?;
    if everywhere_by_choice(&all, name)
        && let Some(layer) = local_layer(&layers, &all)
    {
        return Err(kept_here(name, layer));
    }
    persist(|cfg| {
        let p = profile_mut(&mut cfg.dsp.profiles, name);
        p.layers = layers;
        // A group plays one: the first switched on, or the first of all.
        if p.group {
            let first = p.layers.iter().position(|l| l.on).unwrap_or(0);
            for (i, l) in p.layers.iter_mut().enumerate() {
                l.on = i == first;
            }
        }
    })
    .map_err(|e| e.to_string())
}

/// Delete `name`, and the responses kōan keeps for it. The presets and groups that hold it go on without it; an
/// EQ that plays it refuses, since what it plays is that EQ's to say.
pub fn delete(name: &str) -> Result<(), String> {
    let cfg = Config::cached();
    let playing: Vec<String> = cfg
        .dsp
        .profiles
        .iter()
        .filter(|p| !p.preset && !p.group && p.layers.iter().any(|l| l.profile == name))
        .map(|p| p.name.clone())
        .collect();
    if !playing.is_empty() {
        return Err(format!(
            "{} plays {name}: take it out of {} first",
            playing.join(", "),
            if playing.len() == 1 { "it" } else { "them" }
        ));
    }
    let shared = Config::cached()
        .dsp
        .profiles
        .iter()
        .any(|p| p.name != name && slug(&p.name) == slug(name));
    persist(|cfg| {
        // For sync to delete it on the account's other devices too.
        if let Some(uid) = cfg
            .dsp
            .profiles
            .iter()
            .find(|p| p.name == name)
            .and_then(|p| p.uid.clone())
            && !cfg.dsp.removed.contains(&uid)
        {
            cfg.dsp.removed.push(uid);
        }
        cfg.dsp.profiles.retain(|p| p.name != name);
        for p in &mut cfg.dsp.profiles {
            p.layers.retain(|l| l.profile != name);
            // A group whose member playing went plays its first.
            if p.group
                && !p.layers.iter().any(|l| l.on)
                && let Some(first) = p.layers.first_mut()
            {
                first.on = true;
            }
        }
        cfg.dsp.tunings.retain(|t| t.tuning != name);
        cfg.dsp.presets.retain(|p| p.preset != name);
    })
    .map_err(|e| e.to_string())?;
    // Another profile's name may map to the same folder: its files stay.
    if !shared {
        let _ = std::fs::remove_dir_all(dir(name));
    }
    Ok(())
}

pub fn set_enabled(enabled: bool) -> Result<(), String> {
    persist(|cfg| cfg.dsp.enabled = enabled).map_err(|e| e.to_string())
}

/// Whether `name` is kept everywhere by choice: a stack kept so only because
/// its layers are follows them instead.
fn everywhere_by_choice(all: &[DspProfile], name: &str) -> bool {
    all.iter()
        .find(|p| p.name == name)
        .is_some_and(|p| p.scope == Some(DspScope::Everywhere))
}

fn profile_mut<'a>(profiles: &'a mut Vec<DspProfile>, name: &str) -> &'a mut DspProfile {
    let index = match profiles.iter().position(|p| p.name == name) {
        Some(i) => i,
        None => {
            profiles.push(DspProfile {
                name: name.into(),
                ..Default::default()
            });
            profiles.len() - 1
        }
    };
    &mut profiles[index]
}

/// A directory name for a profile name.
fn slug(name: &str) -> String {
    let s: String = name
        .chars()
        .map(|c| {
            if c.is_alphanumeric() {
                c.to_ascii_lowercase()
            } else {
                '-'
            }
        })
        .collect();
    let s = s
        .split('-')
        .filter(|p| !p.is_empty())
        .collect::<Vec<_>>()
        .join("-");
    if s.is_empty() { "profile".into() } else { s }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::audio::dsp::impulse::{Impulse, Route};

    #[test]
    fn an_import_lands_beside_the_config_and_merges_by_name() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());

        let eq = Imported {
            name: "HD 600".into(),
            source: vec![],
            filters: vec![crate::config::DspFilter::Band(crate::config::EqFilter {
                kind: crate::config::EqFilterKind::Peaking,
                freq: 100.0,
                gain_db: 3.0,
                q: 1.0,
                channels: vec![],
            })],
            impulses: vec![],
        };
        assert_eq!(save(eq, None).unwrap(), "HD 600");
        assert_eq!(slug("HD 600 / Röom"), "hd-600-röom");

        let crossfeed = Impulse {
            rate: 48000,
            channels: Some(2),
            routes: vec![Route {
                ir: vec![1.0],
                inputs: vec![(0, 0.5), (1, 0.5)],
                outputs: vec![(0, 1.0), (1, 1.0)],
            }],
            in_delays: vec![],
            out_delays: vec![],
        };
        let room = Imported {
            name: "whatever".into(),
            source: vec!["whatever-source".into()],
            filters: vec![],
            impulses: vec![Impulse::from_channels(44100, vec![vec![1.0]]), crossfeed],
        };
        save(room, Some("HD 600")).unwrap();
        assign(Some("HD 600"), "Topping E30").unwrap();

        let o = overview();
        let p = &o.profiles[0];
        assert_eq!(o.profiles.len(), 1);
        assert_eq!(p.bands, 1, "the EQ survived the second import");
        assert_eq!(p.rates, vec![44100, 48000]);
        assert_eq!(p.devices, vec!["Topping E30"]);
        assert!(p.problem.is_none(), "{:?}", p.problem);
        assert!(dir.path().join("dsp/hd-600/48000.cfg").exists());

        let d = detail("HD 600").unwrap();
        assert_eq!(d.impulses.len(), 2);
        assert!(!d.impulses[0].mixes);
        assert!(d.impulses[1].mixes, "the crossfeed route mixes");
        assert_eq!(d.source, vec!["whatever-source"]);

        rename("HD 600", "Desk").unwrap();
        assert!(dir.path().join("dsp/desk/48000.cfg").exists());
        let d = detail("Desk").unwrap();
        assert!(d.problem.is_none(), "{:?}", d.problem);
        assert_eq!(d.impulses.len(), 2);
        assert!(rename("Desk", "").is_err());

        delete("Desk").unwrap();
        assert!(!dir.path().join("dsp/desk").exists());
        assert!(overview().profiles.is_empty());
    }

    fn band(freq: f64) -> crate::config::DspFilter {
        crate::config::DspFilter::Band(crate::config::EqFilter {
            kind: crate::config::EqFilterKind::Peaking,
            freq,
            gain_db: 3.0,
            q: 1.0,
            channels: vec![],
        })
    }

    fn layer(profile: &str, on: bool) -> crate::config::DspLayer {
        crate::config::DspLayer {
            profile: profile.into(),
            on,
        }
    }

    /// A stack plays its layers that are on, in order, then its own filters;
    /// it follows a layer's rename, and keeps a layer it plays from being
    /// deleted.
    #[test]
    fn a_stack_plays_its_layers_in_order() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            for (name, f) in [
                ("HD 650", 100.0),
                ("Bass +3", 60.0),
                ("Treble tilt", 8000.0),
            ] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![band(f)],
                    ..Default::default()
                });
            }
        })
        .unwrap();
        set_layers(
            "Desk",
            vec![
                layer("HD 650", true),
                layer("Bass +3", true),
                layer("Treble tilt", false),
            ],
        )
        .unwrap();
        let played = || {
            let cfg = Config::cached();
            let p = cfg.dsp.profiles.iter().find(|p| p.name == "Desk").unwrap();
            Setup::load(p, &cfg.dsp.profiles, dir.path())
                .unwrap()
                .unwrap()
                .filters
        };
        assert_eq!(played(), vec![band(100.0), band(60.0)]);
        set_layers(
            "Desk",
            vec![
                layer("Bass +3", true),
                layer("HD 650", true),
                layer("Treble tilt", true),
            ],
        )
        .unwrap();
        assert_eq!(played(), vec![band(60.0), band(100.0), band(8000.0)]);
        let summary = overview_for(None);
        assert_eq!(
            summary
                .profiles
                .iter()
                .find(|p| p.name == "Desk")
                .unwrap()
                .layers,
            3
        );

        rename("Bass +3", "Bass").unwrap();
        assert_eq!(detail("Desk").unwrap().layers[0].profile, "Bass");
        assert_eq!(played(), vec![band(60.0), band(100.0), band(8000.0)]);
        let refused = delete("Bass").unwrap_err();
        assert!(refused.contains("Desk"), "{refused}");
    }

    #[test]
    fn a_stack_that_could_not_play_is_refused() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Room".into(),
                impulses: vec!["dsp/room/48000.wav".into()],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "EQ".into(),
                filters: vec![band(100.0)],
                ..Default::default()
            });
        })
        .unwrap();
        assert!(
            set_layers("Desk", vec![layer("Nothing", true)]).is_err(),
            "missing"
        );
        assert!(
            set_layers("Desk", vec![layer("Room", true)]).is_err(),
            "impulses"
        );
        assert!(
            set_layers("Desk", vec![layer("Desk", true)]).is_err(),
            "itself"
        );
        set_layers("Desk", vec![layer("EQ", true)]).unwrap();
        // A cycle through another, even with the way back switched off.
        assert!(
            set_layers("EQ", vec![layer("Desk", false)]).is_err(),
            "cycle"
        );
    }

    /// Shared layers resolve, each where it is played; a ladder of them that
    /// would copy its filters exponentially is refused when set, and as a
    /// stack edited by hand it reports the problem and does not load, rather
    /// than growing the chain until the process aborts.
    #[test]
    fn a_stack_cannot_grow_without_bound() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "D".into(),
                filters: vec![band(100.0)],
                ..Default::default()
            });
        })
        .unwrap();
        // A diamond: B and C both play D.
        set_layers("B", vec![layer("D", true)]).unwrap();
        set_layers("C", vec![layer("D", true)]).unwrap();
        set_layers("A", vec![layer("B", true), layer("C", true)]).unwrap();
        {
            let cfg = Config::cached();
            let a = cfg.dsp.profiles.iter().find(|p| p.name == "A").unwrap();
            let played = Setup::load(a, &cfg.dsp.profiles, dir.path())
                .unwrap()
                .unwrap();
            assert_eq!(
                played.filters,
                vec![band(100.0), band(100.0)],
                "a diamond resolves"
            );
        }
        assert!(
            set_layers("X", vec![layer("D", true), layer("D", true)]).is_err(),
            "twice"
        );

        // A ladder, as a hand edit could leave it: each rung plays the two
        // below, 2^30 copies of D at the top.
        persist(|c| {
            for i in 0..30 {
                let below = |n: i32| {
                    if n < 0 {
                        "D".to_string()
                    } else {
                        format!("L{n}")
                    }
                };
                c.dsp.profiles.push(DspProfile {
                    name: format!("L{i}"),
                    layers: vec![layer(&below(i - 1), true), layer(&below(i - 2), true)],
                    ..Default::default()
                });
            }
        })
        .unwrap();
        let cfg = Config::cached();
        let top = cfg.dsp.profiles.iter().find(|p| p.name == "L29").unwrap();
        let err = Setup::load(top, &cfg.dsp.profiles, dir.path())
            .err()
            .unwrap();
        assert!(err.to_string().contains("L29"), "{err}");
        let summary = overview_for(None);
        let l29 = summary.profiles.iter().find(|p| p.name == "L29").unwrap();
        assert!(l29.problem.is_some(), "Settings shows why it does not play");
        assert!(set_layers("L30", vec![layer("L29", true)]).is_err());
    }

    /// The response is what the DSP plays: a 3 dB peak shows as 3 dB at its
    /// frequency and nothing far from it, a stack is its layers summed, and a
    /// band's own curve is drawn alone.
    #[test]
    fn a_response_is_the_filters_the_dsp_runs() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Peak".into(),
                filters: vec![band(1000.0)],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Shelf".into(),
                filters: vec![crate::config::DspFilter::Band(crate::config::EqFilter {
                    kind: crate::config::EqFilterKind::LowShelf,
                    freq: 100.0,
                    gain_db: 6.0,
                    q: 0.7,
                    channels: vec![],
                })],
                ..Default::default()
            });
        })
        .unwrap();
        let r = response("Peak", 48000).unwrap();
        let at = |r: &Response, curve: &[f64], hz: f64| {
            let i = r.freqs.iter().position(|f| *f >= hz).unwrap();
            curve[i]
        };
        assert!(
            (at(&r, &r.total, 1000.0) - 3.0).abs() < 0.2,
            "{}",
            at(&r, &r.total, 1000.0)
        );
        assert!(at(&r, &r.total, 20.0).abs() < 0.1);
        assert_eq!(r.bands.len(), 1);
        assert!(r.measurement.is_none());
        assert!(
            r.preamp_db < -2.5,
            "the peak is taken off ahead: {}",
            r.preamp_db
        );

        set_layers("Both", vec![layer("Shelf", true), layer("Peak", true)]).unwrap();
        let r = response("Both", 48000).unwrap();
        assert_eq!(r.layers.len(), 2);
        assert!((at(&r, &r.total, 30.0) - 6.0).abs() < 0.5, "the shelf");
        assert!((at(&r, &r.total, 1000.0) - 3.0).abs() < 0.5, "the peak");
        assert!(r.bands.is_empty(), "no bands of its own");
        set_layers("Both", vec![layer("Shelf", false), layer("Peak", true)]).unwrap();
        let r = response("Both", 48000).unwrap();
        assert!(at(&r, &r.total, 30.0).abs() < 0.3, "the shelf off");
        assert!(!r.layers[0].on);
    }

    fn fresh_config() -> (std::sync::MutexGuard<'static, ()>, tempfile::TempDir) {
        let guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        (guard, dir)
    }

    /// A new EQ is eight bands, a shelf at each end and six peaks, flat or
    /// at its starter's gains, and a tuning; a name taken is refused.
    #[test]
    fn a_new_eq_starts_as_eight_bands() {
        use crate::config::{DspFilter, EqFilterKind};
        let (_guard, _dir) = fresh_config();
        create_eq("Desk", Starter::Flat).unwrap();
        let d = detail("Desk").unwrap();
        assert_eq!(d.filters.len(), 8);
        assert_eq!(d.role, DspRole::Tuning);
        let kinds: Vec<EqFilterKind> = d
            .filters
            .iter()
            .map(|f| match f {
                DspFilter::Band(b) => {
                    assert_eq!(b.gain_db, 0.0);
                    b.kind
                }
                _ => panic!("bands alone"),
            })
            .collect();
        assert_eq!(kinds[0], EqFilterKind::LowShelf);
        assert_eq!(kinds[7], EqFilterKind::HighShelf);
        assert!(kinds[1..7].iter().all(|k| *k == EqFilterKind::Peaking));
        let r = response("Desk", 48000).unwrap();
        assert!(
            r.total.iter().all(|db| db.abs() < 1e-9),
            "flat plays untouched"
        );

        create_eq("Thump", Starter::BassBoost).unwrap();
        let r = response("Thump", 48000).unwrap();
        assert!(r.total[0] > 3.0 && r.total.last().unwrap().abs() < 0.5);
        assert!(create_eq("Desk", Starter::Warm).is_err());
        assert!(create_eq("  ", Starter::Flat).is_err());
    }

    /// Stereo gives each channel the one list it had; the right channel is
    /// drawn of its own; mono keeps the channel asked for.
    #[test]
    fn an_eq_switches_between_one_list_and_one_per_channel() {
        use crate::config::DspFilter;
        let (_guard, _dir) = fresh_config();
        create_eq("Desk", Starter::Flat).unwrap();
        let layout = || detail("Desk").unwrap().channels.unwrap();
        assert_eq!(
            layout(),
            ChannelLayout {
                stereo: false,
                differ: false
            }
        );
        assert!(response("Desk", 48000).unwrap().right.is_none());

        set_stereo("Desk", true, 0).unwrap();
        assert_eq!(
            layout(),
            ChannelLayout {
                stereo: true,
                differ: false
            }
        );
        assert_eq!(detail("Desk").unwrap().filters.len(), 16);

        // The right channel's bass shelf up.
        set_band("Desk", 8, "low_shelf", 100.0, 6.0, 0.7).unwrap();
        assert_eq!(
            layout(),
            ChannelLayout {
                stereo: true,
                differ: true
            }
        );
        let r = response("Desk", 48000).unwrap();
        assert!(r.total[0].abs() < 1e-9, "left untouched");
        assert!(r.right.unwrap()[0] > 5.0, "right drawn of its own");
        let i = add_band("Desk", Some(1)).unwrap();
        assert_eq!(detail("Desk").unwrap().filters[i].channels(), &[1]);
        remove_filter("Desk", i).unwrap();

        set_stereo("Desk", false, 1).unwrap();
        assert_eq!(
            layout(),
            ChannelLayout {
                stereo: false,
                differ: false
            }
        );
        let filters = detail("Desk").unwrap().filters;
        assert_eq!(filters.len(), 8);
        assert!(filters.iter().all(|f| f.channels().is_empty()));
        assert!(
            matches!(&filters[0], DspFilter::Band(b) if b.gain_db == 6.0),
            "kept the right"
        );
    }

    /// An output playing filters alone has no correction; a preset saved
    /// from it says so and sets it again; choosing a correction ends it.
    #[test]
    fn an_output_plays_filters_alone() {
        let (_guard, _dir) = fresh_config();
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "HD 650".into(),
                role: Some(DspRole::Correction),
                ..Default::default()
            })
        })
        .unwrap();
        create_eq("Room", Starter::Warm).unwrap();
        assign(Some("HD 650"), "Desk").unwrap();
        set_tunings("Desk", &[("Room".into(), true)]).unwrap();

        set_filters_only("Desk", true).unwrap();
        assert!(filters_only("Desk"));
        assert!(
            Config::cached().dsp.profile_for("Desk").is_none(),
            "no correction"
        );
        save_preset("Desk", "Speakers").unwrap();
        assert_eq!(preset_for("Desk"), Some(("Speakers".into(), false)));

        set_filters_only("Desk", false).unwrap();
        assert_eq!(
            preset_for("Desk"),
            Some(("Speakers".into(), true)),
            "changed since"
        );
        apply_preset("Desk", Some("Speakers")).unwrap();
        assert!(filters_only("Desk"));

        assign(Some("HD 650"), "Desk").unwrap();
        assert!(!filters_only("Desk"));

        // A preset for filters alone that holds a correction anyway, as a
        // hand edit or another device can leave one, sets none; nor does
        // one the output came to name some other way play.
        persist(|c| {
            let p = c
                .dsp
                .profiles
                .iter_mut()
                .find(|p| p.name == "Speakers")
                .unwrap();
            p.layers.insert(
                0,
                crate::config::DspLayer {
                    profile: "HD 650".into(),
                    on: true,
                },
            );
        })
        .unwrap();
        apply_preset("Desk", Some("Speakers")).unwrap();
        assert!(filters_only("Desk"));
        assert!(Config::cached().dsp.profile_for("Desk").is_none());
        persist(|c| {
            let p = c
                .dsp
                .profiles
                .iter_mut()
                .find(|p| p.name == "HD 650")
                .unwrap();
            p.devices.push("Desk".into());
        })
        .unwrap();
        assert!(
            Config::cached().dsp.profile_for("Desk").is_none(),
            "never plays"
        );

        // An EQ that does not correct, chosen for the output, neither ends
        // filters alone nor is taken off by it.
        assign(Some("Room"), "Desk").unwrap();
        assert!(filters_only("Desk"));
        set_filters_only("Desk", true).unwrap();
        assert_eq!(
            Config::cached()
                .dsp
                .profile_for("Desk")
                .map(|p| p.name.clone()),
            Some("Room".into())
        );
    }

    /// Only the left or right channel can be kept, and only an EQ of bands
    /// alone has channels to set.
    #[test]
    fn stereo_is_set_only_on_bands_alone() {
        let (_guard, _dir) = fresh_config();
        create_eq("Desk", Starter::Flat).unwrap();
        assert!(set_stereo("Desk", false, 2).is_err());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Stack".into(),
                layers: vec![crate::config::DspLayer {
                    profile: "Desk".into(),
                    on: true,
                }],
                ..Default::default()
            })
        })
        .unwrap();
        assert!(set_stereo("Stack", true, 0).is_err());
    }

    /// A band edited by hand is held to its ranges, keeps its channels, and
    /// changes what plays; one added starts flat; one taken out is gone.
    #[test]
    fn bands_are_edited_in_place() {
        use crate::config::{DspFilter, EqFilter, EqFilterKind};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Mine".into(),
                filters: vec![DspFilter::Band(EqFilter {
                    kind: EqFilterKind::Peaking,
                    freq: 100.0,
                    gain_db: 3.0,
                    q: 1.0,
                    channels: vec![1],
                })],
                ..Default::default()
            })
        })
        .unwrap();
        set_band("Mine", 0, "low_shelf", 80.0, 99.0, 0.0).unwrap();
        let filters = || detail("Mine").unwrap().filters;
        assert_eq!(
            filters()[0],
            DspFilter::Band(EqFilter {
                kind: EqFilterKind::LowShelf,
                freq: 80.0,
                gain_db: 30.0,
                q: 0.1,
                channels: vec![1],
            })
        );
        assert!(set_band("Mine", 0, "wobble", 80.0, 0.0, 1.0).is_err());
        assert!(set_band("Mine", 0, "peaking", f64::NAN, 0.0, 1.0).is_err());
        assert!(set_band("Mine", 5, "peaking", 80.0, 0.0, 1.0).is_err());
        assert_eq!(add_band("Mine", None).unwrap(), 1);
        assert_eq!(filters().len(), 2);
        let r = response("Mine", 48000).unwrap();
        assert_eq!(r.bands.len(), 2);
        remove_filter("Mine", 0).unwrap();
        assert_eq!(filters().len(), 1);
        assert!(remove_filter("Mine", 3).is_err());
        assert!(add_band("Nobody", None).is_err());
        assert!(set_curve("Mine", 0, &[(100.0, 1.0)]).is_err(), "a band");
    }

    /// A preview draws an edit without saving it; saving as a copy keeps the
    /// edit apart, puts the original back and swaps the copy into the
    /// device's tuning.
    #[test]
    fn previews_and_copies_leave_the_original() {
        use crate::config::{DspFilter, DspProfile, EqFilter, EqFilterKind, GraphicEq};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let flat = DspFilter::Band(EqFilter {
            kind: EqFilterKind::Peaking,
            freq: 1000.0,
            gain_db: 0.0,
            q: 1.0,
            channels: vec![],
        });
        let curve = DspFilter::Graphic(GraphicEq {
            points: vec![(20.0, 0.0), (20000.0, 0.0)],
            channels: vec![],
        });
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Warm".into(),
                filters: vec![flat.clone(), curve],
                ..Default::default()
            })
        })
        .unwrap();
        let peak = |r: &Response| r.total.iter().cloned().fold(f64::MIN, f64::max);
        let r = preview_band("Warm", 0, "peaking", 1000.0, 6.0, 1.0, 48000).unwrap();
        assert!((peak(&r) - 6.0).abs() < 0.5, "{}", peak(&r));
        let r = preview_curve("Warm", 1, &[(20.0, 4.0), (20000.0, 4.0)], 48000).unwrap();
        assert!((peak(&r) - 4.0).abs() < 0.5, "{}", peak(&r));
        assert!(preview_band("Warm", 1, "peaking", 1000.0, 6.0, 1.0, 48000).is_none());
        assert!(preview_curve("Warm", 0, &[(20.0, 4.0)], 48000).is_none());
        assert_eq!(detail("Warm").unwrap().filters[0], flat, "nothing saved");

        let dac = "DAC";
        set_tunings(dac, &[("Warm".into(), true)]).unwrap();
        let before = snapshot("Warm").unwrap();
        set_band("Warm", 0, "peaking", 1000.0, 6.0, 1.0).unwrap();
        let saved = save_as_copy("Warm", None, Some(&before), Some(dac)).unwrap();
        assert!(saved.placed);
        let copy = saved.name;
        assert_eq!(copy, "Warm copy");
        assert_eq!(detail("Warm").unwrap().filters[0], flat, "put back");
        assert!(matches!(
            detail(&copy).unwrap().filters[0],
            DspFilter::Band(EqFilter { gain_db: 6.0, .. })
        ));
        assert_eq!(tunings_for(dac), vec![(copy, true)]);
        assert!(save_as_copy("Warm", None, Some("nonsense"), None).is_err());
        let elsewhere = save_as_copy("Warm", Some("Spare"), None, Some("Speakers")).unwrap();
        assert!(!elsewhere.placed, "not in that tuning");

        // A correction is neither previewed nor copied this way.
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "HD 600".into(),
                role: Some(crate::config::DspRole::Correction),
                filters: vec![flat.clone()],
                ..Default::default()
            })
        })
        .unwrap();
        assert!(preview_band("HD 600", 0, "peaking", 1000.0, 6.0, 1.0, 48000).is_none());
        assert!(save_as_copy("HD 600", None, None, None).is_err());
        assert!(detail("HD 600 copy").is_none());

        // Nor is one fitted to a measurement, even said to be a tuning.
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Fitted".into(),
                role: Some(crate::config::DspRole::Tuning),
                filters: vec![flat.clone()],
                fitted: Some(crate::config::DspMeasurement {
                    ear: crate::config::DspEar::Over,
                    target: "harman-over-ear-2018".into(),
                }),
                ..Default::default()
            })
        })
        .unwrap();
        assert!(detail("Fitted").unwrap().read_only);
        assert!(preview_band("Fitted", 0, "peaking", 1000.0, 6.0, 1.0, 48000).is_none());
        let refused = set_band("Fitted", 0, "peaking", 1000.0, 6.0, 1.0).unwrap_err();
        assert!(refused.contains("fitted to a measurement"), "{refused}");
        assert!(save_as_copy("Fitted", None, None, None).is_err());
    }

    /// A graphic curve's points are set whole, clamped and in order of
    /// frequency; a correction's are not.
    #[test]
    fn curves_are_edited_in_place() {
        use crate::config::{DspFilter, DspProfile, GraphicEq};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let curve = DspFilter::Graphic(GraphicEq {
            points: vec![(20.0, 0.0), (1000.0, 2.0)],
            channels: vec![0],
        });
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Mine".into(),
                filters: vec![curve.clone()],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Fixed".into(),
                role: Some(crate::config::DspRole::Correction),
                filters: vec![curve],
                ..Default::default()
            });
        })
        .unwrap();
        set_curve("Mine", 0, &[(5000.0, 99.0), (2.0, -1.0)]).unwrap();
        assert_eq!(
            detail("Mine").unwrap().filters[0],
            DspFilter::Graphic(GraphicEq {
                points: vec![(10.0, -1.0), (5000.0, 30.0)],
                channels: vec![0],
            })
        );
        assert!(set_curve("Mine", 0, &[]).is_err());
        let most = crate::config::dsp_bounds::GRAPHIC_POINTS;
        let many: Vec<(f64, f64)> = (0..=most).map(|i| (20.0 + i as f64, 0.0)).collect();
        assert!(set_curve("Mine", 0, &many).is_err(), "too many points");
        assert!(set_curve("Mine", 0, &many[..most]).is_ok());
        assert!(set_curve("Mine", 0, &[(f64::NAN, 0.0)]).is_err());
        assert!(set_curve("Mine", 1, &[(100.0, 0.0)]).is_err());
        assert!(
            set_curve("Fixed", 0, &[(100.0, 0.0)]).is_err(),
            "a correction"
        );
    }

    /// A group plays one member, chosen like a radio button; a stack plays
    /// each layer switched on. A group can itself be a stack's layer.
    #[test]
    fn a_group_plays_one_member() {
        use crate::config::{DspFilter, DspLayer};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            for (name, hz) in [
                ("Warm", 100.0),
                ("Bright", 8000.0),
                ("Flat", 1000.0),
                ("Bass", 60.0),
            ] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![band(hz)],
                    ..Default::default()
                });
            }
        })
        .unwrap();
        let names = ["Warm", "Bright", "Flat"].map(String::from);
        make_group("Presets", &names).unwrap();
        assert!(make_group("Presets", &names).is_err());
        let freqs = |name: &str| -> Vec<f64> {
            let cfg = Config::cached();
            let p = cfg
                .dsp
                .profiles
                .iter()
                .find(|p| p.name == name)
                .unwrap()
                .clone();
            super::super::chain(&p, &cfg.dsp.profiles, &mut Vec::new())
                .unwrap()
                .into_iter()
                .map(|f| match f {
                    DspFilter::Band(b) => b.freq,
                    other => panic!("{other:?}"),
                })
                .collect()
        };
        assert_eq!(freqs("Presets"), [100.0], "the first plays");
        select("Presets", "Bright").unwrap();
        assert_eq!(freqs("Presets"), [8000.0]);
        assert!(select("Presets", "Bass").is_err(), "not a member");

        // Switching two on in a group leaves the first of them on.
        let layer = |p: &str, on: bool| DspLayer {
            profile: p.into(),
            on,
        };
        set_layers(
            "Presets",
            vec![
                layer("Warm", false),
                layer("Bright", true),
                layer("Flat", true),
            ],
        )
        .unwrap();
        assert_eq!(freqs("Presets"), [8000.0]);
        assert_eq!(
            detail("Presets")
                .unwrap()
                .layers
                .iter()
                .filter(|l| l.on)
                .count(),
            1
        );

        // A group as a stack's layer: its chosen member, then the tuning.
        set_layers("Desk", vec![layer("Presets", true), layer("Bass", true)]).unwrap();
        assert_eq!(freqs("Desk"), [8000.0, 60.0]);

        // A stack again: each layer switched on plays.
        set_group("Presets", false).unwrap();
        set_layers(
            "Presets",
            vec![
                layer("Warm", true),
                layer("Bright", true),
                layer("Flat", false),
            ],
        )
        .unwrap();
        assert_eq!(freqs("Presets"), [100.0, 8000.0]);
        set_group("Presets", true).unwrap();
        assert_eq!(
            freqs("Presets"),
            [100.0],
            "the first switched on keeps playing"
        );

        // None on, as a hand edit can leave it: the first plays.
        persist(|c| {
            let p = c.dsp.profiles.iter_mut().find(|p| p.name == "Presets");
            for l in &mut p.unwrap().layers {
                l.on = false;
            }
        })
        .unwrap();
        assert_eq!(freqs("Presets"), [100.0]);
    }

    /// A group of room corrections plays the chosen one's responses, since
    /// only one plays; a stack cannot layer such a group, as it cannot a
    /// response.
    #[test]
    fn a_group_plays_its_members_responses() {
        use crate::config::DspLayer;
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let mut paths = Vec::new();
        for rate in [44100, 48000] {
            let path = dir.path().join(format!("{rate}.wav"));
            super::super::raw::write_wav(&path, rate, &[vec![1.0, 0.0]]).unwrap();
            paths.push(path);
        }
        persist(|c| {
            for (name, path) in [("Room 44", &paths[0]), ("Room 48", &paths[1])] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    impulses: vec![path.clone()],
                    ..Default::default()
                });
            }
        })
        .unwrap();
        make_group("Room", &["Room 44".into(), "Room 48".into()]).unwrap();
        let rates = || {
            let cfg = Config::cached();
            let p = cfg.dsp.profiles.iter().find(|p| p.name == "Room").unwrap();
            super::super::Setup::load(p, &cfg.dsp.profiles, dir.path())
                .unwrap()
                .unwrap()
                .rates()
        };
        assert_eq!(rates(), [44100]);
        select("Room", "Room 48").unwrap();
        assert_eq!(rates(), [48000]);
        let refused = set_layers(
            "Desk",
            vec![DspLayer {
                profile: "Room".into(),
                on: true,
            }],
        )
        .unwrap_err();
        assert!(
            refused.contains("only bands can be played by another EQ"),
            "{refused}"
        );
    }

    /// A name already taken, or one whose files would go in a folder that is,
    /// is numbered: nothing is written over.
    #[test]
    fn a_free_name_takes_nothing() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        assert_eq!(free_name("Room"), "Room");
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Room".into(),
                filters: vec![band(100.0)],
                ..Default::default()
            })
        })
        .unwrap();
        assert_eq!(free_name("Room"), "Room 2");
        assert_eq!(free_name("room!"), "room! 2", "the same folder as Room's");
    }

    /// A headphone correction travels and a room correction stays; a stack
    /// follows its layers unless set; a stack kept everywhere cannot have a
    /// layer kept here, either way round.
    #[test]
    fn where_a_profile_is_kept() {
        use crate::config::{DspLayer, DspTarget};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "HD 650".into(),
                filters: vec![band(1000.0)],
                target: Some(DspTarget {
                    made_for: "harman-over-ear-2018".into(),
                    chosen: None,
                }),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Room".into(),
                impulses: vec!["dsp/room/48000.wav".into()],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Bass".into(),
                filters: vec![band(80.0)],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Amp".into(),
                filters: vec![band(80.0)],
                devices: vec!["uuid:5f9ec1b3-ed59-79bb-4530-745e2b1d1b10".into()],
                ..Default::default()
            });
        })
        .unwrap();
        let kept = |name: &str| {
            let cfg = Config::cached();
            let p = cfg
                .dsp
                .profiles
                .iter()
                .find(|p| p.name == name)
                .unwrap()
                .clone();
            scope(&p, &cfg.dsp.profiles)
        };
        assert_eq!(kept("HD 650"), DspScope::Everywhere);
        assert_eq!(kept("Room"), DspScope::Device);
        assert_eq!(kept("Bass"), DspScope::Everywhere);
        assert_eq!(
            kept("Amp"),
            DspScope::Device,
            "an amplifier stays where it is"
        );

        let layer = |p: &str| DspLayer {
            profile: p.into(),
            on: true,
        };
        set_layers("Desk", vec![layer("HD 650"), layer("Bass")]).unwrap();
        assert_eq!(kept("Desk"), DspScope::Everywhere);
        set_layers("Speakers", vec![layer("Amp"), layer("Bass")]).unwrap();
        assert_eq!(
            kept("Speakers"),
            DspScope::Device,
            "a stack here may use shared layers"
        );

        set_scope("Desk", DspScope::Everywhere).unwrap();
        let refused = set_layers("Desk", vec![layer("HD 650"), layer("Amp")]).unwrap_err();
        assert!(refused.contains("Amp is kept on this device"), "{refused}");
        let refused = set_scope("Bass", DspScope::Device).unwrap_err();
        assert!(refused.contains("Bass is played by Desk"), "{refused}");
        let locked = |name: &str| {
            let cfg = Config::cached();
            let p = cfg.dsp.profiles.iter().find(|p| p.name == name).unwrap();
            scope_locked(p, &cfg.dsp.profiles)
        };
        assert_eq!(
            locked("Bass").as_deref(),
            Some("Desk plays it on every device")
        );
        assert_eq!(
            locked("Speakers").as_deref(),
            Some("plays Amp, kept on this device")
        );
        assert_eq!(locked("Desk"), None);
        set_scope("Speakers", DspScope::Everywhere).unwrap_err();
        set_scope("Desk", DspScope::Device).unwrap();
        set_scope("Bass", DspScope::Device).unwrap();
        assert_eq!(kept("Bass"), DspScope::Device);
    }

    /// A measurement as text: flat, with `bump` dB at 3 kHz.
    fn measured(bump: f64) -> String {
        let mut text = String::from("frequency,raw\n");
        for hz in super::super::targets::grid() {
            let db = bump * (-((hz / 3000.0).log2() * 3.0).powi(2)).exp();
            text.push_str(&format!("{hz:.2},{db:.2}\n"));
        }
        text
    }

    /// A file the importer cannot read says what it expected and what it
    /// found, so pressing Next never does nothing.
    #[test]
    fn an_unreadable_measurement_says_what_it_expected_and_found() {
        let path = read_measurement("~/Downloads/Speaker/SPL Vertical.txt").unwrap_err();
        assert!(
            path.contains("two-column CSV or a squig.link export"),
            "{path}"
        );
        assert!(path.contains("file's path"), "{path}");
        let short = read_measurement("20, 92.4\n21, 92.6\n").unwrap_err();
        assert!(short.contains("this has 2 from 20 Hz to 21 Hz"), "{short}");
        let prose = read_measurement("Hello there\nnothing numeric").unwrap_err();
        assert!(prose.contains("“Hello there”"), "{prose}");
    }

    /// An Audio Science Review export is a speaker's: on-axis from one
    /// plane, the listening window from both, said which, and corrected to
    /// Flat only.
    #[test]
    fn a_klippel_export_is_a_speaker_measurement() {
        use super::super::klippel::tests::export;
        let tilt = |_: f64, hz: f64| 88.0 - (hz / 1000.0).log2();
        let vertical = export("SPL Vertical", tilt);
        let one = describe_measurement(&vertical).unwrap();
        assert!(one.speaker);
        assert!(
            one.note.starts_with("A speaker's on-axis response"),
            "{}",
            one.note
        );
        assert!(one.note.contains("SPL Horizontal"), "{}", one.note);
        let both = export("SPL Horizontal", tilt) + &vertical;
        assert!(
            describe_measurement(&both)
                .unwrap()
                .note
                .contains("listening window (CTA-2034)")
        );
        let curve = read_measurement(&both).unwrap();
        assert!(curve.last().unwrap().0 > 19_000.0);
        assert!((super::super::targets::at(&curve, 4000.0) + 2.0).abs() < 0.01);
        assert!(preview_measurement(&both, "harman-over-ear-2018", 48000).is_err());
        assert!(!describe_measurement(&measured(6.0)).unwrap().speaker);
        assert!(measured_profile("X", &both, DspEar::Over, "harman-over-ear-2018").is_err());
        assert!(measured_profile("X", &both, DspEar::Speaker, "harman-over-ear-2018").is_err());
        assert!(measured_profile("X", &measured(6.0), DspEar::In, "flat").is_err());
    }

    /// A speaker's listening window corrected to Flat: the fitted bands
    /// bring it toward flat across the band they act in.
    #[test]
    fn a_speakers_listening_window_is_fitted_toward_flat() {
        use super::super::klippel::tests::export;
        // A bass hump, a presence dip and a lift, the same at every angle.
        let level = |_: f64, hz: f64| {
            let bump = |f: f64, db: f64| db * (-((hz / f).log2() * 2.0).powi(2)).exp();
            85.0 + bump(120.0, 5.0) + bump(2500.0, -4.0) + bump(600.0, 2.5)
        };
        let both = export("SPL Horizontal", level) + &export("SPL Vertical", level);
        let preview = preview_measurement(&both, "flat", 48000).unwrap();
        // Spread about the mean, 30 Hz to 6 kHz: the preamp only shifts it.
        let spread = |curve: &[f64]| {
            let band: Vec<f64> = preview
                .freqs
                .iter()
                .zip(curve)
                .filter(|(hz, _)| (30.0..=6000.0).contains(*hz))
                .map(|(_, db)| *db)
                .collect();
            let mean = band.iter().sum::<f64>() / band.len() as f64;
            (band.iter().map(|d| (d - mean).powi(2)).sum::<f64>() / band.len() as f64).sqrt()
        };
        let before = spread(preview.measurement.as_ref().unwrap());
        let after = spread(preview.predicted.as_ref().unwrap());
        assert!(
            preview
                .target
                .as_ref()
                .unwrap()
                .iter()
                .all(|d| d.abs() < 1e-9)
        );
        assert!(before > 1.5, "{before}");
        assert!(after < before / 3.0, "{before} → {after}");
    }

    /// A headphone measured and corrected to a target: a correction, kept
    /// everywhere, playing target minus measurement, said in one line.
    #[test]
    fn a_measurement_is_corrected_to_its_target() {
        use super::super::targets;
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let text = measured(6.0);
        assert!(
            read_measurement("1000,0\n").is_err(),
            "too little to correct from"
        );
        let preview = preview_measurement(&text, "harman-in-ear-2019", 48000).unwrap();
        assert!(preview.predicted.is_some() && preview.measurement.is_some());

        save_measured("AFUL Performer 8S", &text, DspEar::In, "harman-in-ear-2019").unwrap();
        assert!(
            save_measured("AFUL Performer 8S", &text, DspEar::In, "harman-in-ear-2019").is_err()
        );
        let cfg = Config::cached();
        let p = cfg
            .dsp
            .profiles
            .iter()
            .find(|p| p.name == "AFUL Performer 8S")
            .unwrap()
            .clone();
        assert_eq!(role(&p), DspRole::Correction);
        assert_eq!(scope(&p, &cfg.dsp.profiles), DspScope::Everywhere);
        assert_eq!(
            summary("AFUL Performer 8S").unwrap().correction.as_deref(),
            Some("AFUL Performer 8S → Harman in-ear 2019 (from measurement)")
        );

        // What plays is squig.link's bands, fitted to the measurement and
        // the target, and nothing after them: no graphic curve, no taper.
        use crate::config::{DspFilter, EqFilterKind};
        assert!(!p.filters.is_empty());
        assert!(p.filters.iter().all(|f| matches!(
            f,
            DspFilter::Band(b) if b.kind == EqFilterKind::Peaking && b.freq <= 6000.0
        )));
        assert!(p.preamp_db.is_some_and(|db| db <= 0.0));
        assert!(p.measurement.is_none() && p.fitted.is_some());
        let played = super::super::chain(&p, &cfg.dsp.profiles, &mut Vec::new()).unwrap();
        assert_eq!(played, p.filters);
        // At 3 kHz against 1 kHz it does what target minus measurement does,
        // within a decibel and a half.
        let r = response("AFUL Performer 8S", 48000).unwrap();
        let at = |hz: f64| r.total[r.freqs.iter().position(|f| *f >= hz).unwrap()];
        let wanted = targets::difference(
            &read_measurement(&text).unwrap(),
            &targets::choice_curve("harman-in-ear-2019").unwrap(),
        );
        let g = |hz| targets::at(&wanted.points, hz);
        let (ours, theirs) = (at(3000.0) - at(1000.0), g(3000.0) - g(1000.0));
        assert!((ours - theirs).abs() < 1.5, "{ours} against {theirs}");

        // Another target: the same measurement, corrected to it.
        let choices = target_choices("AFUL Performer 8S").unwrap();
        assert!(choices.made_for.is_none());
        choose_target("AFUL Performer 8S", Some("harman-in-ear-2019-without-bass")).unwrap();
        assert_eq!(
            summary("AFUL Performer 8S").unwrap().correction.as_deref(),
            Some("AFUL Performer 8S → Harman in-ear 2019, no bass shelf (from measurement)")
        );
        let moved = Config::cached()
            .dsp
            .profiles
            .iter()
            .find(|p| p.name == "AFUL Performer 8S")
            .unwrap()
            .clone();
        assert_ne!(moved.filters, p.filters, "fitted again to the new target");
    }

    /// A correction saved from a measurement before the bands were kept
    /// holds the measurement alone: it plays the bands fitted to it now,
    /// and its config is not touched.
    #[test]
    fn an_older_measured_correction_plays_the_fit() {
        use super::super::targets;
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let text = measured(6.0);
        let folder = super::dir("Older");
        std::fs::create_dir_all(&folder).unwrap();
        let curve = read_measurement(&text).unwrap();
        std::fs::write(targets::measurement_path(&folder), targets::on_grid(&curve)).unwrap();
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Older".into(),
                role: Some(DspRole::Correction),
                measurement: Some(DspMeasurement {
                    ear: DspEar::In,
                    target: "harman-in-ear-2019".into(),
                }),
                ..Default::default()
            });
        })
        .unwrap();
        let cfg = Config::cached();
        let p = cfg.dsp.profiles.iter().find(|p| p.name == "Older").unwrap();
        let played = super::super::chain(p, &cfg.dsp.profiles, &mut Vec::new()).unwrap();
        let aim = targets::choice_curve("harman-in-ear-2019").unwrap();
        let kept = targets::measurement(&folder).unwrap();
        assert_eq!(played, squig_fit(&kept, &aim).0);
        assert!(!played.is_empty());
        let after = Config::cached();
        let p = after
            .dsp
            .profiles
            .iter()
            .find(|p| p.name == "Older")
            .unwrap();
        assert!(p.measurement.is_some() && p.fitted.is_none() && p.filters.is_empty());

        // A new target fits it, and keeps it as a fitted correction.
        choose_target("Older", Some("diffuse-field-iso-11904-1")).unwrap();
        let cfg = Config::cached();
        let p = cfg.dsp.profiles.iter().find(|p| p.name == "Older").unwrap();
        assert!(p.measurement.is_none());
        assert_eq!(
            p.fitted.as_ref().unwrap().target,
            "diffuse-field-iso-11904-1"
        );
        let diffuse = targets::choice_curve("diffuse-field-iso-11904-1").unwrap();
        assert_eq!(p.filters, squig_fit(&kept, &diffuse).0);
    }

    /// A tuning's target difference on a fitted correction is tapered above
    /// 6 kHz, as on any correction built from a measurement: the bands stop
    /// there.
    #[test]
    fn a_target_step_on_a_fitted_correction_is_tapered() {
        use super::super::targets;
        let neutral = targets::choice_curve("diffuse-field-iso-11904-1").unwrap();
        let harman = targets::choice_curve("harman-in-ear-2019").unwrap();
        let fitted = DspProfile {
            name: "Fitted".into(),
            role: Some(DspRole::Correction),
            fitted: Some(DspMeasurement {
                ear: DspEar::In,
                target: "diffuse-field-iso-11904-1".into(),
            }),
            ..Default::default()
        };
        let all = vec![fitted.clone()];
        let step = target_step(&fitted, &all, &neutral, &harman);
        assert_eq!(step, targets::tapered_difference(&neutral, &harman));
        assert_ne!(step, targets::difference(&neutral, &harman));
    }

    /// A correction fitted to a measurement plays its stored bands, exactly,
    /// through the device's chain, and they are squig.link's Harman preset.
    #[test]
    fn a_fitted_correction_plays_its_bands() {
        use crate::config::{DspFilter, EqFilter, EqFilterKind};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let bands: Vec<DspFilter> = [
            (190.0, -2.2, 0.7),
            (740.0, -1.8, 2.4),
            (1700.0, -2.7, 1.5),
            (2100.0, -1.0, 5.6),
            (2800.0, 1.6, 4.2),
            (4200.0, 5.6, 0.7),
            (4600.0, -1.8, 5.3),
        ]
        .into_iter()
        .map(|(freq, gain_db, q)| {
            DspFilter::Band(EqFilter {
                kind: EqFilterKind::Peaking,
                freq,
                gain_db,
                q,
                channels: Vec::new(),
            })
        })
        .collect();
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Performer 8S".into(),
                role: Some(DspRole::Correction),
                fitted: Some(DspMeasurement {
                    ear: DspEar::In,
                    target: "harman-in-ear-2019".into(),
                }),
                filters: bands.clone(),
                preamp_db: Some(-4.99),
                ..Default::default()
            });
        })
        .unwrap();
        let played = chain_response("IEMs", Some("Performer 8S"), None, 48_000).unwrap();
        let freqs: Vec<f64> = played.iter().map(|(hz, _)| *hz).collect();
        let stored = super::super::response(&bands, &freqs, 48_000);
        for ((hz, db), want) in played.iter().zip(&stored) {
            assert!((db - want).abs() < 0.01, "{hz} Hz: {db} against {want}");
        }
    }

    /// A tuning on a correction takes its headroom from the chain's summed
    /// response, not the correction's own preamp: boosts that cancel leave
    /// the chain at unity.
    #[test]
    fn a_layered_chain_has_the_headroom_of_its_sum() {
        use crate::config::{DspFilter, EqFilter, EqFilterKind};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let peak = |gain_db| {
            DspFilter::Band(EqFilter {
                kind: EqFilterKind::Peaking,
                freq: 1000.0,
                gain_db,
                q: 1.0,
                channels: Vec::new(),
            })
        };
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Boost".into(),
                role: Some(DspRole::Correction),
                filters: vec![peak(6.0)],
                preamp_db: Some(-6.0),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Cut".into(),
                role: Some(DspRole::Tuning),
                filters: vec![peak(-6.0)],
                ..Default::default()
            });
        })
        .unwrap();
        set_chain("DAC", Some(Some("Boost")), Some(&[])).unwrap();
        let alone = output_response("DAC", 48_000).unwrap();
        assert!((alone.preamp_db + 6.0).abs() < 0.01, "{}", alone.preamp_db);
        set_chain("DAC", None, Some(&["Cut".to_string()])).unwrap();
        let both = output_response("DAC", 48_000).unwrap();
        assert!(both.total.iter().all(|db| db.abs() < 0.01));
        assert!(both.preamp_db.abs() < 0.01, "{}", both.preamp_db);
    }

    /// A gain the file states as a filter and one stated as the preamp put
    /// the curve, and the level it sits at, in the same place: the graph
    /// does not move between them.
    #[test]
    fn a_gain_filter_and_a_preamp_draw_alike() {
        use crate::config::{DspFilter, EqFilter, EqFilterKind};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let band = |kind, gain_db| {
            DspFilter::Band(EqFilter {
                kind,
                freq: 1000.0,
                gain_db,
                q: 1.0,
                channels: Vec::new(),
            })
        };
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "As a filter".into(),
                filters: vec![
                    band(EqFilterKind::Gain, -5.0),
                    band(EqFilterKind::Peaking, 3.0),
                ],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "As the preamp".into(),
                filters: vec![band(EqFilterKind::Peaking, 3.0)],
                preamp_db: Some(-5.0),
                ..Default::default()
            });
        })
        .unwrap();
        let filter = response("As a filter", 48_000).unwrap();
        let preamp = response("As the preamp", 48_000).unwrap();
        let level = |r: &Response| r.preamp_db + r.gain_db;
        assert!((level(&filter) + 5.0).abs() < 0.01, "{}", level(&filter));
        assert!((level(&preamp) + 5.0).abs() < 0.01, "{}", level(&preamp));
        for (a, b) in filter.total.iter().zip(&preamp.total) {
            assert!((a + filter.preamp_db - b - preamp.preamp_db).abs() < 0.01);
        }
        assert_eq!(filter.bands.len(), 1, "the gain is not drawn as a band");
    }

    /// A correction fitted to one target under a tuning made against another
    /// is fitted to the tuning's target instead: the chain plays what the
    /// correction fitted to that target plays with the same tuning, which is
    /// squig.link's result, rather than a target difference on top.
    #[test]
    fn a_fitted_correction_is_fitted_again_for_its_tuning() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let text = measured(6.0);
        save_measured("To ISO", &text, DspEar::In, "diffuse-field-iso-11904-1").unwrap();
        save_measured("To Harman", &text, DspEar::In, "harman-in-ear-2019").unwrap();
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Lush".into(),
                role: Some(DspRole::Tuning),
                tuned_for: Some("harman-in-ear-2019".into()),
                filters: vec![band(9000.0)],
                ..Default::default()
            });
        })
        .unwrap();
        let lush = ["Lush".to_string()];
        set_chain("Via ISO", Some(Some("To ISO")), Some(&lush)).unwrap();
        set_chain("Direct", Some(Some("To Harman")), Some(&lush)).unwrap();
        let via = chain_response("Via ISO", None, None, 48_000).unwrap();
        let direct = chain_response("Direct", None, None, 48_000).unwrap();
        for ((hz, a), (_, b)) in via.iter().zip(&direct) {
            assert!((a - b).abs() < 0.01, "{hz} Hz: {a} against {b}");
        }

        let view = chain_view("Via ISO");
        assert!(matches!(
            &view.tuning[0].join,
            Some(Join::Refitted { to, .. }) if to == "Harman in-ear 2019"
        ));
        assert!(
            view.sentence
                .ends_with("Lush was made for Harman in-ear 2019, so the correction is fitted to Harman in-ear 2019 for it."),
            "{}",
            view.sentence
        );
        let graph = output_response("Via ISO", 48_000).unwrap();
        let tuning = graph.tuning.unwrap();
        let alone = super::super::response(&[band(9000.0)], &graph.freqs, 48_000);
        for (t, l) in tuning.iter().zip(&alone) {
            assert!(
                (t - l).abs() < 0.01,
                "the legend's tuning is the tuning alone"
            );
        }
        let direct_alone = output_response("Direct", 48_000)
            .unwrap()
            .correction
            .unwrap();
        for (a, b) in graph.correction.unwrap().iter().zip(&direct_alone) {
            assert!((a - b).abs() < 0.01, "the legend's correction is the refit");
        }

        // Saying Lush was made against ISO is matched: no refit.
        let previews = made_against_previews("Lush", "Via ISO");
        let of = |id: &str| {
            &previews
                .iter()
                .find(|(t, _)| t.as_deref() == Some(id))
                .unwrap()
                .1
        };
        let iso = of("diffuse-field-iso-11904-1");
        for (p, l) in iso.iter().zip(&alone) {
            assert!((p - l).abs() < 0.01);
        }
        // Against Harman, the preview adds the refit's move to the tuning.
        let harman = of("harman-in-ear-2019");
        let moved: Vec<f64> = direct
            .iter()
            .zip(&chain_response("Via ISO", None, Some(&[]), 48_000).unwrap())
            .map(|((_, d), (_, own))| d - own)
            .collect();
        for (p, m) in harman.iter().zip(&moved) {
            assert!((p - m).abs() < 0.01, "{p} against {m}");
        }
        // A third target compares with the refit's: the difference runs from
        // Harman to it.
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Other".into(),
                role: Some(DspRole::Tuning),
                tuned_for: Some("diffuse-field-iso-11904-1".into()),
                filters: vec![band(200.0)],
                ..Default::default()
            });
        })
        .unwrap();
        let both = ["Lush".to_string(), "Other".to_string()];
        set_chain("Via ISO", None, Some(&both)).unwrap();
        let iso_name = target_name("diffuse-field-iso-11904-1");
        let view = chain_view("Via ISO");
        assert!(matches!(
            &view.tuning[1].join,
            Some(Join::Converted { from, to }) if from == "Harman in-ear 2019" && *to == iso_name
        ));
        assert!(
            view.sentence.ends_with(&format!(
                "Other was made for {iso_name}, so the difference from Harman in-ear 2019 to {iso_name} plays first."
            )),
            "{}",
            view.sentence
        );
    }

    /// A correction saved before kōan fitted bands, holding the measurement
    /// alone, is fitted again for its tuning as a fitted one is, and its
    /// previews move from the fit it plays.
    #[test]
    fn an_older_measured_correction_is_fitted_again_for_its_tuning() {
        use super::super::targets;
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let text = measured(6.0);
        let folder = super::dir("Older");
        std::fs::create_dir_all(&folder).unwrap();
        let curve = read_measurement(&text).unwrap();
        std::fs::write(targets::measurement_path(&folder), targets::on_grid(&curve)).unwrap();
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Older".into(),
                role: Some(DspRole::Correction),
                measurement: Some(DspMeasurement {
                    ear: DspEar::In,
                    target: "diffuse-field-iso-11904-1".into(),
                }),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Lush".into(),
                role: Some(DspRole::Tuning),
                tuned_for: Some("harman-in-ear-2019".into()),
                filters: vec![band(9000.0)],
                ..Default::default()
            });
        })
        .unwrap();
        let lush = ["Lush".to_string()];
        set_chain("Older DAC", Some(Some("Older")), Some(&lush)).unwrap();
        let kept = targets::measurement(&folder).unwrap();
        let harman = squig_fit(&kept, &targets::choice_curve("harman-in-ear-2019").unwrap()).0;
        let mut wanted = harman.clone();
        wanted.push(band(9000.0));
        let freqs = targets::grid();
        let want = super::super::response(&wanted, &freqs, 48_000);
        let played = chain_response("Older DAC", None, None, 48_000).unwrap();
        for ((hz, a), b) in played.iter().zip(&want) {
            assert!((a - b).abs() < 0.01, "{hz} Hz: {a} against {b}");
        }
        let previews = made_against_previews("Lush", "Older DAC");
        let moved = &previews
            .iter()
            .find(|(t, _)| t.as_deref() == Some("harman-in-ear-2019"))
            .unwrap()
            .1;
        let own = chain_response("Older DAC", None, Some(&[]), 48_000).unwrap();
        for ((p, w), (_, o)) in moved.iter().zip(&want).zip(&own) {
            assert!((p - (w - o)).abs() < 0.01, "{p} against {}", w - o);
        }
    }

    /// The refit follows the tuning that asks for it: where the chain cannot
    /// hold that tuning and leaves it out, the correction plays its own fit.
    #[test]
    fn a_refit_goes_with_the_tuning_that_asked() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        save_measured(
            "To ISO",
            &measured(6.0),
            DspEar::In,
            "diffuse-field-iso-11904-1",
        )
        .unwrap();
        persist(|c| {
            for i in 0..4 {
                c.dsp.profiles.push(DspProfile {
                    name: format!("Big {i}"),
                    role: Some(DspRole::Tuning),
                    filters: vec![band(1000.0 + i as f64); 64],
                    ..Default::default()
                });
            }
            c.dsp.profiles.push(DspProfile {
                name: "Lush".into(),
                role: Some(DspRole::Tuning),
                tuned_for: Some("harman-in-ear-2019".into()),
                layers: (0..4).map(|i| layer(&format!("Big {i}"), true)).collect(),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Plain".into(),
                role: Some(DspRole::Tuning),
                tuned_for: Some("diffuse-field-iso-11904-1".into()),
                filters: vec![band(200.0)],
                ..Default::default()
            });
        })
        .unwrap();
        let eqs = ["Plain".to_string(), "Lush".to_string()];
        set_chain("DAC", Some(Some("To ISO")), Some(&eqs)).unwrap();
        let chain = super::super::output_chain(&Config::cached().dsp, "DAC").unwrap();
        assert_eq!(chain.left_out_eqs, ["Lush"]);
        assert_eq!(chain.refit, None);
        assert!(matches!(
            chain_view("DAC").tuning[0].join,
            Some(Join::Matched)
        ));
    }

    /// One correction to a chain: a second layer is refused, naming the one
    /// already there, and one made so by its role is warned of; tuning on
    /// top is fine.
    #[test]
    fn a_chain_corrects_once() {
        use crate::config::{DspLayer, DspTarget};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            for (name, target) in [("HD 650", true), ("HD 600", true), ("Warm", false)] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![band(100.0)],
                    target: target.then(|| DspTarget {
                        made_for: "harman-over-ear-2018".into(),
                        chosen: None,
                    }),
                    ..Default::default()
                });
            }
        })
        .unwrap();
        let layer = |p: &str| DspLayer {
            profile: p.into(),
            on: true,
        };
        set_layers("Desk", vec![layer("HD 650"), layer("Warm")]).unwrap();
        let s = summary("Desk").unwrap();
        assert_eq!(
            s.correction.as_deref(),
            Some("HD 650: ready-made EQ (made for Harman over-ear 2018)")
        );
        assert_eq!(s.tunings, vec!["Warm".to_string()]);
        let refused = set_layers(
            "Desk",
            vec![layer("HD 650"), layer("Warm"), layer("HD 600")],
        )
        .unwrap_err();
        assert_eq!(
            refused,
            "This EQ already plays the correction HD 650. Take that out first, or add HD 600 to a device's tuning instead."
        );
        // Said to be a correction, it is one: the stack says so.
        set_role("Warm", DspRole::Correction).unwrap();
        assert_eq!(
            detail("Desk").unwrap().corrects_twice.as_deref(),
            Some("This EQ corrects twice: HD 650 (ready-made) and Warm (correction). Keep one.")
        );
        set_role("Warm", DspRole::Tuning).unwrap();
        set_role("HD 600", DspRole::Tuning).unwrap();
        set_layers(
            "Desk",
            vec![layer("HD 650"), layer("Warm"), layer("HD 600")],
        )
        .unwrap();
    }

    /// What a ready-made EQ was made for is a target that ships, said of a
    /// profile that is there and not built from a measurement; a target
    /// chosen for another kind of headphone goes with the old one.
    #[test]
    fn made_for_is_checked() {
        use crate::config::{DspEar, DspMeasurement};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Preset".into(),
                filters: vec![band(100.0)],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Measured".into(),
                measurement: Some(DspMeasurement {
                    ear: DspEar::In,
                    target: "harman-in-ear-2019".into(),
                }),
                ..Default::default()
            });
        })
        .unwrap();
        assert!(set_made_for("Nobody", Some("harman-in-ear-2019")).is_err());
        assert!(set_made_for("Preset", Some("made-up")).is_err());
        assert!(set_made_for("Measured", Some("harman-in-ear-2019")).is_err());
        let target = || {
            Config::cached()
                .dsp
                .profiles
                .iter()
                .find(|p| p.name == "Preset")
                .unwrap()
                .target
                .clone()
        };
        assert_eq!(target(), None);
        set_made_for("Preset", Some("harman-in-ear-2019")).unwrap();
        choose_target("Preset", Some("diffuse-field-iso-11904-1")).unwrap();
        set_made_for("Preset", Some("harman-over-ear-2018")).unwrap();
        let t = target().unwrap();
        assert_eq!(t.made_for, "harman-over-ear-2018");
        assert_eq!(t.chosen, None, "an in-ear target is no move for over-ears");
        set_made_for("Preset", None).unwrap();
        assert_eq!(target(), None);
    }

    /// Where the target difference is what tips the chain past the filters
    /// it may hold, it is the step that goes: the tuning plays without it,
    /// and says so.
    #[test]
    fn the_target_difference_goes_before_the_tuning() {
        use crate::config::{DspFilter, DspLayer, DspTarget};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let spread = |n: usize, from: f64| -> Vec<DspFilter> {
            (0..n)
                .map(|i| {
                    DspFilter::Band(crate::config::EqFilter {
                        kind: crate::config::EqFilterKind::Peaking,
                        freq: from + i as f64,
                        gain_db: 1.0,
                        q: 1.0,
                        channels: vec![(i % 4) as u16],
                    })
                })
                .collect()
        };
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Base".into(),
                filters: spread(100, 1000.0),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "HD 600".into(),
                filters: vec![band(100.0)],
                layers: vec![DspLayer {
                    profile: "Base".into(),
                    on: true,
                }],
                target: Some(DspTarget {
                    made_for: "harman-over-ear-2018".into(),
                    chosen: None,
                }),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Many".into(),
                filters: spread(156, 100.0),
                tuned_for: Some("diffuse-field-gras-kemar".into()),
                ..Default::default()
            });
        })
        .unwrap();
        let dac = "Desk DAC";
        assign(Some("HD 600"), dac).unwrap();
        set_tuning(dac, Some("Many")).unwrap();
        let cfg = Config::cached();
        let chain = super::super::output_chain(&cfg.dsp, dac).unwrap();
        assert!(chain.tuning_plays);
        let played = super::super::chain(&chain.profile, &chain.all, &mut Vec::new()).unwrap();
        assert_eq!(
            played.len(),
            100 + 156 + 1,
            "Base, the tuning, the correction's own"
        );
        assert!(
            !played.iter().any(|f| matches!(f, DspFilter::Graphic(_))),
            "no target difference"
        );
        assert!(
            chain
                .left_out
                .as_deref()
                .is_some_and(|l| l.starts_with("Many plays without the target difference")),
            "{:?}",
            chain.left_out
        );
    }

    /// A baked EQ, a correction and a bass band in one, splits back into the
    /// two: the correction from the measurement, the band as the tuning,
    /// made against the target, and the output that played it plays them.
    #[test]
    fn a_baked_eq_splits_into_correction_and_tuning() {
        use super::super::targets;
        use crate::config::DspFilter;
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let mut text = String::from("frequency,raw\n");
        for hz in targets::grid() {
            let peak = |at: f64, db: f64| db * (-(hz / at).log2().powi(2) / 0.1).exp();
            text.push_str(&format!(
                "{hz:.2},{:.2}\n",
                90.0 + peak(3000.0, 6.0) + peak(8000.0, 5.0)
            ));
        }
        let target = "harman-in-ear-2019";
        let measured = read_measurement(&text).unwrap();
        // As a squig.link export bakes it: target minus measurement whole.
        let correction = targets::difference(&measured, &targets::choice_curve(target).unwrap());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Lush".into(),
                filters: vec![DspFilter::Graphic(correction), band(80.0)],
                role: Some(DspRole::Baked),
                devices: vec!["Desk DAC".into()],
                ..Default::default()
            })
        })
        .unwrap();

        let r = preview_split("Lush", &text, target, 48_000).unwrap();
        let at = |db: &[f64], hz: f64| {
            let i = r.freqs.iter().position(|&f| f >= hz).unwrap();
            db[i]
        };
        let tuning = r.tuning.as_ref().unwrap();
        assert!((at(tuning, 80.0) - 3.0).abs() < 1.0, "{}", at(tuning, 80.0));
        assert!(at(tuning, 3000.0).abs() < 0.7, "{}", at(tuning, 3000.0));
        // The headphones' treble is the correction's, not the taste's.
        assert!(at(tuning, 8000.0).abs() < 1.0, "{}", at(tuning, 8000.0));
        let original = r.original.as_ref().unwrap();
        for hz in [50.0, 200.0, 1000.0, 4000.0] {
            assert!((at(&r.total, hz) - at(original, hz)).abs() < 1.0, "{hz} Hz");
        }

        let (c, t) = split_baked("Lush", &text, DspEar::In, target).unwrap();
        assert_eq!((c.as_str(), t.as_str()), ("Lush correction", "Lush tuning"));
        let cfg = Config::cached();
        assert_eq!(cfg.dsp.profile_for("Desk DAC").unwrap().name, c);
        assert_eq!(tuning_for("Desk DAC").as_deref(), Some(t.as_str()));
        let made = cfg.dsp.profiles.iter().find(|p| p.name == t).unwrap();
        assert_eq!(made.tuned_for.as_deref(), Some(target));
        assert_eq!(role(made), DspRole::Tuning);
        assert!(cfg.dsp.profiles.iter().any(|p| p.name == "Lush"), "kept");
        // On its own target, no difference to play: the correction's bands
        // and the tuning's curve.
        let chain = super::super::output_chain(&cfg.dsp, "Desk DAC").unwrap();
        let played = super::super::chain(&chain.profile, &chain.all, &mut Vec::new()).unwrap();
        let bands = &cfg
            .dsp
            .profiles
            .iter()
            .find(|p| p.name == c)
            .unwrap()
            .filters;
        assert!(!bands.is_empty());
        assert_eq!(played.len(), bands.len() + 1);
        assert!(played.windows(bands.len()).any(|w| w == &bands[..]));
        assert_eq!(
            played
                .iter()
                .filter(|f| matches!(f, DspFilter::Graphic(_)))
                .count(),
            1
        );
        assert!(split_baked("Lush", &text, DspEar::In, "made-up").is_err());

        // One EQ the same on every channel splits; nothing else does.
        let stack = |c: &mut Config| {
            c.dsp.profiles.push(DspProfile {
                name: "Stack".into(),
                layers: vec![crate::config::DspLayer {
                    profile: "Lush".into(),
                    on: true,
                }],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Left".into(),
                filters: vec![DspFilter::Band(crate::config::EqFilter {
                    kind: crate::config::EqFilterKind::Peaking,
                    freq: 100.0,
                    gain_db: 2.0,
                    q: 1.0,
                    channels: vec![0],
                })],
                ..Default::default()
            });
        };
        persist(stack).unwrap();
        let refused = preview_split("Stack", &text, target, 48_000).unwrap_err();
        assert!(refused.contains("plays other EQs"), "{refused}");
        let refused = preview_split("Left", &text, target, 48_000).unwrap_err();
        assert!(
            refused.contains("treats its channels differently"),
            "{refused}"
        );
    }

    /// A squig.link preset is bands fitted to the target and the taste, its
    /// treble held back. Split, its tuning is the taste alone: none of the
    /// measurement's treble, inverted, which the fit never corrected.
    #[test]
    fn a_fitted_preset_splits_without_the_measurements_treble() {
        use super::super::targets;
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let peak =
            |hz: f64, at: f64, db: f64, width: f64| db * (-(hz / at).log2().powi(2) / width).exp();
        let mut text = String::from("frequency,raw\n");
        for hz in targets::grid() {
            text.push_str(&format!(
                "{hz:.2},{:.2}\n",
                90.0 + peak(hz, 3000.0, 6.0, 0.1)
                    + peak(hz, 6000.0, -9.0, 0.02)
                    + peak(hz, 9000.0, 7.0, 0.02)
                    + peak(hz, 13000.0, -8.0, 0.03)
            ));
        }
        let target = "harman-in-ear-2019";
        let measured = read_measurement(&text).unwrap();
        let shelf = |hz: f64| 3.0 / (1.0 + (hz / 80.0).powi(2));
        let tasted: targets::Curve = targets::choice_curve(target)
            .unwrap()
            .into_iter()
            .map(|(hz, db)| (hz, db + shelf(hz)))
            .collect();
        let (bands, _) = squig_fit(&measured, &tasted);
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Super".into(),
                filters: bands,
                role: Some(DspRole::Baked),
                ..Default::default()
            })
        })
        .unwrap();

        let r = preview_split("Super", &text, target, 48_000).unwrap();
        let tuning = r.tuning.as_ref().unwrap();
        let worst = r
            .freqs
            .iter()
            .zip(tuning)
            .filter(|(hz, _)| **hz >= 2000.0)
            .map(|(_, db)| db.abs())
            .fold(0.0, f64::max);
        assert!(worst < 1.5, "the tuning's treble reaches {worst:.1} dB");
        let i = r.freqs.iter().position(|&f| f >= 40.0).unwrap();
        assert!(
            (tuning[i] - shelf(40.0)).abs() < 1.0,
            "{} at 40 Hz",
            tuning[i]
        );
        // Correction and tuning together play what the preset played.
        let original = r.original.as_ref().unwrap();
        let apart = r
            .total
            .iter()
            .zip(original)
            .map(|(t, o)| (t - o).abs())
            .fold(0.0, f64::max);
        assert!(apart < 0.5, "{apart:.2} dB from the preset");
    }

    /// A tuning is EQs in order, each on or off, each with its own target
    /// difference; a preset saves a correction and its tuning and sets an
    /// output from them, and says when the output was changed since.
    #[test]
    fn a_tuning_is_eqs_in_order_and_a_preset_saves_it() {
        use crate::config::{DspFilter, DspTarget};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let curve = |db: f64| {
            DspFilter::Graphic(crate::config::GraphicEq {
                points: vec![(20.0, 0.0), (1000.0, db), (20_000.0, 0.0)],
                channels: vec![],
            })
        };
        persist(|c| {
            let harman = || {
                Some(DspTarget {
                    made_for: "harman-over-ear-2018".into(),
                    chosen: None,
                })
            };
            c.dsp.profiles.push(DspProfile {
                name: "HD 600".into(),
                filters: vec![band(100.0)],
                target: harman(),
                ..Default::default()
            });
            for (name, freq, made) in [
                ("Warm", 60.0, Some("diffuse-field-gras-kemar")),
                ("Bright", 8000.0, Some("harman-over-ear-2018")),
                ("Spare", 200.0, None),
            ] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![band(freq)],
                    tuned_for: made.map(str::to_owned),
                    ..Default::default()
                });
            }
            for (name, db) in [("Tilt", 1.0), ("Lift", 2.0)] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![curve(db)],
                    ..Default::default()
                });
            }
        })
        .unwrap();
        let dac = "Desk DAC";
        let plays = |device: &str| -> Vec<String> {
            let cfg = Config::cached();
            let Some(chain) = super::super::output_chain(&cfg.dsp, device) else {
                return Vec::new();
            };
            super::super::chain(&chain.profile, &chain.all, &mut Vec::new())
                .unwrap()
                .into_iter()
                .map(|f| match f {
                    DspFilter::Band(b) => format!("{}", b.freq),
                    DspFilter::Graphic(_) => "curve".into(),
                    other => panic!("{other:?}"),
                })
                .collect()
        };
        let list = |names: &[(&str, bool)]| -> Vec<(String, bool)> {
            names.iter().map(|(n, on)| (n.to_string(), *on)).collect()
        };
        assign(Some("HD 600"), dac).unwrap();
        set_tunings(
            dac,
            &list(&[("Warm", true), ("Bright", true), ("Spare", false)]),
        )
        .unwrap();
        // Warm's difference ahead of it, Bright on its own target, Spare off;
        // then the correction's own band.
        assert_eq!(plays(dac), ["curve", "60", "8000", "100"]);
        assert_eq!(tuning_for(dac).as_deref(), Some("Warm"));
        assert!(set_tunings(dac, &list(&[("Warm", true), ("Warm", false)])).is_err());
        assert!(set_tunings(dac, &list(&[("HD 600", true)])).is_err());

        // The correction's curves first, then each EQ's while they fit.
        set_tunings(
            dac,
            &list(&[("Tilt", true), ("Lift", true), ("Spare", true)]),
        )
        .unwrap();
        assert_eq!(plays(dac), ["curve", "curve", "200", "100"]);
        let o = overview_for(Some(dac.into()));
        assert!(o.left_out.as_deref().is_none(), "{:?}", o.left_out);
        persist(|c| {
            let hd = c
                .dsp
                .profiles
                .iter_mut()
                .find(|p| p.name == "HD 600")
                .unwrap();
            hd.filters.push(curve(-1.0));
        })
        .unwrap();
        assert_eq!(plays(dac), ["curve", "200", "100", "curve"]);
        let o = overview_for(Some(dac.into()));
        assert!(
            o.left_out
                .as_deref()
                .is_some_and(|l| l.starts_with("Lift is left out")),
            "{:?}",
            o.left_out
        );

        // A preset saves the correction and the tuning, on and off.
        set_tunings(dac, &list(&[("Warm", true), ("Spare", false)])).unwrap();
        save_preset(dac, "Late night").unwrap();
        assert_eq!(preset_for(dac), Some(("Late night".into(), false)));
        let other = "Speakers";
        apply_preset(other, Some("Late night")).unwrap();
        assert_eq!(
            Config::cached().dsp.profile_for(other).unwrap().name,
            "HD 600"
        );
        assert_eq!(
            tunings_for(other),
            list(&[("Warm", true), ("Spare", false)])
        );
        assert_eq!(plays(other), plays(dac));
        set_tunings(other, &list(&[("Warm", true), ("Spare", true)])).unwrap();
        assert_eq!(
            preset_for(other),
            Some(("Late night".into(), true)),
            "edited"
        );
        // Reverting is setting it from the preset again: the tuning, on and
        // off, as saved.
        apply_preset(other, Some("Late night")).unwrap();
        assert_eq!(preset_for(other), Some(("Late night".into(), false)));
        assert_eq!(
            tunings_for(other),
            list(&[("Warm", true), ("Spare", false)])
        );
        assert_eq!(plays(other), plays(dac));
        assert!(save_preset(other, "Warm").is_err(), "not over an EQ");
        // Flat: nothing, and untouched.
        apply_preset(other, None).unwrap();
        assert!(Config::cached().dsp.profile_for(other).is_none());
        assert!(tunings_for(other).is_empty());
        assert_eq!(preset_for(other), None);
        assert!(plays(other).is_empty());
    }

    /// A correction plays as made: its bands are not edited. An imported EQ
    /// keeps what it was imported as, says when it was changed, and goes
    /// back; a copy is its own.
    #[test]
    fn corrections_are_read_only_and_imports_can_go_back() {
        use crate::config::DspTarget;
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "HD 600".into(),
                filters: vec![band(100.0)],
                target: Some(DspTarget {
                    made_for: "harman-over-ear-2018".into(),
                    chosen: None,
                }),
                ..Default::default()
            })
        })
        .unwrap();
        let refused = set_band("HD 600", 0, "peaking", 200.0, 1.0, 1.0).unwrap_err();
        assert!(refused.contains("plays as made"), "{refused}");
        assert!(add_band("HD 600", None).is_err());
        assert!(remove_filter("HD 600", 0).is_err());
        assert!(detail("HD 600").unwrap().read_only);

        let lush = Imported {
            name: "Lush".into(),
            source: vec!["Lush.txt".into()],
            filters: vec![band(80.0)],
            impulses: vec![],
        };
        save(lush, None).unwrap();
        let d = detail("Lush").unwrap();
        assert!(!d.read_only && d.can_revert && !d.edited);
        set_band("Lush", 0, "peaking", 80.0, 12.0, 1.0).unwrap();
        assert!(detail("Lush").unwrap().edited);
        let copy = duplicate("Lush", None).unwrap();
        assert_eq!(copy, "Lush copy");
        let c = detail(&copy).unwrap();
        assert!(!c.can_revert && c.devices.is_empty());
        assert_eq!(c.filters, detail("Lush").unwrap().filters, "as it is now");
        revert("Lush").unwrap();
        assert!(!detail("Lush").unwrap().edited);
        assert!(revert(&copy).is_err(), "made here");
        assert!(duplicate("Lush", Some("Lush copy")).is_err(), "taken");
    }

    /// Configs from before: a stack of a correction and EQs becomes a
    /// preset, its outputs set from it with the tuning they had on top and
    /// without a correction switched off; an output a preset was assigned to
    /// is set from it; an output whose correction was a group plays the
    /// member that played.
    #[test]
    fn old_stacks_become_presets() {
        use crate::config::{DspLayer, DspTarget};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let layer = |p: &str, on: bool| DspLayer {
            profile: p.into(),
            on,
        };
        persist(|c| {
            for name in ["HD 600", "HD 650"] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![band(100.0)],
                    target: Some(DspTarget {
                        made_for: "harman-over-ear-2018".into(),
                        chosen: None,
                    }),
                    ..Default::default()
                });
            }
            for (name, hz) in [("Warm", 60.0), ("Bright", 8000.0)] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![band(hz)],
                    ..Default::default()
                });
            }
            c.dsp.tunings.push(crate::config::DspOutputTuning {
                device: "DAC".into(),
                tuning: "Bright".into(),
                on: true,
            });
            c.dsp.profiles.push(DspProfile {
                name: "Quiet".into(),
                devices: vec!["Amp".into()],
                layers: vec![layer("HD 650", false), layer("Warm", true)],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Saved".into(),
                devices: vec!["Speaker".into()],
                preset: true,
                layers: vec![layer("HD 650", true), layer("Bright", true)],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Desk".into(),
                devices: vec!["DAC".into()],
                layers: vec![layer("HD 600", true), layer("Warm", false)],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Cans".into(),
                devices: vec!["Phone".into()],
                group: true,
                layers: vec![layer("HD 600", false), layer("HD 650", true)],
                ..Default::default()
            });
        })
        .unwrap();
        migrate().unwrap();
        let cfg = Config::cached();
        let desk = cfg.dsp.profiles.iter().find(|p| p.name == "Desk").unwrap();
        assert!(desk.preset && desk.devices.is_empty());
        assert_eq!(cfg.dsp.profile_for("DAC").unwrap().name, "HD 600");
        assert_eq!(
            tunings_for("DAC"),
            vec![("Warm".to_string(), false), ("Bright".to_string(), true)],
            "the stack's EQs, then the tuning it had on top"
        );
        assert_eq!(preset_for("DAC"), Some(("Desk".into(), true)));
        assert!(cfg.dsp.profile_for("Amp").is_none(), "switched off");
        assert_eq!(tunings_for("Amp"), vec![("Warm".to_string(), true)]);
        assert_eq!(preset_for("Amp"), Some(("Quiet".into(), false)));
        assert_eq!(cfg.dsp.profile_for("Speaker").unwrap().name, "HD 650");
        assert_eq!(tunings_for("Speaker"), vec![("Bright".to_string(), true)]);
        assert_eq!(preset_for("Speaker"), Some(("Saved".into(), false)));
        assert_eq!(cfg.dsp.profile_for("Phone").unwrap().name, "HD 650");
        assign(Some("Saved"), "Laptop").unwrap();
        assert_eq!(preset_for("Laptop"), Some(("Saved".into(), false)));
        assert!(
            Config::cached()
                .dsp
                .profiles
                .iter()
                .all(|p| !p.preset || p.devices.is_empty()),
            "a preset sets an output, never is its correction"
        );
        migrate().unwrap();
        assert_eq!(
            Config::cached().dsp.profile_for("DAC").unwrap().name,
            "HD 600",
            "once"
        );
    }

    /// A whole chain set in one go, the same twice changing nothing; a name
    /// that is not a correction or EQ refused with the choices, before
    /// anything is set; and the chain said as the EQ page says it.
    #[test]
    fn a_chain_is_set_whole_and_said() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Wharfedale".into(),
                filters: vec![band(100.0)],
                role: Some(DspRole::Correction),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Lush".into(),
                filters: vec![band(60.0)],
                role: Some(DspRole::Baked),
                ..Default::default()
            });
            for (name, hz) in [("Warm", 80.0), ("Air", 9000.0)] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![band(hz)],
                    ..Default::default()
                });
            }
        })
        .unwrap();
        let dac = "Scarlett";
        let eqs = ["Warm".to_string(), "Air".to_string()];
        assert_eq!(
            chain_view(dac).sentence,
            "Scarlett is flat: the music plays untouched."
        );
        set_chain(dac, Some(Some("Wharfedale")), Some(&eqs)).unwrap();
        let once = std::fs::read_to_string(dir.path().join("config.local.toml")).unwrap();
        set_chain(dac, Some(Some("Wharfedale")), Some(&eqs)).unwrap();
        let twice = std::fs::read_to_string(dir.path().join("config.local.toml")).unwrap();
        assert_eq!(once, twice, "the same twice changes nothing");
        let view = chain_view(dac);
        assert_eq!(view.correction.as_deref(), Some("Wharfedale"));
        assert_eq!(view.tuning.len(), 2);
        assert_eq!(
            view.sentence,
            "Music to Scarlett, corrected by Wharfedale, then tuned with Warm and Air."
        );

        let refused = set_chain(dac, Some(Some("Nope")), None).unwrap_err();
        assert_eq!(
            refused,
            "No correction called Nope. Corrections: Wharfedale, Lush"
        );
        let refused = set_chain(dac, None, Some(&["Nope".to_string()])).unwrap_err();
        assert_eq!(refused, "No EQ called Nope. EQs: Warm, Air");
        let twice = ["Warm".to_string(), "Warm".to_string()];
        let refused = set_chain(dac, Some(None), Some(&twice)).unwrap_err();
        assert_eq!(refused, "Warm is in the tuning twice");
        assert_eq!(
            chain_view(dac).correction.as_deref(),
            Some("Wharfedale"),
            "a refusal changes nothing"
        );
        // A correction that includes a tuning takes none: nothing is set.
        set_chain(dac, Some(Some("Lush")), Some(&eqs)).unwrap_err();
        assert_eq!(chain_view(dac).correction.as_deref(), Some("Wharfedale"));
        // Changing only the correction keeps the tuning, which is said
        // skipped rather than hidden.
        set_chain(dac, Some(Some("Lush")), None).unwrap();
        let view = chain_view(dac);
        assert_eq!(view.tuning.len(), 2);
        assert_eq!(
            view.sentence,
            "Music to Scarlett, corrected by Lush. Its tuning, Warm and Air, is skipped: Lush already includes one."
        );
        set_chain(dac, Some(Some("Lush")), Some(&[])).unwrap();
        assert_eq!(
            chain_view(dac).sentence,
            "Music to Scarlett, corrected by Lush."
        );
        set_chain(dac, Some(None), None).unwrap();
        assert!(chain_view(dac).flat);
    }

    /// Deleting an EQ takes it out of the presets and groups that hold it;
    /// an EQ that plays it refuses, naming itself.
    #[test]
    fn a_deleted_eq_leaves_its_presets_and_groups() {
        use crate::config::DspLayer;
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let layer = |p: &str, on: bool| DspLayer {
            profile: p.into(),
            on,
        };
        persist(|c| {
            for (name, hz) in [("Warm", 60.0), ("Air", 9000.0)] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![band(hz)],
                    ..Default::default()
                });
            }
            c.dsp.profiles.push(DspProfile {
                name: "Evening".into(),
                preset: true,
                layers: vec![layer("Warm", true), layer("Air", true)],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Tastes".into(),
                group: true,
                layers: vec![layer("Warm", true), layer("Air", false)],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Both".into(),
                layers: vec![layer("Air", true)],
                ..Default::default()
            });
        })
        .unwrap();
        let held = overview()
            .profiles
            .into_iter()
            .find(|p| p.name == "Warm")
            .unwrap()
            .held_by;
        assert_eq!(held, ["Evening", "Tastes"]);
        assert_eq!(
            delete("Air").unwrap_err(),
            "Both plays Air: take it out of it first"
        );
        delete("Warm").unwrap();
        let cfg = Config::cached();
        let of = |n: &str| {
            cfg.dsp
                .profiles
                .iter()
                .find(|p| p.name == n)
                .unwrap()
                .layers
                .clone()
        };
        assert_eq!(of("Evening"), vec![layer("Air", true)]);
        assert_eq!(
            of("Tastes"),
            vec![layer("Air", true)],
            "the group plays what is left"
        );
    }

    /// Processing switched off is every output flat, what each played kept
    /// as a preset named for it, unless a preset already holds it as it was.
    #[test]
    fn processing_off_becomes_flat() {
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "HD 600".into(),
                filters: vec![band(100.0)],
                role: Some(DspRole::Correction),
                devices: vec!["DAC".into(), "Amp".into()],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Warm".into(),
                filters: vec![band(60.0)],
                ..Default::default()
            });
            // Chosen as corrections before roles were asked: a room's
            // impulse response, and bands with no role.
            c.dsp.profiles.push(DspProfile {
                name: "Room".into(),
                impulses: vec!["room.wav".into()],
                devices: vec!["Monitors".into()],
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Plain".into(),
                filters: vec![band(300.0)],
                devices: vec!["Phones".into()],
                ..Default::default()
            });
            // Taken: the preset is named apart from it.
            c.dsp.profiles.push(DspProfile {
                name: "DAC".into(),
                filters: vec![band(80.0)],
                role: Some(DspRole::Tuning),
                ..Default::default()
            });
        })
        .unwrap();
        set_tunings("DAC", &[("Warm".into(), true)]).unwrap();
        save_preset("Amp", "Speakers").unwrap();
        set_enabled(false).unwrap();
        migrate().unwrap();
        let cfg = Config::cached();
        assert!(cfg.dsp.enabled);
        for device in ["DAC", "Amp"] {
            assert!(cfg.dsp.profile_for(device).is_none(), "{device} is flat");
            assert!(tunings_for(device).is_empty());
            assert_eq!(preset_for(device), None);
        }
        let kept = cfg.dsp.profiles.iter().find(|p| p.name == "DAC 2").unwrap();
        assert!(kept.preset);
        apply_preset("DAC", Some("DAC 2")).unwrap();
        assert_eq!(
            Config::cached().dsp.profile_for("DAC").unwrap().name,
            "HD 600"
        );
        assert_eq!(tunings_for("DAC"), vec![("Warm".to_string(), true)]);
        assert!(
            !Config::cached()
                .dsp
                .profiles
                .iter()
                .any(|p| p.name == "Amp"),
            "Amp was set from Speakers, unchanged"
        );
        for (device, correction) in [("Monitors", "Room"), ("Phones", "Plain")] {
            assert!(Config::cached().dsp.profile_for(device).is_none());
            apply_preset(device, Some(device)).unwrap();
            assert_eq!(
                Config::cached().dsp.profile_for(device).unwrap().name,
                correction,
                "back as {device}'s correction"
            );
            assert!(tunings_for(device).is_empty(), "{device}");
        }
    }

    /// A tuning that does not say what it was made against is offered the
    /// target its curve fits: the same preset split against Harman and
    /// against neutral, as a person brought them in.
    #[test]
    fn a_tuning_is_offered_the_target_it_looks_made_against() {
        use super::super::targets;
        use crate::config::DspTarget;
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let eq = |name: &str, text: &str| DspProfile {
            name: name.into(),
            filters: super::super::apo::parse(text).unwrap().filters,
            role: Some(DspRole::Tuning),
            ..Default::default()
        };
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Performer 8S".into(),
                filters: vec![band(100.0)],
                target: Some(DspTarget {
                    made_for: "harman-in-ear-2019".into(),
                    chosen: None,
                }),
                ..Default::default()
            });
            c.dsp
                .profiles
                .push(eq("Lush", include_str!("testdata/lush-tuning-harman.txt")));
            c.dsp.profiles.push(eq(
                "Lush N",
                include_str!("testdata/lush-tuning-neutral.txt"),
            ));
        })
        .unwrap();
        let dac = "Q5K";
        assign(Some("Performer 8S"), dac).unwrap();
        let harman = "harman-in-ear-2019";
        let neutral = "diffuse-field-iso-11904-1";
        let suggested = |name: &str| suggest_made_against(name, dac).map(|(id, _)| id);
        assert_eq!(suggested("Lush").as_deref(), Some(harman));
        assert_eq!(suggested("Lush N").as_deref(), Some(neutral));
        // The same on a correction to neutral: the guess is of the tuning.
        choose_target("Performer 8S", Some(neutral)).unwrap();
        assert_eq!(suggested("Lush").as_deref(), Some(harman));
        assert_eq!(suggested("Lush N").as_deref(), Some(neutral));
        choose_target("Performer 8S", None).unwrap();

        // Nothing to judge by: a flat tuning, or one small band, is offered
        // nothing, rather than Harman for the shelf it lacks.
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Flat".into(),
                filters: vec![crate::config::DspFilter::Band(crate::config::EqFilter {
                    kind: crate::config::EqFilterKind::Peaking,
                    freq: 1000.0,
                    gain_db: 0.0,
                    q: 1.0,
                    channels: vec![],
                })],
                role: Some(DspRole::Tuning),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Air".into(),
                filters: vec![crate::config::DspFilter::Band(crate::config::EqFilter {
                    kind: crate::config::EqFilterKind::Peaking,
                    freq: 8000.0,
                    gain_db: 2.0,
                    q: 1.0,
                    channels: vec![],
                })],
                role: Some(DspRole::Tuning),
                ..Default::default()
            });
        })
        .unwrap();
        assert_eq!(suggested("Flat"), None);
        assert_eq!(suggested("Air"), None);
        // Nor a group, whose Made against would be every member's.
        make_group("Both", &["Lush".into(), "Lush N".into()]).unwrap();
        assert_eq!(suggested("Both"), None);

        // At the join, while it is unknown.
        set_tunings(dac, &[("Lush N".into(), true)]).unwrap();
        let join = || overview_for(Some(dac.into())).joins[0].clone();
        assert_eq!(join().join, Some(Join::Unknown));
        assert_eq!(
            join().suggestion.map(|(id, _)| id).as_deref(),
            Some(neutral)
        );

        // Said wrongly, Harman's bass shelf plays twice: the preview shows it.
        let low = targets::grid().iter().position(|&hz| hz >= 30.0).unwrap();
        let previews = made_against_previews("Lush N", dac);
        let bass = |id: &str| {
            previews
                .iter()
                .find(|(t, _)| t.as_deref() == Some(id))
                .unwrap()
                .1[low]
        };
        assert!(
            bass(harman) - bass(neutral) > 6.0,
            "{} {}",
            bass(harman),
            bass(neutral)
        );

        // Said rightly, the conversion plays, and the join carries its curve:
        // Harman's shelf taken out ahead of a tuning that puts it back.
        set_tuned_for("Lush N", Some(neutral)).unwrap();
        assert_eq!(suggested("Lush N"), None, "nothing to suggest once said");
        let j = join();
        assert!(
            matches!(j.join, Some(Join::Converted { .. })),
            "{:?}",
            j.join
        );
        assert_eq!(j.step.len(), targets::grid().len());
        assert!(j.step[low] < -3.0, "{}", j.step[low]);
        assert_eq!(j.suggestion, None);
    }

    /// An output plays its tuning on top of its correction, with the
    /// difference between the correction's target and the one the tuning was
    /// made against: dynamic baking. Never on a correction with a tuning
    /// baked in, and never across kinds of headphone.
    #[test]
    fn an_output_plays_its_tuning_on_its_correction() {
        use crate::config::{DspFilter, DspTarget};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "HD 600".into(),
                filters: vec![band(100.0)],
                target: Some(DspTarget {
                    made_for: "harman-over-ear-2018".into(),
                    chosen: None,
                }),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Warm".into(),
                filters: vec![band(60.0)],
                tuned_for: Some("diffuse-field-gras-kemar".into()),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Lush".into(),
                filters: vec![band(200.0)],
                role: Some(DspRole::Baked),
                ..Default::default()
            });
            let harman = || {
                Some(DspTarget {
                    made_for: "harman-over-ear-2018".into(),
                    chosen: None,
                })
            };
            c.dsp.profiles.push(DspProfile {
                name: "HD 650".into(),
                filters: vec![band(110.0)],
                target: harman(),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Bright".into(),
                filters: vec![band(8000.0)],
                tuned_for: Some("harman-over-ear-2018".into()),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Room".into(),
                impulses: vec!["dsp/room/48000.wav".into()],
                ..Default::default()
            });
            let curve = |db: f64| {
                DspFilter::Graphic(crate::config::GraphicEq {
                    points: vec![(20.0, 0.0), (1000.0, db), (20_000.0, 0.0)],
                    channels: vec![],
                })
            };
            c.dsp.profiles.push(DspProfile {
                name: "Curved".into(),
                filters: vec![curve(2.0)],
                target: harman(),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Tilt".into(),
                filters: vec![curve(-1.0)],
                tuned_for: Some("diffuse-field-gras-kemar".into()),
                ..Default::default()
            });
        })
        .unwrap();
        let dac = "Desk DAC";
        let shown = || {
            super::super::output_chain(&Config::cached().dsp, dac)
                .unwrap()
                .name
        };
        let plays = || -> Vec<String> {
            let cfg = Config::cached();
            let Some(chain) = super::super::output_chain(&cfg.dsp, dac) else {
                return Vec::new();
            };
            super::super::chain(&chain.profile, &chain.all, &mut Vec::new())
                .unwrap()
                .into_iter()
                .map(|f| match f {
                    DspFilter::Band(b) => format!("{}", b.freq),
                    DspFilter::Graphic(_) => "step".into(),
                    other => panic!("{other:?}"),
                })
                .collect()
        };
        assign(Some("HD 600"), dac).unwrap();
        assert_eq!(plays(), ["100"]);

        // Made against neutral, played on a correction to Harman: Harman's
        // preference comes out first.
        set_tuning(dac, Some("Warm")).unwrap();
        assert_eq!(tuning_for(dac).as_deref(), Some("Warm"));
        assert_eq!(plays(), ["step", "60", "100"]);
        let join = || overview_for(Some(dac.into())).joins[0].clone();
        let harman = target_name("harman-over-ear-2018");
        assert_eq!(
            join().join,
            Some(Join::Converted {
                from: harman.clone(),
                to: target_name("diffuse-field-gras-kemar"),
            })
        );
        assert_eq!(chain_view(dac).tuning[0].matched, Some(false));
        // Made against the correction's own target, or nothing said: as it is.
        set_tuned_for("Warm", Some("harman-over-ear-2018")).unwrap();
        assert_eq!(
            detail("Warm").unwrap().tuned_for.as_deref(),
            Some("harman-over-ear-2018")
        );
        assert_eq!(plays(), ["60", "100"]);
        assert_eq!(join().join, Some(Join::Matched));
        assert_eq!(join().made_for, Some(harman.clone()));
        let view = chain_view(dac);
        assert_eq!(view.tuning[0].matched, Some(true));
        assert!(
            view.sentence
                .ends_with(&format!("Warm was made for {harman}: matched.")),
            "{}",
            view.sentence
        );
        set_tuned_for("Warm", None).unwrap();
        assert_eq!(plays(), ["60", "100"]);
        assert_eq!(join().join, Some(Join::Unknown), "nothing converts");
        assert_eq!(join().made_for, None);
        assert!(
            chain_view(dac)
                .sentence
                .contains("What Warm was made against is not set.")
        );
        // Switched off, it meets nothing.
        set_tunings(dac, &[("Warm".into(), false)]).unwrap();
        assert_eq!(join().join, None);
        set_tunings(dac, &[("Warm".into(), true)]).unwrap();
        // An in-ear target says nothing of over-ears.
        set_tuned_for("Warm", Some("harman-in-ear-2019")).unwrap();
        assert_eq!(plays(), ["60", "100"]);
        assert_eq!(join().join, None);
        assert!(set_tuned_for("Warm", Some("made-up")).is_err());

        // A correction is not a tuning, and a baked one takes none.
        let refused = set_tuning(dac, Some("HD 600")).unwrap_err();
        assert!(refused.contains("corrects headphones"), "{refused}");
        assign(Some("Lush"), dac).unwrap();
        assert_eq!(plays(), ["200"], "the tuning waits");
        assert_eq!(
            overview_for(Some(dac.into())).left_out.as_deref(),
            Some("Warm is left out: Lush already includes a tuning."),
            "and says why"
        );
        assert_eq!(
            join(),
            EqJoin {
                made_for: Some(target_name("harman-in-ear-2019")),
                join: None,
                note: Some("Warm is left out: Lush already includes a tuning.".into()),
                ..Default::default()
            },
            "at the EQ it is about"
        );
        assert_eq!(
            set_tuning(dac, Some("Warm")).unwrap_err(),
            "Lush already includes a tuning. Split it into a correction and an EQ to change the tuning."
        );

        // A group corrects with its member playing, the tuning on top, and is
        // called by its own name.
        make_group("Cans", &["HD 600".into(), "HD 650".into()]).unwrap();
        assign(Some("Cans"), dac).unwrap();
        set_tuning(dac, Some("Warm")).unwrap();
        set_tuned_for("Warm", Some("diffuse-field-gras-kemar")).unwrap();
        assert_eq!(plays(), ["step", "60", "100"]);
        select("Cans", "HD 650").unwrap();
        assert_eq!(plays(), ["step", "60", "110"]);
        assert_eq!(shown(), "Cans");

        // A group of tunings is made against its playing member's target.
        make_group("Tastes", &["Warm".into(), "Bright".into()]).unwrap();
        set_tuning(dac, Some("Tastes")).unwrap();
        assert_eq!(plays(), ["step", "60", "110"]);
        select("Tastes", "Bright").unwrap();
        assert_eq!(plays(), ["8000", "110"], "made against Harman, on Harman");
        set_tuning(dac, Some("Warm")).unwrap();
        delete("Tastes").unwrap();

        // Impulse responses correct a room: never a tuning.
        let refused = set_tuning(dac, Some("Room")).unwrap_err();
        assert!(refused.contains("impulse responses"), "{refused}");

        // The correction's curves come first in the chain's budget: the step
        // is left out rather than push one out.
        assign(Some("Curved"), dac).unwrap();
        set_tuning(dac, Some("Tilt")).unwrap();
        let cfg = Config::cached();
        let chain = super::super::output_chain(&cfg.dsp, dac).unwrap();
        let played = super::super::chain(&chain.profile, &chain.all, &mut Vec::new()).unwrap();
        let curved = cfg
            .dsp
            .profiles
            .iter()
            .find(|p| p.name == "Curved")
            .unwrap();
        assert_eq!(played.len(), 2, "the tuning's curve and the correction's");
        assert_eq!(played.last(), curved.filters.first());
        let o = overview_for(Some(dac.into()));
        assert!(o.tuning_plays);
        assert!(
            o.left_out
                .as_deref()
                .is_some_and(|l| l.starts_with("Tilt plays without the target difference")),
            "{:?}",
            o.left_out
        );
        set_tuning(dac, Some("Warm")).unwrap();

        // A chain past the filters one may hold loses the tuning, never the
        // correction, and says so. Each is within bounds, a channel's bands
        // spread over four; the layers together are not.
        let spread = |n: usize, from: f64| -> Vec<DspFilter> {
            (0..n)
                .map(|i| {
                    DspFilter::Band(crate::config::EqFilter {
                        kind: crate::config::EqFilterKind::Peaking,
                        freq: from + i as f64,
                        gain_db: 1.0,
                        q: 1.0,
                        channels: vec![(i % 4) as u16],
                    })
                })
                .collect()
        };
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Busy".into(),
                filters: spread(200, 100.0),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "Base".into(),
                filters: spread(100, 1000.0),
                ..Default::default()
            });
            let hd = c
                .dsp
                .profiles
                .iter_mut()
                .find(|p| p.name == "HD 600")
                .unwrap();
            hd.layers = vec![crate::config::DspLayer {
                profile: "Base".into(),
                on: true,
            }];
        })
        .unwrap();
        assign(Some("HD 600"), dac).unwrap();
        set_tuning(dac, Some("Busy")).unwrap();
        assert_eq!(plays().len(), 101, "the correction alone");
        let o = overview_for(Some(dac.into()));
        assert!(!o.tuning_plays);
        assert!(
            o.left_out
                .as_deref()
                .is_some_and(|l| l.starts_with("Busy is left out")),
            "{:?}",
            o.left_out
        );
        assign(Some("Curved"), dac).unwrap();
        set_tuning(dac, Some("Warm")).unwrap();

        // Nor without a correction: nothing plays, and it says why.
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "Heavy".into(),
                layers: ["Busy", "Base"]
                    .map(|p| crate::config::DspLayer {
                        profile: p.into(),
                        on: true,
                    })
                    .to_vec(),
                ..Default::default()
            });
        })
        .unwrap();
        assign(None, dac).unwrap();
        set_tuning(dac, Some("Heavy")).unwrap();
        assert!(plays().is_empty());
        let o = overview_for(Some(dac.into()));
        assert!(!o.tuning_plays);
        assert!(
            o.left_out
                .as_deref()
                .is_some_and(|l| l.starts_with("Heavy is left out")),
            "{:?}",
            o.left_out
        );
        set_tuning(dac, Some("Warm")).unwrap();

        // No correction: the tuning alone, called by its name.
        assign(None, dac).unwrap();
        assert_eq!(plays(), ["60"]);
        assert_eq!(shown(), "Warm");

        // It follows the profile's name, and goes with it.
        rename("Warm", "Warm bass").unwrap();
        assert_eq!(tuning_for(dac).as_deref(), Some("Warm bass"));
        delete("Warm bass").unwrap();
        assert_eq!(tuning_for(dac), None);
        assert!(plays().is_empty());
    }

    /// A correction with a tuning baked in is the chain's correction. A stack
    /// made before a second correction was refused still plays, says so,
    /// and can be edited, but gains no other correction.
    #[test]
    fn a_baked_preset_is_the_correction() {
        use crate::config::{DspLayer, DspTarget};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let layer = |p: &str, on: bool| DspLayer {
            profile: p.into(),
            on,
        };
        persist(|c| {
            let autoeq = || {
                Some(DspTarget {
                    made_for: "harman-in-ear-2019".into(),
                    chosen: None,
                })
            };
            c.dsp.profiles.push(DspProfile {
                name: "Cantor".into(),
                filters: vec![band(100.0)],
                target: autoeq(),
                ..Default::default()
            });
            c.dsp.profiles.push(DspProfile {
                name: "HD 600".into(),
                filters: vec![band(100.0)],
                target: autoeq(),
                ..Default::default()
            });
            for name in ["Performer 8S", "Warm"] {
                c.dsp.profiles.push(DspProfile {
                    name: name.into(),
                    filters: vec![band(200.0)],
                    ..Default::default()
                });
            }
            // As 0.59 allowed: two corrections in one stack.
            c.dsp.profiles.push(DspProfile {
                name: "Old".into(),
                layers: vec![layer("Cantor", true), layer("Performer 8S", true)],
                ..Default::default()
            });
        })
        .unwrap();
        // AutoEQ's measurement, kept beside Cantor as an install keeps it.
        let folder = super::dir("Cantor");
        std::fs::create_dir_all(&folder).unwrap();
        let mut csv = String::from("frequency,raw,target\n");
        for hz in super::super::targets::grid() {
            csv.push_str(&format!("{hz:.2},0.0,0.0\n"));
        }
        std::fs::write(super::super::targets::result_path(&folder), csv).unwrap();
        let cfg = Config::cached();
        let named = |n: &str| cfg.dsp.profiles.iter().find(|p| p.name == n).unwrap();
        assert_eq!(
            role(named("Cantor")),
            DspRole::Correction,
            "an AutoEQ install"
        );
        assert_eq!(role(named("Warm")), DspRole::Tuning, "anything else");
        assert_eq!(
            shown_role(named("Old"), &cfg.dsp.profiles),
            DspRole::Correction,
            "a stack is what it corrects with"
        );
        assert_eq!(corrects_twice(named("Old"), &cfg.dsp.profiles), None);

        set_role("Performer 8S", DspRole::Baked).unwrap();
        let d = detail("Old").unwrap();
        assert_eq!(
            d.corrects_twice.as_deref(),
            Some(
                "This EQ corrects twice: Cantor (AutoEQ) and Performer 8S (includes a tuning). Keep one."
            )
        );
        assert_eq!(
            d.layer_roles,
            vec![Some(DspRole::Correction), Some(DspRole::Baked)]
        );
        // It still plays, and can be edited towards one correction.
        let cfg = Config::cached();
        let old = cfg.dsp.profiles.iter().find(|p| p.name == "Old").unwrap();
        assert!(super::super::chain(old, &cfg.dsp.profiles, &mut Vec::new()).is_ok());
        set_layers(
            "Old",
            vec![layer("Cantor", true), layer("Performer 8S", false)],
        )
        .unwrap();
        let refused = set_layers(
            "Old",
            vec![
                layer("Cantor", true),
                layer("Performer 8S", false),
                layer("HD 600", true),
            ],
        )
        .unwrap_err();
        assert!(
            refused.starts_with("This EQ already plays the correction"),
            "{refused}"
        );

        // A baked preset is a stack's correction: another is refused.
        set_layers(
            "Desk",
            vec![layer("Performer 8S", true), layer("Warm", true)],
        )
        .unwrap();
        let s = summary("Desk").unwrap();
        assert_eq!(
            s.correction.as_deref(),
            Some("Performer 8S (correction + tuning in one)")
        );
        assert!(s.baked);
        assert_eq!(s.tunings, vec!["Warm".to_string()]);
        let refused = set_layers(
            "Desk",
            vec![
                layer("Performer 8S", true),
                layer("Warm", true),
                layer("Cantor", true),
            ],
        )
        .unwrap_err();
        assert_eq!(
            refused,
            "This EQ already plays the correction Performer 8S. Take that out first, or add Cantor to a device's tuning instead."
        );
    }

    /// An AutoEQ correction moved to another target is rebuilt from the
    /// measurement AutoEQ kept, rather than played as its bands and a step.
    #[test]
    fn autoeq_moved_to_another_target_is_rebuilt() {
        use crate::config::{DspFilter, DspTarget};
        let _guard = crate::config::tests::PERSIST_LOCK
            .lock()
            .unwrap_or_else(|e| e.into_inner());
        let dir = tempfile::tempdir().unwrap();
        config::set_config_dir(dir.path());
        let folder = super::dir("HD 650");
        std::fs::create_dir_all(&folder).unwrap();
        let mut csv = String::from("frequency,raw,target\n");
        for hz in super::super::targets::grid() {
            csv.push_str(&format!("{hz:.2},0.0,0.0\n"));
        }
        std::fs::write(super::super::targets::result_path(&folder), csv).unwrap();
        persist(|c| {
            c.dsp.profiles.push(DspProfile {
                name: "HD 650".into(),
                filters: vec![band(100.0), band(1000.0)],
                target: Some(DspTarget {
                    made_for: "harman-over-ear-2018".into(),
                    chosen: None,
                }),
                ..Default::default()
            })
        })
        .unwrap();
        let chain = || {
            let cfg = Config::cached();
            let p = cfg.dsp.profiles[0].clone();
            super::super::chain(&p, &cfg.dsp.profiles, &mut Vec::new()).unwrap()
        };
        assert_eq!(chain().len(), 2, "AutoEQ's bands, as made");
        choose_target("HD 650", Some("harman-over-ear-2018-without-bass")).unwrap();
        let rebuilt = chain();
        assert_eq!(rebuilt.len(), 1, "{rebuilt:?}");
        assert!(matches!(rebuilt[0], DspFilter::Graphic(_)));
        assert!(
            summary("HD 650")
                .unwrap()
                .correction
                .unwrap()
                .contains("rebuilt from AutoEQ's measurement")
        );
    }

    #[test]
    fn previews_never_push_out_the_playing_fit() {
        use super::super::targets;
        let measured = read_measurement(&measured(6.0)).unwrap();
        let aim = targets::choice_curve("harman-in-ear-2019").unwrap();
        let fit = for_playing(|| squig_fit(&measured, &aim));
        let key = fit_key(&measured, &aim);
        let kept = |key| FITS.lock().playing.entries.iter().any(|(k, _)| *k == key);
        assert!(kept(key));
        for preview in 0..100u64 {
            FITS.lock().keep(preview ^ 0x5eed, fit.clone(), false);
        }
        assert!(kept(key), "the playing fit is still kept");
        assert_eq!(squig_fit(&measured, &aim), fit);
        assert!(
            kept(key),
            "used again by a page, it stays with the player's"
        );
    }

    #[test]
    fn a_full_lru_lets_go_of_the_least_recently_used_alone() {
        let fit = (Vec::new(), 0.0);
        let mut lru = Lru::new(3);
        for k in 0..3 {
            lru.put(k, fit.clone());
        }
        let used = lru.take(0).unwrap();
        lru.put(0, used);
        lru.put(3, fit);
        let keys: Vec<_> = lru.entries.iter().map(|(k, _)| *k).collect();
        assert_eq!(keys, [2, 0, 3]);
    }
}