#!/usr/bin/env python3
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║   Audio Enhancement Engine v8.0 — "Calibrated Precision"                  ║
║   المرجع: الشيخ ياسر الدوسري — 1425H                                        ║
╠══════════════════════════════════════════════════════════════════════════════╣
║                                                                              ║
║  الأخطاء المُشخَّصة في v7.6 (Forensic Deep-Dive):                           ║
║                                                                              ║
║  🔴 BUG #1 — SPECTRAL_BIAS اتجاه معكوس في 3 نطاقات حرجة                   ║
║     250Hz: bias=+11 → cut بدل boost (output -7dB تحت ref!)                 ║
║     4kHz:  bias=-1.5 → boost بدل cut (output +5dB فوق ref!)                ║
║     8kHz:  bias=-4.0 → boost بدل cut (output +10dB فوق ref!)               ║
║     الإصلاح: SPECTRAL_BIAS_V8 بالاتفاقية الصحيحة (output-ref)              ║
║                                                                              ║
║  🔴 BUG #2 — Double Compand Stacking يسحق Crest                            ║
║     LRA compand + Main compand → ضغط مزدوج → Crest ينهار                  ║
║     الإصلاح: حذف LRA compand من Pass1 — Main compand وحيد                  ║
║                                                                              ║
║  🟠 BUG #3 — 5 تطبيقات alimiter تطحن Crest تراكمياً                        ║
║     P1(×2) + P2 + P3 + P4 = 5 مرات limit=0.891 → Crest ينخفض 0.8-1.5LU  ║
║     الإصلاح: WAV وسيطة = limit=0.9997 فقط | MP3 نهائي = 0.891             ║
║                                                                              ║
║  🟠 BUG #4 — build_compand_mds يستخدم DR بدل LRA                          ║
║     lra_delta = damage.dr - TARGET['dr'] ← خطأ نوع!                        ║
║     الإصلاح: lra_delta = inp_lra - ref_fp.lra_clip (صحيح)                 ║
║                                                                              ║
║  🟡 BUG #5 — Quality Gate لا يحمي Crest بشكل منفصل                        ║
║     عتبة 1.0 نقطة تتجاهل انهيار Crest 3+LU                                ║
║     الإصلاح: حارس مستقل Crest < P1-1.5LU AND < target-0.8                 ║
║                                                                              ║
║  المحافظ عليه من v7.6 (Architecture سليم):                                  ║
║  ✅ MDS System (SFM + DR + Spectral Distance + Per-Band SNR)               ║
║  ✅ SFM-Adaptive NR                                                          ║
║  ✅ Full-File LRA Target 4.19 (v7.6 fix)                                    ║
║  ✅ Dual LRA: lra_clip للـ compand | lra للـ quality score                  ║
║  ✅ 9-Segment Full-File Spectral Average                                    ║
║  ✅ 4-Pass WAV Pipeline (lossless حتى Pass4)                               ║
║  ✅ Crest-Aware Warmth Nodes                                                ║
║  ✅ Scipy Perceptual EQ (Bark + A-weight)                                   ║
║  ✅ Arabic Filename Safety                                                   ║
║                                                                              ║
║  الهدف: LUFS=-6.29 RMS=-10.01 Crest=10.25 LRA=4.19 ≥96/100               ║
╚══════════════════════════════════════════════════════════════════════════════╝
"""
from __future__ import annotations
import argparse, json, os, shutil, subprocess, sys, warnings, time
from dataclasses import dataclass, field
from pathlib import Path
from typing import Dict, List, Optional, Tuple
warnings.filterwarnings('ignore')

try:
    import numpy as np
    from scipy.fft import rfft, rfftfreq
    from scipy.optimize import minimize
    from scipy.interpolate import CubicSpline
    NUMPY_OK = SCIPY_OK = True
except ImportError:
    NUMPY_OK = SCIPY_OK = False

# ══════════════════════════════════════════════════════════════════════════════
#  CONSTANTS
# ══════════════════════════════════════════════════════════════════════════════
SR = 48000

TARGET = {
    'lufs':      -6.29,
    'rms':      -10.01,
    'crest':     10.25,
    'lra':        4.19,   # full-file measurement (corrected in v7.6, kept in v8)
    'true_peak':  -1.0,
    'bitrate':  '320k',
    'sfm':        0.0444,
    'dr':          7.9,
}

REF_FILES = [
    '/mnt/user-data/uploads/المرجع1425.mp3',
    '/mnt/user-data/uploads/سوره_الفتح.mp3',
    '/mnt/user-data/uploads/ياسر_الدوسري_ما_تسير_من_سورة_فاطر_1425__اول_مرة_تنشر_-_سعد_العنزي.mp3',
]
REF_CACHE = '/tmp/enhance_ref_fp.v80.json'

CENTERS_31 = [
    20,25,31.5,40,50,63,80,100,125,160,
    200,250,315,400,500,630,800,1000,1250,1600,
    2000,2500,3150,4000,5000,6300,8000,10000,12500,16000,20000,
]

A_WEIGHT: Dict[float,float] = {
    20:-50.5,25:-44.7,31.5:-39.4,40:-34.6,50:-30.2,
    63:-26.2,80:-22.5,100:-19.1,125:-16.1,160:-13.4,
    200:-10.9,250:-8.6,315:-6.6,400:-4.8,500:-3.2,
    630:-1.9,800:-0.8,1000:0.0,1250:0.6,1600:1.0,
    2000:1.2,2500:1.3,3150:1.2,4000:1.0,5000:0.5,
    6300:-0.1,8000:-1.1,10000:-2.5,12500:-4.3,16000:-6.6,20000:-9.3,
}

# ══════════════════════════════════════════════════════════════════════════════
#  v8 BUG #1 FIX — SPECTRAL_BIAS_V8: اتفاقية صحيحة موحدة
#
#  الاتفاقية: bias = (output - ref)
#    سالب  = output تحت ref   → g = -(-)*scale = موجب (boost) ✅
#    موجب  = output فوق ref   → g = -(+)*scale = سالب (cut)  ✅
#
#  v7.6 كان يستخدم "رغبة في التصحيح" بدل "الخطأ المُقاس":
#    250Hz: +11 → يقطع بدل رفع (output -7dB تحت ref) ❌
#    4kHz:  -1.5 → يرفع بدل قطع (output +5dB فوق ref) ❌
#    8kHz:  -4.0 → يرفع بدل قطع (output +10dB فوق ref) ❌
# ══════════════════════════════════════════════════════════════════════════════
SPECTRAL_BIAS_V8: Dict[int,float] = {
    # النطاقات الدنيا — محتاج رفع (output تحت ref في ملفات 64kbps)
    80:    -2.50,   # output -2.5dB تحت ref → g=+0.625dB boost
    100:   -4.00,   # output -4dB تحت ref  → g=+1.00dB boost
    125:   +3.50,   # output +3.5dB فوق ref → g=-0.875dB cut
    200:   -4.00,   # output -4dB تحت ref  → g=+1.00dB boost
    # ↓ إصلاح v8 الحرج: كان +11.00 → يقطع عوضاً عن الرفع!
    250:   -7.00,   # output -7dB تحت ref  → g=+1.75dB boost ← v8 FIX الأكبر
    315:   +6.00,   # output +6dB فوق ref  → g=-1.50dB cut
    400:   -1.50,   # output تحت ref      → g=+0.375dB boost
    500:   +1.50,   # output فوق ref      → g=-0.375dB cut
    630:   -2.50,   # output تحت ref      → g=+0.625dB boost
    800:   +1.50,   # output فوق ref      → g=-0.375dB cut
    1000:  -1.00,   # output تحت ref      → g=+0.25dB boost (v7.55: كان يعطي قطع)
    1250:  +0.40,   # صغير جداً → تأثير ضئيل
    2000:  +0.50,   # صغير جداً → تأثير ضئيل
    2500:  +1.80,   # output فوق ref      → g=-0.45dB cut
    3150:  +1.20,   # output فوق ref      → g=-0.30dB cut
    # ↓ إصلاح v8 الحرج: كان -1.50 → يرفع عوضاً عن القطع!
    4000:  +5.00,   # output +5dB فوق ref  → g=-1.25dB cut ← v8 FIX
    # ↓ إصلاح v8: كان -0.80 و-0.90 → يرفع في منطقة مرتفعة أصلاً
    5000:  +0.80,   # output فوق ref      → g=-0.20dB cut ← v8 FIX (was -0.80)
    6300:  +0.90,   # output فوق ref      → g=-0.225dB cut ← v8 FIX (was -0.90)
    # ↓ إصلاح v8 الحرج: كان -4.00 → يرفع عوضاً عن القطع!
    8000:  +8.00,   # output +8-10dB فوق ref → g=-2.00dB cut ← v8 FIX الأكبر
    10000: -2.00,   # output تحت ref (rolloff) → g=+0.50dB boost
}
BIAS_SCALE = 0.25   # الصيغة: g = round(-bias_db * BIAS_SCALE, 2)

# ══════════════════════════════════════════════════════════════════════════════
#  DATA CLASSES
# ══════════════════════════════════════════════════════════════════════════════

@dataclass
class ReferenceFingerprint:
    third_oct:     Dict[float,float] = field(default_factory=dict)
    a_weighted:    Dict[float,float] = field(default_factory=dict)
    rms:           float = TARGET['rms']
    peak:          float = TARGET['true_peak']
    crest:         float = TARGET['crest']
    lra:           float = TARGET['lra']
    lra_clip:      float = 2.94
    tilt_slope:    float = 0.0
    warmth_ratio:  float = 0.0
    sfm:           float = TARGET['sfm']
    dr:            float = TARGET['dr']
    n_files:       int   = 0

@dataclass
class DamageProfile:
    """v7.6 Multi-Metric Damage Score (MDS) — محافَظ عليه في v8"""
    snr:            float = 30.0
    sfm:            float = 0.05
    dr:             float = 8.0
    hf_deficit:     float = 0.0
    spectral_dist:  float = 0.0
    crest:          float = 10.0
    src_br:         int   = 128000
    band_snr:       Dict[float,float] = field(default_factory=dict)
    mds:            float = 0.0
    nr_intensity:   float = 0.0
    compand_score:  float = 0.0
    has_ringing:    bool  = False
    rolloff_hz:     float = 20000.0
    quality_label:  str   = 'GOOD'

@dataclass
class QualityReport:
    score:       float = 0.0
    spectral:    float = 0.0
    lufs:        float = 0.0
    crest:       float = 0.0
    lra:         float = 0.0
    warmth:      float = 0.0
    hf:          float = 0.0
    avg_err:     float = 99.0
    warmth_tilt: float = 0.0
    warmth_ref:  float = 0.0
    lra_target:  float = TARGET['lra']
    notes:       List[str] = field(default_factory=list)

# ══════════════════════════════════════════════════════════════════════════════
#  AUDIO I/O
# ══════════════════════════════════════════════════════════════════════════════

def _safe(path:str) -> Tuple[str,Optional[str]]:
    try: path.encode('ascii'); return path,None
    except UnicodeEncodeError:
        import uuid as _u
        ext=os.path.splitext(path)[1] or '.mp3'
        tmp=f'/tmp/v80_safe_{_u.uuid4().hex[:8]}{ext}'
        shutil.copy2(path,tmp); return tmp,tmp

def load_audio(path:str,sr:int=SR,mono:bool=True,
               skip:int=0,duration:Optional[int]=None) -> 'np.ndarray':
    sp,tc=_safe(path)
    cmd=['ffmpeg','-i',sp]
    if skip>0:   cmd+=['-ss',str(skip)]
    if duration: cmd+=['-t',str(duration)]
    cmd+=['-f','s16le','-ac','1' if mono else '2',
          '-ar',str(sr),'-loglevel','error','-']
    r=subprocess.run(cmd,capture_output=True)
    if tc:
        try: os.remove(tc)
        except: pass
    if not r.stdout: raise RuntimeError(f'فشل تحميل: {path}')
    return np.frombuffer(r.stdout,np.int16).astype(np.float32)/32768.0

def probe(path:str) -> Dict:
    sp,tc=_safe(path)
    r=subprocess.run(['ffprobe','-v','quiet','-print_format','json',
                      '-show_streams','-show_format',sp],
                     capture_output=True,text=True)
    if tc:
        try: os.remove(tc)
        except: pass
    return json.loads(r.stdout) if r.returncode==0 else {}

def measure_lufs(path:str) -> float:
    sp,tc=_safe(path)
    r=subprocess.run(['ffmpeg','-i',sp,'-af','ebur128=peak=true',
                      '-f','null','-','-loglevel','info'],
                     capture_output=True,text=True)
    if tc:
        try: os.remove(tc)
        except: pass
    for line in r.stderr.split('\n'):
        s=line.strip()
        if s.startswith('I:') and 'LUFS' in s and 'LRA' not in s:
            try: return float(s.split('I:')[1].strip().split()[0])
            except: pass
    return -99.0

# ══════════════════════════════════════════════════════════════════════════════
#  SIGNAL METRICS
# ══════════════════════════════════════════════════════════════════════════════

def rms_db(a:'np.ndarray') -> float:
    return float(20*np.log10(np.sqrt(np.mean(a**2))+1e-10))

def peak_db(a:'np.ndarray') -> float:
    return float(20*np.log10(np.max(np.abs(a))+1e-10))

def crest_factor(a:'np.ndarray') -> float:
    return float(peak_db(a)-rms_db(a))

def lra_estimate(a:'np.ndarray',sr:int=SR) -> float:
    n=int(0.4*sr); step=n//2
    lvls=np.array([20*np.log10(np.sqrt(np.mean(a[i:i+n]**2))+1e-10)
                   for i in range(0,len(a)-n,step)])
    if len(lvls)<2: return 0.0
    active=lvls[lvls>np.max(lvls)-30]
    return float(np.percentile(active,95)-np.percentile(active,10)) if len(active)>=2 else 0.0

def snr_estimate(a:'np.ndarray',sr:int=SR) -> float:
    n=int(0.1*sr)
    blocks=np.array([np.sqrt(np.mean(a[i:i+n]**2)) for i in range(0,len(a)-n,n)])
    if len(blocks)<4: return 30.0
    return float(20*np.log10(np.percentile(blocks,85)/(np.percentile(blocks,3)+1e-10)))

def count_clips(a:'np.ndarray',thr:float=0.99) -> int:
    return int(np.sum(np.abs(a)>=thr))

def declip(audio:'np.ndarray',thr:float=0.98) -> Tuple['np.ndarray',int]:
    clipped=np.abs(audio)>=thr; nc=int(np.sum(clipped))
    if nc==0: return audio,0
    out=audio.copy(); n=len(audio)
    diff=np.diff(clipped.astype(int))
    starts=np.where(diff==1)[0]+1; ends=np.where(diff==-1)[0]+1
    if clipped[0]:  starts=np.insert(starts,0,0)
    if clipped[-1]: ends=np.append(ends,n)
    for s,e in zip(starts,ends):
        ctx=40; pre=np.arange(max(0,s-ctx),s); post=np.arange(e,min(n,e+ctx))
        good=np.concatenate([pre,post])
        if len(good)<4: continue
        try:
            cs=CubicSpline(good,audio[good],extrapolate=True)
            out[np.arange(s,e)]=cs(np.arange(s,e))
        except: pass
    return out,nc

# ══════════════════════════════════════════════════════════════════════════════
#  SPECTRAL ANALYSIS
# ══════════════════════════════════════════════════════════════════════════════

def third_octave(audio:'np.ndarray',sr:int=SR,
                 chunk_sec:int=45,a_weighted:bool=False) -> Dict[float,float]:
    chunk=audio[:sr*chunk_sec] if len(audio)>sr*chunk_sec else audio
    N=len(chunk); spec=np.abs(rfft(chunk)); freqs=rfftfreq(N,1.0/sr)
    out:Dict[float,float]={}
    for fc in CENTERS_31:
        if fc>=sr/2: continue
        fl=fc/(2**(1/6)); fh=fc*(2**(1/6))
        mask=(freqs>=fl)&(freqs<fh)
        if mask.sum()>0:
            v=float(20*np.log10(np.mean(spec[mask])+1e-10))
            if a_weighted and fc in A_WEIGHT: v+=A_WEIGHT[fc]
            out[fc]=v
    return out

def hf_status(bands:Dict[float,float]) -> str:
    hfk=[f for f in bands if f>=8000]
    if not hfk: return 'absent'
    avg=float(np.mean([bands[f] for f in hfk]))
    return 'good' if avg>10 else 'weak' if avg>-5 else 'absent'

def detect_hf_rolloff(bands:Dict[float,float],drop:float=12.0) -> float:
    fs=sorted([f for f in bands if 1600<=f<=20000])
    if not fs: return 20000.0
    prev=bands[fs[0]]
    for fc in fs[1:]:
        curr=bands[fc]
        if prev-curr>drop: return float(fc)
        prev=curr
    return 20000.0

def spectral_tilt(bands:Dict[float,float],lo:float=100.0,hi:float=10000.0) -> float:
    fc_arr=np.array([fc for fc in CENTERS_31 if lo<=fc<=hi and fc in bands],dtype=float)
    if len(fc_arr)<3: return 0.0
    return float(np.polyfit(np.log2(fc_arr/1000.0),
                            np.array([bands[fc] for fc in fc_arr]),1)[0])

def warmth_tilt(bands:Dict[float,float]) -> float:
    return spectral_tilt(bands,200.0,2000.0)

def merge_eq(nodes:List[Tuple],gap:float=50.0) -> List[Tuple]:
    if not nodes: return nodes
    nodes=sorted(nodes,key=lambda x:x[0]); merged=[list(nodes[0])]
    for f0,g,Q in nodes[1:]:
        pf,pg,pq=merged[-1]
        if abs(f0-pf)<gap:
            total=float(np.clip(pg+g,-16,16))
            avg_f=(pf*abs(pg)+f0*abs(g))/(abs(pg)+abs(g)+1e-6)
            merged[-1]=[round(avg_f,0),round(total,2),round((pq+Q)/2,2)]
        else: merged.append([f0,g,Q])
    return [tuple(x) for x in merged]

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 1a — SPECTRAL FLATNESS MEASURE (SFM)
# ══════════════════════════════════════════════════════════════════════════════

def compute_sfm(audio:'np.ndarray',sr:int=SR,
                f_lo:float=100.0,f_hi:float=8000.0) -> float:
    """Wiener entropy — مقياس نظافة الطيف | REF 1425H: 0.044"""
    chunk=audio[:sr*30] if len(audio)>sr*30 else audio
    N=len(chunk); spec=np.abs(rfft(chunk))**2; freqs=rfftfreq(N,1.0/sr)
    mask=(freqs>=f_lo)&(freqs<=f_hi)
    s=spec[mask]
    if len(s)<10: return 0.1
    eps=1e-10
    geo=float(np.exp(np.mean(np.log(s+eps))))
    arith=float(np.mean(s))
    return float(np.clip(geo/(arith+eps),0.0,1.0))

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 1b — DYNAMIC RANGE SCORE
# ══════════════════════════════════════════════════════════════════════════════

def compute_dynamic_range(audio:'np.ndarray',sr:int=SR) -> float:
    """نطاق الديناميك الفعلي (20ms frames) | REF: 7.9dB"""
    n=int(0.020*sr)
    frames=np.array([float(np.sqrt(np.mean(audio[i:i+n]**2)))
                     for i in range(0,len(audio)-n,n)])
    if len(frames)<10: return 8.0
    frames_db=20*np.log10(frames+1e-10)
    return float(np.percentile(frames_db,95)-np.percentile(frames_db,5))

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 1c — SPECTRAL SHAPE DISTANCE FROM REFERENCE
# ══════════════════════════════════════════════════════════════════════════════

def compute_spectral_distance(inp_b:Dict,ref_fp:ReferenceFingerprint,
                               hf_rolloff:float=20000.0) -> float:
    """المسافة الطيفية الحقيقية من المرجع بعد level normalization"""
    ref_b=ref_fp.third_oct
    ceil=min(10000.0,hf_rolloff*0.9)
    common=[fc for fc in inp_b if fc in ref_b and 80<=fc<=ceil]
    if len(common)<4: return 20.0
    out_arr=np.array([inp_b[fc] for fc in common])
    ref_arr=np.array([ref_b[fc] for fc in common])
    loff=float(np.mean(ref_arr-out_arr))
    shape_diffs=np.abs((ref_arr-out_arr)-loff)
    aw=np.array([max(0.2,1+A_WEIGHT.get(fc,0)/10) for fc in common])
    return float(np.sum(aw*shape_diffs)/np.sum(aw))

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 1d — CODEC DAMAGE FINGERPRINT (Per-Band SNR)
# ══════════════════════════════════════════════════════════════════════════════

def compute_band_snr(audio:'np.ndarray',sr:int=SR) -> Dict[float,float]:
    """SNR لكل Bark band — يُحدد أين تحتاج NR"""
    N=len(audio); spec=np.abs(rfft(audio))**2; freqs=rfftfreq(N,1.0/sr)
    band_snr={}
    for fc in [125,250,500,1000,2000,4000,8000]:
        fl=fc*0.7; fh=fc*1.4
        mask=(freqs>=fl)&(freqs<fh)
        if mask.sum()<4: continue
        s=spec[mask]
        snr=float(10*np.log10(np.percentile(s,85)/(np.percentile(s,5)+1e-30)+1e-10))
        band_snr[float(fc)]=snr
    return band_snr

# ══════════════════════════════════════════════════════════════════════════════
#  MULTI-METRIC DAMAGE SCORE (MDS)
# ══════════════════════════════════════════════════════════════════════════════

def compute_mds(snr:float,sfm:float,dr:float,hf_deficit:float,
                spectral_dist:float,src_br:int,
                ref_sfm:float=TARGET['sfm'],
                ref_dr:float=TARGET['dr']) -> float:
    """
    Multi-Metric Damage Score: 0=مثالي | 100=أسوأ حالة
    أوزان: SNR 25% | SFM 25% | Spectral Distance 20% | HF 15% | DR 10% | BR 5%
    """
    snr_score  =float(np.clip((30.0-snr)/30.0,0,1))*100
    sfm_ratio  =sfm/(ref_sfm+1e-6)
    sfm_score  =float(np.clip((sfm_ratio-1.0)/5.0,0,1))*100
    spec_score =float(np.clip(spectral_dist/15.0,0,1))*100
    hf_score   =float(np.clip(hf_deficit/30.0,0,1))*100
    dr_excess  =max(0.0,dr-ref_dr)
    dr_score   =float(np.clip(dr_excess/8.0,0,1))*100
    br_score   =float(np.clip((128000-src_br)/100000,0,1))*100
    mds=(snr_score*0.25+sfm_score*0.25+spec_score*0.20+
         hf_score*0.15+dr_score*0.10+br_score*0.05)
    return float(np.clip(mds,0,100))

def mds_to_label(mds:float) -> str:
    if mds>=75: return 'EXTREME'
    if mds>=55: return 'VERY_POOR'
    if mds>=35: return 'POOR'
    if mds>=18: return 'FAIR'
    return 'GOOD'

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 2a — SFM-ADAPTIVE NR
# ══════════════════════════════════════════════════════════════════════════════

def build_nr_sfm(damage:DamageProfile) -> List[str]:
    """NR intensity = f(SFM ratio) — محافَظ عليه من v7.6"""
    parts:List[str]=[]
    if damage.src_br < 96000 and damage.band_snr.get(1000.0,20) < 8:
        if damage.has_ringing and damage.rolloff_hz < 17000:
            parts.append(f'lowpass=f={int(damage.rolloff_hz*0.97)}:poles=2')
        return parts
    sfm_ratio=damage.sfm/(TARGET['sfm']+1e-6)
    if sfm_ratio >= 5.0:
        parts.append('afftdn=nr=20:nf=-55:tn=1')
        parts.append('afftdn=nr=6:nf=-65:tn=1')
    elif sfm_ratio >= 3.0:
        nr=int(np.interp(sfm_ratio,[3,5],[12,20]))
        parts.append(f'afftdn=nr={nr}:nf=-58:tn=1')
    elif sfm_ratio >= 2.0:
        nr=int(np.interp(sfm_ratio,[2,3],[6,12]))
        parts.append(f'afftdn=nr={nr}:nf=-62:tn=1')
    elif sfm_ratio >= 1.5:
        parts.append('afftdn=nr=4:nf=-68:tn=1')
    if damage.has_ringing and damage.rolloff_hz < 17000:
        parts.append(f'lowpass=f={int(damage.rolloff_hz*0.97)}:poles=2')
    return parts

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 2b — v8 BUG #4 FIX — DR-CALIBRATED COMPAND (LRA delta صحيح)
# ══════════════════════════════════════════════════════════════════════════════

def build_compand_mds(damage:DamageProfile,
                      ref_fp:ReferenceFingerprint,
                      inp_lra:float) -> Tuple[str,float,str,float]:
    """
    v8 FIX #4: compand selection باستخدام LRA الفعلي بدل DR
    v7.6 كان: lra_delta = damage.dr - TARGET['dr']  ← خطأ نوع!
    v8:       lra_delta = inp_lra - ref_fp.lra_clip  ← صحيح
    """
    crest_delta = damage.crest - TARGET['crest']
    # v8 FIX: LRA excess الحقيقي مقارنة بالـ clip reference
    lra_delta   = max(0.0, inp_lra - ref_fp.lra_clip)
    # MDS contribution — مقلّص من 3.0 إلى 2.0 لتجنب overweighting
    mds_contrib = damage.mds / 100.0 * 2.0

    score = crest_delta * 0.72 + lra_delta * 0.20 + mds_contrib

    if score >= 11:
        return ("-90/-68|-45/-20|-28/-9|-14/-4.5|-7/-2.0|-3/-0.6|0/-0.1",
                2.5,'EXTREME',2.0)
    elif score >= 6.5:
        return ("-90/-72|-42/-21|-26/-10.5|-13/-5.2|-6/-2.4|-2.5/-0.8|-0.5/-0.3|0/-0.1",
                3.2,'HEAVY',1.8)
    elif score >= 3.5:
        return ("-90/-78|-40/-25|-22/-12.5|-12/-6.8|-6/-3.5|-2.5/-1.6|-0.8/-0.5|0/-0.2",
                2.5,'MEDIUM',1.4)
    elif score >= 1.5:
        return ("-90/-85|-40/-36|-20/-17|-10/-8.2|-5/-4.1|-2/-1.6|-0.5/-0.4|0/-0.3",
                1.2,'LIGHT',0.9)
    elif score >= 0.5:
        return ("-90/-89|-40/-39|-20/-19.5|-10/-9.8|-4/-3.9|-1/-0.95|0/-0.3",
                0.4,'MINIMAL',0.4)
    else:
        return ("-90/-90|-20/-20|-3/-3|0/0",0.0,'BYPASS',0.0)

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 2c — v8 BUG #1 FIX — CORRECTED SPECTRAL BIAS
# ══════════════════════════════════════════════════════════════════════════════

def build_bias_filter(hf_rolloff:float=20000.0) -> str:
    """
    v8 FIX #1: SPECTRAL_BIAS_V8 باتفاقية صحيحة موحدة
    الصيغة: g = -bias * BIAS_SCALE
    bias سالب → g موجب (boost) | bias موجب → g سالب (cut)
    """
    parts=[]
    for fc,bias_db in SPECTRAL_BIAS_V8.items():
        if fc > hf_rolloff * 0.9: continue
        g=round(-bias_db * BIAS_SCALE, 2)
        if abs(g) >= 0.20:  # عتبة أقل من v7.6 (0.25) للتقاط تصحيحات أدق
            Q=0.65 if abs(g)>1.5 else 0.90
            parts.append(f'equalizer=f={fc}:width_type=q:width={Q}:g={g}')
    return ','.join(parts)

# ══════════════════════════════════════════════════════════════════════════════
#  STEP 2d — SPECTRAL DISTANCE EQ (Perceptual Optimizer)
# ══════════════════════════════════════════════════════════════════════════════

def optimize_eq(new_b:Dict,ref_fp:ReferenceFingerprint,
                n_nodes:int=12,max_db:float=6.0,
                shape_only:bool=False,hf_rolloff:float=20000.0) -> List[Tuple]:
    """scipy optimizer — يُصحح المسافة الطيفية الحقيقية | محافَظ عليه من v7.6"""
    ref_b=ref_fp.third_oct
    ceil=min(12000.0,hf_rolloff*0.92)
    common=sorted([fc for fc in new_b if fc in ref_b and 63<=fc<=ceil])
    if len(common)<4: return []

    fc_arr=np.array(common,dtype=float)
    new_arr=np.array([new_b[fc] for fc in common])
    ref_arr=np.array([ref_b[fc] for fc in common])
    loff=float(np.mean(ref_arr-new_arr))
    target=(ref_arr-new_arr)-loff
    if shape_only: target=target-float(np.mean(target))

    def baw(fc:float) -> float:
        bw=2.0 if 500<=fc<=4000 else 1.6 if 200<=fc<500 else 1.4 if 4000<fc<=8000 else 0.9
        return bw*max(0.3,1+A_WEIGHT.get(fc,0)/10)
    aw=np.array([baw(fc) for fc in common])
    init_f=np.logspace(np.log10(63),np.log10(ceil),n_nodes)

    def resp(fa,p):
        r=np.zeros(len(fa))
        for i in range(n_nodes):
            f0=abs(p[i*3])+1e-6; g=p[i*3+1]; Q=max(0.3,abs(p[i*3+2]))
            rat=fa/f0; r+=g/(1+Q**2*(rat-1.0/(rat+1e-9))**2)
        return r

    def obj(p):
        e=np.mean(aw*(resp(fc_arr,p)-target)**2)
        gs=[p[i*3+1] for i in range(n_nodes)]
        sm=sum(0.012*(gs[i+1]-gs[i])**2 for i in range(len(gs)-1))
        mg=sum(0.002*g**2 for g in gs)
        return e+sm+mg

    ig=np.interp(np.log10(init_f),np.log10(fc_arr),target)
    x0=[]
    for f,g in zip(init_f,ig):
        x0.extend([float(np.clip(f,63,ceil)),float(np.clip(g,-max_db,max_db)),1.0])

    res=minimize(obj,x0,method='L-BFGS-B',
                 bounds=[(63,ceil),(-max_db,max_db),(0.3,4.5)]*n_nodes,
                 options={'maxiter':500,'ftol':1e-10,'gtol':1e-9})
    nodes=[]
    for i in range(n_nodes):
        f0=abs(res.x[i*3]); g=res.x[i*3+1]; Q=max(0.3,abs(res.x[i*3+2]))
        if shape_only and g<0 and 400<=f0<=1600: g=max(g,-2.0)
        if abs(g)>=0.35: nodes.append((round(f0,0),round(g,2),round(Q,2)))
    return sorted(nodes,key=lambda x:x[0])

# ══════════════════════════════════════════════════════════════════════════════
#  WARMTH CORRECTION (Crest-Aware — محافَظ عليه من v7.55/v7.6)
# ══════════════════════════════════════════════════════════════════════════════

def build_warmth_nodes(inp_b:Dict,ref_fp:ReferenceFingerprint,
                       hf_rolloff:float=20000.0,post_compand:bool=False,
                       current_crest:float=99.0) -> List[Tuple]:
    tfc=np.array([fc for fc in CENTERS_31 if 200<=fc<=2000
                   and fc in inp_b and fc<hf_rolloff],dtype=float)
    if len(tfc)<3: return []
    tdb=np.array([inp_b[fc] for fc in tfc])
    new_tilt=float(np.polyfit(np.log2(tfc/1000.0),tdb,1)[0])
    tilt_diff=ref_fp.warmth_ratio-new_tilt
    threshold=1.5 if not post_compand else 2.5
    if abs(tilt_diff)<threshold: return []

    # حارس Crest (من v7.55 — محافَظ عليه)
    if current_crest-TARGET['crest']<-1.0: return []

    max_adj=min(3.0,2.0+(current_crest-TARGET['crest'])*0.5) if not post_compand else 1.2
    scale=0.35 if not post_compand else 0.20
    nodes=[]
    adj=float(np.clip(tilt_diff*scale,-max_adj,max_adj))
    if abs(adj)>=0.4: nodes.append((200.0,round(adj,2),0.55))
    madj=float(np.clip(-tilt_diff*0.12,-1.5,1.5))
    if abs(madj)>=0.3: nodes.append((1000.0,round(madj,2),0.80))
    return nodes

# ══════════════════════════════════════════════════════════════════════════════
#  SPECTRAL CORRECTION (Conservative — محافَظ عليه من v7.6)
# ══════════════════════════════════════════════════════════════════════════════

def spectral_correction(out_b:Dict,ref_fp:ReferenceFingerprint,
                        hf_rolloff:float=20000.0,max_db:float=3.0,
                        pass_num:int=2,current_crest:float=99.0) -> List[Tuple]:
    ref_b=ref_fp.third_oct
    ceil=min(10000.0,hf_rolloff*0.9)
    common=sorted([fc for fc in out_b if fc in ref_b and 80<=fc<=ceil])
    if len(common)<4: return []

    out_arr=np.array([out_b[fc] for fc in common])
    ref_arr=np.array([ref_b[fc] for fc in common])
    loff=float(np.mean(ref_arr-out_arr))
    shape=(ref_arr-out_arr)-loff
    avg_err=float(np.mean(np.abs(shape)))

    base=0.58 if avg_err>4.0 else 0.48 if avg_err>2.0 else 0.35
    pm={2:1.00,3:0.70,4:0.45}.get(pass_num,1.00)
    scale=base*pm

    aw=np.array([max(0.3,1+A_WEIGHT.get(fc,0)/10) for fc in common])

    tfc=np.array([fc for fc in common if 200<=fc<=2000],dtype=float)
    warmth_ok=False
    if len(tfc)>=3:
        tdb=np.array([out_b[fc] for fc in tfc])
        out_tw=float(np.polyfit(np.log2(tfc/1000.0),tdb,1)[0])
        warmth_ok=abs(out_tw-ref_fp.warmth_ratio)<3.0

    crest_headroom=current_crest-TARGET['crest']

    nodes:List[Tuple]=[]; prev_g=0.0
    for i,fc in enumerate(common):
        raw_g=float(shape[i])
        g=float(np.clip(raw_g*aw[i]*scale,-max_db,max_db))
        if warmth_ok and 400<=fc<=1600 and g<-0.3 and abs(raw_g)<4.0:
            g=max(g*0.08,-0.20)
        if crest_headroom<-1.5 and fc<=400 and g>0:
            g=g*0.20
        if abs(g)>=0.28 and abs(g-prev_g)<5.0:
            Q=1.2 if abs(g)<2 else 0.85
            nodes.append((float(fc),round(g,2),Q))
        prev_g=g
    return nodes

# ══════════════════════════════════════════════════════════════════════════════
#  QUALITY SCORE (محافَظ عليه — ref_fp.lra = 4.19 صحيح منذ v7.6)
# ══════════════════════════════════════════════════════════════════════════════

def quality_score(out_b:Dict,ref_fp:ReferenceFingerprint,
                  metrics:Dict,hf_rolloff:float=20000.0) -> Tuple[float,QualityReport]:
    ref_b=ref_fp.third_oct
    ceil=min(10000,int(hf_rolloff*0.85))
    common=[fc for fc in out_b if fc in ref_b and 80<=fc<=ceil]

    if common:
        out_v=np.array([out_b[fc] for fc in common])
        ref_v=np.array([ref_b[fc] for fc in common])
        aw=np.array([max(0.2,1+A_WEIGHT.get(fc,0)/10) for fc in common])
        loff=float(np.mean(ref_v-out_v))
        diffs=np.abs((ref_v-out_v)-loff)
        w_avg=float(np.sum(aw*diffs)/np.sum(aw))
        spectral_s=max(0.0,100.0-w_avg*4.5)
    else:
        w_avg=99.0; spectral_s=0.0

    lufs_e=abs(metrics.get('lufs',-20)-TARGET['lufs'])
    crest_e=abs(metrics.get('crest',15)-TARGET['crest'])
    lra_t=ref_fp.lra  # 4.19 — صحيح في v7.6 وv8
    lra_e=abs(metrics.get('lra',8)-lra_t)
    lufs_s=max(0.0,100.0-lufs_e*12)
    crest_s=max(0.0,100.0-crest_e*8)
    lra_s=max(0.0,100.0-lra_e*10)

    tfc=np.array([fc for fc in CENTERS_31 if 200<=fc<=2000
                   and fc in out_b and fc<hf_rolloff],dtype=float)
    out_tilt=(float(np.polyfit(np.log2(tfc/1000.0),
                               np.array([out_b[fc] for fc in tfc]),1)[0])
              if len(tfc)>=3 else 0.0)
    warmth_s=max(0.0,100.0-abs(out_tilt-ref_fp.warmth_ratio)*5.5)

    hf_fcs=[fc for fc in [4000,5000,6300,8000,10000,12500]
            if fc<hf_rolloff and fc in out_b and fc in ref_b]
    if len(hf_fcs)>=3:
        hf_o=np.array([out_b[fc] for fc in hf_fcs])
        hf_r=np.array([ref_b[fc] for fc in hf_fcs])
        hf_e=float(np.mean(np.abs((hf_r-hf_o)-float(np.mean(hf_r-hf_o)))))
        hf_s=max(0.0,100.0-hf_e*4)
    else: hf_s=50.0

    total=(spectral_s*0.38+lufs_s*0.20+crest_s*0.15+
           lra_s*0.12+warmth_s*0.10+hf_s*0.05)

    notes=[]
    if lufs_e>0.6:  notes.append(f"LUFS:{metrics.get('lufs',-99):.2f}→{TARGET['lufs']}")
    if crest_e>1.2: notes.append(f"Crest:{metrics.get('crest',0):.2f}→{TARGET['crest']}")
    if lra_e>1.0:   notes.append(f"LRA:{metrics.get('lra',0):.2f}→{lra_t:.2f}")
    if w_avg>2.5:   notes.append(f"Spectral:±{w_avg:.2f}dB")

    rpt=QualityReport(
        score=round(total,1),spectral=round(spectral_s,1),
        lufs=round(lufs_s,1),crest=round(crest_s,1),lra=round(lra_s,1),
        warmth=round(warmth_s,1),hf=round(hf_s,1),
        avg_err=round(w_avg,2),warmth_tilt=round(out_tilt,2),
        warmth_ref=round(ref_fp.warmth_ratio,2),lra_target=round(lra_t,2),
        notes=notes)
    return rpt.score,rpt

# ══════════════════════════════════════════════════════════════════════════════
#  9-SEGMENT FULL-FILE SPECTRAL AVERAGE
# ══════════════════════════════════════════════════════════════════════════════

def analyze_full_spectrum(input_path:str,total_s:int) -> Dict[float,float]:
    pcts=[0.10,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.90]
    skips=[max(10,int(total_s*p)) for p in pcts]
    clips=[f'/tmp/v80_seg{i}.wav' for i in range(len(skips))]
    procs=[subprocess.Popen(['ffmpeg','-y','-i',input_path,
            '-ss',str(sk),'-t','20','-f','s16le','-ac','1',
            '-ar',str(SR),cl,'-loglevel','error'])
           for sk,cl in zip(skips,clips)]
    for p in procs: p.wait()
    all_bands:List[Dict]=[]
    for cl in clips:
        try:
            if not os.path.exists(cl) or os.path.getsize(cl)<SR*2: continue
            a=np.frombuffer(open(cl,'rb').read(),np.int16).astype(np.float32)/32768.0
            if len(a)<SR*3: continue
            all_bands.append(third_octave(a,a_weighted=False))
        except: pass
    if not all_bands: return {}
    result={}
    for fc in CENTERS_31:
        vals=[b.get(fc) for b in all_bands if b.get(fc) is not None]
        if len(vals)>=2: result[fc]=float(np.median(vals))
    return result

# ══════════════════════════════════════════════════════════════════════════════
#  REFERENCE FINGERPRINT
# ══════════════════════════════════════════════════════════════════════════════

def get_reference_fingerprint() -> ReferenceFingerprint:
    primary=REF_FILES[0]
    if os.path.exists(REF_CACHE):
        try:
            mref=os.path.getmtime(primary) if os.path.exists(primary) else 0
            if os.path.getmtime(REF_CACHE)>=mref:
                with open(REF_CACHE,'r',encoding='utf-8') as f: d=json.load(f)
                if d.get('version')=='v8.0':
                    fp=ReferenceFingerprint()
                    fp.third_oct   ={float(k):v for k,v in d['third_oct'].items()}
                    fp.a_weighted  ={float(k):v for k,v in d.get('a_weighted',{}).items()}
                    fp.rms=d['rms']; fp.peak=d['peak']
                    fp.crest=d['crest']
                    fp.lra=d.get('lra',TARGET['lra'])
                    fp.lra_clip=d.get('lra_clip',2.94)
                    fp.tilt_slope=d['tilt_slope']
                    fp.warmth_ratio=d['warmth_ratio']
                    fp.sfm=d.get('sfm',TARGET['sfm'])
                    fp.dr=d.get('dr',TARGET['dr'])
                    fp.n_files=d.get('n_files',1)
                    return fp
        except: pass

    SAFE_PCT=[0.12,0.22,0.33,0.44,0.55,0.66,0.77,0.88]
    all_fp:List[Dict]=[]

    for idx,path in enumerate(REF_FILES):
        if not os.path.exists(path): continue
        try:
            p_info=probe(path)
            total_s=int(float(p_info.get('format',{}).get('duration',300)))
            skips=[max(15,int(total_s*r)) for r in SAFE_PCT]
            clips=[f'/tmp/ref80_f{idx}_s{i}.wav' for i in range(len(skips))]
            procs=[subprocess.Popen(['ffmpeg','-y','-i',path,
                   '-ss',str(sk),'-t','30','-f','s16le','-ac','1',
                   '-ar',str(SR),cl,'-loglevel','error'])
                   for sk,cl in zip(skips,clips)]
            for p in procs: p.wait()
            segs_spec=[]; segs_rms=[]; segs_crest=[]; segs_lra=[]
            segs_sfm=[]; segs_dr=[]
            for cl in clips:
                try:
                    if not os.path.exists(cl) or os.path.getsize(cl)<SR*2: continue
                    a=np.frombuffer(open(cl,'rb').read(),np.int16).astype(np.float32)/32768.0
                    if len(a)<SR*3: continue
                    segs_spec.append(third_octave(a,a_weighted=False))
                    segs_rms.append(rms_db(a)); segs_crest.append(crest_factor(a))
                    segs_lra.append(lra_estimate(a))
                    segs_sfm.append(compute_sfm(a))
                    segs_dr.append(compute_dynamic_range(a))
                except: pass
            if len(segs_spec)>=4:
                common=[fc for fc in CENTERS_31 if all(fc in s for s in segs_spec)]
                all_fp.append({
                    'spec':{fc:float(np.median([s[fc] for s in segs_spec])) for fc in common},
                    'rms':float(np.median(segs_rms)),
                    'crest':float(np.median(segs_crest)),
                    'lra_clip':float(np.median(segs_lra)),
                    'sfm':float(np.median(segs_sfm)),
                    'dr':float(np.median(segs_dr)),
                })
        except: continue

    if len(all_fp)<2:
        fp=_build_single_ref(primary) if os.path.exists(primary) else ReferenceFingerprint()
        fp.n_files=len(all_fp) or 1; return fp

    ref_lvl=float(np.mean([f['rms'] for f in all_fp]))
    common_all=[fc for fc in CENTERS_31 if all(fc in f['spec'] for f in all_fp)]
    normed=[{fc:f['spec'][fc]+(ref_lvl-f['rms']) for fc in common_all} for f in all_fp]
    multi={fc:float(np.median([s[fc] for s in normed])) for fc in common_all}

    fp=ReferenceFingerprint()
    fp.third_oct   =multi
    fp.rms         =float(np.median([f['rms']      for f in all_fp]))
    fp.peak        =TARGET['true_peak']
    fp.crest       =float(np.median([f['crest']    for f in all_fp]))
    fp.lra_clip    =float(np.median([f['lra_clip'] for f in all_fp]))
    fp.lra         =TARGET['lra']   # 4.19 hardcoded full-file (corrected in v7.6)
    fp.sfm         =float(np.median([f['sfm']      for f in all_fp]))
    fp.dr          =float(np.median([f['dr']       for f in all_fp]))
    fp.n_files     =len(all_fp)
    fp.tilt_slope  =spectral_tilt(fp.third_oct)
    fp.warmth_ratio=warmth_tilt(fp.third_oct)

    try:
        p_info=probe(primary)
        ts=int(float(p_info.get('format',{}).get('duration',300)))
        pa=load_audio(primary,skip=int(ts*0.35),duration=60)
        fp.a_weighted=third_octave(pa,a_weighted=True)
    except: pass

    try:
        d={
            'version':'v8.0',
            'third_oct':{str(k):v for k,v in fp.third_oct.items()},
            'a_weighted':{str(k):v for k,v in fp.a_weighted.items()},
            'rms':fp.rms,'peak':fp.peak,'crest':fp.crest,
            'lra':fp.lra,'lra_clip':fp.lra_clip,
            'tilt_slope':fp.tilt_slope,'warmth_ratio':fp.warmth_ratio,
            'sfm':fp.sfm,'dr':fp.dr,'n_files':fp.n_files,
        }
        with open(REF_CACHE,'w',encoding='utf-8') as f:
            json.dump(d,f,ensure_ascii=False,indent=2)
    except: pass
    return fp

def _build_single_ref(path:str) -> ReferenceFingerprint:
    p_info=probe(path); total_s=int(float(p_info.get('format',{}).get('duration',300)))
    skips=[max(10,int(total_s*r)) for r in [0.12,0.28,0.44,0.60,0.78]]
    clips=[f'/tmp/ref80_s{i}.wav' for i in range(len(skips))]
    procs=[subprocess.Popen(['ffmpeg','-y','-i',path,'-ss',str(sk),'-t','40',
            '-f','s16le','-ac','1','-ar',str(SR),cl,'-loglevel','error'])
           for sk,cl in zip(skips,clips)]
    for p in procs: p.wait()
    segs=[]
    for cl in clips:
        try:
            a=np.frombuffer(open(cl,'rb').read(),np.int16).astype(np.float32)/32768.0
            if len(a)>SR: segs.append(a)
        except: pass
    ref=np.concatenate(segs) if segs else load_audio(path,skip=30,duration=120)
    chunk_n=SR*20; all_b=[]; crests=[]; lras=[]; sfms=[]; drs=[]
    for ci in range(max(1,len(ref)//chunk_n)):
        seg=ref[ci*chunk_n:(ci+1)*chunk_n]
        if len(seg)<SR*3: continue
        all_b.append(third_octave(seg)); crests.append(crest_factor(seg))
        lras.append(lra_estimate(seg)); sfms.append(compute_sfm(seg))
        drs.append(compute_dynamic_range(seg))
    if not all_b: all_b=[third_octave(ref)]
    fp=ReferenceFingerprint()
    for fc in CENTERS_31:
        vals=[b.get(fc) for b in all_b if b.get(fc) is not None]
        if vals: fp.third_oct[fc]=float(np.median(vals))
    fp.rms=rms_db(ref); fp.peak=peak_db(ref)
    fp.crest   =float(np.median(crests)) if crests else crest_factor(ref)
    fp.lra_clip=float(np.median(lras))   if lras   else lra_estimate(ref)
    fp.lra     =TARGET['lra']
    fp.sfm     =float(np.median(sfms))   if sfms   else TARGET['sfm']
    fp.dr      =float(np.median(drs))    if drs    else TARGET['dr']
    fp.tilt_slope=spectral_tilt(fp.third_oct)
    fp.warmth_ratio=warmth_tilt(fp.third_oct)
    fp.n_files=1; return fp

# ══════════════════════════════════════════════════════════════════════════════
#  LUFS SAMPLING
# ══════════════════════════════════════════════════════════════════════════════

def sample_lufs_7pt(input_path:str,total_s:int,n_ch:str,filter_str:str) -> float:
    pts=[max(10,int(total_s*p)) for p in [0.08,0.18,0.32,0.50,0.65,0.78,0.90]]
    for i in range(1,len(pts)):
        if pts[i]-pts[i-1]<30: pts[i]=pts[i-1]+30
    clips=[f'/tmp/v80_lc{i}.wav' for i in range(len(pts))]
    procs=[subprocess.Popen(['ffmpeg','-y','-i',input_path,
            '-ss',str(sk),'-t','22','-ar','48000','-ac',n_ch,
            cl,'-loglevel','error']) for sk,cl in zip(pts,clips)]
    for p in procs: p.wait()
    lp=[subprocess.Popen(['ffmpeg','-y','-i',cl,'-af',
         filter_str+',ebur128=peak=true','-f','null','-','-loglevel','info'],
         stderr=subprocess.PIPE,stdout=subprocess.PIPE) for cl in clips]
    vals:List[float]=[]
    for p in lp:
        _,err=p.communicate()
        for line in err.decode().split('\n'):
            s=line.strip()
            if s.startswith('I:') and 'LUFS' in s and 'LRA' not in s:
                try: vals.append(float(s.split('I:')[1].strip().split()[0])); break
                except: pass
    if not vals: return -12.0
    gw=[0.05,0.12,0.20,0.26,0.20,0.12,0.05][:len(vals)]
    gw=[w/sum(gw) for w in gw]
    return float(np.average(vals,weights=gw))

# ══════════════════════════════════════════════════════════════════════════════
#  FILTER CHAIN BUILDER — v8 BUG #2 + #3 FIX
# ══════════════════════════════════════════════════════════════════════════════

def build_filter_chain(eq_nodes:List[Tuple],compand_pts:str,makeup:float,
                       hf:str,is_mono:bool,gain_db:float,
                       nr_parts:List[str],bias_filter:str,
                       warmth_pre:List[Tuple],intensity:str,
                       inp_lra:float,damage:DamageProfile,
                       hf_rolloff:float,src_sr:int,
                       ref_lra_clip:float,tilt_slope:float,
                       correction_nodes:List[Tuple]=None,
                       post_warmth:List[Tuple]=None) -> str:
    """
    v8 FIX #2: حذف LRA compand من الـ chain — compand رئيسي واحد فقط
    v8 FIX #3: alimiter واحد ناعم (0.9997) في WAV الوسيطة بدل 0.891
    """
    if correction_nodes is None: correction_nodes=[]
    if post_warmth is None:      post_warmth=[]
    parts:List[str]=[]; is_bypass=(intensity=='BYPASS')
    is_extreme=(damage.quality_label=='EXTREME')

    # 1. DC blocking
    parts.append('highpass=f=28:poles=2')

    # 2. NR
    parts.extend(nr_parts)

    # 3. Tilt correction
    if not is_bypass and abs(tilt_slope)>1.0:
        db=min(abs(tilt_slope)*0.35,5.0)
        if tilt_slope>0: parts.append(f'treble=g={db:.1f}:f=8000:width_type=o:width=2')
        else:            parts.append(f'bass=g={db:.1f}:f=150:width_type=o:width=2')

    # 4. Perceptual EQ (scipy Bark + A-weight)
    for f0,g,Q in eq_nodes:
        parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')

    # 5. Warmth pre-compand (Crest-aware)
    for f0,g,Q in warmth_pre:
        parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')

    # 6. HF reconstruction
    if not is_bypass:
        if is_extreme:
            parts.append('crystalizer=i=7')
            if hf_rolloff<8000:
                parts.append(f'treble=g=3.5:f={max(2000,int(hf_rolloff*0.65))}:width_type=o:width=2')
            parts.append('treble=g=3.0:f=7000:width_type=o:width=1.5')
        elif damage.quality_label=='VERY_POOR':
            parts.append('crystalizer=i=6')
            parts.append('treble=g=2.0:f=6000:width_type=o:width=2')
        elif damage.quality_label in ('POOR','GOOD','FAIR'):
            if hf=='weak':   parts.append('crystalizer=i=4')
            elif hf=='absent': parts.append('crystalizer=i=6')

    # 7. Post-NR
    if not is_bypass and nr_parts:
        if is_extreme: parts.append('afftdn=nr=4:nf=-80:tn=0')
        elif damage.quality_label in ('POOR','VERY_POOR'):
            parts.append('afftdn=nr=6:nf=-74:tn=0')
        elif damage.snr<40:
            nr=max(3,min(10,int((40.0-damage.snr)*0.4)))
            parts.append(f'afftdn=nr={nr}:nf=-74:tn=1')

    # ══════════════════════════════════════════════════════════════════
    # v8 FIX #2: LRA CONTROL — agate للـ LRA المنخفض فقط
    #
    # v7.6 كان يضيف compand ثانٍ عندما inp_lra > ref_lra_clip
    # هذا كان يسبب double compression → Crest collapse
    #
    # v8: نحذف LRA compand تماماً
    #   - Low LRA (lra_deficit > 0.5): agate لتوسيع الديناميك فقط
    #   - High LRA (lra_deficit < -0.4): نتركها للـ compand الرئيسي
    #     الرعاية المتبقية تتم في Pass 3 feedback
    # ══════════════════════════════════════════════════════════════════
    lra_deficit=ref_lra_clip-inp_lra
    if not is_bypass and lra_deficit>0.5:
        # LRA منخفض جداً → agate لتوسيع النطاق الديناميكي
        ratio=min(4.0 if is_extreme else 3.5,
                  1.0+lra_deficit*(0.40 if is_extreme else 0.28))
        thr=max(0.010,min(0.045,0.022+lra_deficit*0.004))
        rel=1200 if is_extreme else 800
        parts.append(f'agate=threshold={thr:.3f}:ratio={ratio:.2f}'
                     f':attack=20:release={rel}:makeup=1.0:range=0.06')
    # v8 FIX: لا يوجد elif lra_deficit<-0.4 هنا!
    # LRA مرتفع → Main compand يعالجه | Pass 3 يعالج الباقي

    # 8. Single clean compand (v7.0 proven architecture)
    if not is_bypass:
        atk={'MINIMAL':0.050,'LIGHT':0.030,'MEDIUM':0.015,'HEAVY':0.008,'EXTREME':0.020}
        dcy={'MINIMAL':3.0,  'LIGHT':2.0,  'MEDIUM':1.0,  'HEAVY':0.5,  'EXTREME':0.40}
        parts.append(f'compand=attacks={atk.get(intensity,0.015)}'
                     f':decays={dcy.get(intensity,1.0)}'
                     f':points={compand_pts}:gain={makeup}')

    # 9. Post-compand warmth (Crest-aware)
    for f0,g,Q in post_warmth:
        parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')

    # 10. Spectral bias (v8 corrected)
    if not is_bypass and bias_filter:
        parts.append(bias_filter)

    # 11. Correction nodes
    for f0,g,Q in correction_nodes:
        parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')

    # v8 FIX #3: حذف alimiter الوسيط (0.978/0.982) من هنا!
    # v7.6 كان يضيف: alimiter=limit=0.978:attack=5:release=40 هنا
    # هذا كان يسحق Crest قبل أن يصل للـ alimiter الرئيسي

    # 12. Volume
    if abs(gain_db)>0.05: parts.append(f'volume={gain_db:.3f}dB')

    # 13. Stereo
    if is_mono: parts.append('aformat=channel_layouts=stereo')

    # v8 FIX #3: alimiter ناعم جداً للـ WAV الوسيطة (يحمي من overflow فقط)
    # True Peak الحقيقي (0.891) يُطبَّق في Pass 4 فقط
    if is_bypass:
        parts.append('alimiter=limit=0.999:level=false:attack=5:release=15')
    else:
        parts.append('alimiter=limit=0.9997:level=false:attack=10:release=100')

    return ','.join(f'\n    {p}' for p in parts)

# ══════════════════════════════════════════════════════════════════════════════
#  MAIN ENHANCE — v8.0
# ══════════════════════════════════════════════════════════════════════════════

def enhance(input_path:str,output_path:str,
            max_iterations:int=3,target_score:float=96.0) -> Dict:
    log:List[str]=[]; t0=time.time()
    def L(m:str='') -> None: print(m); log.append(m)

    _input_tmp=None
    try: input_path.encode('ascii')
    except UnicodeEncodeError:
        import uuid as _u2; ext=os.path.splitext(input_path)[1] or '.mp3'
        _input_tmp=f'/tmp/v80_in_{_u2.uuid4().hex[:8]}{ext}'
        shutil.copy2(input_path,_input_tmp); input_path=_input_tmp

    L(f"╔{'═'*70}╗")
    L(f"║  Audio Enhancement Engine v8.0 — \"Calibrated Precision\"             ║")
    L(f"║  المرجع: الشيخ ياسر الدوسري — 1425H                                 ║")
    L(f"║  الإصلاحات: BIAS_SIGN ✓ | NO_STACKING ✓ | SINGLE_LIMITER ✓          ║")
    L(f"╚{'═'*70}╝")
    L(f"  الملف: {os.path.basename(input_path)}")

    # ── Reference ────────────────────────────────────────────────────────────
    L(f"\n[١] بصمة المرجع v8.0 (MDS: SFM + DR + Spectral Distance)...")
    ref_fp=get_reference_fingerprint()
    L(f"  ✓ {ref_fp.n_files} سورة | RMS={ref_fp.rms:.2f} Crest={ref_fp.crest:.2f}"
      f" LRA={ref_fp.lra:.2f}(full)/{ref_fp.lra_clip:.2f}(clip)")
    L(f"  ✓ SFM={ref_fp.sfm:.4f} DR={ref_fp.dr:.1f}dB"
      f" Warmth={ref_fp.warmth_ratio:.2f} Tilt={ref_fp.tilt_slope:.2f}")

    # ── File Analysis ─────────────────────────────────────────────────────────
    L(f"\n[٢] تحليل شامل (MDS: 4 مقاييس)...")
    pr=probe(input_path)
    stream=pr.get('streams',[{}])[0]
    is_mono=stream.get('channels',2)==1
    src_sr=int(stream.get('sample_rate',44100))
    src_br=int(stream.get('bit_rate',128000))
    total_s=int(float(pr.get('format',{}).get('duration',300)))
    n_ch='1' if is_mono else '2'; skip_s=min(30,total_s//4)

    full_b=analyze_full_spectrum(input_path,total_s)
    inp=load_audio(input_path,skip=skip_s,duration=45)
    inp_b=full_b if full_b else third_octave(inp,a_weighted=False)

    inp_rms=rms_db(inp); inp_crest=crest_factor(inp)
    inp_lra=lra_estimate(inp); inp_hf=hf_status(inp_b)

    hf_freqs=[fc for fc in inp_b if fc>=8000]
    hf_avg=float(np.mean([inp_b[fc] for fc in hf_freqs])) if hf_freqs else -80.0
    ref_hf=float(np.mean([ref_fp.third_oct.get(fc,-60) for fc in hf_freqs])) if hf_freqs else -40.0
    hf_deficit=ref_hf-hf_avg
    hf_rolloff=max(detect_hf_rolloff(inp_b,12.0),2000.0)

    # Step 1a: SFM
    inp_sfm=compute_sfm(inp)
    sfm_ratio=inp_sfm/(ref_fp.sfm+1e-6)
    L(f"  Step 1a — SFM={inp_sfm:.4f} (ref={ref_fp.sfm:.4f}, ratio={sfm_ratio:.1f}x)")

    # Step 1b: DR
    inp_dr=compute_dynamic_range(inp)
    L(f"  Step 1b — DR={inp_dr:.1f}dB (ref={ref_fp.dr:.1f}dB, excess={inp_dr-ref_fp.dr:+.1f})")

    # Step 1c: Spectral distance
    spec_dist=compute_spectral_distance(inp_b,ref_fp,hf_rolloff)
    L(f"  Step 1c — Spectral distance=±{spec_dist:.2f}dB from 1425H")

    # Step 1d: Per-band SNR
    band_snr=compute_band_snr(inp)
    snr_global=float(np.mean(list(band_snr.values()))) if band_snr else 30.0

    # MDS
    mds=compute_mds(snr_global,inp_sfm,inp_dr,hf_deficit,spec_dist,src_br,
                    ref_fp.sfm,ref_fp.dr)
    quality_label=mds_to_label(mds)

    has_ringing=(src_br<65000)
    br_rolloff=15500.0 if src_br<65000 else 16500.0 if src_br<97000 else hf_rolloff

    damage=DamageProfile(
        snr=snr_global,sfm=inp_sfm,dr=inp_dr,hf_deficit=hf_deficit,
        spectral_dist=spec_dist,crest=inp_crest,src_br=src_br,
        band_snr=band_snr,mds=mds,has_ringing=has_ringing,
        rolloff_hz=br_rolloff,quality_label=quality_label
    )

    L(f"\n  MDS={mds:.1f}/100 → {quality_label}")
    L(f"  Crest={inp_crest:.2f} LRA={inp_lra:.2f} BR={src_br//1000}kbps"
      f" Ringing={'✓' if has_ringing else '✗'}")

    # ── STEP 2: MDS-Driven Processing ─────────────────────────────────────────
    L(f"\n[٣] Step 2a — SFM-Adaptive NR...")
    use_nr=(src_br>=96000) and (snr_global>=8.0)
    nr_parts=build_nr_sfm(damage) if use_nr or has_ringing else (
        [f'lowpass=f={int(br_rolloff*0.97)}:poles=2'] if has_ringing else [])

    L(f"\n[٤] Step 2b — MDS-Calibrated Compand (v8 FIX: LRA delta صحيح)...")
    # v8 FIX #4: نمرر inp_lra للدالة
    compand_pts,makeup,intensity,calib=build_compand_mds(damage,ref_fp,inp_lra)
    lra_delta_actual=max(0.0,inp_lra-ref_fp.lra_clip)
    L(f"  Compand={intensity} Makeup=+{makeup:.1f}dB calib={calib:+.1f}dB"
      f" (LRA_delta={lra_delta_actual:.2f} | MDS={mds:.0f})")

    L(f"\n[٥] Step 2d — Spectral Distance EQ (scipy Bark)...")
    max_eq_db=4.0 if quality_label=='EXTREME' else 5.0 if quality_label=='VERY_POOR' else 6.0
    n_eq=12 if quality_label=='EXTREME' else 10
    eq_nodes=optimize_eq(inp_b,ref_fp,n_nodes=n_eq,max_db=max_eq_db,
                         shape_only=(quality_label=='EXTREME'),hf_rolloff=hf_rolloff)

    warmth_pre=build_warmth_nodes(inp_b,ref_fp,hf_rolloff,
                                  post_compand=False,current_crest=inp_crest)
    eq_all=merge_eq(sorted(eq_nodes+warmth_pre,key=lambda x:x[0]),60.0)
    eq_all=[(f,float(np.clip(g,-max_eq_db,max_eq_db)),q) for f,g,q in eq_all]
    eq_final=[]
    for f0,g,q in eq_all:
        if f0>=hf_rolloff and g>0:
            if f0<hf_rolloff*1.5: eq_final.append((f0,min(-0.5,g*-0.3),q))
        else: eq_final.append((f0,g,q))
    eq_nodes_cur=eq_final
    L(f"  {len(eq_nodes_cur)} نقطة EQ (±{max_eq_db}dB)")

    inp_tilt=spectral_tilt(inp_b); tilt_corr=ref_fp.tilt_slope-inp_tilt
    # v8 FIX #1: build_bias_filter يستخدم SPECTRAL_BIAS_V8 المُصحَّح
    bias_filter=build_bias_filter(hf_rolloff)
    L(f"  Bias: 250Hz→+{abs(-(-7.00)*BIAS_SCALE):.2f}dB↑ | "
      f"4kHz→{-(5.00*BIAS_SCALE):.2f}dB↓ | "
      f"8kHz→{-(8.00*BIAS_SCALE):.2f}dB↓ (v8 FIX)")

    # ── STEP 3: Do-No-Harm Convergence ────────────────────────────────────────
    L(f"\n{'─'*70}")
    L(f"  STEP 3 — Do-No-Harm Convergence (v8 — Single Compand + Single Limiter)")
    L(f"{'─'*70}")

    best_score=0.0; best_path=None

    for iteration in range(max_iterations):
        L(f"\n  ◆ تكرار {iteration+1}/{max_iterations}")

        # LUFS 7-point
        L(f"  [٦] LUFS 7-point Gaussian...")
        chain0=build_filter_chain(
            eq_nodes_cur,compand_pts,makeup,inp_hf,is_mono,0.0,
            nr_parts,bias_filter,[],intensity,inp_lra,damage,
            hf_rolloff,src_sr,ref_fp.lra_clip,tilt_corr
        ).replace('\n','').replace('    ','')

        l0=sample_lufs_7pt(input_path,total_s,n_ch,chain0)
        gain_needed=float(np.clip(TARGET['lufs']-l0-calib,-18,12))
        L(f"    LUFS_7pt={l0:.2f}  gain={gain_needed:+.2f}dB")

        # Pass 1 → WAV
        L(f"  [٧] Pass 1 → WAV (single compand, soft limiter)...")
        tmp_p1='/tmp/v80_p1.wav'
        chain1=build_filter_chain(
            eq_nodes_cur,compand_pts,makeup,inp_hf,is_mono,gain_needed,
            nr_parts,bias_filter,[],intensity,inp_lra,damage,
            hf_rolloff,src_sr,ref_fp.lra_clip,tilt_corr
        ).replace('\n','').replace('    ','')

        r1=subprocess.run(['ffmpeg','-y','-i',input_path,'-af',
                           chain1+',ebur128=peak=true',
                           '-ar','48000','-ac','2',tmp_p1,'-loglevel','info'],
                          capture_output=True,text=True)
        lufs_p1=-99.0
        for line in r1.stderr.split('\n'):
            s=line.strip()
            if s.startswith('I:') and 'LUFS' in s and 'LRA' not in s:
                try: lufs_p1=float(s.split('I:')[1].strip().split()[0]); break
                except: pass
        if lufs_p1==-99.0: lufs_p1=gain_needed+l0

        p1_a=load_audio(tmp_p1,skip=skip_s,duration=45)
        p1_b=third_octave(p1_a)
        p1_crest=crest_factor(p1_a)
        p1_m={'lufs':lufs_p1,'rms':rms_db(p1_a),'crest':p1_crest,'lra':lra_estimate(p1_a)}
        s1,_=quality_score(p1_b,ref_fp,p1_m,hf_rolloff)
        L(f"    LUFS={lufs_p1:.2f} RMS={p1_m['rms']:.2f} Crest={p1_crest:.2f}"
          f" LRA={p1_m['lra']:.2f} Score={s1}")

        # Pass 2 → WAV (spectral correction + warmth)
        L(f"  [٨] Pass 2 → WAV (Crest-aware spectral correction)...")
        lufs_corr=TARGET['lufs']-lufs_p1
        p1_adj={fc:v+lufs_corr for fc,v in p1_b.items()}
        max_c2=2.5 if quality_label=='EXTREME' else 3.0
        corr2=spectral_correction(p1_adj,ref_fp,hf_rolloff,max_c2,2,p1_crest)
        pw2=build_warmth_nodes(p1_adj,ref_fp,hf_rolloff,True,p1_crest)

        p2_parts=[f'volume={lufs_corr:.3f}dB']
        for f0,g,Q in corr2:
            p2_parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')
        for f0,g,Q in pw2:
            p2_parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')
        # v8 FIX #3: WAV وسيطة = limit ناعم جداً (يحفظ Crest)
        p2_parts.append('alimiter=limit=0.9997:level=false:attack=10:release=100')

        tmp_p2='/tmp/v80_p2.wav'
        subprocess.run(['ffmpeg','-y','-i',tmp_p1,'-af',','.join(p2_parts),
                        '-ar','48000','-ac','2',tmp_p2,'-loglevel','error'],
                       capture_output=True)

        p2_a=load_audio(tmp_p2,skip=skip_s,duration=45)
        p2_b=third_octave(p2_a)
        p2_crest=crest_factor(p2_a); p2_lra=lra_estimate(p2_a); p2_rms=rms_db(p2_a)
        p2_m={'lufs':TARGET['lufs'],'rms':p2_rms,'crest':p2_crest,'lra':p2_lra}
        s2,_=quality_score(p2_b,ref_fp,p2_m,hf_rolloff)
        L(f"    RMS={p2_rms:.2f} Crest={p2_crest:.2f} LRA={p2_lra:.2f} Score={s2}")
        L(f"    Crest P1→P2: {p1_crest:.2f}→{p2_crest:.2f} (Δ={p1_crest-p2_crest:+.2f}LU)")

        # ══════════════════════════════════════════════════════════════
        # v8 FIX #5: Quality Gate مع حارس Crest مستقل
        # ══════════════════════════════════════════════════════════════
        crest_collapsed=(p2_crest < p1_crest-1.5 and
                         p2_crest < TARGET['crest']-0.8)
        score_regressed=(s2 < s1-1.0)

        if score_regressed or crest_collapsed:
            reason=('Crest انهار' if crest_collapsed else f'Score P2({s2})<P1({s1})')
            L(f"    ⚠ Quality Gate v8 [{reason}] → رجوع لـ P1")
            shutil.copy(tmp_p1,tmp_p2); p2_b=p1_b
            p2_crest=p1_crest; p2_lra=p1_m['lra']
            p2_rms=p1_m['rms']; p2_m=p1_m; s2=s1

        # Pass 3 → WAV (LRA + RMS feedback)
        L(f"  [٩] Pass 3 → WAV (LRA+RMS feedback)...")
        p3_parts=[]
        lra_gap=ref_fp.lra-p2_lra    # target=4.19
        rms_gap=ref_fp.rms-p2_rms

        # v8: LRA gate هنا فقط (ليس في Pass 1) + حارس Crest
        if lra_gap>0.3 and p2_crest>TARGET['crest']-1.5:
            if   lra_gap<0.8: thr,ratio,rel=0.020,1.8,700
            elif lra_gap<1.5: thr,ratio,rel=0.026,2.2,580
            else:             thr,ratio,rel=0.032,2.6,450
            p3_parts.append(f'agate=threshold={thr:.3f}:ratio={ratio:.1f}'
                            f':attack=15:release={rel}:makeup=1.0:range=0.08')

        rms_leak=lra_gap*0.14 if lra_gap>0.3 else 0.0
        rms_adj=float(np.clip((rms_gap+rms_leak)*0.45,-1.2,1.2))
        if abs(rms_adj)>0.12:
            p3_parts.append(f'volume={rms_adj:.3f}dB')

        corr3=spectral_correction(p2_b,ref_fp,hf_rolloff,1.8,3,p2_crest)
        for f0,g,Q in corr3:
            p3_parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')
        # v8 FIX #3: WAV وسيطة = limit ناعم
        p3_parts.append('alimiter=limit=0.9997:level=false:attack=10:release=100')

        tmp_p3='/tmp/v80_p3.wav'
        if len(p3_parts)>1:
            subprocess.run(['ffmpeg','-y','-i',tmp_p2,'-af',','.join(p3_parts),
                            '-ar','48000','-ac','2',tmp_p3,'-loglevel','error'],
                           capture_output=True)
        else:
            shutil.copy(tmp_p2,tmp_p3)

        p3_a=load_audio(tmp_p3,skip=skip_s,duration=45)
        p3_b=third_octave(p3_a)
        p3_crest=crest_factor(p3_a); p3_lufs=measure_lufs(tmp_p3)
        p3_m={'lufs':p3_lufs,'rms':rms_db(p3_a),'crest':p3_crest,'lra':lra_estimate(p3_a)}
        s3,_=quality_score(p3_b,ref_fp,p3_m,hf_rolloff)

        if s3<s2-1.0:
            L(f"    ⚠ Quality Gate: P3({s3})<P2({s2}) → رجوع لـ P2")
            shutil.copy(tmp_p2,tmp_p3); p3_b=p2_b
            p3_lufs=TARGET['lufs']; p3_crest=p2_crest; s3=s2

        # Pass 4 → MP3 (True Peak Compliance)
        # v8 FIX #3: alimiter=0.891 هنا فقط — التطبيق الوحيد الحقيقي
        lufs_trim=TARGET['lufs']-p3_lufs
        p4_parts=[]
        if abs(lufs_trim)>0.08: p4_parts.append(f'volume={lufs_trim:.3f}dB')
        if s3<93.0:
            c4=spectral_correction(p3_b,ref_fp,hf_rolloff,0.8,4,p3_crest)
            for f0,g,Q in c4:
                p4_parts.append(f'equalizer=f={f0:.0f}:width_type=q:width={Q}:g={g}')
        # التطبيق الوحيد الحقيقي لـ True Peak limiter
        p4_parts.append('alimiter=limit=0.891:level=false:attack=1:release=15')

        tmp_out=f'/tmp/v80_out_{iteration}.mp3'
        subprocess.run(['ffmpeg','-y','-i',tmp_p3,'-af',','.join(p4_parts),
                        '-b:a','320k','-ar','48000','-ac','2',
                        tmp_out,'-loglevel','error'],capture_output=True)

        out_a=load_audio(tmp_out,skip=skip_s,duration=45)
        out_b_=third_octave(out_a)
        out_lufs=measure_lufs(tmp_out)
        out_m={'lufs':out_lufs,'rms':rms_db(out_a),
               'crest':crest_factor(out_a),'lra':lra_estimate(out_a)}
        fs,fbd=quality_score(out_b_,ref_fp,out_m,hf_rolloff)

        L(f"\n  ★ P1={s1}→P2={s2}→P3={s3}→Final={fs}/100")
        L(f"    LUFS={out_m['lufs']:.2f} RMS={out_m['rms']:.2f}"
          f" Crest={out_m['crest']:.2f} LRA={out_m['lra']:.2f}")

        if fs>best_score: best_score=fs; best_path=tmp_out
        if fs>=target_score: L(f"  ✅ هدف {target_score} محقق!"); break

        # Adaptive EQ
        if iteration<max_iterations-1:
            rv={fc:ref_fp.third_oct[fc] for fc in ref_fp.third_oct
                if fc in out_b_ and 100<=fc<=10000}
            ov={fc:out_b_[fc] for fc in rv}
            loff_i=float(np.mean([rv[fc]-ov[fc] for fc in rv]))
            sr_={fc:(rv[fc]-ov[fc])-loff_i for fc in rv}
            avg_se=float(np.mean(np.abs(list(sr_.values()))))
            scale=0.20 if avg_se>3.0 else 0.13 if avg_se>1.5 else 0.07
            big=sorted([(fc,v) for fc,v in sr_.items() if abs(v)>2.5],
                       key=lambda x:-abs(x[1]))[:3]
            if big:
                corr=[(fc,round(v*scale,2),1.5) for fc,v in big]
                eq_nodes_cur=merge_eq(list(eq_nodes_cur)+corr,60.0)
                eq_nodes_cur=[(f,float(np.clip(g,-max_eq_db,max_eq_db)),q)
                              for f,g,q in eq_nodes_cur]
                L(f"  🔄 {len(corr)} EQ adaptive (avg_error={avg_se:.1f}dB, scale={scale:.0%})")

    # Finalize
    shutil.copy(best_path if best_path else tmp_out,output_path)
    if _input_tmp and os.path.exists(_input_tmp):
        try: os.remove(_input_tmp)
        except: pass

    fin_a=load_audio(output_path,skip=skip_s,duration=45)
    fin_b=third_octave(fin_a)
    fin_lufs=measure_lufs(output_path)
    fin_m={'lufs':fin_lufs,'rms':rms_db(fin_a),
           'crest':crest_factor(fin_a),'lra':lra_estimate(fin_a)}
    top_s,top_bd=quality_score(fin_b,ref_fp,fin_m,hf_rolloff)
    elapsed=time.time()-t0

    L(f"\n{'═'*70}")
    L(f"  FINAL REPORT — v8.0 ({elapsed:.0f}s)")
    L(f"{'═'*70}")
    L(f"  {'المقياس':<18} {'المدخل':>8}  {'المخرج':>8}  {'الهدف 1425H':>12}")
    L(f"  {'─'*52}")
    L(f"  {'LUFS':<18} {'N/A':>8}  {fin_m['lufs']:>8.2f}  {TARGET['lufs']:>12.2f}")
    L(f"  {'RMS (dBFS)':<18} {inp_rms:>8.2f}  {fin_m['rms']:>8.2f}  {ref_fp.rms:>12.2f}")
    L(f"  {'Crest (LU)':<18} {inp_crest:>8.2f}  {fin_m['crest']:>8.2f}  {TARGET['crest']:>12.2f}")
    L(f"  {'LRA (LU)':<18} {inp_lra:>8.2f}  {fin_m['lra']:>8.2f}  {ref_fp.lra:>12.2f}")
    L(f"  {'MDS Score':<18} {mds:>8.1f}  {'→':>8}  {'0 (perfect)':>12}")

    bar='█'*int(top_s/5)+'░'*(20-int(top_s/5))
    L()
    L(f"  ★ {bar} {top_s}/100"
      f"  {'✅ EXCELLENT' if top_s>=96 else '✅ PASS' if top_s>=92 else '✓' if top_s>=88 else '⚠'}")
    L(f"    Spectral:{top_bd.spectral} LUFS:{top_bd.lufs} Crest:{top_bd.crest}"
      f" LRA:{top_bd.lra} Warmth:{top_bd.warmth} HF:{top_bd.hf}")
    L(f"    خطأ طيفي:±{top_bd.avg_err}dB  MDS:{mds:.1f}/100({quality_label})")
    for n in top_bd.notes: L(f"    ⚠ {n}")

    # v8 Bug fixes summary in log
    L()
    L(f"  v8 Fixes Applied:")
    L(f"    ✓ BIAS 250Hz: +1.75dB boost (was -2.75dB cut in v7.6)")
    L(f"    ✓ BIAS 4kHz:  -1.25dB cut  (was +0.375dB boost in v7.6)")
    L(f"    ✓ BIAS 8kHz:  -2.00dB cut  (was +1.00dB boost in v7.6)")
    L(f"    ✓ No LRA stacking (single compand only)")
    L(f"    ✓ Single True Peak limiter in Pass 4 only")
    L(f"    ✓ LRA delta uses inp_lra vs lra_clip (was DR in v7.6)")
    L(); L(f"  ✅ {output_path}"); L(f"{'═'*70}\n")

    return {
        'score':top_s,'breakdown':top_bd,'final_metrics':fin_m,
        'input_metrics':{'rms':inp_rms,'crest':inp_crest,'lra':inp_lra,
                         'snr':snr_global,'sfm':inp_sfm,'dr':inp_dr,'mds':mds},
        'quality_tier':quality_label,'mds':mds,
        'hf_rolloff_hz':hf_rolloff,'ref_lra':ref_fp.lra,
        'iterations':iteration+1,'log':log,
    }

def enhance_auto(input_path:str,output_path:str,
                 max_iterations:int=3,target_score:float=96.0) -> Dict:
    return enhance(input_path,output_path,max_iterations,target_score)

def process_batch(input_dir:str,output_dir:str) -> None:
    in_p=Path(input_dir); out_p=Path(output_dir); out_p.mkdir(parents=True,exist_ok=True)
    files=sorted([f for f in in_p.iterdir()
                  if f.suffix.lower() in {'.mp3','.wav','.m4a','.flac'}])
    if not files: print("لا توجد ملفات"); return
    scores=[]; results=[]
    for i,f in enumerate(files,1):
        dst=out_p/(f.stem+'_1425h_v8.mp3'); print(f"\n[{i}/{len(files)}] {f.name}")
        try:
            r=enhance_auto(str(f),str(dst))
            sc=r.get('score',0); scores.append(sc)
            results.append({'file':f.name,'score':sc,'status':'ok'}); print(f"  ✅ {sc}/100")
        except Exception as e:
            results.append({'file':f.name,'score':0,'status':'error','error':str(e)}); print(f"  ❌ {e}")
    avg=sum(scores)/len(scores) if scores else 0
    print(f"\n  Batch: {len(scores)}/{len(files)} avg={avg:.1f}/100")
    try:
        with open(out_p/'_batch_v80.json','w',encoding='utf-8') as jf:
            json.dump({'results':results,'avg_score':round(avg,1)},jf,ensure_ascii=False,indent=2)
    except: pass

def main() -> int:
    if not NUMPY_OK or not SCIPY_OK:
        print("pip install numpy scipy"); return 1
    p=argparse.ArgumentParser(description='Audio Enhancement Engine v8.0 — 1425H')
    p.add_argument('-i','--input');  p.add_argument('-o','--output')
    p.add_argument('--iterations',type=int,default=3)
    p.add_argument('--target',type=float,default=96.0)
    p.add_argument('--batch-in');   p.add_argument('--batch-out')
    p.add_argument('--serve',action='store_true')
    p.add_argument('--port',type=int,default=5000)
    p.add_argument('--clear-cache',action='store_true')
    args=p.parse_args()
    if args.clear_cache:
        if os.path.exists(REF_CACHE): os.remove(REF_CACHE); print("✅ Cache v8 حُذف")
        return 0
    if args.serve:
        try: from flask import Flask,request,send_file,jsonify
        except: print("pip install flask"); return 1
        import threading, uuid as _uuid, re
        app=Flask(__name__); app.jobs={}
        @app.route('/')
        def index():
            return (Path(__file__).parent/'templates'/'index.html').read_text()
        @app.route('/upload',methods=['POST'])
        def upload():
            f=request.files.get('file')
            if not f: return jsonify(error='لم يُرسَل ملف'),400
            data=f.read()
            if len(data)>300*1024*1024: return jsonify(error='الحد الأقصى 300MB'),400
            jid=str(_uuid.uuid4())[:8]; home=Path(os.environ.get('HOME','/tmp'))
            (home/'uploads').mkdir(exist_ok=True); (home/'outputs').mkdir(exist_ok=True)
            ext=Path(f.filename or 'a.mp3').suffix or '.mp3'
            in_p=home/'uploads'/f'{jid}{ext}'; out_p=home/'outputs'/f'{jid}.mp3'
            in_p.write_bytes(data); stem=Path(f.filename or 'audio').stem
            app.jobs[jid]={'status':'processing','progress':5,'label':'جارٍ المعالجة...','new_log':[],
                           'in':str(in_p),'out':str(out_p),'filename':f'{stem}_v8.0.mp3'}
            def run(jid=jid,in_p=in_p,out_p=out_p):
                j=app.jobs[jid]
                try:
                    PHASES={'[١]':10,'[٢]':18,'[٣]':26,'[٤]':32,'[٥]':38,
                            '[٦]':50,'[٧]':62,'[٨]':74,'[٩]':86}
                    proc=subprocess.Popen(
                        ['python',__file__,'-i',str(in_p),'-o',str(out_p),'--iterations','3'],
                        stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True,bufsize=1)
                    for line in proc.stdout:
                        line=line.rstrip()
                        if not line: continue
                        j.setdefault('new_log',[]).append(line)
                        for tag,pct in PHASES.items():
                            if tag in line: j['progress']=pct; j['label']=line.strip()[:60]; break
                        if '★' in line:
                            m=re.search(r'([\d.]+)/100',line)
                            if m: j['score']=m.group(1)
                        for k,pat in [('crest',r'Crest'),('lra',r'LRA'),('rms',r'RMS')]:
                            if re.search(pat+r'\s*[=:]',line):
                                nums=re.findall(r'-?[\d.]+',line)
                                if len(nums)>=2: j.setdefault(k,nums[-2])
                    proc.wait()
                    if proc.returncode==0 and out_p.exists():
                        j.update({'status':'done','progress':100,'label':'اكتملت'})
                    else:
                        j.update({'status':'error','error':'فشلت المعالجة'})
                except Exception as e:
                    j.update({'status':'error','error':str(e)})
                finally:
                    try: in_p.unlink()
                    except: pass
            threading.Thread(target=run,daemon=True).start()
            return jsonify(job_id=jid)
        @app.route('/status/<jid>')
        def status(jid):
            j=app.jobs.get(jid)
            if not j: return jsonify(error='not found'),404
            r={'status':j['status'],'progress':j['progress'],
               'label':j.get('label',''),'log':j.pop('new_log',[])}
            if j['status']=='done':
                for k in ['score','crest','lra','rms','filename']: r[k]=j.get(k)
                r['job_id']=jid
            if j['status']=='error': r['error']=j.get('error','خطأ')
            return jsonify(r)
        @app.route('/download/<jid>')
        def download(jid):
            j=app.jobs.get(jid)
            if not j or not Path(j['out']).exists(): return 'Not found',404
            return send_file(j['out'],as_attachment=True,
                           download_name=j.get('filename','v8.0.mp3'))
        print(f"\n  محسّن التلاوة v8.0 — http://localhost:{args.port}\n")
        app.run(host='0.0.0.0',port=args.port,debug=False,threaded=True)
        return 0
    if args.batch_in and args.batch_out:
        process_batch(args.batch_in,args.batch_out); return 0
    if not args.input or not args.output:
        p.print_help(); return 1
    try:
        r=enhance_auto(args.input,args.output,args.iterations,args.target)
        print(f"\n  ★ {r['score']}/100  MDS={r['mds']:.0f}  ✅ {args.output}")
        return 0 if r['score']>=85 else 1
    except Exception as e:
        print(f"❌ {e}"); return 1

if __name__=='__main__':
    sys.exit(main())