Streaming TTS

val longText = """
    This is a very long text that will be synthesized in chunks.
    Each chunk will be delivered as soon as it's ready,
    allowing playback to start immediately without waiting
    for the entire synthesis to complete.
""".trimIndent()

RunAnywhere.synthesizeStream(
    text = longText,
    options = TTSOptions(rate = 1.0f),
    onAudioChunk = { chunk ->
        // Play each chunk as it arrives
        audioPlayer.enqueue(chunk)
    }
)

class StreamingAudioPlayer {
    private val audioQueue = ConcurrentLinkedQueue<ByteArray>()
    private var isPlaying = false

    fun enqueue(audioChunk: ByteArray) {
        audioQueue.add(audioChunk)
        if (!isPlaying) {
            startPlayback()
        }
    }

    private fun startPlayback() {
        isPlaying = true
        CoroutineScope(Dispatchers.IO).launch {
            while (audioQueue.isNotEmpty() || isPlaying) {
                val chunk = audioQueue.poll()
                if (chunk != null) {
                    playChunk(chunk)
                } else {
                    delay(10) // Wait for more chunks
                }
            }
        }
    }

    private fun playChunk(chunk: ByteArray) {
        // Play audio chunk using AudioTrack
    }

    fun stop() {
        isPlaying = false
        audioQueue.clear()
    }
}

class ChatViewModel : ViewModel() {
    private val audioPlayer = StreamingAudioPlayer()

    fun sendMessageAndSpeak(prompt: String) {
        viewModelScope.launch {
            // Generate text with streaming
            val streamResult = RunAnywhere.generateStreamWithMetrics(prompt)

            // Collect full response for TTS
            val fullResponse = StringBuilder()
            streamResult.stream.collect { token ->
                fullResponse.append(token)
                _displayText.value += token
            }

            // Stream synthesize the full response
            RunAnywhere.synthesizeStream(
                text = fullResponse.toString(),
                options = TTSOptions(),
                onAudioChunk = { chunk ->
                    audioPlayer.enqueue(chunk)
                }
            )
        }
    }
}

// Stop synthesis mid-stream
RunAnywhere.stopSynthesis()