Phoenix/src/state.rs

use std::{
    collections::HashMap,
    sync::{
        atomic::{AtomicU64, Ordering},
        Arc, Mutex,
    },
};

use anyhow::{anyhow, Context};
use tokio::{
    fs,
    sync::{broadcast, RwLock},
};

use crate::{
    audio::{spawn_audio_capture_worker, AudioWorkerDeps},
    config::PhoenixConfig,
    model::{
        InputSource, MeterFrame, PhoenixGlobalConfig, PhoenixGlobalConfigEnvelope,
        PhoenixRtaConfig, ServiceStatus,
    },
};

#[derive(Clone)]
pub struct AppState {
    pub config: PhoenixConfig,
    current_input: Arc<RwLock<InputSource>>,
    seq: Arc<AtomicU64>,
    actual_sample_rate: Arc<AtomicU64>,
    metrics_tx: broadcast::Sender<Arc<MeterFrame>>,
    restart_token: Arc<AtomicU64>,
    rta_config: Arc<RwLock<PhoenixRtaConfig>>,
    global_config: Arc<RwLock<PhoenixGlobalConfig>>,
    global_config_rev: Arc<AtomicU64>,
    native_wav_recorders: Arc<Mutex<HashMap<u64, NativeWavRecorder>>>,
}

#[derive(Clone)]
pub struct NativeWavCapture {
    pub sample_rate: u32,
    pub channels: u16,
    pub pcm_bytes: Vec<u8>,
}

pub(crate) struct NativeWavRecorder {
    pub sample_rate: u32,
    pub channels: u16,
    pub pcm_bytes: Vec<u8>,
    pub total_frames: usize,
    pub last_l: i16,
    pub last_r: i16,
    pub pending_discontinuity: bool,
}

const NATIVE_RECORDING_EDGE_FADE_FRAMES: usize = 128;

fn apply_native_recording_edge_fades(pcm_bytes: &mut [u8], channels: u16) {
    let ch = usize::from(channels.max(1));
    let frame_size = ch.saturating_mul(2);
    if frame_size == 0 || pcm_bytes.len() < frame_size * 2 {
        return;
    }
    let total_frames = pcm_bytes.len() / frame_size;
    if total_frames < 2 {
        return;
    }
    let fade_frames = NATIVE_RECORDING_EDGE_FADE_FRAMES
        .min(total_frames / 2)
        .max(1);

    for frame_idx in 0..fade_frames {
        let in_gain = (frame_idx as f32 + 1.0) / fade_frames as f32;
        let out_gain = (fade_frames as f32 - frame_idx as f32) / fade_frames as f32;
        let out_frame_idx = total_frames - fade_frames + frame_idx;
        for ch_idx in 0..ch {
            let in_off = frame_idx * frame_size + ch_idx * 2;
            let in_sample = i16::from_le_bytes([pcm_bytes[in_off], pcm_bytes[in_off + 1]]);
            let in_scaled = (in_sample as f32 * in_gain)
                .round()
                .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
            pcm_bytes[in_off..in_off + 2].copy_from_slice(&in_scaled.to_le_bytes());

            let out_off = out_frame_idx * frame_size + ch_idx * 2;
            let out_sample = i16::from_le_bytes([pcm_bytes[out_off], pcm_bytes[out_off + 1]]);
            let out_scaled = (out_sample as f32 * out_gain)
                .round()
                .clamp(i16::MIN as f32, i16::MAX as f32) as i16;
            pcm_bytes[out_off..out_off + 2].copy_from_slice(&out_scaled.to_le_bytes());
        }
    }
}

impl AppState {
    pub fn new(config: PhoenixConfig) -> Self {
        // WebSocket consumers always drain to the newest state. A small
        // channel bounds memory and prevents seconds of stale measurements.
        let (metrics_tx, _) = broadcast::channel(32);
        let initial_global_config = load_global_config(&config);
        let initial_rta_config =
            apply_global_to_rta(config.default_rta_config(), &initial_global_config);
        let configured_sample_rate = config.sample_rate;
        Self {
            config,
            current_input: Arc::new(RwLock::new(InputSource::Line)),
            seq: Arc::new(AtomicU64::new(0)),
            actual_sample_rate: Arc::new(AtomicU64::new(configured_sample_rate as u64)),
            metrics_tx,
            restart_token: Arc::new(AtomicU64::new(0)),
            rta_config: Arc::new(RwLock::new(initial_rta_config)),
            global_config: Arc::new(RwLock::new(initial_global_config)),
            global_config_rev: Arc::new(AtomicU64::new(1)),
            native_wav_recorders: Arc::new(Mutex::new(HashMap::new())),
        }
    }

    pub fn subscribe_metrics(&self) -> broadcast::Receiver<Arc<MeterFrame>> {
        self.metrics_tx.subscribe()
    }

    pub async fn input(&self) -> InputSource {
        *self.current_input.read().await
    }

    pub async fn status(&self) -> ServiceStatus {
        ServiceStatus {
            ok: true,
            input: self.input().await,
            audio_engine: "alsa-direct",
            metrics_mode: "live",
            alsa_device: self.config.alsa_device(),
            sample_rate: self
                .actual_sample_rate
                .load(Ordering::SeqCst)
                .min(u32::MAX as u64) as u32,
        }
    }

    pub async fn rta_config(&self) -> PhoenixRtaConfig {
        self.rta_config.read().await.clone()
    }

    pub async fn set_rta_config(&self, config: PhoenixRtaConfig) -> PhoenixRtaConfig {
        let normalized = normalize_rta_config(config);
        *self.rta_config.write().await = normalized.clone();
        let current = self.global_config.read().await.clone();
        let updated_global = PhoenixGlobalConfig {
            fft_size: normalized.fft_size,
            input_source: current.input_source,
            rta_bpo_mode: current.rta_bpo_mode.clone(),
            input_offset_db_l: normalized.input_offset_db_l,
            input_offset_db_r: normalized.input_offset_db_r,
            mono_input: normalized.mono_input,
            lr_fractional_delay_enabled: normalized.lr_fractional_delay_enabled,
            lr_fractional_delay_samples: normalized.lr_fractional_delay_samples,
            al_markers_enabled: current.al_markers_enabled,
            meter_bar_thin: current.meter_bar_thin,
            panel_dividers_enabled: current.panel_dividers_enabled,
            ppm_din_attack_ms: normalized.ppm_din_attack_ms,
            ppm_din_decay_db_per_s: normalized.ppm_din_decay_db_per_s,
            ppm_din_fast_attack: normalized.ppm_din_fast_attack,
            ppm_ebu_attack_ms: normalized.ppm_ebu_attack_ms,
            ppm_ebu_decay_db_per_s: normalized.ppm_ebu_decay_db_per_s,
            lufs_i_window_min: normalized.lufs_i_window_min,
            lufs_i_norm_enabled: normalized.lufs_i_norm_enabled,
            ppm_din_loudness_boxes: current.ppm_din_loudness_boxes,
            ppm_din_loudness_offset_db: current.ppm_din_loudness_offset_db,
            xy_points: normalized.xy_points,
            gonio_display_gain_db: current.gonio_display_gain_db,
            record_output_format: current.record_output_format.clone(),
            record_mp3_bitrate_kbps: current.record_mp3_bitrate_kbps,
            record_target: current.record_target.clone(),
            record_auto_split_gap_sec: current.record_auto_split_gap_sec,
            record_auto_threshold_dbfs: current.record_auto_threshold_dbfs,
            clock_led_color: current.clock_led_color.clone(),
            header_text_color: current.header_text_color.clone(),
            rta_bar_base_color: current.rta_bar_base_color.clone(),
            spectro_gamma: current.spectro_gamma,
            spectro_scroll_mode: current.spectro_scroll_mode,
            peak_history_scroll_mode: current.peak_history_scroll_mode,
            peak_history_fill_enabled: current.peak_history_fill_enabled,
            peak_history_fill_invert: current.peak_history_fill_invert,
            peak_history_slot: current.peak_history_slot.clone(),
            phase_display_gain_db: current.phase_display_gain_db,
            phase_agc_enabled: current.phase_agc_enabled,
            phase_trail_enabled: current.phase_trail_enabled,
            phase_amplitude_mode: current.phase_amplitude_mode.clone(),
            classic_needles_slot: current.classic_needles_slot.clone(),
            waveform_color_left: current.waveform_color_left.clone(),
            waveform_color_right: current.waveform_color_right.clone(),
            waveform_color_diff: current.waveform_color_diff.clone(),
            vu_color_normal: current.vu_color_normal.clone(),
            vu_color_warn: current.vu_color_warn.clone(),
            ppm_din_color_normal: current.ppm_din_color_normal.clone(),
            ppm_din_color_warn: current.ppm_din_color_warn.clone(),
            ppm_ebu_color_normal: current.ppm_ebu_color_normal.clone(),
            ppm_ebu_color_warn: current.ppm_ebu_color_warn.clone(),
            tp_color_normal: current.tp_color_normal.clone(),
            tp_color_warn: current.tp_color_warn.clone(),
            rms_color_normal: current.rms_color_normal.clone(),
            rms_color_warn: current.rms_color_warn.clone(),
            lufs_color_i: current.lufs_color_i.clone(),
            lufs_color_m: current.lufs_color_m.clone(),
            lufs_color_s: current.lufs_color_s.clone(),
            lufs_scale_label_color: current.lufs_scale_label_color.clone(),
            screensaver_enabled: current.screensaver_enabled,
            screensaver_idle_min: current.screensaver_idle_min,
            screensaver_activity_db: current.screensaver_activity_db,
            screensaver_mode: current.screensaver_mode.clone(),
            screensaver_led_glow: current.screensaver_led_glow,
            screensaver_led_color: current.screensaver_led_color.clone(),
        };
        if current != updated_global {
            *self.global_config.write().await = updated_global.clone();
            let _ = persist_global_config(&self.config, &updated_global).await;
            self.global_config_rev.fetch_add(1, Ordering::SeqCst);
        }
        normalized
    }

    pub async fn global_config(&self) -> PhoenixGlobalConfig {
        self.global_config.read().await.clone()
    }

    pub fn global_config_revision(&self) -> u64 {
        self.global_config_rev.load(Ordering::SeqCst)
    }

    pub async fn global_config_envelope(&self) -> PhoenixGlobalConfigEnvelope {
        PhoenixGlobalConfigEnvelope {
            revision: self.global_config_revision(),
            config: self.global_config().await,
        }
    }

    pub async fn set_global_config(
        &self,
        payload: PhoenixGlobalConfig,
    ) -> anyhow::Result<PhoenixGlobalConfigEnvelope> {
        let normalized = normalize_global_config(payload, &self.config);
        let current_global = self.global_config.read().await.clone();
        if current_global == normalized {
            return Ok(PhoenixGlobalConfigEnvelope {
                revision: self.global_config_revision(),
                config: current_global,
            });
        }
        let merged_rta = {
            let current = self.rta_config.read().await.clone();
            apply_global_to_rta(current, &normalized)
        };
        *self.global_config.write().await = normalized.clone();
        *self.rta_config.write().await = merged_rta;
        persist_global_config(&self.config, &normalized).await?;
        let revision = self.global_config_rev.fetch_add(1, Ordering::SeqCst) + 1;
        Ok(PhoenixGlobalConfigEnvelope {
            revision,
            config: normalized,
        })
    }

    pub fn spawn_audio_capture(&self) {
        spawn_audio_capture_worker(AudioWorkerDeps {
            config: self.config.clone(),
            input: self.current_input.clone(),
            rta_config: self.rta_config.clone(),
            global_config_rev: self.global_config_rev.clone(),
            native_wav_recorders: self.native_wav_recorders.clone(),
            seq: self.seq.clone(),
            actual_sample_rate: self.actual_sample_rate.clone(),
            metrics_tx: self.metrics_tx.clone(),
            restart_token: self.restart_token.clone(),
        });
    }

    pub fn start_native_wav_recording(&self, session_id: u64) -> anyhow::Result<()> {
        if session_id == 0 {
            return Err(anyhow!("invalid recording session"));
        }
        let mut guard = self
            .native_wav_recorders
            .lock()
            .map_err(|_| anyhow!("native recorder lock poisoned"))?;
        guard.insert(
            session_id,
            NativeWavRecorder {
                sample_rate: self
                    .actual_sample_rate
                    .load(Ordering::SeqCst)
                    .min(u32::MAX as u64) as u32,
                channels: 2,
                pcm_bytes: Vec::new(),
                total_frames: 0,
                last_l: 0,
                last_r: 0,
                pending_discontinuity: false,
            },
        );
        Ok(())
    }

    pub fn stop_native_wav_recording(&self, session_id: u64) -> anyhow::Result<NativeWavCapture> {
        let mut guard = self
            .native_wav_recorders
            .lock()
            .map_err(|_| anyhow!("native recorder lock poisoned"))?;
        let Some(capture) = guard.remove(&session_id) else {
            return Err(anyhow!("recording session not found"));
        };
        let mut pcm_bytes = capture.pcm_bytes;
        apply_native_recording_edge_fades(&mut pcm_bytes, capture.channels);
        Ok(NativeWavCapture {
            sample_rate: capture.sample_rate,
            channels: capture.channels,
            pcm_bytes,
        })
    }
}

fn normalize_rta_config(mut config: PhoenixRtaConfig) -> PhoenixRtaConfig {
    config.engine = match config.engine.trim().to_ascii_lowercase().as_str() {
        "fft" => "fft".to_string(),
        _ => "iir".to_string(),
    };
    config.filterbank = match config.filterbank.trim().to_ascii_lowercase().as_str() {
        "butterworth" | "butter" => "butterworth".to_string(),
        _ => "legacy".to_string(),
    };
    config.fft_size = match config.fft_size {
        2048 | 4096 | 8192 | 16384 => config.fft_size,
        n if n < 3072 => 2048,
        n if n < 6144 => 4096,
        n if n < 12288 => 8192,
        _ => 16384,
    };
    config.mono_input = !!config.mono_input;
    config.lr_fractional_delay_enabled = !!config.lr_fractional_delay_enabled;
    let lr_delay = if config.lr_fractional_delay_samples.is_finite() {
        config.lr_fractional_delay_samples
    } else {
        0.05
    };
    config.lr_fractional_delay_samples = lr_delay.clamp(-1.5, 1.5);
    config.bpo = match config.bpo.trim().replace('/', "_").as_str() {
        "1_3" => "1_3".to_string(),
        "1_12" => "1_12".to_string(),
        _ => "1_6".to_string(),
    };
    config.freq_range = match config.freq_range.trim().to_ascii_lowercase().as_str() {
        "lf" => "lf".to_string(),
        _ => "norm".to_string(),
    };
    config.weighting = match config.weighting.trim().to_ascii_lowercase().as_str() {
        "a" => "a".to_string(),
        "c" => "c".to_string(),
        _ => "z".to_string(),
    };
    config.layout = match config.layout.trim().to_ascii_lowercase().as_str() {
        "iec" => "iec".to_string(),
        _ => "rtw".to_string(),
    };
    config.integration = match config.integration.trim().to_ascii_lowercase().as_str() {
        "impulse" => "impulse".to_string(),
        "medium" => "medium".to_string(),
        "slow" => "slow".to_string(),
        "average" => "average".to_string(),
        "peak" => "peak".to_string(),
        _ => "fast".to_string(),
    };
    config.order = config.order.clamp(2, 8);
    if config.order % 2 != 0 {
        config.order = (config.order + 1).min(8);
    }
    if config.layout == "rtw" {
        config.engine = "iir".to_string();
        config.order = 6;
        config.freq_range = "norm".to_string();
    }

    let tau_fast = if config.tau_fast.is_finite() {
        config.tau_fast
    } else {
        0.12
    };
    let tau_slow = if config.tau_slow.is_finite() {
        config.tau_slow
    } else {
        1.0
    };
    config.tau_fast = tau_fast.clamp(0.01, 3.0);
    config.tau_slow = tau_slow.clamp(0.05, 10.0);
    if config.tau_slow < config.tau_fast {
        config.tau_slow = config.tau_fast;
    }
    let offset_l = if config.input_offset_db_l.is_finite() {
        config.input_offset_db_l
    } else {
        -5.0
    };
    let offset_r = if config.input_offset_db_r.is_finite() {
        config.input_offset_db_r
    } else {
        -5.0
    };
    config.input_offset_db_l = offset_l.clamp(-60.0, 20.0);
    config.input_offset_db_r = offset_r.clamp(-60.0, 20.0);
    // Standard profiles are fixed. Keeping the serialized fields preserves
    // compatibility with older clients without allowing silent mistuning.
    config.ppm_din_attack_ms = 10.0;
    config.ppm_din_decay_db_per_s = 20.0 / 1.5;
    config.ppm_din_fast_attack = !!config.ppm_din_fast_attack;
    config.ppm_ebu_attack_ms = 10.0;
    config.ppm_ebu_decay_db_per_s = 24.0 / 2.8;
    config.lufs_i_window_min = config.lufs_i_window_min.clamp(1, 10);
    config.lufs_i_norm_enabled = !!config.lufs_i_norm_enabled;
    config.correlation_response_s =
        crate::correlation::normalize_response_seconds(config.correlation_response_s);
    config.xy_points = match config.xy_points {
        128 | 256 | 512 | 1024 | 2048 => config.xy_points,
        n if n < 192 => 128,
        n if n < 384 => 256,
        n if n < 768 => 512,
        n if n < 1536 => 1024,
        _ => 2048,
    };
    config
}

fn normalize_ui_color(input: String, fallback: &str) -> String {
    let trimmed = input.trim();
    if trimmed.is_empty() {
        fallback.to_string()
    } else {
        trimmed.to_string()
    }
}

fn normalize_meter_slot(input: String, fallback: &str) -> String {
    match input.trim().to_ascii_lowercase().as_str() {
        "vu" => "vu".to_string(),
        "ppm-ebu" | "ppm_ebu" | "ppm" => "ppm-ebu".to_string(),
        "ppm-din" | "ppm_din" => "ppm-din".to_string(),
        "tp" => "tp".to_string(),
        "hifi-peak" | "hifi_peak" => "hifi-peak".to_string(),
        "rms" => "rms".to_string(),
        "lufs" => "lufs".to_string(),
        "stopwatch" => "stopwatch".to_string(),
        _ => fallback.to_string(),
    }
}

fn normalize_global_config(
    mut config: PhoenixGlobalConfig,
    runtime: &PhoenixConfig,
) -> PhoenixGlobalConfig {
    config.fft_size = match config.fft_size {
        2048 | 4096 | 8192 | 16384 => config.fft_size,
        n if n < 3072 => 2048,
        n if n < 6144 => 4096,
        n if n < 12288 => 8192,
        _ => 16384,
    };
    config.input_source = InputSource::Line;
    config.rta_bpo_mode = match config.rta_bpo_mode.trim().replace('/', "_").as_str() {
        "1_3" => "1_3".to_string(),
        "1_12" => "1_12".to_string(),
        _ => "1_6".to_string(),
    };
    let offset_l = if config.input_offset_db_l.is_finite() {
        config.input_offset_db_l
    } else {
        -5.0
    };
    let offset_r = if config.input_offset_db_r.is_finite() {
        config.input_offset_db_r
    } else {
        -5.0
    };
    config.input_offset_db_l = offset_l.clamp(-10.0, 10.0);
    config.input_offset_db_r = offset_r.clamp(-10.0, 10.0);
    config.mono_input = !!config.mono_input;
    config.lr_fractional_delay_enabled = !!config.lr_fractional_delay_enabled;
    let delay = if config.lr_fractional_delay_samples.is_finite() {
        config.lr_fractional_delay_samples
    } else {
        runtime.lr_fractional_delay_samples
    };
    config.lr_fractional_delay_samples = delay.clamp(-1.5, 1.5);
    config.al_markers_enabled = !!config.al_markers_enabled;
    let thin = if config.meter_bar_thin.is_finite() {
        config.meter_bar_thin
    } else {
        0.55
    };
    config.meter_bar_thin = thin.clamp(0.35, 0.9);
    config.panel_dividers_enabled = !!config.panel_dividers_enabled;
    config.ppm_din_attack_ms = 10.0;
    config.ppm_din_decay_db_per_s = 20.0 / 1.5;
    config.ppm_din_fast_attack = !!config.ppm_din_fast_attack;
    config.ppm_ebu_attack_ms = 10.0;
    config.ppm_ebu_decay_db_per_s = 24.0 / 2.8;
    config.lufs_i_window_min = config.lufs_i_window_min.clamp(1, 10);
    config.lufs_i_norm_enabled = !!config.lufs_i_norm_enabled;
    config.ppm_din_loudness_boxes = !!config.ppm_din_loudness_boxes;
    let loudness_offset = if config.ppm_din_loudness_offset_db.is_finite() {
        config.ppm_din_loudness_offset_db
    } else {
        0.0
    };
    config.ppm_din_loudness_offset_db = loudness_offset.clamp(-7.0, 7.0);
    config.xy_points = match config.xy_points {
        128 | 256 | 512 | 1024 | 2048 => config.xy_points,
        n if n < 192 => 128,
        n if n < 384 => 256,
        n if n < 768 => 512,
        n if n < 1536 => 1024,
        _ => 2048,
    };
    let gonio_gain = if config.gonio_display_gain_db.is_finite() {
        config.gonio_display_gain_db
    } else {
        -5.0
    };
    config.gonio_display_gain_db = gonio_gain.clamp(-35.0, 35.0);
    config.record_output_format = match config
        .record_output_format
        .trim()
        .to_ascii_lowercase()
        .as_str()
    {
        "mp3" => "mp3".to_string(),
        "webm" => "webm".to_string(),
        _ => "wav".to_string(),
    };
    config.record_mp3_bitrate_kbps = match config.record_mp3_bitrate_kbps {
        64 | 128 | 192 | 256 | 320 => config.record_mp3_bitrate_kbps,
        n if n < 96 => 64,
        n if n < 160 => 128,
        n if n < 224 => 192,
        n if n < 288 => 256,
        _ => 320,
    };
    config.record_target = match config.record_target.trim().to_ascii_lowercase().as_str() {
        "volumio" => "volumio".to_string(),
        _ => "analyzer".to_string(),
    };
    let auto_gap = if config.record_auto_split_gap_sec.is_finite() {
        config.record_auto_split_gap_sec
    } else {
        1.5
    };
    config.record_auto_split_gap_sec = (auto_gap.clamp(0.5, 3.0) * 2.0).round() / 2.0;
    let auto_threshold = if config.record_auto_threshold_dbfs.is_finite() {
        config.record_auto_threshold_dbfs
    } else {
        -50.0
    };
    config.record_auto_threshold_dbfs = auto_threshold.clamp(-120.0, 20.0);
    config.clock_led_color = normalize_ui_color(config.clock_led_color, "#ff0000");
    config.header_text_color = normalize_ui_color(config.header_text_color, "#ffe066");
    config.rta_bar_base_color = normalize_ui_color(config.rta_bar_base_color, "#ffe066");
    config.spectro_gamma = if config.spectro_gamma.is_finite() {
        config.spectro_gamma.clamp(0.3, 1.2)
    } else {
        0.9
    };
    config.spectro_scroll_mode = match config.spectro_scroll_mode {
        x if !x.is_finite() => 1.0,
        x if (x - 0.5).abs() < f32::EPSILON => 0.5,
        x if (x - 1.0).abs() < f32::EPSILON => 1.0,
        x if (x - 2.0).abs() < f32::EPSILON => 2.0,
        x if (x - 4.0).abs() < f32::EPSILON => 4.0,
        x if (x - 6.0).abs() < f32::EPSILON => 6.0,
        x if x < 0.75 => 0.5,
        x if x < 1.5 => 1.0,
        x if x < 3.0 => 2.0,
        x if x < 5.0 => 4.0,
        _ => 6.0,
    };
    config.peak_history_scroll_mode = match config.peak_history_scroll_mode {
        x if !x.is_finite() => 1.0,
        x if (x - 0.5).abs() < f32::EPSILON => 0.5,
        x if (x - 1.0).abs() < f32::EPSILON => 1.0,
        x if (x - 2.0).abs() < f32::EPSILON => 2.0,
        x if (x - 4.0).abs() < f32::EPSILON => 4.0,
        x if (x - 6.0).abs() < f32::EPSILON => 6.0,
        x if x < 0.75 => 0.5,
        x if x < 1.5 => 1.0,
        x if x < 3.0 => 2.0,
        x if x < 5.0 => 4.0,
        _ => 6.0,
    };
    config.peak_history_fill_enabled = !!config.peak_history_fill_enabled;
    config.peak_history_fill_invert = !!config.peak_history_fill_invert;
    config.peak_history_slot = normalize_meter_slot(config.peak_history_slot, "ppm-din");
    let phase_gain = if config.phase_display_gain_db.is_finite() {
        config.phase_display_gain_db
    } else {
        0.0
    };
    config.phase_display_gain_db = (phase_gain.clamp(-35.0, 35.0) / 5.0).round() * 5.0;
    config.phase_amplitude_mode = match config
        .phase_amplitude_mode
        .trim()
        .to_ascii_lowercase()
        .as_str()
    {
        "ppm-din" => "ppm-din".to_string(),
        _ => "bandpass".to_string(),
    };
    config.phase_agc_enabled = if config.phase_amplitude_mode == "ppm-din" {
        false
    } else {
        !!config.phase_agc_enabled
    };
    config.phase_trail_enabled = !!config.phase_trail_enabled;
    config.classic_needles_slot = normalize_meter_slot(config.classic_needles_slot, "vu");
    config.waveform_color_left = normalize_ui_color(config.waveform_color_left, "#00e7ff");
    config.waveform_color_right = normalize_ui_color(config.waveform_color_right, "#ff6b81");
    config.waveform_color_diff = normalize_ui_color(config.waveform_color_diff, "#00e7ff");
    config.vu_color_normal = normalize_ui_color(config.vu_color_normal, "#ffe066");
    config.vu_color_warn = normalize_ui_color(config.vu_color_warn, "#ff3b3b");
    config.ppm_din_color_normal = normalize_ui_color(config.ppm_din_color_normal, "#ffe066");
    config.ppm_din_color_warn = normalize_ui_color(config.ppm_din_color_warn, "#ff3b3b");
    config.ppm_ebu_color_normal = normalize_ui_color(config.ppm_ebu_color_normal, "#ffe066");
    config.ppm_ebu_color_warn = normalize_ui_color(config.ppm_ebu_color_warn, "#ff3b3b");
    config.tp_color_normal = normalize_ui_color(config.tp_color_normal, "#ffe066");
    config.tp_color_warn = normalize_ui_color(config.tp_color_warn, "#ff3b3b");
    config.rms_color_normal = normalize_ui_color(config.rms_color_normal, "#34d399");
    config.rms_color_warn = normalize_ui_color(config.rms_color_warn, "#ff3b3b");
    config.lufs_color_i = normalize_ui_color(config.lufs_color_i, "#34d399");
    config.lufs_color_m = normalize_ui_color(config.lufs_color_m, "#ffe066");
    config.lufs_color_s = normalize_ui_color(config.lufs_color_s, "#ff3b3b");
    config.lufs_scale_label_color = normalize_ui_color(config.lufs_scale_label_color, "#8fd3d4");
    config.screensaver_enabled = !!config.screensaver_enabled;
    let idle = if config.screensaver_idle_min.is_finite() {
        config.screensaver_idle_min
    } else {
        5.0
    };
    config.screensaver_idle_min = idle.clamp(0.0, 120.0);
    let activity = if config.screensaver_activity_db.is_finite() {
        config.screensaver_activity_db
    } else {
        -50.0
    };
    config.screensaver_activity_db = activity.clamp(-120.0, 0.0);
    config.screensaver_mode = match config.screensaver_mode.trim().to_ascii_lowercase().as_str() {
        "starfield" => "starfield".to_string(),
        "black" => "black".to_string(),
        "dvd" => "dvd".to_string(),
        _ => "clock".to_string(),
    };
    config.screensaver_led_glow = !!config.screensaver_led_glow;
    let color = config.screensaver_led_color.trim();
    config.screensaver_led_color = if color.is_empty() {
        "#ff0000".to_string()
    } else {
        color.to_string()
    };
    config
}

fn apply_global_to_rta(
    mut config: PhoenixRtaConfig,
    global: &PhoenixGlobalConfig,
) -> PhoenixRtaConfig {
    config.fft_size = global.fft_size;
    config.bpo = global.rta_bpo_mode.clone();
    config.input_offset_db_l = global.input_offset_db_l;
    config.input_offset_db_r = global.input_offset_db_r;
    config.mono_input = global.mono_input;
    config.lr_fractional_delay_enabled = global.lr_fractional_delay_enabled;
    config.lr_fractional_delay_samples = global.lr_fractional_delay_samples;
    config.ppm_din_attack_ms = global.ppm_din_attack_ms;
    config.ppm_din_decay_db_per_s = global.ppm_din_decay_db_per_s;
    config.ppm_din_fast_attack = global.ppm_din_fast_attack;
    config.ppm_ebu_attack_ms = global.ppm_ebu_attack_ms;
    config.ppm_ebu_decay_db_per_s = global.ppm_ebu_decay_db_per_s;
    config.lufs_i_window_min = global.lufs_i_window_min;
    config.lufs_i_norm_enabled = global.lufs_i_norm_enabled;
    config.xy_points = global.xy_points;
    normalize_rta_config(config)
}

fn load_global_config(runtime: &PhoenixConfig) -> PhoenixGlobalConfig {
    let fallback = normalize_global_config(runtime.default_global_config(), runtime);
    let Ok(raw) = std::fs::read_to_string(&runtime.global_config_path) else {
        return fallback;
    };
    let Ok(parsed) = serde_json::from_str::<PhoenixGlobalConfig>(&raw) else {
        return fallback;
    };
    normalize_global_config(parsed, runtime)
}

async fn persist_global_config(
    runtime: &PhoenixConfig,
    config: &PhoenixGlobalConfig,
) -> anyhow::Result<()> {
    let path = runtime.global_config_path.clone();
    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent)
            .await
            .with_context(|| format!("failed to create Phoenix config dir {}", parent.display()))?;
    }
    let json = serde_json::to_vec_pretty(config)?;
    fs::write(&path, json)
        .await
        .with_context(|| format!("failed to write Phoenix config {}", path.display()))?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn rtw_profile_is_iir_and_retains_selected_resolution() {
        let config = normalize_rta_config(PhoenixRtaConfig {
            engine: "fft".to_string(),
            bpo: "1_12".to_string(),
            order: 2,
            freq_range: "lf".to_string(),
            layout: "rtw".to_string(),
            ..PhoenixRtaConfig::default()
        });
        assert_eq!(config.engine, "iir");
        assert_eq!(config.filterbank, "legacy");
        assert_eq!(config.bpo, "1_12");
        assert_eq!(config.order, 6);
        assert_eq!(config.freq_range, "norm");
    }

    #[test]
    fn phoenix_profile_retains_explicit_extensions() {
        let config = normalize_rta_config(PhoenixRtaConfig {
            engine: "fft".to_string(),
            filterbank: "butterworth".to_string(),
            bpo: "1_12".to_string(),
            order: 8,
            freq_range: "lf".to_string(),
            layout: "iec".to_string(),
            integration: "medium".to_string(),
            ..PhoenixRtaConfig::default()
        });
        assert_eq!(config.engine, "fft");
        assert_eq!(config.filterbank, "butterworth");
        assert_eq!(config.bpo, "1_12");
        assert_eq!(config.order, 8);
        assert_eq!(config.freq_range, "lf");
        assert_eq!(config.integration, "medium");
    }

    #[test]
    fn non_third_octave_global_selection_retains_rtw_profile() {
        let mut global = PhoenixGlobalConfig::default();
        global.rta_bpo_mode = "1_12".to_string();
        let config = apply_global_to_rta(PhoenixRtaConfig::default(), &global);
        assert_eq!(config.layout, "rtw");
        assert_eq!(config.bpo, "1_12");
        assert_eq!(config.engine, "iir");
    }
}