use serde::Serialize;

const DEFAULT_AUDIO_WINDOW_MS: u32 = 5;
const DEFAULT_MAX_PAIR_GAP_S: f64 = 0.5;
const DEFAULT_PULSE_PERIOD_S: f64 = 1.0;
const DEFAULT_PULSE_WIDTH_S: f64 = 0.12;
const DEFAULT_MARKER_TICK_PERIOD: u32 = 5;
const CALIBRATION_MIN_PAIRED_EVENTS: usize = 13;
const CALIBRATION_MAX_DRIFT_MS: f64 = 40.0;
const CALIBRATION_MAX_START_MEDIAN_DISAGREEMENT_MS: f64 = 250.0;
const CALIBRATION_SETTLED_SKEW_MS: f64 = 5.0;
const RAW_ACTIVITY_CONFIRMS_PAIR_MAX_DISAGREEMENT_MS: f64 = 250.0;
const VERDICT_MIN_PAIRED_EVENTS: usize = 3;
const VERDICT_PREFERRED_P95_ABS_SKEW_MS: f64 = 35.0;
const VERDICT_ACCEPTABLE_P95_ABS_SKEW_MS: f64 = 80.0;
const VERDICT_GROSS_FAILURE_P95_ABS_SKEW_MS: f64 = 250.0;
const VERDICT_CATASTROPHIC_MAX_ABS_SKEW_MS: f64 = 1_000.0;

#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct SyncAnalysisReport {
    pub video_event_count: usize,
    pub audio_event_count: usize,
    pub paired_event_count: usize,
    pub coded_events: bool,
    pub activity_start_delta_ms: f64,
    pub raw_first_video_activity_s: f64,
    pub raw_first_audio_activity_s: f64,
    pub first_skew_ms: f64,
    pub last_skew_ms: f64,
    pub mean_skew_ms: f64,
    pub median_skew_ms: f64,
    pub max_abs_skew_ms: f64,
    pub drift_ms: f64,
    pub skews_ms: Vec<f64>,
    pub video_onsets_s: Vec<f64>,
    pub audio_onsets_s: Vec<f64>,
    pub paired_events: Vec<SyncEventPair>,
}

#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct SyncEventPair {
    pub event_id: usize,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub server_event_id: Option<usize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_code: Option<u32>,
    pub video_time_s: f64,
    pub audio_time_s: f64,
    pub skew_ms: f64,
    pub confidence: f64,
}

#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct SyncAnalysisVerdict {
    pub status: String,
    pub passed: bool,
    pub p95_abs_skew_ms: f64,
    pub max_abs_skew_ms: f64,
    pub preferred_p95_abs_skew_ms: f64,
    pub acceptable_p95_abs_skew_ms: f64,
    pub gross_failure_p95_abs_skew_ms: f64,
    pub catastrophic_max_abs_skew_ms: f64,
    pub reason: String,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
pub struct SyncCalibrationRecommendation {
    pub ready: bool,
    pub recommended_audio_offset_adjust_us: i64,
    pub recommended_video_offset_adjust_us: i64,
    pub note: String,
}

impl SyncAnalysisReport {
    #[must_use]
    pub fn verdict(&self) -> SyncAnalysisVerdict {
        let p95_abs_skew_ms = percentile_abs(&self.skews_ms, 0.95);
        let base = SyncAnalysisVerdict {
            status: String::new(),
            passed: false,
            p95_abs_skew_ms,
            max_abs_skew_ms: self.max_abs_skew_ms,
            preferred_p95_abs_skew_ms: VERDICT_PREFERRED_P95_ABS_SKEW_MS,
            acceptable_p95_abs_skew_ms: VERDICT_ACCEPTABLE_P95_ABS_SKEW_MS,
            gross_failure_p95_abs_skew_ms: VERDICT_GROSS_FAILURE_P95_ABS_SKEW_MS,
            catastrophic_max_abs_skew_ms: VERDICT_CATASTROPHIC_MAX_ABS_SKEW_MS,
            reason: String::new(),
        };

        if self.paired_event_count < VERDICT_MIN_PAIRED_EVENTS {
            return SyncAnalysisVerdict {
                status: "insufficient_data".to_string(),
                reason: format!(
                    "need at least {VERDICT_MIN_PAIRED_EVENTS} paired events; saw {}",
                    self.paired_event_count
                ),
                ..base
            };
        }

        if self.max_abs_skew_ms >= VERDICT_CATASTROPHIC_MAX_ABS_SKEW_MS {
            return SyncAnalysisVerdict {
                status: "catastrophic_failure".to_string(),
                reason: format!(
                    "max skew {:.1} ms is at or above the {:.1} ms catastrophic boundary",
                    self.max_abs_skew_ms, VERDICT_CATASTROPHIC_MAX_ABS_SKEW_MS
                ),
                ..base
            };
        }

        if self.activity_start_delta_ms.abs() >= VERDICT_CATASTROPHIC_MAX_ABS_SKEW_MS
            && self.raw_activity_start_is_verdict_relevant()
        {
            return SyncAnalysisVerdict {
                status: "catastrophic_failure".to_string(),
                reason: format!(
                    "audio/video activity starts are separated by {:+.1} ms, at or above the {:.1} ms catastrophic boundary",
                    self.activity_start_delta_ms, VERDICT_CATASTROPHIC_MAX_ABS_SKEW_MS
                ),
                ..base
            };
        }

        if p95_abs_skew_ms > VERDICT_GROSS_FAILURE_P95_ABS_SKEW_MS {
            return SyncAnalysisVerdict {
                status: "gross_failure".to_string(),
                reason: format!(
                    "p95 skew {:.1} ms exceeds the {:.1} ms gross-failure boundary",
                    p95_abs_skew_ms, VERDICT_GROSS_FAILURE_P95_ABS_SKEW_MS
                ),
                ..base
            };
        }

        let raw_activity_note = self.raw_activity_note();
        if p95_abs_skew_ms <= VERDICT_PREFERRED_P95_ABS_SKEW_MS {
            return SyncAnalysisVerdict {
                status: "preferred".to_string(),
                passed: true,
                reason: format!(
                    "p95 skew {:.1} ms is inside the preferred {:.1} ms band{}",
                    p95_abs_skew_ms, VERDICT_PREFERRED_P95_ABS_SKEW_MS, raw_activity_note
                ),
                ..base
            };
        }

        if p95_abs_skew_ms <= VERDICT_ACCEPTABLE_P95_ABS_SKEW_MS {
            return SyncAnalysisVerdict {
                status: "acceptable".to_string(),
                passed: true,
                reason: format!(
                    "p95 skew {:.1} ms is inside the acceptable {:.1} ms band{}",
                    p95_abs_skew_ms, VERDICT_ACCEPTABLE_P95_ABS_SKEW_MS, raw_activity_note
                ),
                ..base
            };
        }

        SyncAnalysisVerdict {
            status: "gross_failure".to_string(),
            reason: format!(
                "p95 skew {:.1} ms exceeds the {:.1} ms acceptable band",
                p95_abs_skew_ms, VERDICT_ACCEPTABLE_P95_ABS_SKEW_MS
            ),
            ..base
        }
    }

    #[must_use]
    pub fn calibration_recommendation(&self) -> SyncCalibrationRecommendation {
        if self.paired_event_count < CALIBRATION_MIN_PAIRED_EVENTS {
            return SyncCalibrationRecommendation {
                ready: false,
                recommended_audio_offset_adjust_us: 0,
                recommended_video_offset_adjust_us: 0,
                note: format!(
                    "need at least {CALIBRATION_MIN_PAIRED_EVENTS} paired pulses; saw {}",
                    self.paired_event_count
                ),
            };
        }

        if self.drift_ms.abs() > CALIBRATION_MAX_DRIFT_MS {
            return SyncCalibrationRecommendation {
                ready: false,
                recommended_audio_offset_adjust_us: 0,
                recommended_video_offset_adjust_us: 0,
                note: format!(
                    "drift {:.1} ms exceeds the {:.1} ms calibration limit",
                    self.drift_ms, CALIBRATION_MAX_DRIFT_MS
                ),
            };
        }

        let start_median_disagreement_ms = self.activity_start_pair_disagreement_ms();
        if self.raw_activity_start_is_verdict_relevant()
            && start_median_disagreement_ms.abs() > CALIBRATION_MAX_START_MEDIAN_DISAGREEMENT_MS
        {
            return SyncCalibrationRecommendation {
                ready: false,
                recommended_audio_offset_adjust_us: 0,
                recommended_video_offset_adjust_us: 0,
                note: format!(
                    "activity start delta {:+.1} ms disagrees with median skew {:+.1} ms by {:.1} ms, above the {:.1} ms calibration-safe band",
                    self.activity_start_delta_ms,
                    self.median_skew_ms,
                    start_median_disagreement_ms.abs(),
                    CALIBRATION_MAX_START_MEDIAN_DISAGREEMENT_MS
                ),
            };
        }

        let recommended_audio_offset_adjust_us = (-(self.median_skew_ms * 1_000.0)).round() as i64;
        let recommended_video_offset_adjust_us = -recommended_audio_offset_adjust_us;
        let raw_activity_note = self.raw_activity_calibration_note();
        let note = if self.median_skew_ms.abs() <= CALIBRATION_SETTLED_SKEW_MS {
            format!(
                "median skew {:.1} ms is already within the settled {:.1} ms band{}",
                self.median_skew_ms, CALIBRATION_SETTLED_SKEW_MS, raw_activity_note
            )
        } else {
            format!(
                "apply the audio offset adjustment to move median skew from {:+.1} ms toward 0.0 ms{}",
                self.median_skew_ms, raw_activity_note
            )
        };

        SyncCalibrationRecommendation {
            ready: true,
            recommended_audio_offset_adjust_us,
            recommended_video_offset_adjust_us,
            note,
        }
    }

    #[must_use]
    pub fn activity_start_pair_disagreement_ms(&self) -> f64 {
        self.activity_start_delta_ms - self.median_skew_ms
    }

    #[must_use]
    pub fn raw_activity_start_confirms_pairs(&self) -> bool {
        self.activity_start_pair_disagreement_ms().abs()
            <= RAW_ACTIVITY_CONFIRMS_PAIR_MAX_DISAGREEMENT_MS
    }

    pub fn raw_activity_start_is_verdict_relevant(&self) -> bool {
        if self.raw_activity_start_confirms_pairs() {
            return true;
        }
        if self.coded_events || self.paired_event_count < VERDICT_MIN_PAIRED_EVENTS {
            return false;
        }
        // Cadence-only pairing can alias by a whole pulse period and look
        // deceptively good. Use raw activity as a guard only when paired
        // evidence otherwise appears passable; if paired pulses already fail,
        // report that direct failure instead of promoting a noisy raw edge.
        percentile_abs(&self.skews_ms, 0.95) <= VERDICT_ACCEPTABLE_P95_ABS_SKEW_MS
    }

    fn raw_activity_note(&self) -> String {
        if self.activity_start_delta_ms.abs() < VERDICT_CATASTROPHIC_MAX_ABS_SKEW_MS
            || self.raw_activity_start_is_verdict_relevant()
        {
            String::new()
        } else {
            format!(
                "; raw activity start delta {:+.1} ms is reported separately because it disagrees with paired pulses by {:.1} ms",
                self.activity_start_delta_ms,
                self.activity_start_pair_disagreement_ms().abs()
            )
        }
    }

    fn raw_activity_calibration_note(&self) -> String {
        if self.raw_activity_start_is_verdict_relevant() {
            String::new()
        } else {
            format!(
                "; raw activity start delta {:+.1} ms is not used for calibration because paired pulses disagree by {:.1} ms",
                self.activity_start_delta_ms,
                self.activity_start_pair_disagreement_ms().abs()
            )
        }
    }
}

fn percentile_abs(values: &[f64], percentile: f64) -> f64 {
    if values.is_empty() {
        return 0.0;
    }

    let mut sorted = values.iter().copied().map(f64::abs).collect::<Vec<_>>();
    sorted.sort_by(|left, right| left.total_cmp(right));
    let index = ((sorted.len() as f64 * percentile).ceil() as usize)
        .saturating_sub(1)
        .min(sorted.len() - 1);
    sorted[index]
}

#[derive(Clone, Debug, PartialEq)]
pub struct SyncAnalysisOptions {
    pub audio_window_ms: u32,
    pub max_pair_gap_s: f64,
    pub pulse_period_s: f64,
    pub pulse_width_s: f64,
    pub marker_tick_period: u32,
    pub event_width_codes: Vec<u32>,
    pub analysis_start_s: Option<f64>,
    pub analysis_end_s: Option<f64>,
}

impl Default for SyncAnalysisOptions {
    fn default() -> Self {
        Self {
            audio_window_ms: DEFAULT_AUDIO_WINDOW_MS,
            max_pair_gap_s: DEFAULT_MAX_PAIR_GAP_S,
            pulse_period_s: DEFAULT_PULSE_PERIOD_S,
            pulse_width_s: DEFAULT_PULSE_WIDTH_S,
            marker_tick_period: DEFAULT_MARKER_TICK_PERIOD,
            event_width_codes: Vec::new(),
            analysis_start_s: None,
            analysis_end_s: None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::{SyncAnalysisOptions, SyncAnalysisReport};

    #[test]
    fn default_options_match_live_probe_expectations() {
        let options = SyncAnalysisOptions::default();
        assert_eq!(options.audio_window_ms, 5);
        assert!((options.max_pair_gap_s - 0.5).abs() < f64::EPSILON);
        assert!((options.pulse_period_s - 1.0).abs() < f64::EPSILON);
        assert!((options.pulse_width_s - 0.12).abs() < f64::EPSILON);
        assert_eq!(options.marker_tick_period, 5);
        assert!(options.event_width_codes.is_empty());
    }

    #[test]
    fn calibration_recommendation_requires_enough_pairs() {
        let report = SyncAnalysisReport {
            video_event_count: 4,
            audio_event_count: 4,
            paired_event_count: 4,
            coded_events: false,
            activity_start_delta_ms: 0.0,
            raw_first_video_activity_s: 0.0,
            raw_first_audio_activity_s: 0.0,
            first_skew_ms: 20.0,
            last_skew_ms: 20.0,
            mean_skew_ms: 20.0,
            median_skew_ms: 20.0,
            max_abs_skew_ms: 20.0,
            drift_ms: 0.0,
            skews_ms: vec![20.0; 4],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let recommendation = report.calibration_recommendation();
        assert!(!recommendation.ready);
        assert_eq!(recommendation.recommended_audio_offset_adjust_us, 0);
        assert!(
            recommendation
                .note
                .contains("need at least 13 paired pulses")
        );
    }

    #[test]
    fn calibration_recommendation_rejects_unstable_drift() {
        let report = SyncAnalysisReport {
            video_event_count: 12,
            audio_event_count: 12,
            paired_event_count: 14,
            coded_events: false,
            activity_start_delta_ms: 0.0,
            raw_first_video_activity_s: 0.0,
            raw_first_audio_activity_s: 0.0,
            first_skew_ms: 10.0,
            last_skew_ms: 70.0,
            mean_skew_ms: 40.0,
            median_skew_ms: 35.0,
            max_abs_skew_ms: 70.0,
            drift_ms: 60.0,
            skews_ms: vec![10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 70.0],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let recommendation = report.calibration_recommendation();
        assert!(!recommendation.ready);
        assert_eq!(recommendation.recommended_audio_offset_adjust_us, 0);
        assert!(recommendation.note.contains("drift 60.0 ms exceeds"));
    }

    #[test]
    fn calibration_recommendation_maps_median_skew_to_audio_and_video_offsets() {
        let report = SyncAnalysisReport {
            video_event_count: 14,
            audio_event_count: 14,
            paired_event_count: 14,
            coded_events: false,
            activity_start_delta_ms: 0.0,
            raw_first_video_activity_s: 0.0,
            raw_first_audio_activity_s: 0.0,
            first_skew_ms: 28.0,
            last_skew_ms: 32.0,
            mean_skew_ms: 30.0,
            median_skew_ms: 30.0,
            max_abs_skew_ms: 32.0,
            drift_ms: 4.0,
            skews_ms: vec![28.0, 30.0, 32.0],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let recommendation = report.calibration_recommendation();
        assert!(recommendation.ready);
        assert_eq!(recommendation.recommended_audio_offset_adjust_us, -30_000);
        assert_eq!(recommendation.recommended_video_offset_adjust_us, 30_000);
        assert!(recommendation.note.contains("move median skew"));
    }

    #[test]
    fn calibration_recommendation_accepts_large_stable_measured_offsets() {
        let report = SyncAnalysisReport {
            video_event_count: 16,
            audio_event_count: 16,
            paired_event_count: 16,
            coded_events: false,
            activity_start_delta_ms: -766.4,
            raw_first_video_activity_s: 7.491,
            raw_first_audio_activity_s: 6.725,
            first_skew_ms: -766.4,
            last_skew_ms: -769.2,
            mean_skew_ms: -756.0,
            median_skew_ms: -766.4,
            max_abs_skew_ms: 775.7,
            drift_ms: -2.8,
            skews_ms: vec![-766.4; 16],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let recommendation = report.calibration_recommendation();
        assert!(recommendation.ready);
        assert_eq!(recommendation.recommended_audio_offset_adjust_us, 766_400);
        assert!(recommendation.note.contains("move median skew"));
    }

    #[test]
    fn calibration_recommendation_uses_pairs_when_raw_activity_disagrees() {
        let report = SyncAnalysisReport {
            video_event_count: 16,
            audio_event_count: 16,
            paired_event_count: 16,
            coded_events: false,
            activity_start_delta_ms: 6_735.0,
            raw_first_video_activity_s: 0.0,
            raw_first_audio_activity_s: 6.735,
            first_skew_ms: -90.0,
            last_skew_ms: -100.0,
            mean_skew_ms: -95.0,
            median_skew_ms: -99.0,
            max_abs_skew_ms: 120.0,
            drift_ms: -10.0,
            skews_ms: vec![-99.0; 16],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let recommendation = report.calibration_recommendation();
        assert!(recommendation.ready);
        assert_eq!(recommendation.recommended_audio_offset_adjust_us, 99_000);
        assert!(recommendation.note.contains("paired pulses disagree"));
    }

    #[test]
    fn calibration_recommendation_uses_coded_pairs_when_raw_activity_disagrees() {
        let report = SyncAnalysisReport {
            video_event_count: 14,
            audio_event_count: 14,
            paired_event_count: 13,
            coded_events: true,
            activity_start_delta_ms: -3_620.7,
            raw_first_video_activity_s: 9.361,
            raw_first_audio_activity_s: 5.740,
            first_skew_ms: -270.0,
            last_skew_ms: -230.0,
            mean_skew_ms: -205.0,
            median_skew_ms: -188.4,
            max_abs_skew_ms: 273.8,
            drift_ms: 40.0,
            skews_ms: vec![-270.0, -240.0, -188.4, -175.0, -130.0],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let recommendation = report.calibration_recommendation();
        assert!(recommendation.ready);
        assert_eq!(recommendation.recommended_audio_offset_adjust_us, 188_400);
        assert!(recommendation.note.contains("paired pulses disagree"));
    }

    #[test]
    fn calibration_recommendation_reports_when_skew_is_already_settled() {
        let report = SyncAnalysisReport {
            video_event_count: 14,
            audio_event_count: 14,
            paired_event_count: 14,
            coded_events: false,
            activity_start_delta_ms: 0.0,
            raw_first_video_activity_s: 0.0,
            raw_first_audio_activity_s: 0.0,
            first_skew_ms: 3.0,
            last_skew_ms: 4.0,
            mean_skew_ms: 3.5,
            median_skew_ms: 4.0,
            max_abs_skew_ms: 4.0,
            drift_ms: 1.0,
            skews_ms: vec![3.0, 4.0],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let recommendation = report.calibration_recommendation();
        assert!(recommendation.ready);
        assert_eq!(recommendation.recommended_audio_offset_adjust_us, -4_000);
        assert!(recommendation.note.contains("already within the settled"));
    }

    #[test]
    fn verdict_passes_preferred_skew_band() {
        let report = SyncAnalysisReport {
            video_event_count: 5,
            audio_event_count: 5,
            paired_event_count: 5,
            coded_events: false,
            activity_start_delta_ms: 0.0,
            raw_first_video_activity_s: 0.0,
            raw_first_audio_activity_s: 0.0,
            first_skew_ms: 10.0,
            last_skew_ms: 20.0,
            mean_skew_ms: 15.0,
            median_skew_ms: 15.0,
            max_abs_skew_ms: 20.0,
            drift_ms: 10.0,
            skews_ms: vec![10.0, 12.0, 15.0, 18.0, 20.0],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let verdict = report.verdict();
        assert!(verdict.passed);
        assert_eq!(verdict.status, "preferred");
    }

    #[test]
    fn verdict_flags_catastrophic_desync() {
        let report = SyncAnalysisReport {
            video_event_count: 5,
            audio_event_count: 5,
            paired_event_count: 5,
            coded_events: false,
            activity_start_delta_ms: 0.0,
            raw_first_video_activity_s: 0.0,
            raw_first_audio_activity_s: 0.0,
            first_skew_ms: 8_000.0,
            last_skew_ms: 8_000.0,
            mean_skew_ms: 8_000.0,
            median_skew_ms: 8_000.0,
            max_abs_skew_ms: 8_000.0,
            drift_ms: 0.0,
            skews_ms: vec![8_000.0; 5],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let verdict = report.verdict();
        assert!(!verdict.passed);
        assert_eq!(verdict.status, "catastrophic_failure");
    }

    #[test]
    fn verdict_flags_catastrophic_activity_start_delta() {
        let report = SyncAnalysisReport {
            video_event_count: 20,
            audio_event_count: 20,
            paired_event_count: 20,
            coded_events: false,
            activity_start_delta_ms: 20_000.0,
            raw_first_video_activity_s: 0.0,
            raw_first_audio_activity_s: 0.0,
            first_skew_ms: 900.0,
            last_skew_ms: 900.0,
            mean_skew_ms: 19_900.0,
            median_skew_ms: 19_900.0,
            max_abs_skew_ms: 900.0,
            drift_ms: 0.0,
            skews_ms: vec![900.0; 20],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let verdict = report.verdict();
        assert!(!verdict.passed);
        assert_eq!(verdict.status, "catastrophic_failure");
        assert!(verdict.reason.contains("activity starts"));
    }

    #[test]
    fn verdict_ignores_uncorroborated_raw_activity_for_coded_runs() {
        let report = SyncAnalysisReport {
            video_event_count: 20,
            audio_event_count: 20,
            paired_event_count: 20,
            coded_events: true,
            activity_start_delta_ms: -3_620.7,
            raw_first_video_activity_s: 9.361,
            raw_first_audio_activity_s: 5.740,
            first_skew_ms: -20.0,
            last_skew_ms: -18.0,
            mean_skew_ms: -19.0,
            median_skew_ms: -19.0,
            max_abs_skew_ms: 20.0,
            drift_ms: 2.0,
            skews_ms: vec![-20.0; 20],
            video_onsets_s: vec![],
            audio_onsets_s: vec![],
            paired_events: vec![],
        };

        let verdict = report.verdict();
        assert!(verdict.passed);
        assert_eq!(verdict.status, "preferred");
        assert!(verdict.reason.contains("raw activity start delta"));
    }
}