use std::path::PathBuf;
use std::sync::{Arc, Mutex};

use anyhow::{Context, Result};
use chrono::Utc;
use lesavka_common::lesavka::{
    CalibrationAction, CalibrationRequest, CalibrationState as ProtoCalibrationState,
};

use crate::upstream_media_runtime::UpstreamMediaRuntime;

pub const FACTORY_MJPEG_AUDIO_OFFSET_US: i64 = 0;
// Direct UVC/UAC output-delay probes against the lab RC target put the
// server-to-target sync center near 170ms for MJPEG/UVC video. This is an
// output-path compensation, not a freshness buffer.
pub const FACTORY_MJPEG_VIDEO_OFFSET_US: i64 = 170_000;
const LEGACY_FACTORY_MJPEG_AUDIO_OFFSET_US: i64 = -45_000;
const PREVIOUS_FACTORY_MJPEG_AUDIO_OFFSET_US: i64 = 720_000;
const PREVIOUS_TUNED_MJPEG_AUDIO_OFFSET_US: i64 = 1_260_000;
const PREVIOUS_FACTORY_MJPEG_VIDEO_OFFSET_US: i64 = 0;
const PREVIOUS_DELAYED_FACTORY_MJPEG_VIDEO_OFFSET_US: i64 = 350_000;
const PREVIOUS_BROWSER_FACTORY_MJPEG_VIDEO_OFFSET_US: i64 = 130_000;
const PREVIOUS_OVERSHOT_FACTORY_MJPEG_VIDEO_OFFSET_US: i64 = 1_090_000;
const PROFILE: &str = "mjpeg";
const FACTORY_CONFIDENCE: &str = "factory";
const PREVIOUS_OFFSET_LIMIT_US: i64 = 500_000;
const OFFSET_LIMIT_US: i64 = 1_500_000;

#[derive(Debug, Clone, PartialEq, Eq)]
struct CalibrationSnapshot {
    profile: String,
    factory_audio_offset_us: i64,
    factory_video_offset_us: i64,
    default_audio_offset_us: i64,
    default_video_offset_us: i64,
    active_audio_offset_us: i64,
    active_video_offset_us: i64,
    source: String,
    confidence: String,
    updated_at: String,
    detail: String,
}

#[derive(Debug)]
pub struct CalibrationStore {
    path: PathBuf,
    runtime: Arc<UpstreamMediaRuntime>,
    state: Mutex<CalibrationSnapshot>,
}

impl CalibrationStore {
    pub fn load(runtime: Arc<UpstreamMediaRuntime>) -> Self {
        let path = calibration_path();
        let state = std::fs::read_to_string(&path)
            .ok()
            .map(|raw| migrate_legacy_snapshot(parse_snapshot(&raw)))
            .unwrap_or_else(snapshot_from_env);
        runtime.set_playout_offsets(state.active_video_offset_us, state.active_audio_offset_us);
        Self {
            path,
            runtime,
            state: Mutex::new(state),
        }
    }

    pub fn current(&self) -> ProtoCalibrationState {
        self.state
            .lock()
            .expect("calibration mutex poisoned")
            .to_proto()
    }

    pub fn apply(&self, request: CalibrationRequest) -> Result<ProtoCalibrationState> {
        let mut state = self.state.lock().expect("calibration mutex poisoned");
        let action =
            CalibrationAction::try_from(request.action).unwrap_or(CalibrationAction::Unspecified);
        match action {
            CalibrationAction::Unspecified => {}
            CalibrationAction::RestoreDefault => {
                state.active_audio_offset_us = state.default_audio_offset_us;
                state.active_video_offset_us = state.default_video_offset_us;
                state.source = "default".to_string();
                state.confidence = "saved-default".to_string();
                state.detail = "restored saved upstream A/V calibration".to_string();
                touch(&mut state);
            }
            CalibrationAction::RestoreFactory => {
                state.active_audio_offset_us = state.factory_audio_offset_us;
                state.active_video_offset_us = state.factory_video_offset_us;
                state.source = "factory".to_string();
                state.confidence = FACTORY_CONFIDENCE.to_string();
                state.detail = "restored release-shipped MJPEG upstream calibration".to_string();
                touch(&mut state);
            }
            CalibrationAction::AdjustActive => {
                state.active_audio_offset_us = clamp_offset(
                    state
                        .active_audio_offset_us
                        .saturating_add(request.audio_delta_us),
                );
                state.active_video_offset_us = clamp_offset(
                    state
                        .active_video_offset_us
                        .saturating_add(request.video_delta_us),
                );
                state.source = "manual".to_string();
                state.confidence = "manual".to_string();
                state.detail = format!(
                    "manual upstream A/V calibration nudge: audio {:+.1}ms, video {:+.1}ms",
                    request.audio_delta_us as f64 / 1000.0,
                    request.video_delta_us as f64 / 1000.0
                );
                touch(&mut state);
            }
            CalibrationAction::BlindEstimate => {
                state.active_audio_offset_us = clamp_offset(
                    state
                        .active_audio_offset_us
                        .saturating_add(request.audio_delta_us),
                );
                state.active_video_offset_us = clamp_offset(
                    state
                        .active_video_offset_us
                        .saturating_add(request.video_delta_us),
                );
                state.source = "blind".to_string();
                state.confidence = "estimated".to_string();
                state.detail = if request.note.trim().is_empty() {
                    format!(
                        "blind estimate applied from relay telemetry: delivery skew {:.1}ms, enqueue skew {:.1}ms",
                        request.observed_delivery_skew_ms, request.observed_enqueue_skew_ms
                    )
                } else {
                    request.note
                };
                touch(&mut state);
            }
            CalibrationAction::SaveActiveAsDefault => {
                state.default_audio_offset_us = state.active_audio_offset_us;
                state.default_video_offset_us = state.active_video_offset_us;
                state.source = "default".to_string();
                state.confidence = "measured".to_string();
                state.detail = "saved current upstream A/V calibration as site default".to_string();
                touch(&mut state);
            }
        }
        self.runtime
            .set_playout_offsets(state.active_video_offset_us, state.active_audio_offset_us);
        persist_snapshot(&self.path, &state)?;
        Ok(state.to_proto())
    }

    pub fn apply_transient_blind_estimate(
        &self,
        audio_delta_us: i64,
        video_delta_us: i64,
        observed_delivery_skew_ms: f32,
        observed_enqueue_skew_ms: f32,
        note: impl Into<String>,
    ) -> ProtoCalibrationState {
        let mut state = self.state.lock().expect("calibration mutex poisoned");
        state.active_audio_offset_us =
            clamp_offset(state.active_audio_offset_us.saturating_add(audio_delta_us));
        state.active_video_offset_us =
            clamp_offset(state.active_video_offset_us.saturating_add(video_delta_us));
        state.source = "blind".to_string();
        state.confidence = "runtime-estimated".to_string();
        let note = note.into();
        state.detail = if note.trim().is_empty() {
            format!(
                "transient blind estimate from relay telemetry: delivery skew {:.1}ms, enqueue skew {:.1}ms",
                observed_delivery_skew_ms, observed_enqueue_skew_ms
            )
        } else {
            note
        };
        touch(&mut state);
        self.runtime
            .set_playout_offsets(state.active_video_offset_us, state.active_audio_offset_us);
        state.to_proto()
    }
}

impl CalibrationSnapshot {
    fn to_proto(&self) -> ProtoCalibrationState {
        ProtoCalibrationState {
            profile: self.profile.clone(),
            factory_audio_offset_us: self.factory_audio_offset_us,
            factory_video_offset_us: self.factory_video_offset_us,
            default_audio_offset_us: self.default_audio_offset_us,
            default_video_offset_us: self.default_video_offset_us,
            active_audio_offset_us: self.active_audio_offset_us,
            active_video_offset_us: self.active_video_offset_us,
            source: self.source.clone(),
            confidence: self.confidence.clone(),
            updated_at: self.updated_at.clone(),
            detail: self.detail.clone(),
        }
    }
}

pub fn calibration_path() -> PathBuf {
    std::env::var("LESAVKA_CALIBRATION_PATH")
        .ok()
        .filter(|path| !path.trim().is_empty())
        .map(PathBuf::from)
        .unwrap_or_else(|| PathBuf::from("/var/lib/lesavka/calibration.toml"))
}

fn snapshot_from_env() -> CalibrationSnapshot {
    let env_audio = env_i64("LESAVKA_UPSTREAM_AUDIO_PLAYOUT_OFFSET_US");
    let env_video = env_i64("LESAVKA_UPSTREAM_VIDEO_PLAYOUT_OFFSET_US");
    let default_audio_offset_us = env_audio.unwrap_or(FACTORY_MJPEG_AUDIO_OFFSET_US);
    let default_video_offset_us = env_video.unwrap_or(FACTORY_MJPEG_VIDEO_OFFSET_US);
    let source = if env_audio.is_some() || env_video.is_some() {
        "env".to_string()
    } else {
        "factory".to_string()
    };
    let confidence = if source == "factory" {
        FACTORY_CONFIDENCE.to_string()
    } else {
        "configured".to_string()
    };
    CalibrationSnapshot {
        profile: PROFILE.to_string(),
        factory_audio_offset_us: FACTORY_MJPEG_AUDIO_OFFSET_US,
        factory_video_offset_us: FACTORY_MJPEG_VIDEO_OFFSET_US,
        default_audio_offset_us,
        default_video_offset_us,
        active_audio_offset_us: default_audio_offset_us,
        active_video_offset_us: default_video_offset_us,
        source,
        confidence,
        updated_at: Utc::now().to_rfc3339(),
        detail: "loaded upstream A/V calibration defaults".to_string(),
    }
}

fn parse_snapshot(raw: &str) -> CalibrationSnapshot {
    let fallback = snapshot_from_env();
    let value = |key: &str| -> Option<String> {
        raw.lines().find_map(|line| {
            let trimmed = line.trim();
            let (left, right) = trimmed.split_once('=')?;
            (left.trim() == key).then(|| right.trim().trim_matches('"').to_string())
        })
    };
    let number = |key: &str, default: i64| -> i64 {
        value(key)
            .and_then(|raw| raw.parse::<i64>().ok())
            .map(clamp_offset)
            .unwrap_or(default)
    };
    CalibrationSnapshot {
        profile: value("profile").unwrap_or(fallback.profile),
        factory_audio_offset_us: FACTORY_MJPEG_AUDIO_OFFSET_US,
        factory_video_offset_us: FACTORY_MJPEG_VIDEO_OFFSET_US,
        default_audio_offset_us: number(
            "default_audio_offset_us",
            fallback.default_audio_offset_us,
        ),
        default_video_offset_us: number(
            "default_video_offset_us",
            fallback.default_video_offset_us,
        ),
        active_audio_offset_us: number("active_audio_offset_us", fallback.active_audio_offset_us),
        active_video_offset_us: number("active_video_offset_us", fallback.active_video_offset_us),
        source: value("source").unwrap_or(fallback.source),
        confidence: value("confidence").unwrap_or(fallback.confidence),
        updated_at: value("updated_at").unwrap_or(fallback.updated_at),
        detail: value("detail").unwrap_or(fallback.detail),
    }
}

fn migrate_legacy_snapshot(mut state: CalibrationSnapshot) -> CalibrationSnapshot {
    let source_allows_migration = matches!(state.source.as_str(), "factory" | "env");
    let confidence_allows_migration = matches!(state.confidence.as_str(), "factory" | "configured");
    let clamped_previous_baseline = matches!(
        state.default_audio_offset_us,
        PREVIOUS_OFFSET_LIMIT_US | OFFSET_LIMIT_US
    ) && state
        .detail
        .contains("loaded upstream A/V calibration defaults");
    let untouched_legacy_audio = (matches!(
        state.default_audio_offset_us,
        FACTORY_MJPEG_AUDIO_OFFSET_US
            | LEGACY_FACTORY_MJPEG_AUDIO_OFFSET_US
            | PREVIOUS_FACTORY_MJPEG_AUDIO_OFFSET_US
            | PREVIOUS_TUNED_MJPEG_AUDIO_OFFSET_US
    ) || clamped_previous_baseline)
        && state.active_audio_offset_us == state.default_audio_offset_us;
    let untouched_legacy_video = matches!(
        state.default_video_offset_us,
        PREVIOUS_FACTORY_MJPEG_VIDEO_OFFSET_US
            | PREVIOUS_DELAYED_FACTORY_MJPEG_VIDEO_OFFSET_US
            | PREVIOUS_BROWSER_FACTORY_MJPEG_VIDEO_OFFSET_US
            | PREVIOUS_OVERSHOT_FACTORY_MJPEG_VIDEO_OFFSET_US
    ) && state.active_video_offset_us == state.default_video_offset_us;
    if state.profile == PROFILE
        && source_allows_migration
        && confidence_allows_migration
        && untouched_legacy_audio
        && untouched_legacy_video
    {
        let old_audio_offset_us = state.default_audio_offset_us;
        let old_video_offset_us = state.default_video_offset_us;
        state.default_audio_offset_us = FACTORY_MJPEG_AUDIO_OFFSET_US;
        state.active_audio_offset_us = FACTORY_MJPEG_AUDIO_OFFSET_US;
        state.default_video_offset_us = FACTORY_MJPEG_VIDEO_OFFSET_US;
        state.active_video_offset_us = FACTORY_MJPEG_VIDEO_OFFSET_US;
        state.source = "factory".to_string();
        state.confidence = FACTORY_CONFIDENCE.to_string();
        state.detail = format!(
            "migrated legacy MJPEG upstream A/V baseline from audio {:+.1}ms/video {:+.1}ms to audio {:+.1}ms/video {:+.1}ms",
            old_audio_offset_us as f64 / 1000.0,
            old_video_offset_us as f64 / 1000.0,
            FACTORY_MJPEG_AUDIO_OFFSET_US as f64 / 1000.0,
            FACTORY_MJPEG_VIDEO_OFFSET_US as f64 / 1000.0
        );
        touch(&mut state);
    }
    state
}

fn persist_snapshot(path: &PathBuf, state: &CalibrationSnapshot) -> Result<()> {
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent)
            .with_context(|| format!("creating calibration directory {}", parent.display()))?;
    }
    std::fs::write(path, serialize_snapshot(state))
        .with_context(|| format!("writing calibration state {}", path.display()))
}

fn serialize_snapshot(state: &CalibrationSnapshot) -> String {
    format!(
        "profile=\"{}\"\ndefault_audio_offset_us={}\ndefault_video_offset_us={}\nactive_audio_offset_us={}\nactive_video_offset_us={}\nsource=\"{}\"\nconfidence=\"{}\"\nupdated_at=\"{}\"\ndetail=\"{}\"\n",
        escape_value(&state.profile),
        state.default_audio_offset_us,
        state.default_video_offset_us,
        state.active_audio_offset_us,
        state.active_video_offset_us,
        escape_value(&state.source),
        escape_value(&state.confidence),
        escape_value(&state.updated_at),
        escape_value(&state.detail),
    )
}

fn touch(state: &mut CalibrationSnapshot) {
    state.updated_at = Utc::now().to_rfc3339();
}

fn env_i64(name: &str) -> Option<i64> {
    std::env::var(name)
        .ok()
        .and_then(|value| value.trim().parse::<i64>().ok())
        .map(clamp_offset)
}

fn clamp_offset(value: i64) -> i64 {
    value.clamp(-OFFSET_LIMIT_US, OFFSET_LIMIT_US)
}

fn escape_value(value: &str) -> String {
    value.replace('\\', "\\\\").replace('"', "\\\"")
}

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

    #[test]
    fn default_snapshot_uses_factory_mjpeg_calibration() {
        temp_env::with_vars(
            [
                ("LESAVKA_UPSTREAM_AUDIO_PLAYOUT_OFFSET_US", None::<&str>),
                ("LESAVKA_UPSTREAM_VIDEO_PLAYOUT_OFFSET_US", None::<&str>),
            ],
            || {
                let state = snapshot_from_env();
                assert_eq!(state.default_audio_offset_us, 0);
                assert_eq!(state.active_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
                assert_eq!(state.source, "factory");
            },
        );
    }

    #[test]
    fn store_persists_manual_adjustments_and_updates_runtime() {
        let file = NamedTempFile::new().expect("temp calibration file");
        let path = file.path().to_string_lossy().to_string();
        temp_env::with_var("LESAVKA_CALIBRATION_PATH", Some(path.as_str()), || {
            let runtime = Arc::new(UpstreamMediaRuntime::new());
            let store = CalibrationStore::load(runtime.clone());
            let state = store
                .apply(CalibrationRequest {
                    action: CalibrationAction::AdjustActive as i32,
                    audio_delta_us: -5_000,
                    video_delta_us: 0,
                    observed_delivery_skew_ms: 0.0,
                    observed_enqueue_skew_ms: 0.0,
                    note: String::new(),
                })
                .expect("manual adjust applies");
            assert_eq!(state.active_audio_offset_us, -5_000);
            assert_eq!(
                runtime.playout_offsets(),
                (FACTORY_MJPEG_VIDEO_OFFSET_US, -5_000)
            );
            let raw = std::fs::read_to_string(file.path()).expect("persisted calibration");
            assert!(raw.contains("active_audio_offset_us=-5000"));
        });
    }

    #[test]
    fn calibration_path_uses_default_for_blank_override() {
        temp_env::with_var("LESAVKA_CALIBRATION_PATH", Some(""), || {
            assert_eq!(
                calibration_path(),
                PathBuf::from("/var/lib/lesavka/calibration.toml")
            );
        });
    }

    #[test]
    fn snapshot_from_env_uses_configured_offsets_and_clamps_extremes() {
        temp_env::with_vars(
            [
                ("LESAVKA_UPSTREAM_AUDIO_PLAYOUT_OFFSET_US", Some("-9999999")),
                ("LESAVKA_UPSTREAM_VIDEO_PLAYOUT_OFFSET_US", Some("12345")),
            ],
            || {
                let state = snapshot_from_env();
                assert_eq!(state.default_audio_offset_us, -OFFSET_LIMIT_US);
                assert_eq!(state.default_video_offset_us, 12_345);
                assert_eq!(state.source, "env");
                assert_eq!(state.confidence, "configured");
            },
        );
    }

    #[test]
    fn parse_snapshot_falls_back_for_missing_and_malformed_fields() {
        temp_env::with_vars(
            [
                ("LESAVKA_UPSTREAM_AUDIO_PLAYOUT_OFFSET_US", None::<&str>),
                ("LESAVKA_UPSTREAM_VIDEO_PLAYOUT_OFFSET_US", None::<&str>),
            ],
            || {
                let state = parse_snapshot(
                    r#"
                    profile="mjpeg"
                    default_audio_offset_us=bad
                    default_video_offset_us=2500
                    active_audio_offset_us=-1600000
                    source="saved"
                    detail="loaded \"quoted\" value"
                    "#,
                );
                assert_eq!(state.default_audio_offset_us, FACTORY_MJPEG_AUDIO_OFFSET_US);
                assert_eq!(state.default_video_offset_us, 2_500);
                assert_eq!(state.active_audio_offset_us, -OFFSET_LIMIT_US);
                assert_eq!(state.active_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
                assert_eq!(state.source, "saved");
                assert_eq!(state.confidence, FACTORY_CONFIDENCE);
            },
        );
    }

    #[test]
    fn load_migrates_untouched_legacy_factory_mjpeg_baseline() {
        let file = NamedTempFile::new().expect("temp calibration file");
        std::fs::write(
            file.path(),
            r#"
            profile="mjpeg"
            default_audio_offset_us=-45000
            default_video_offset_us=0
            active_audio_offset_us=-45000
            active_video_offset_us=0
            source="env"
            confidence="configured"
            detail="loaded upstream A/V calibration defaults"
            "#,
        )
        .expect("legacy calibration seed");
        let path = file.path().to_string_lossy().to_string();
        temp_env::with_var("LESAVKA_CALIBRATION_PATH", Some(path.as_str()), || {
            let runtime = Arc::new(UpstreamMediaRuntime::new());
            let store = CalibrationStore::load(runtime.clone());
            let state = store.current();
            assert_eq!(state.active_audio_offset_us, 0);
            assert_eq!(state.default_audio_offset_us, 0);
            assert_eq!(state.active_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.default_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.source, "factory");
            assert_eq!(
                runtime.playout_offsets(),
                (FACTORY_MJPEG_VIDEO_OFFSET_US, 0)
            );
            assert!(state.detail.contains("migrated legacy MJPEG"));
        });
    }

    #[test]
    fn load_migrates_untouched_previous_factory_mjpeg_baseline() {
        let file = NamedTempFile::new().expect("temp calibration file");
        std::fs::write(
            file.path(),
            r#"
            profile="mjpeg"
            default_audio_offset_us=720000
            default_video_offset_us=0
            active_audio_offset_us=720000
            active_video_offset_us=0
            source="env"
            confidence="configured"
            detail="loaded upstream A/V calibration defaults"
            "#,
        )
        .expect("previous calibration seed");
        let path = file.path().to_string_lossy().to_string();
        temp_env::with_var("LESAVKA_CALIBRATION_PATH", Some(path.as_str()), || {
            let runtime = Arc::new(UpstreamMediaRuntime::new());
            let store = CalibrationStore::load(runtime.clone());
            let state = store.current();
            assert_eq!(state.active_audio_offset_us, 0);
            assert_eq!(state.default_audio_offset_us, 0);
            assert_eq!(state.active_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.default_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.source, "factory");
            assert_eq!(
                runtime.playout_offsets(),
                (FACTORY_MJPEG_VIDEO_OFFSET_US, 0)
            );
            assert!(state.detail.contains("to audio +0.0ms/video +170.0ms"));
        });
    }

    #[test]
    fn load_migrates_overshot_video_factory_mjpeg_baseline() {
        let file = NamedTempFile::new().expect("temp calibration file");
        std::fs::write(
            file.path(),
            r#"
            profile="mjpeg"
            default_audio_offset_us=0
            default_video_offset_us=1090000
            active_audio_offset_us=0
            active_video_offset_us=1090000
            source="factory"
            confidence="factory"
            detail="loaded upstream A/V calibration defaults"
            "#,
        )
        .expect("overshot video calibration seed");
        let path = file.path().to_string_lossy().to_string();
        temp_env::with_var("LESAVKA_CALIBRATION_PATH", Some(path.as_str()), || {
            let runtime = Arc::new(UpstreamMediaRuntime::new());
            let store = CalibrationStore::load(runtime.clone());
            let state = store.current();
            assert_eq!(state.active_audio_offset_us, 0);
            assert_eq!(state.default_audio_offset_us, 0);
            assert_eq!(state.active_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.default_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.source, "factory");
            assert_eq!(
                runtime.playout_offsets(),
                (FACTORY_MJPEG_VIDEO_OFFSET_US, 0)
            );
            assert!(state.detail.contains("from audio +0.0ms/video +1090.0ms"));
        });
    }

    #[test]
    fn load_migrates_browser_video_factory_mjpeg_baseline() {
        let file = NamedTempFile::new().expect("temp calibration file");
        std::fs::write(
            file.path(),
            r#"
            profile="mjpeg"
            default_audio_offset_us=0
            default_video_offset_us=130000
            active_audio_offset_us=0
            active_video_offset_us=130000
            source="factory"
            confidence="factory"
            detail="loaded upstream A/V calibration defaults"
            "#,
        )
        .expect("browser video calibration seed");
        let path = file.path().to_string_lossy().to_string();
        temp_env::with_var("LESAVKA_CALIBRATION_PATH", Some(path.as_str()), || {
            let runtime = Arc::new(UpstreamMediaRuntime::new());
            let store = CalibrationStore::load(runtime.clone());
            let state = store.current();
            assert_eq!(state.active_audio_offset_us, 0);
            assert_eq!(state.default_audio_offset_us, 0);
            assert_eq!(state.active_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.default_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.source, "factory");
            assert_eq!(
                runtime.playout_offsets(),
                (FACTORY_MJPEG_VIDEO_OFFSET_US, 0)
            );
        });
    }

    #[test]
    fn load_migrates_delayed_video_factory_mjpeg_baseline() {
        let file = NamedTempFile::new().expect("temp calibration file");
        std::fs::write(
            file.path(),
            r#"
            profile="mjpeg"
            default_audio_offset_us=0
            default_video_offset_us=350000
            active_audio_offset_us=0
            active_video_offset_us=350000
            source="factory"
            confidence="factory"
            detail="loaded upstream A/V calibration defaults"
            "#,
        )
        .expect("delayed video calibration seed");
        let path = file.path().to_string_lossy().to_string();
        temp_env::with_var("LESAVKA_CALIBRATION_PATH", Some(path.as_str()), || {
            let runtime = Arc::new(UpstreamMediaRuntime::new());
            let store = CalibrationStore::load(runtime.clone());
            let state = store.current();
            assert_eq!(state.active_audio_offset_us, 0);
            assert_eq!(state.default_audio_offset_us, 0);
            assert_eq!(state.active_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.default_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.source, "factory");
            assert_eq!(
                runtime.playout_offsets(),
                (FACTORY_MJPEG_VIDEO_OFFSET_US, 0)
            );
        });
    }

    #[test]
    fn load_migrates_early_zero_video_factory_mjpeg_baseline() {
        let file = NamedTempFile::new().expect("temp calibration file");
        std::fs::write(
            file.path(),
            r#"
            profile="mjpeg"
            default_audio_offset_us=0
            default_video_offset_us=0
            active_audio_offset_us=0
            active_video_offset_us=0
            source="factory"
            confidence="factory"
            detail="loaded upstream A/V calibration defaults"
            "#,
        )
        .expect("early zero calibration seed");
        let path = file.path().to_string_lossy().to_string();
        temp_env::with_var("LESAVKA_CALIBRATION_PATH", Some(path.as_str()), || {
            let runtime = Arc::new(UpstreamMediaRuntime::new());
            let store = CalibrationStore::load(runtime.clone());
            let state = store.current();
            assert_eq!(state.active_audio_offset_us, 0);
            assert_eq!(state.default_audio_offset_us, 0);
            assert_eq!(state.active_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.default_video_offset_us, FACTORY_MJPEG_VIDEO_OFFSET_US);
            assert_eq!(state.source, "factory");
            assert_eq!(
                runtime.playout_offsets(),
                (FACTORY_MJPEG_VIDEO_OFFSET_US, 0)
            );
        });
    }

    #[test]
    fn load_keeps_manual_legacy_sized_calibration() {
        let file = NamedTempFile::new().expect("temp calibration file");
        std::fs::write(
            file.path(),
            r#"
            profile="mjpeg"
            default_audio_offset_us=-45000
            default_video_offset_us=0
            active_audio_offset_us=-45000
            active_video_offset_us=0
            source="manual"
            confidence="manual"
            detail="operator-set"
            "#,
        )
        .expect("manual calibration seed");
        let path = file.path().to_string_lossy().to_string();
        temp_env::with_var("LESAVKA_CALIBRATION_PATH", Some(path.as_str()), || {
            let runtime = Arc::new(UpstreamMediaRuntime::new());
            let store = CalibrationStore::load(runtime.clone());
            let state = store.current();
            assert_eq!(state.active_audio_offset_us, -45_000);
            assert_eq!(state.active_video_offset_us, 0);
            assert_eq!(state.source, "manual");
            assert_eq!(runtime.playout_offsets(), (0, -45_000));
        });
    }

    #[test]
    fn store_applies_all_calibration_actions_and_persists_defaults() {
        let dir = tempfile::tempdir().expect("calibration dir");
        let path = dir.path().join("calibration.toml");
        let path_string = path.to_string_lossy().to_string();
        temp_env::with_var(
            "LESAVKA_CALIBRATION_PATH",
            Some(path_string.as_str()),
            || {
                let runtime = Arc::new(UpstreamMediaRuntime::new());
                let store = CalibrationStore::load(runtime.clone());

                let blind = store
                    .apply(CalibrationRequest {
                        action: CalibrationAction::BlindEstimate as i32,
                        audio_delta_us: 5_000,
                        video_delta_us: -2_000,
                        observed_delivery_skew_ms: 44.0,
                        observed_enqueue_skew_ms: 3.5,
                        note: String::new(),
                    })
                    .expect("blind estimate");
                assert_eq!(blind.source, "blind");
                assert!(blind.detail.contains("delivery skew 44.0ms"));
                assert_eq!(
                    runtime.playout_offsets(),
                    (FACTORY_MJPEG_VIDEO_OFFSET_US - 2_000, 5_000)
                );

                let manual = store
                    .apply(CalibrationRequest {
                        action: CalibrationAction::AdjustActive as i32,
                        audio_delta_us: 1_999_999,
                        video_delta_us: 0,
                        observed_delivery_skew_ms: 0.0,
                        observed_enqueue_skew_ms: 0.0,
                        note: String::new(),
                    })
                    .expect("manual clamp");
                assert_eq!(manual.active_audio_offset_us, OFFSET_LIMIT_US);

                let saved = store
                    .apply(CalibrationRequest {
                        action: CalibrationAction::SaveActiveAsDefault as i32,
                        ..CalibrationRequest::default()
                    })
                    .expect("save default");
                assert_eq!(saved.default_audio_offset_us, saved.active_audio_offset_us);
                assert_eq!(saved.confidence, "measured");

                let factory = store
                    .apply(CalibrationRequest {
                        action: CalibrationAction::RestoreFactory as i32,
                        ..CalibrationRequest::default()
                    })
                    .expect("factory restore");
                assert_eq!(
                    factory.active_audio_offset_us,
                    FACTORY_MJPEG_AUDIO_OFFSET_US
                );
                assert_eq!(
                    factory.active_video_offset_us,
                    FACTORY_MJPEG_VIDEO_OFFSET_US
                );
                assert_eq!(factory.source, "factory");

                let restored = store
                    .apply(CalibrationRequest {
                        action: CalibrationAction::RestoreDefault as i32,
                        ..CalibrationRequest::default()
                    })
                    .expect("default restore");
                assert_eq!(
                    restored.active_audio_offset_us,
                    restored.default_audio_offset_us
                );
                assert_eq!(
                    store.current().active_audio_offset_us,
                    restored.active_audio_offset_us
                );

                let no_op = store
                    .apply(CalibrationRequest::default())
                    .expect("unspecified action is ok");
                assert_eq!(
                    no_op.active_audio_offset_us,
                    restored.active_audio_offset_us
                );

                let raw = std::fs::read_to_string(&path).expect("persisted actions");
                assert!(raw.contains("confidence="));
                assert!(raw.contains("detail="));
                assert_eq!(escape_value("a\\b\"c"), "a\\\\b\\\"c");
            },
        );
    }

    #[test]
    fn transient_blind_estimate_updates_runtime_without_persisting_active_file_state() {
        let dir = tempfile::tempdir().expect("calibration dir");
        let path = dir.path().join("calibration.toml");
        let path_string = path.to_string_lossy().to_string();
        temp_env::with_var(
            "LESAVKA_CALIBRATION_PATH",
            Some(path_string.as_str()),
            || {
                let runtime = Arc::new(UpstreamMediaRuntime::new());
                let store = CalibrationStore::load(runtime.clone());
                let before_raw = std::fs::read_to_string(&path).ok();

                let state = store.apply_transient_blind_estimate(
                    0,
                    -12_000,
                    48.0,
                    7.0,
                    "runtime blind healer nudge",
                );

                assert_eq!(state.source, "blind");
                assert_eq!(state.confidence, "runtime-estimated");
                assert_eq!(
                    runtime.playout_offsets(),
                    (FACTORY_MJPEG_VIDEO_OFFSET_US - 12_000, 0)
                );
                assert_eq!(std::fs::read_to_string(&path).ok(), before_raw);
            },
        );
    }
}