import { useSusurro } from 'susurro-audio';

function VoiceAssistant() {
  const { startStreamingRecording, transcriptions } = useSusurro();
  return <ChatInterface onVoice={startStreamingRecording} messages={transcriptions} />;
}

import { useSusurro } from 'susurro-audio';

function ClinicalEncounter() {
  const { startRecording, transcriptions, speakerDiarization } = useSusurro({
    medicalMode: true,
    hipaaCompliant: true,
    multiSpeaker: true
  });

  return (
    <EncounterNotes 
      onRecord={startRecording}
      transcriptions={transcriptions}
      speakers={speakerDiarization}
    />
  );
}

import { useSusurro } from 'susurro'

function AudioProcessor() {
  const { 
    startRecording,
    stopRecording,
    isRecording,
    transcriptions, 
    isProcessing,
    whisperReady 
  } = useSusurro()

  const handleRecord = async () => {
    if (isRecording) {
      stopRecording()
    } else {
      await startRecording()
    }
  }

  return (
    <div>
      {whisperReady ? 'Ready to record!' : 'Loading models...'}
      <button onClick={handleRecord}>
        {isRecording ? 'Stop Recording' : 'Start Recording'}
      </button>
      {transcriptions.map((t, i) => (
        <p key={i}>{t.text}</p>
      ))}
    </div>
  )
}

import { useSusurro, SusurroChunk } from 'susurro'

function ConversationalApp() {
  const [messages, setMessages] = useState<Array<{
    audioUrl: string
    text: string
    timestamp: number
  }>>([])
  const [isRecording, setIsRecording] = useState(false)

  const { startRecording, stopRecording } = useSusurro({
    // Enable conversational mode
    conversational: {
      onChunk: (chunk: SusurroChunk) => {
        // Each chunk is a complete audio+transcript message
        setMessages(prev => [...prev, {
          audioUrl: chunk.audioUrl,
          text: chunk.transcript,
          timestamp: chunk.startTime
        }])
      },
      enableInstantTranscription: true, // Real-time processing
      chunkTimeout: 5000 // Max 5s wait for transcript
    }
  })

  const handleRecord = async () => {
    if (isRecording) {
      stopRecording()
      setIsRecording(false)
    } else {
      await startRecording()
      setIsRecording(true)
    }
  }

  return (
    <div className="chat-interface">
      <button onClick={handleRecord}>
        {isRecording ? 'Stop Recording' : 'Start Recording'}
      </button>
      
      {messages.map((msg, i) => (
        <div key={i} className="message">
          <audio src={msg.audioUrl} controls />
          <p>{msg.text}</p>
          <small>{new Date(msg.timestamp).toLocaleTimeString()}</small>
        </div>
      ))}
    </div>
  )
}

const { startRecording, stopRecording, conversationalChunks } = useSusurro({
  // Audio processing settings
  chunkDurationMs: 6000,    // 6-second chunks for conversations
  
  // Whisper configuration
  whisperConfig: {
    language: 'en',
    model: 'whisper-1'
  },
  
  // Conversational features
  conversational: {
    onChunk: (chunk: SusurroChunk) => {
      console.log(`Processing latency: ${chunk.processingLatency}ms`)
      console.log(`VAD confidence: ${chunk.vadScore}`)
      console.log(`Complete: ${chunk.isComplete}`)
      
      // Send to your chat system, AI assistant, etc.
      sendToChatBot(chunk.transcript, chunk.audioUrl)
    },
    enableInstantTranscription: true,
    chunkTimeout: 3000,
    enableChunkEnrichment: true
  }
})

import React, { useState, useRef, useEffect } from 'react'
import { useSusurro, SusurroChunk } from 'susurro'

interface ChatMessage {
  id: string
  type: 'user' | 'assistant'
  audioUrl?: string
  text: string
  timestamp: number
  isProcessing?: boolean
}

export function VoiceChatUI() {
  const [messages, setMessages] = useState<ChatMessage[]>([])
  const [isRecording, setIsRecording] = useState(false)
  const [aiResponse, setAiResponse] = useState('')
  const messagesEndRef = useRef<HTMLDivElement>(null)

  const { 
    startRecording, 
    stopRecording, 
    whisperReady,
    isProcessing 
  } = useSusurro({
    chunkDurationMs: 3000, // 3-second chunks for responsive chat
    conversational: {
      onChunk: async (chunk: SusurroChunk) => {
        // Add user message to chat
        const userMessage: ChatMessage = {
          id: chunk.id,
          type: 'user',
          audioUrl: chunk.audioUrl,
          text: chunk.transcript,
          timestamp: chunk.startTime,
        }
        
        setMessages(prev => [...prev, userMessage])

        // Send to AI assistant (example with OpenAI)
        if (chunk.transcript.trim()) {
          await handleAIResponse(chunk.transcript)
        }
      },
      enableInstantTranscription: true,
      chunkTimeout: 2000,
    }
  })

  const handleAIResponse = async (userText: string) => {
    // Add processing indicator
    const processingMessage: ChatMessage = {
      id: `processing-${Date.now()}`,
      type: 'assistant',
      text: 'Thinking...',
      timestamp: Date.now(),
      isProcessing: true,
    }
    setMessages(prev => [...prev, processingMessage])

    try {
      // Example AI integration
      const response = await fetch('/api/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ message: userText }),
      })
      
      const data = await response.json()
      
      // Replace processing message with actual response
      setMessages(prev => 
        prev.map(msg => 
          msg.id === processingMessage.id 
            ? { ...msg, text: data.response, isProcessing: false }
            : msg
        )
      )
    } catch (error) {
      // Handle error
      setMessages(prev => 
        prev.map(msg => 
          msg.id === processingMessage.id 
            ? { ...msg, text: 'Sorry, I encountered an error.', isProcessing: false }
            : msg
        )
      )
    }
  }

  const handleRecordToggle = async () => {
    if (isRecording) {
      stopRecording()
      setIsRecording(false)
    } else {
      await startRecording()
      setIsRecording(true)
    }
  }

  // Auto-scroll to bottom when new messages arrive
  useEffect(() => {
    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
  }, [messages])

  return (
    <div className="voice-chat-container">
      {/* Header */}
      <div className="chat-header">
        <h2>🎙️ Voice Assistant</h2>
        <div className="status">
          {!whisperReady && <span>Loading AI models...</span>}
          {whisperReady && !isRecording && <span>Ready to chat</span>}
          {isRecording && <span>🔴 Recording...</span>}
          {isProcessing && <span>🔄 Processing...</span>}
        </div>
      </div>

      {/* Messages */}
      <div className="messages-container">
        {messages.map((message) => (
          <div 
            key={message.id} 
            className={`message ${message.type}`}
          >
            <div className="message-content">
              {/* Audio playback for user messages */}
              {message.audioUrl && (
                <div className="audio-player">
                  <audio 
                    src={message.audioUrl} 
                    controls 
                    preload="metadata"
                  />
                </div>
              )}
              
              {/* Text content */}
              <div className="text-content">
                {message.isProcessing ? (
                  <div className="processing-indicator">
                    <span className="dots">...</span>
                    {message.text}
                  </div>
                ) : (
                  message.text
                )}
              </div>
              
              {/* Timestamp */}
              <div className="timestamp">
                {new Date(message.timestamp).toLocaleTimeString()}
              </div>
            </div>
          </div>
        ))}
        <div ref={messagesEndRef} />
      </div>

      {/* Controls */}
      <div className="chat-controls">
        <button 
          onClick={handleRecordToggle}
          disabled={!whisperReady}
          className={`record-button ${isRecording ? 'recording' : ''}`}
        >
          {isRecording ? '⏹️ Stop' : '🎙️ Record'}
        </button>
        
        <div className="recording-indicator">
          {isRecording && (
            <div className="pulse-animation">
              <div className="pulse-dot"></div>
              Recording...
            </div>
          )}
        </div>
      </div>
    </div>
  )
}

// Process voice messages as they arrive
conversational: {
  onChunk: (chunk) => {
    // Send to WebSocket, store in chat, trigger AI response
    sendVoiceMessage(chunk.audioUrl, chunk.transcript)
  }
}

// Batch process audio files with real-time feedback
conversational: {
  onChunk: (chunk) => {
    updateTranscriptionProgress(chunk.startTime, chunk.transcript)
  }
}

// Build ChatGPT-style voice interfaces
conversational: {
  onChunk: async (chunk) => {
    const aiResponse = await openai.chat.completions.create({
      messages: [{ role: 'user', content: chunk.transcript }]
    })
    speakResponse(aiResponse.choices[0].message.content)
  }
}

import { ChunkMiddlewarePipeline, translationMiddleware, sentimentMiddleware } from 'susurro'

function MyApp() {
  const { middlewarePipeline, startRecording } = useSusurro({
    conversational: {
      onChunk: (chunk) => {
        // Chunk has been processed through middleware pipeline
        console.log('Enhanced chunk:', chunk.metadata)
      }
    }
  })

  // Enable built-in middlewares
  useEffect(() => {
    middlewarePipeline.enable('translation')
    middlewarePipeline.enable('sentiment')
    middlewarePipeline.enable('intent')
  }, [])

  return <VoiceInterface />
}

middlewarePipeline.enable('translation')

// Chunks will include:
chunk.metadata = {
  originalLanguage: 'en',
  translatedText: 'Hola mundo',
  translationConfidence: 0.95
}

middlewarePipeline.enable('sentiment')

// Chunks will include:
chunk.metadata = {
  sentiment: 'positive',
  sentimentScore: 0.87,
  emotion: 'happy'
}

middlewarePipeline.enable('intent')

// Chunks will include:
chunk.metadata = {
  intent: 'question',
  intentConfidence: 0.82,
  entities: ['weather', 'today']
}

// Automatically applied to all chunks:
chunk.metadata = {
  audioQuality: 0.92,
  noiseLevel: 0.05,
  clarity: 0.96,
  enhancement: ['neural_denoising', 'voice_enhancement']
}

import { ChunkMiddleware, SusurroChunk } from 'susurro'

const customMiddleware: ChunkMiddleware = {
  name: 'keyword-detection',
  enabled: true,
  priority: 5,
  async process(chunk: SusurroChunk): Promise<SusurroChunk> {
    const keywords = detectKeywords(chunk.transcript)
    
    return {
      ...chunk,
      metadata: {
        ...chunk.metadata,
        keywords,
        hasActionKeywords: keywords.some(k => k.type === 'action'),
        urgencyLevel: calculateUrgency(keywords)
      }
    }
  }
}

// Register your custom middleware
middlewarePipeline.register(customMiddleware)

function detectKeywords(text: string) {
  // Your custom keyword detection logic
  return [
    { word: 'urgent', type: 'urgency', confidence: 0.9 },
    { word: 'schedule', type: 'action', confidence: 0.8 }
  ]
}

const { conversationalChunks } = useSusurro({
  conversational: {
    onChunk: (chunk) => {
      // Real-time processing as chunks arrive
      handleNewMessage(chunk)
    },
    enableInstantTranscription: true,
    chunkTimeout: 3000,
    enableChunkEnrichment: true, // Enables middleware processing
  }
})

const { 
  isRecording,
  isProcessing,
  averageVad,
  processingStatus 
} = useSusurro()

// Monitor recording state changes
useEffect(() => {
  if (isRecording) {
    console.log('Recording started')
  }
}, [isRecording])

// Track processing progress
useEffect(() => {
  console.log('VAD Score:', averageVad)
  console.log('Processing Stage:', processingStatus.stage)
}, [averageVad, processingStatus])

const { 
  whisperReady,
  whisperProgress,
  whisperError,
  transcribeWithWhisper 
} = useSusurro({
  whisperConfig: {
    language: 'en',
    model: 'whisper-1',
    temperature: 0.2
  }
})

// Custom transcription with direct Whisper access
const handleCustomTranscription = async (audioBlob: Blob) => {
  const result = await transcribeWithWhisper(audioBlob)
  console.log('Custom transcription:', result)
}

const { middlewarePipeline } = useSusurro()

// Enable/disable middlewares dynamically
middlewarePipeline.enable('sentiment')
middlewarePipeline.disable('translation')

// Check middleware status
const status = middlewarePipeline.getStatus()
console.log('Active middlewares:', status)

// Register custom middleware
middlewarePipeline.register(myCustomMiddleware)

// Remove middleware
middlewarePipeline.unregister('sentiment')

import { useSusurro } from 'susurro'
import { useWebSocket } from 'ws'

function CollaborativeVoiceChat() {
  const ws = useWebSocket('wss://my-server.com/voice-chat')
  
  const { startRecording, stopRecording } = useSusurro({
    conversational: {
      onChunk: (chunk) => {
        // Send chunk to other participants
        ws.send(JSON.stringify({
          type: 'voice-chunk',
          data: {
            audioUrl: chunk.audioUrl,
            transcript: chunk.transcript,
            metadata: chunk.metadata,
            userId: 'current-user-id'
          }
        }))
      },
      enableInstantTranscription: true
    }
  })

  // Handle incoming chunks from other users
  useEffect(() => {
    ws.onmessage = (event) => {
      const message = JSON.parse(event.data)
      if (message.type === 'voice-chunk') {
        displayRemoteChunk(message.data)
      }
    }
  }, [ws])

  return <VoiceInterface />
}

interface UseSusurroOptions {
  // Core configuration
  modelSize?: 'tiny' | 'base' | 'small' | 'medium' | 'large' // default: 'base'
  language?: string // ISO 639-1 code, default: auto-detect
  
  // Conversational mode
  conversational?: {
    onChunk: (chunk: SusurroChunk) => void
    enableInstantTranscription?: boolean // default: true
    chunkTimeout?: number // milliseconds, default: 5000
  }
  
  // Medical mode
  medicalMode?: boolean // Enhanced medical terminology, default: false
  hipaaCompliant?: boolean // Local-only processing, default: true
  multiSpeaker?: boolean // Speaker diarization, default: false
  
  // Performance
  webGPU?: boolean // Use WebGPU acceleration, default: true
  quantization?: 'q4' | 'q8' | 'f16' // Model quantization, default: 'q4'
  
  // Advanced
  vadThreshold?: number // Voice activity detection sensitivity 0-1, default: 0.5
  silenceTimeout?: number // End recording after silence (ms), default: 2000
}

interface UseSusurroReturn {
  // Recording controls
  startRecording: () => Promise<void>
  stopRecording: () => void
  startStreamingRecording: () => Promise<void>
  
  // State
  isRecording: boolean
  isProcessing: boolean
  whisperReady: boolean
  
  // Results
  transcriptions: Transcription[]
  conversationalChunks?: SusurroChunk[]
  speakerDiarization?: SpeakerSegment[]
  
  // Utilities
  clearTranscriptions: () => void
  exportSession: () => SessionData
}

interface Transcription {
  text: string
  timestamp: number
  language?: string
  confidence?: number
  audioUrl?: string
}

interface SusurroChunk {
  id: string
  audioUrl: string
  transcript: string
  startTime: number
  endTime: number
  metadata: {
    language?: string
    confidence?: number
    speaker?: number
  }
}

interface SpeakerSegment {
  speaker: number
  text: string
  startTime: number
  endTime: number
}

// High-accuracy medical transcription
const medicalConfig: UseSusurroOptions = {
  modelSize: 'large',
  medicalMode: true,
  hipaaCompliant: true,
  multiSpeaker: true,
  quantization: 'f16', // Higher precision
  vadThreshold: 0.3 // More sensitive
}

// Low-latency chat interface
const chatConfig: UseSusurroOptions = {
  modelSize: 'tiny',
  conversational: {
    onChunk: handleChunk,
    chunkTimeout: 2000
  },
  webGPU: true,
  quantization: 'q4' // Fastest
}

// Multi-language support
const multilingualConfig: UseSusurroOptions = {
  language: 'auto', // Auto-detect
  modelSize: 'medium',
  conversational: {
    onChunk: (chunk) => {
      console.log(`Detected language: ${chunk.metadata.language}`)
    }
  }
}