"""Librosa-based objective acoustic feature extraction."""

from __future__ import annotations

import logging
from dataclasses import dataclass, field
from pathlib import Path
from typing import Any

import librosa
import numpy as np

from app.config import get_settings
from app.services.audio.vad import VadResult, detect_speech_activity

logger = logging.getLogger(__name__)


@dataclass
class AudioFeatureResult:
    audio_duration_seconds: float
    sample_rate: int
    speech_duration_seconds: float
    silence_duration_seconds: float
    silence_percentage: float
    pause_count: int
    pause_durations_seconds: list[float]
    long_pause_count: int
    words_per_minute: float | None
    word_count: int | None
    pitch_median_hz: float | None
    pitch_range_hz: float | None
    pitch_std_hz: float | None
    pitch_available: bool
    zero_crossing_rate_mean: float | None
    spectral_centroid_mean_hz: float | None
    rms_energy_mean: float | None
    rms_energy_std: float | None
    clipping_detected: bool
    clipping_ratio: float | None
    snr_estimate_db: float | None
    quality_warnings: list[str] = field(default_factory=list)
    limitations: list[str] = field(default_factory=list)
    vad_method: str = "energy_spectral_flatness"
    feature_version: str = "1.0.0"

    def to_features_dict(self) -> dict[str, Any]:
        """Compact dict for confidence/behavioral `audio_features` passthrough."""
        return {
            "feature_version": self.feature_version,
            "audio_duration_seconds": self.audio_duration_seconds,
            "speech_duration_seconds": self.speech_duration_seconds,
            "silence_percentage": self.silence_percentage,
            "pause_count": self.pause_count,
            "words_per_minute": self.words_per_minute,
            "pitch_median_hz": self.pitch_median_hz,
            "rms_energy_mean": self.rms_energy_mean,
            "clipping_detected": self.clipping_detected,
            "vad_method": self.vad_method,
        }


def _count_words(transcript: str | None) -> int | None:
    if transcript is None:
        return None
    text = transcript.strip()
    if not text:
        return 0
    return len([w for w in text.split() if w])


def _speaking_rate_wpm(
    word_count: int | None, speech_duration_seconds: float
) -> tuple[float | None, list[str]]:
    limitations: list[str] = []
    if word_count is None:
        limitations.append("words_per_minute unavailable — no transcript provided")
        return None, limitations
    if speech_duration_seconds <= 0.05:
        limitations.append(
            "words_per_minute unavailable — speech-active duration too short"
        )
        return None, limitations
    wpm = (word_count / speech_duration_seconds) * 60.0
    return round(wpm, 2), limitations


def _clipping_stats(y: np.ndarray, threshold: float) -> tuple[bool, float]:
    if len(y) == 0:
        return False, 0.0
    ratio = float(np.mean(np.abs(y) >= threshold))
    return ratio >= 0.001, round(ratio, 6)


def _snr_estimate_db(y: np.ndarray, vad: VadResult) -> float | None:
    """Rough SNR: mean speech-frame power vs mean silence-frame power (dB)."""
    if len(vad.is_speech) == 0 or len(y) == 0:
        return None
    # Align frames roughly via hop from times
    speech_power = []
    noise_power = []
    # Use whole-signal percentiles as fallback if VAD unbalanced
    if np.any(vad.is_speech) and np.any(~vad.is_speech):
        # Reconstruct approximate mask at sample level via frame times
        # Simpler: use RMS of top/bottom energy regions
        frame_len = max(1, int(len(y) / max(len(vad.is_speech), 1)))
        for i, flag in enumerate(vad.is_speech):
            start = i * frame_len
            end = min(len(y), start + frame_len)
            if end <= start:
                continue
            p = float(np.mean(y[start:end] ** 2))
            if flag:
                speech_power.append(p)
            else:
                noise_power.append(p)
    if not speech_power or not noise_power:
        return None
    sp = float(np.mean(speech_power))
    npow = float(np.mean(noise_power)) + 1e-12
    if sp <= 0:
        return None
    snr = 10.0 * np.log10(sp / npow)
    # Cap extreme values from near-zero noise floors
    if not np.isfinite(snr):
        return None
    return round(float(np.clip(snr, -10.0, 60.0)), 2)


def _pitch_stats(
    y: np.ndarray, sr: int, *, fmin: float, fmax: float, min_voiced_frames: int
) -> tuple[float | None, float | None, float | None, bool, list[str]]:
    """Estimate F0 with librosa.yin (faster than pyin; still marked null if weak)."""
    limitations: list[str] = []
    if len(y) < int(0.1 * sr):
        limitations.append("pitch unavailable — audio too short for F0")
        return None, None, None, False, limitations

    # Cap analysis window for latency (center crop)
    max_samples = int(20.0 * sr)
    if len(y) > max_samples:
        start = (len(y) - max_samples) // 2
        y = y[start : start + max_samples]
        limitations.append("pitch computed on center 20s crop for latency")

    try:
        # Larger hop → fewer frames → lower latency
        frame_length = 2048
        hop_length = 512
        f0 = librosa.yin(
            y,
            fmin=fmin,
            fmax=fmax,
            sr=sr,
            frame_length=frame_length,
            hop_length=hop_length,
        )
    except Exception as exc:  # noqa: BLE001
        logger.info("Pitch estimation failed: %s", type(exc).__name__)
        limitations.append("pitch unavailable — yin estimation failed")
        return None, None, None, False, limitations

    if f0 is None or len(f0) == 0:
        limitations.append("pitch unavailable — no F0 track")
        return None, None, None, False, limitations

    # yin returns Hz; unvoiced often appears as fmin boundary — filter extremes
    voiced = f0[np.isfinite(f0)]
    voiced = voiced[(voiced > fmin * 1.05) & (voiced < fmax * 0.98)]

    if len(voiced) < min_voiced_frames:
        limitations.append(
            "pitch unavailable — insufficient reliable voiced frames "
            f"({len(voiced)} < {min_voiced_frames})"
        )
        return None, None, None, False, limitations

    # Reject if coefficient of variation is absurd (noise tracking)
    median = float(np.median(voiced))
    std = float(np.std(voiced))
    if median > 0 and (std / median) > 0.85:
        limitations.append("pitch unavailable — F0 track too unstable (likely noise)")
        return None, None, None, False, limitations

    p_range = float(np.percentile(voiced, 95) - np.percentile(voiced, 5))
    return round(median, 2), round(p_range, 2), round(std, 2), True, limitations


def extract_audio_features(
    wav_path: Path,
    *,
    sample_rate: int | None = None,
    transcript_text: str | None = None,
) -> AudioFeatureResult:
    """Extract acoustic metrics from a normalized WAV path."""
    settings = get_settings()
    sr_target = sample_rate or int(settings.audio_analysis_sample_rate)
    quality_warnings: list[str] = []
    limitations: list[str] = [
        "Acoustic metrics are objective signal descriptors only — "
        "not emotion, confidence, honesty, personality, or hiring suitability."
    ]

    y, sr = librosa.load(str(wav_path), sr=sr_target, mono=True)
    duration = float(librosa.get_duration(y=y, sr=sr))

    if len(y) == 0 or duration <= 0:
        limitations.append("Empty audio after load")
        return AudioFeatureResult(
            audio_duration_seconds=0.0,
            sample_rate=sr,
            speech_duration_seconds=0.0,
            silence_duration_seconds=0.0,
            silence_percentage=0.0,
            pause_count=0,
            pause_durations_seconds=[],
            long_pause_count=0,
            words_per_minute=None,
            word_count=_count_words(transcript_text),
            pitch_median_hz=None,
            pitch_range_hz=None,
            pitch_std_hz=None,
            pitch_available=False,
            zero_crossing_rate_mean=None,
            spectral_centroid_mean_hz=None,
            rms_energy_mean=None,
            rms_energy_std=None,
            clipping_detected=False,
            clipping_ratio=0.0,
            snr_estimate_db=None,
            quality_warnings=quality_warnings,
            limitations=limitations,
        )

    peak = float(np.max(np.abs(y)))
    if peak < 1e-3:
        quality_warnings.append("Very low peak amplitude — possible silence or gain issue")
    if peak > 0.99:
        quality_warnings.append("Peak near full scale — possible clipping risk")

    clip_thr = float(settings.audio_clipping_threshold)
    clipping_detected, clipping_ratio = _clipping_stats(y, clip_thr)
    if clipping_detected:
        quality_warnings.append(
            f"Clipping indicators present (ratio={clipping_ratio:.4f})"
        )

    rms = librosa.feature.rms(y=y)[0]
    rms_mean = float(np.mean(rms)) if len(rms) else None
    rms_std = float(np.std(rms)) if len(rms) else None

    zcr = librosa.feature.zero_crossing_rate(y)[0]
    zcr_mean = float(np.mean(zcr)) if len(zcr) else None

    centroid = librosa.feature.spectral_centroid(y=y, sr=sr)[0]
    centroid_mean = float(np.mean(centroid)) if len(centroid) else None

    vad = detect_speech_activity(
        y,
        sr,
        frame_ms=float(settings.audio_vad_frame_ms),
        hop_ms=float(settings.audio_vad_hop_ms),
        energy_percentile=float(settings.audio_vad_energy_percentile),
        flatness_speech_max=float(settings.audio_vad_flatness_max),
        min_speech_ms=float(settings.audio_vad_min_speech_ms),
        min_pause_ms=float(settings.audio_min_pause_ms),
        long_pause_ms=float(settings.audio_long_pause_ms),
    )

    if vad.speech_duration_seconds < float(settings.audio_min_speech_seconds):
        quality_warnings.append(
            "Insufficient speech-active duration for reliable delivery metrics"
        )

    snr = _snr_estimate_db(y, vad)
    if snr is not None and snr < float(settings.audio_low_snr_db):
        quality_warnings.append(f"Low estimated SNR ({snr} dB) — metrics may be unreliable")
        limitations.append("Low SNR may degrade pitch and VAD accuracy")

    pitch_median, pitch_range, pitch_std, pitch_ok, pitch_lims = _pitch_stats(
        y,
        sr,
        fmin=float(settings.audio_pitch_fmin_hz),
        fmax=float(settings.audio_pitch_fmax_hz),
        min_voiced_frames=int(settings.audio_pitch_min_voiced_frames),
    )
    limitations.extend(pitch_lims)
    if not pitch_ok and snr is not None and snr < float(settings.audio_low_snr_db):
        # already covered
        pass

    word_count = _count_words(transcript_text)
    wpm, wpm_lims = _speaking_rate_wpm(word_count, vad.speech_duration_seconds)
    limitations.extend(wpm_lims)

    return AudioFeatureResult(
        audio_duration_seconds=round(duration, 4),
        sample_rate=int(sr),
        speech_duration_seconds=vad.speech_duration_seconds,
        silence_duration_seconds=vad.silence_duration_seconds,
        silence_percentage=vad.silence_percentage,
        pause_count=vad.pause_count,
        pause_durations_seconds=vad.pause_durations_seconds,
        long_pause_count=vad.long_pause_count,
        words_per_minute=wpm,
        word_count=word_count,
        pitch_median_hz=pitch_median,
        pitch_range_hz=pitch_range,
        pitch_std_hz=pitch_std,
        pitch_available=pitch_ok,
        zero_crossing_rate_mean=round(zcr_mean, 6) if zcr_mean is not None else None,
        spectral_centroid_mean_hz=round(centroid_mean, 2)
        if centroid_mean is not None
        else None,
        rms_energy_mean=round(rms_mean, 6) if rms_mean is not None else None,
        rms_energy_std=round(rms_std, 6) if rms_std is not None else None,
        clipping_detected=clipping_detected,
        clipping_ratio=clipping_ratio,
        snr_estimate_db=snr,
        quality_warnings=quality_warnings,
        limitations=limitations,
        vad_method=vad.method,
    )
