// ---------- Аудио: запись, TTS, фонетический анализ ----------

// ---------- Индикатор микрофона ----------
function startMicMeter(stream) {
  try {
    const ctx = new (window.AudioContext || window.webkitAudioContext)();
    const src = ctx.createMediaStreamSource(stream);
    micAnalyser = ctx.createAnalyser();
    micAnalyser.fftSize = 256;
    src.connect(micAnalyser);
    const bar = document.getElementById('micBar');
    const fill = document.getElementById('micFill');
    bar.style.display = 'block';
    fill.style.width = '0%';
    const data = new Uint8Array(micAnalyser.frequencyBinCount);
    function tick() {
      if (!micAnalyser) return;
      micAnalyser.getByteFrequencyData(data);
      const max = Math.max(...data);
      const pct = Math.min(100, Math.round(max / 255 * 100));
      fill.style.width = pct + '%';
      fill.style.background = pct > 70 ? '#ff5722' : pct > 30 ? '#ff9800' : '#4caf50';
      micAnimId = requestAnimationFrame(tick);
    }
    tick();
  } catch(e) { console.warn('Mic meter:', e); }
}

function stopMicMeter() {
  if (micAnimId) cancelAnimationFrame(micAnimId);
  micAnimId = null;
  micAnalyser = null;
  document.getElementById('micBar').style.display = 'none';
}

// ---------- TTS ----------
function playTTS(text) {
  return new Promise((resolve) => {
    const utter = new SpeechSynthesisUtterance(text);
    utter.lang = 'it-IT';
    utter.rate = 0.9;
    const voices = speechSynthesis.getVoices();
    const it = voices.find(v => v.lang.startsWith('it'));
    if (it) utter.voice = it;
    utter.onend = resolve;
    utter.onerror = resolve;
    speechSynthesis.cancel();
    speechSynthesis.speak(utter);
  });
}

// ---------- Запись ----------
async function startRecording() {
  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
  startMicMeter(stream);
  audioChunks = [];
  let mimeType = 'audio/webm;codecs=opus';
  if (!MediaRecorder.isTypeSupported(mimeType)) {
    mimeType = 'audio/webm';
    if (!MediaRecorder.isTypeSupported(mimeType)) mimeType = '';
  }
  const opts = mimeType ? { mimeType } : {};
  mediaRecorder = new MediaRecorder(stream, opts);
  mediaRecorder.ondataavailable = e => { if (e.data.size > 0) audioChunks.push(e.data); };
  mediaRecorder.onstop = () => {
    stopMicMeter();
    recordDuration = (Date.now() - recordStartTime) / 1000;
    userAudioBlob = new Blob(audioChunks, { type: mimeType || 'audio/webm' });
    stream.getTracks().forEach(t => t.stop());
    enable('btnCompare', true);
    enable('btnStereo', true);
    enable('btnPlayUser', true);
    const btn = document.getElementById('btnRecord');
    btn.textContent = '🎙 Записать';
    btn.disabled = false;
    isRecording = false;
    setStatus('Запись завершена. ' + recordDuration.toFixed(1) + 'с · ' + (userAudioBlob.size/1024).toFixed(1) + ' KB');
    if (ttsText) saveRecording(userAudioBlob, ttsText, recordDuration);
    else {
      const t = document.getElementById('inputText').value.trim();
      if (t) saveRecording(userAudioBlob, t, recordDuration);
    }
  };
  mediaRecorder.start(100);
  recordStartTime = Date.now();
  setStatus('Идёт запись...');
}

function stopRecording() {
  if (mediaRecorder && mediaRecorder.state === 'recording') mediaRecorder.stop();
}

// ---------- Воспроизведение (с обрезкой 0.2с в начале) ----------
async function playTrimmed(blob) {
  const ctx = await getAudioCtx();
  const ab = await blob.arrayBuffer();
  const rawBuf = await ctx.decodeAudioData(ab);
  const sr = rawBuf.sampleRate;
  const data = rawBuf.getChannelData(0);
  const cutSamples = Math.floor(sr * 0.2);
  const trimmed = data.slice(cutSamples);
  const buf = ctx.createBuffer(1, trimmed.length, sr);
  buf.getChannelData(0).set(trimmed);
  const src = ctx.createBufferSource();
  src.buffer = buf;
  const gain = ctx.createGain();
  gain.gain.setValueAtTime(0, ctx.currentTime);
  gain.gain.linearRampToValueAtTime(1, ctx.currentTime + 0.01);
  src.connect(gain).connect(ctx.destination);
  src.start();
  return new Promise(resolve => { src.onended = resolve; });
}

async function playRec(id) {
  try {
    const db = await openRecDB();
    const tx = db.transaction('recs', 'readonly');
    const store = tx.objectStore('recs');
    const rec = await new Promise(r => { const req = store.get(id); req.onsuccess = () => r(req.result); });
    if (rec?.blob) await playTrimmed(rec.blob);
  } catch(e) { /* тихо */ }
}

async function playStereo(ttsText, userBlob) {
  const ctx = new AudioContext();
  const userURL = URL.createObjectURL(userBlob);
  const userAudio = new Audio(userURL);
  const userSource = ctx.createMediaElementSource(userAudio);
  const userPan = ctx.createStereoPanner();
  userPan.pan.value = 1;
  userSource.connect(userPan).connect(ctx.destination);
  await playTTS(ttsText);
  userAudio.play();
  setStatus('Стерео-воспроизведение: левое ухо — эталон, правое — ваш голос');
}

// ---------- Фонетический анализ ----------
function phoneticAnalysis(blob) {
  return new Promise((resolve) => {
    const reader = new FileReader();
    reader.onload = async (e) => {
      try {
        const ctx = new (window.OfflineAudioContext || window.webkitOfflineAudioContext)(1, 1, 44100);
        const buf = await ctx.decodeAudioData(e.target.result);
        const data = buf.getChannelData(0);
        const sr = buf.sampleRate;
        const len = data.length;
        const frameSize = Math.floor(sr * 0.025);
        const step = Math.floor(frameSize / 2);
        const numFrames = Math.max(1, Math.floor((len - frameSize) / step));

        const rmsArr = new Float32Array(numFrames);
        const zcrArr = new Float32Array(numFrames);
        for (let fi = 0; fi < numFrames; fi++) {
          const s = fi * step;
          let rmsSum = 0, zcr = 0;
          for (let i = s; i < s + frameSize; i++) {
            rmsSum += data[i] * data[i];
            if (i > s && (data[i] >= 0) !== (data[i - 1] >= 0)) zcr++;
          }
          rmsArr[fi] = Math.sqrt(rmsSum / frameSize);
          zcrArr[fi] = zcr / frameSize * sr;
        }

        let meanRms = 0;
        for (let fi = 0; fi < numFrames; fi++) meanRms += rmsArr[fi];
        meanRms /= numFrames;
        const energyThresh = Math.max(0.005, meanRms * 0.4);

        const pitches = [];
        let voicedCount = 0;
        for (let fi = 0; fi < numFrames; fi++) {
          if (rmsArr[fi] > energyThresh) {
            voicedCount++;
            const p = pitchFrame(data, fi * step, frameSize, sr);
            if (p > 70 && p < 450) pitches.push(p);
          }
        }
        const voiceRatio = voicedCount / numFrames;

        let pitchHz = 0, pitchStability = 0;
        if (pitches.length >= 5) {
          const sorted = [...pitches].sort((a, b) => a - b);
          const median = sorted[Math.floor(sorted.length / 2)];
          const mad = pitches.map(p => Math.abs(p - median)).sort((a, b) => a - b)[Math.floor(pitches.length / 2)];
          const relMad = (mad / median) * 100;
          pitchStability = Math.round(Math.max(0, Math.min(100, 100 - relMad * 2.5)));
          pitchHz = Math.round(median);
        }

        const vzArr = [];
        for (let fi = 0; fi < numFrames; fi++) {
          if (rmsArr[fi] > energyThresh) vzArr.push(zcrArr[fi]);
        }
        let articulationScore = 40;
        if (vzArr.length > 0) {
          const mzc = vzArr.reduce((a, b) => a + b, 0) / vzArr.length;
          articulationScore = Math.round(Math.max(0, Math.min(100,
            mzc < 150  ? mzc / 1.5 :
            mzc < 500  ? 60 + (mzc - 150) / 350 * 20 :
            mzc < 1800 ? 80 + (mzc - 500) / 1300 * 18 :
            mzc < 3000 ? 98 - (mzc - 1800) / 1200 * 40 :
            Math.max(0, 58 - (mzc - 3000) / 1000 * 20)
          )));
        }

        const endStart = Math.floor(numFrames * 0.78);
        let endVoiced = 0;
        const endTotal = numFrames - endStart;
        for (let fi = endStart; fi < numFrames; fi++) {
          if (rmsArr[fi] > energyThresh) endVoiced++;
        }
        const endingScore = endTotal > 0 ? Math.round(Math.min(100, (endVoiced / endTotal) * 125)) : 50;

        const clarityScore = Math.round(
          voiceRatio < 0.05 ? 0 :
          voiceRatio < 0.35 ? voiceRatio / 0.35 * 50 :
          voiceRatio < 0.65 ? 50 + (voiceRatio - 0.35) / 0.30 * 45 :
          voiceRatio < 0.82 ? 95 - (voiceRatio - 0.65) / 0.17 * 15 :
          Math.max(40, 80 - (voiceRatio - 0.82) / 0.18 * 40)
        );

        const hasSpeech = voiceRatio > 0.08;
        const phonScore = hasSpeech ? Math.round(
          pitchStability    * 0.30 +
          articulationScore * 0.25 +
          clarityScore      * 0.25 +
          endingScore       * 0.20
        ) : 0;

        resolve({ pitchHz, pitchStability, voiceClarity: articulationScore, phonScore });
      } catch (err) {
        resolve({ pitchHz: 0, pitchStability: 0, voiceClarity: 0, phonScore: 0 });
      }
    };
    reader.readAsArrayBuffer(blob);
  });
}

function pitchFrame(data, start, len, sr) {
  const n = len;
  let e0 = 0;
  for (let i = 0; i < n; i++) e0 += data[start + i] * data[start + i];
  if (e0 < 1e-8) return 0;
  const minLag = Math.floor(sr / 400);
  const maxLag = Math.min(n - 1, Math.floor(sr / 70));
  let bestR = 0, bestLag = 0;
  for (let lag = minLag; lag <= maxLag; lag++) {
    let num = 0, e1 = 0, e2 = 0;
    const m = n - lag;
    for (let i = 0; i < m; i++) {
      const a = data[start + i], b = data[start + i + lag];
      num += a * b;
      e1 += a * a;
      e2 += b * b;
    }
    const den = Math.sqrt(e1 * e2);
    const r = den > 0 ? num / den : 0;
    if (r > bestR) { bestR = r; bestLag = lag; }
  }
  return bestR > 0.30 ? sr / bestLag : 0;
}

// ---------- Обрезка тишины — возвращает {buffer, startSample, endSample} ----------
async function trimSilence(blob) {
  try {
    const ctx = new (window.OfflineAudioContext || window.webkitOfflineAudioContext)(1, 1, 44100);
    const ab = await blob.arrayBuffer();
    const buf = await ctx.decodeAudioData(ab);
    const data = buf.getChannelData(0);
    const sr = buf.sampleRate;
    const len = data.length;

    const win = Math.floor(sr * 0.01);
    const rms = [];
    let maxRms = 0;
    for (let i = 0; i < len; i += win) {
      let sum = 0, n = 0;
      for (let j = i; j < i + win && j < len; j++, n++) sum += data[j] * data[j];
      const v = Math.sqrt(sum / n);
      rms.push(v);
      if (v > maxRms) maxRms = v;
    }
    if (maxRms < 0.001) return null;

    const threshold = maxRms * 0.02;

    let startIdx = 0;
    for (let i = 0; i < rms.length; i++) {
      if (rms[i] > threshold) { startIdx = Math.max(0, i - 2); break; }
    }
    let endIdx = rms.length - 1;
    for (let i = rms.length - 1; i >= 0; i--) {
      if (rms[i] > threshold) { endIdx = Math.min(rms.length - 1, i + 2); break; }
    }

    const startSample = startIdx * win;
    const endSample = Math.min((endIdx + 1) * win, len);
    if (endSample - startSample < sr * 0.08) return null;

    const trimmedBuf = new (window.OfflineAudioContext || window.webkitOfflineAudioContext)(1, endSample - startSample, sr);
    return { buffer: trimmedBuf, data: data.slice(startSample, endSample), sr, startSample, endSample };
  } catch(e) { return null; }
}

// ---------- WAV кодирование (для отправки в Whisper) ----------
function encodeWAV(samples, sampleRate) {
  const buf = new ArrayBuffer(44 + samples.length * 2);
  const v = new DataView(buf);
  const w = (o, s) => { for (let i=0;i<s.length;i++) v.setUint8(o+i, s.charCodeAt(i)); };
  w(0, 'RIFF'); v.setUint32(4, 36+samples.length*2, true); w(8, 'WAVE');
  w(12, 'fmt '); v.setUint32(16, 16, true); v.setUint16(20, 1, true); v.setUint16(22, 1, true);
  v.setUint32(24, sampleRate, true); v.setUint32(28, sampleRate*2, true); v.setUint16(32, 2, true); v.setUint16(34, 16, true);
  w(36, 'data'); v.setUint32(40, samples.length*2, true);
  for (let i=0;i<samples.length;i++) {
    const s = Math.max(-1, Math.min(1, samples[i]));
    v.setInt16(44+i*2, s<0?s*0x8000:s*0x7FFF, true);
  }
  return buf;
}

// Обрезает первые cutSec секунд, возвращает WAV Blob (для Groq)
async function trimStartBlob(blob, cutSec = 0.2) {
  try {
    const ab = await blob.arrayBuffer();
    const actx = new AudioContext();
    const rawBuf = await actx.decodeAudioData(ab);
    const sr = rawBuf.sampleRate;
    const cutSamples = Math.floor(sr * cutSec);
    const newLen = rawBuf.length - cutSamples;
    if (newLen < sr * 0.05) { actx.close(); return blob; }

    // Render trimmed via OfflineAudioContext (надёжнее ручного slice)
    const offline = new OfflineAudioContext(1, newLen, sr);
    const src = offline.createBufferSource();
    src.buffer = rawBuf;
    src.connect(offline.destination);
    src.start(0, cutSec / sr);
    const rendered = await offline.startRendering();
    actx.close();

    const wav = encodeWAV(rendered.getChannelData(0), sr);
    return new Blob([wav], { type: 'audio/wav' });
  } catch(e) {
    console.log('[trimStartBlob] fallback to raw:', e);
    return blob;
  }
}