import { TTCSpeechClient } from 'ttc-sc';

// Create client with conversation ID and callbacks
const client = new TTCSpeechClient({
  conversationId: 'your-conversation-id',
  serverUrl: 'ws://localhost:8080',
  
  // Receive transcriptions
  onTranscript: (result) => {
    console.log('Transcription:', result.text);
    if (result.isFinal) {
      console.log('Final result:', result.text);
    }
  },
  
  // Receive audio chunks
  onAudioChunk: (audioBlob) => {
    // Play audio immediately
    const audio = new Audio();
    audio.src = URL.createObjectURL(audioBlob);
    audio.play();
  },
  
  // Handle errors
  onError: (error) => {
    console.error('Speech service error:', error);
  }
});

// Connect and start using the service
async function startSpeechSession() {
  await client.connect();
  
  // Start recording for speech-to-text
  await client.startRecording();
  
  // Stop recording after some time
  setTimeout(async () => {
    await client.stopRecording();
    
    // Synthesize text-to-speech
    await client.synthesize('Hello, this is a test message!');
  }, 5000);
}

startSpeechSession();

new TTCSpeechClient(config: TTCClientConfig)

interface TTCClientConfig {
  conversationId: string;                           // Required: Unique conversation identifier
  serverUrl?: string;                              // Server WebSocket URL (default: ws://localhost:8080)
  debug?: boolean;                                 // Enable debug logging (default: false)
  
  // Callbacks
  onTranscript?: (result: TranscriptResult) => void;     // Speech-to-text results
  onAudioChunk?: (audioBlob: Blob) => void;             // Text-to-speech audio
  onConnectionChange?: (connected: boolean) => void;     // Connection status changes
  onRecordingChange?: (recording: boolean) => void;      // Recording status changes
  onError?: (error: ErrorEvent) => void;                // Error handling
  onVoicesUpdated?: (voices: Voice[]) => void;          // Available voices updated
  
  // Audio configuration
  audioOptions?: {
    sampleRate?: number;        // Audio sample rate (default: 16000)
    channels?: number;          // Number of channels (default: 1)
    bufferSize?: number;        // Buffer size (default: 4096)
  };
  
  // Connection configuration  
  connectionOptions?: {
    timeout?: number;           // Connection timeout (default: 10000ms)
    maxRetries?: number;        // Max reconnection attempts (default: 5)
    retryDelay?: number;        // Initial retry delay (default: 1000ms)
  };
}

// Connect to the service
await client.connect(): Promise<void>

// Disconnect from the service
client.disconnect(): void

// Check connection status
client.isConnected(): boolean
client.getConnectionState(): ConnectionState

// Start recording audio for transcription
await client.startRecording(): Promise<void>

// Stop recording
await client.stopRecording(): Promise<void>

// Check recording status
client.isRecording(): boolean
client.getRecordingState(): RecordingState

// Synthesize text to speech
await client.synthesize(text: string, options?: TTSOptions): Promise<void>

// Cancel ongoing synthesis
client.cancelSynthesis(): void

// Get available voices
await client.getVoices(): Promise<Voice[]>

// Get client statistics
client.getStats(): ClientStats

interface TranscriptResult {
  text: string;           // Transcribed text
  confidence: number;     // Confidence score (0-1)
  isFinal: boolean;       // Whether this is a final result
  timestamp: number;      // Timestamp of the result
}

interface ErrorEvent {
  type: 'connection' | 'stt' | 'tts' | 'audio';
  message: string;
  timestamp: number;
  code?: string;
  originalError?: any;
}

interface Voice {
  id: string;
  name: string;
  language: string;
  gender?: 'male' | 'female';
  accent?: string;
}

const client = new TTCSpeechClient({
  conversationId: 'demo-session',
  onTranscript: (result) => {
    if (result.isFinal) {
      document.getElementById('transcript').textContent = result.text;
    }
  },
  onAudioChunk: (audioBlob) => {
    const audio = new Audio(URL.createObjectURL(audioBlob));
    audio.play();
  }
});

await client.connect();

await client.connect();
const voices = await client.getVoices();

// Use a specific voice
await client.synthesize('Hello world!', {
  voiceId: voices[0].id,
  speed: 1.0,
  pitch: 1.0
});

const client = new TTCSpeechClient({
  conversationId: 'demo',
  onError: (error) => {
    switch (error.type) {
      case 'connection':
        console.log('Connection issue:', error.message);
        break;
      case 'audio':
        console.log('Microphone issue:', error.message);
        break;
      case 'stt':
        console.log('Speech recognition issue:', error.message);
        break;
      case 'tts':
        console.log('Speech synthesis issue:', error.message);
        break;
    }
  }
});