main.go

package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"os/signal"
	"strings"
	"syscall"
	"time"

	"github.com/boyuanchen/asr-audio-streamer/audio"
	"github.com/boyuanchen/asr-audio-streamer/config"
)

var (
	sampleRate      = flag.Int("rate", 16000, "Sample rate in Hz (e.g., 16000, 44100)")
	chunkSize       = flag.Int("chunk", 0, "Chunk size in frames (0 for auto-calculated ~200ms)")
	deviceIndex     = flag.Int("device", -1, "Input device index (-1 for default)")
	languageCode    = flag.String("lang", "en-US", "Language code for ASR (e.g., en-US, zh-CN)")
	asrEndpoint     = flag.String("endpoint", "ws://localhost:8080/asr", "ASR WebSocket endpoint URL (ws:// or wss://)")
	listDevices     = flag.Bool("list", false, "List available audio input devices and exit")
	enableInterrupt = flag.Bool("enable-interrupt", false, "Enable TTS interrupt handling")
	statsInterval   = flag.Int("stats", 10, "Statistics print interval in seconds (0 to disable)")
	bufferSize      = flag.Int("buffer", 50, "Audio buffer size (number of chunks to buffer)")
)

func main() {
	flag.Parse()

	// List devices if requested
	if *listDevices {
		if err := audio.ListDevices(); err != nil {
			log.Fatalf("Error listing devices: %v", err)
		}
		return
	}

	// Create configuration
	cfg := config.DefaultConfig()
	cfg.SampleRate = *sampleRate
	cfg.ChunkSize = *chunkSize
	cfg.DeviceIndex = *deviceIndex
	cfg.LanguageCode = *languageCode
	cfg.ASREndpoint = *asrEndpoint
	cfg.EnableTTSInterrupt = *enableInterrupt
	cfg.BufferSize = *bufferSize

	// Print configuration
	printConfiguration(cfg)

	// Create audio input stream
	log.Println("Initializing audio input stream...")
	inputStream, err := audio.NewInputStream(cfg, nil)
	if err != nil {
		log.Fatalf("Failed to create input stream: %v", err)
	}

	// Create audio sender
	sender := audio.NewSender(cfg)

	// Start the audio input stream
	if err := inputStream.Start(); err != nil {
		log.Fatalf("Failed to start input stream: %v", err)
	}

	// Start the sender
	if err := sender.Start(inputStream); err != nil {
		log.Fatalf("Failed to start sender: %v", err)
	}

	log.Println("Audio streaming started. Press Ctrl+C to stop.")

	// Start statistics printer if enabled
	var statsTicker *time.Ticker
	if *statsInterval > 0 {
		statsTicker = time.NewTicker(time.Duration(*statsInterval) * time.Second)
		defer statsTicker.Stop()

		go func() {
			for range statsTicker.C {
				sender.PrintStatistics()
			}
		}()
	}

	// Wait for interrupt signal
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
	<-sigChan

	log.Println("\nShutting down...")

	// Stop sender first
	sender.Stop()

	// Then stop input stream
	inputStream.Stop()

	// Print final statistics
	if *statsInterval > 0 {
		fmt.Println("\nFinal Statistics:")
		sender.PrintStatistics()
	}

	log.Println("Shutdown complete")
}

func printConfiguration(cfg *config.AudioConfig) {
	fmt.Println("\n=== Audio Streamer Configuration ===")
	fmt.Printf("Sample Rate: %d Hz\n", cfg.SampleRate)
	if cfg.ChunkSize > 0 {
		fmt.Printf("Chunk Size: %d frames\n", cfg.ChunkSize)
	} else {
		calculatedSize := cfg.CalculateChunkSize()
		fmt.Printf("Chunk Size: %d frames (auto-calculated ~200ms)\n", calculatedSize)
	}
	if cfg.DeviceIndex >= 0 {
		fmt.Printf("Device Index: %d\n", cfg.DeviceIndex)
	} else {
		fmt.Println("Device Index: Default device")
	}
	fmt.Printf("Language Code: %s\n", cfg.LanguageCode)
	fmt.Printf("ASR Endpoint: %s\n", cfg.ASREndpoint)
	fmt.Printf("TTS Interrupt: %v\n", cfg.EnableTTSInterrupt)
	fmt.Printf("Buffer Size: %d\n", cfg.BufferSize)
	fmt.Printf("Timeout: %v\n", cfg.Timeout)
	fmt.Println(strings.Repeat("=", 37))
	fmt.Println()
}