const stream = await navigator.mediaDevices.getUserMedia({
  audio: {
    echoCancellation: true,      // Remove echo feedback
    noiseSuppression: true,       // Filter background clinic noise
    autoGainControl: true,        // Normalize volume levels
  },
});

const recorder = new MediaRecorder(stream, {
  mimeType: 'audio/webm;codecs=opus',  // High quality, low file size
});

const recognition = new SpeechRecognition();
recognition.continuous = true;        // Don't stop after pauses
recognition.interimResults = true;    // Show partial results
recognition.lang = 'en-US';

recognition.onresult = (event) => {
  let finalText = '';
  let interimText = '';
  
  for (let i = 0; i < event.results.length; i++) {
    if (event.results[i].isFinal) {
      finalText += event.results[i][0].transcript + ' ';
    } else {
      interimText += event.results[i][0].transcript;
    }
  }
  
  setLiveTranscript(finalText + interimText);
};

// Client: Convert audio blob to base64
const reader = new FileReader();
const base64 = await new Promise((resolve) => {
  reader.onload = () => resolve(reader.result.split(',')[1]);
  reader.readAsDataURL(audioBlob);
});

// Send to backend
const response = await fetch(`${API_BASE}/api/ai/transcribe`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    audio: base64,
    mimeType: 'audio/webm',
  }),
});

const { transcription } = await response.json();

app.post('/api/ai/transcribe', async (req, res) => {
  const { audio, mimeType } = req.body;
  
  // Decode base64 and write to temp file
  const buffer = Buffer.from(audio, 'base64');
  const ext = mimeType.includes('mp4') ? 'mp4' : 'webm';
  const tmpPath = path.join(os.tmpdir(), `dictation-${Date.now()}.${ext}`);
  fs.writeFileSync(tmpPath, buffer);
  
  try {
    const transcription = await openai.audio.transcriptions.create({
      file: fs.createReadStream(tmpPath),
      model: 'whisper-1',
      language: 'en',
      response_format: 'text',  // Plain text output
    });
    
    res.json({ transcription });
  } finally {
    fs.unlinkSync(tmpPath);  // Clean up temp file
  }
});

// Dynamic prompt construction based on selected template
const sectionGuide = templateSections
  .map(sec => {
    const fields = sec.fields.length > 0
      ? ` (include: ${sec.fields.join(', ')})`
      : '';
    return `- "${sec.id}" = ${sec.name}${fields}`;
  })
  .join('\n');

const systemPrompt = `You are an expert veterinary medical scribe AI.
Generate structured clinical notes from the following dictation.

Template: "${templateName}"
Sections to fill:
${sectionGuide}

Patient: ${patientName} (${species}, ${breed})
Detail level: ${detailLevel}  // "concise" or "detailed"

Return JSON with keys: ${sectionKeys.join(', ')}
Only valid JSON, no markdown.`;

const { error } = await supabase.from('medical_records').insert({
  id: `rec-${Date.now()}`,
  pet_id: selectedPatient,
  status: 'draft',  // Requires review
  soap_subjective: soapContent.subjective,
  soap_objective: soapContent.objective,
  soap_assessment: soapContent.assessment,
  soap_plan: soapContent.plan,
  notes: allNotes + '\n\n[AI-generated, requires verification]',
  created_at: new Date().toISOString(),
});

try {
  // Try Whisper API
  const response = await fetch(`${API_BASE}/api/ai/transcribe`, ...);
  const { transcription } = await response.json();
  setTranscription(transcription);
} catch (err) {
  // Fallback to browser SpeechRecognition
  if (liveTranscriptRef.current.trim()) {
    setTranscription(liveTranscriptRef.current);
    setSuccess('Used live transcription (server unavailable)');
    return;
  }
  
  // Last resort: manual entry
  setError('Transcription unavailable. Please use Type tab.');
  setInputMethod('type');
}