import AudioStream from '@mustafakarali/react-native-audio-stream';

// Initialize the audio stream (optional but recommended)
// If not called, default configuration will be used
await AudioStream.initialize({
  enableBackgroundMode: true,
  autoPlay: true,
});

// Start streaming
await AudioStream.startStream('https://your-audio-stream-url.mp3');

// Or start HLS/DASH streaming (automatically detected)
await AudioStream.startStream('https://example.com/playlist.m3u8');

// Add event listeners
AudioStream.addEventListener('onProgress', (progress) => {
  console.log(`Current time: ${progress.currentTime}s`);
});

AudioStream.addEventListener('onError', (error) => {
  console.error('Stream error:', error);
});

// Cancel stream if needed
await AudioStream.cancelStream();

await AudioStream.initialize({
  bufferSize: 64,              // Buffer size in KB (default: 64)
  prebufferThreshold: 16,      // Start playback threshold in KB (default: 16)
  enableBackgroundMode: true,   // Enable background playback (default: false)
  enableCache: true,           // Enable caching (default: false)
  cacheSize: 100,             // Cache size in MB (default: 100)
  logLevel: LogLevel.DEBUG,    // Logging level (default: WARNING)
});

await AudioStream.startStream('https://example.com/audio.mp3', {
  headers: {
    'Authorization': 'Bearer token',
  },
  autoPlay: true,
});

// Example with ElevenLabs TTS
const response = await fetch('https://api.elevenlabs.io/v1/text-to-speech/voice-id', {
  method: 'POST',
  headers: {
    'xi-api-key': 'your-api-key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ text: 'Hello world' })
});

// Convert response to base64
const audioBlob = await response.blob();
const reader = new FileReader();
reader.readAsDataURL(audioBlob);
reader.onloadend = () => {
  const base64Data = reader.result.split(',')[1]; // Remove data:audio/mpeg;base64, prefix
  AudioStream.playFromData(base64Data, { autoPlay: true });
};

await AudioStream.seek(30.5); // Seek to 30.5 seconds

await AudioStream.setVolume(0.8);        // 80% volume
await AudioStream.setPlaybackRate(1.5);  // 1.5x speed

const stats = await AudioStream.getStats();
console.log(`Buffer health: ${stats.bufferHealth}%`);
console.log(`Network speed: ${stats.networkSpeed} KB/s`);

// Available presets
const presets = [
  { name: 'Flat', bands: [/* ... */] },      // Index 0
  { name: 'Bass Boost', bands: [/* ... */] }, // Index 1
  { name: 'Treble Boost', bands: [/* ... */] }, // Index 2
  { name: 'Vocal', bands: [/* ... */] },     // Index 3
  { name: 'Rock', bands: [/* ... */] },      // Index 4
  { name: 'Pop', bands: [/* ... */] },       // Index 5
  { name: 'Jazz', bands: [/* ... */] },      // Index 6
  { name: 'Dance', bands: [/* ... */] },     // Index 7
  { name: 'Classical', bands: [/* ... */] },  // Index 8
];

// Apply bass boost preset
await AudioStream.applyEqualizerPreset(1);

// Custom equalizer (5 bands: 60Hz, 230Hz, 910Hz, 3600Hz, 14000Hz)
await AudioStream.setEqualizer([
  { frequency: 60, gain: 6 },    // Bass
  { frequency: 230, gain: 4 },   // Low-mid
  { frequency: 910, gain: 0 },   // Mid
  { frequency: 3600, gain: 2 },  // High-mid
  { frequency: 14000, gain: 4 }, // Treble
]);

// Progress tracking
AudioStream.addEventListener('onProgress', (progress) => {
  console.log(`${progress.currentTime}s / ${progress.duration}s`);
  console.log(`Buffered: ${progress.percentage}%`);
});

// Error handling with recovery
AudioStream.addEventListener('onError', (error) => {
  console.error(`Error Code: ${error.code}`);
  console.error(`Error Message: ${error.message}`);
  
  if (error.recoverable) {
    // Implement retry logic
    setTimeout(() => {
      AudioStream.startStream(currentUrl);
    }, 3000);
  }
});

// Metadata display
AudioStream.addEventListener('onMetadata', (metadata) => {
  console.log(`Now playing: ${metadata.title} by ${metadata.artist}`);
  console.log(`Album: ${metadata.album}`);
});

// Network monitoring
AudioStream.addEventListener('onNetworkStateChange', (state) => {
  console.log(`Network connected: ${state.isConnected}`);
  console.log(`Connection type: ${state.type}`);
});

// Preload first 30 seconds
await AudioStream.preloadStream(url, 30);

// Set audio session category
await AudioStream.setAudioSessionCategory('playback');

// Request audio focus
const granted = await AudioStream.requestAudioFocus();

interface AudioStreamConfig {
  bufferSize?: number;
  prebufferThreshold?: number;
  maxBufferSize?: number;
  chunkSize?: number;
  protocol?: StreamingProtocol;
  reconnectAttempts?: number;
  reconnectDelay?: number;
  timeout?: number;
  format?: AudioFormat;
  sampleRate?: number;
  channels?: number;
  bitRate?: number;
  autoPlay?: boolean;
  enableBackgroundMode?: boolean;
  maintainAudioFocus?: boolean;
  enableCache?: boolean;
  cacheSize?: number;
  cachePath?: string;
  logLevel?: LogLevel;
  headers?: Record<string, string>;
}

enum PlaybackState {
  IDLE = 'idle',
  LOADING = 'loading',
  BUFFERING = 'buffering',
  PLAYING = 'playing',
  PAUSED = 'paused',
  STOPPED = 'stopped',
  ERROR = 'error',
  COMPLETED = 'completed',
}

interface PlaybackStats {
  bufferedDuration: number;    // Seconds of buffered content
  playedDuration: number;      // Seconds played
  totalDuration: number;       // Total duration if known
  networkSpeed: number;        // KB/s
  latency: number;            // Network latency in ms
  bufferHealth: number;       // 0-100 percentage
  droppedFrames: number;      // Dropped audio frames
  bitRate: number;           // Actual bitrate in kbps
  bufferedPosition: number;   // End position of buffer in seconds
  currentPosition: number;    // Current playback position
  bufferedPercentage: number; // Percentage of total duration buffered
  isBuffering: boolean;       // Currently buffering
  playWhenReady: boolean;     // Will play when buffer is ready
}

import React, { useEffect, useState } from 'react';
import { View, Button, Text } from 'react-native';
import AudioStream, { PlaybackState, LogLevel } from '@mustafakarali/react-native-audio-stream';

export default function AudioPlayer() {
  const [state, setState] = useState<PlaybackState>(PlaybackState.IDLE);
  const [progress, setProgress] = useState({ current: 0, total: 0 });
  const [metadata, setMetadata] = useState({ title: '', artist: '' });

  useEffect(() => {
    // Initialize audio stream (optional)
    AudioStream.initialize({
      enableBackgroundMode: true,
      enableCache: true,
      logLevel: LogLevel.INFO,
    });

    // Setup event listeners
    AudioStream.addEventListener('onStateChange', setState);
    AudioStream.addEventListener('onProgress', (data) => {
      setProgress({ current: data.currentTime, total: data.duration });
    });
    AudioStream.addEventListener('onMetadata', (data) => {
      setMetadata({ title: data.title || '', artist: data.artist || '' });
    });

    return () => {
      AudioStream.removeAllEventListeners();
      AudioStream.destroy();
    };
  }, []);

  const handlePlay = async () => {
    if (state === PlaybackState.IDLE) {
      await AudioStream.startStream('https://example.com/stream.mp3');
    } else {
      await AudioStream.play();
    }
  };

  return (
    <View>
      <Text>State: {state}</Text>
      <Text>Progress: {progress.current.toFixed(1)}s / {progress.total.toFixed(1)}s</Text>
      {metadata.title ? (
        <Text>Now Playing: {metadata.title} - {metadata.artist}</Text>
      ) : null}
      <Button title="Play" onPress={handlePlay} />
      <Button title="Pause" onPress={() => AudioStream.pause()} />
      <Button title="Stop" onPress={() => AudioStream.stop()} />
      <Button title="Cancel" onPress={() => AudioStream.cancelStream()} />
    </View>
  );
}

// HLS streaming
await AudioStream.startStream('https://example.com/playlist.m3u8');

// DASH streaming  
await AudioStream.startStream('https://example.com/manifest.mpd');

// With authentication
await AudioStream.startStream('https://example.com/playlist.m3u8', {
  headers: {
    'Authorization': 'Bearer token',
  },
});

await AudioStream.startStream(url, {
  headers: {
    'Authorization': 'Bearer your-token',
    'X-Custom-Header': 'value',
  },
});

await AudioStream.initialize({
  reconnectAttempts: 5,
  reconnectDelay: 2000,  // 2 seconds
  timeout: 30000,        // 30 seconds
});

AudioStream.addEventListener('onError', (error) => {
  console.error(`Error Code: ${error.code}`);
  console.error(`Error Message: ${error.message}`);
  
  if (error.recoverable) {
    // Implement retry logic
    setTimeout(() => {
      AudioStream.startStream(currentUrl);
    }, 3000);
  }
});

// Show input device picker (Future iOS feature)
await AudioStream.showInputPicker();

// Get list of available input devices
const inputs = await AudioStream.getAvailableInputs();
console.log(inputs);
// [
//   {
//     portName: "iPhone Microphone",
//     portType: "MicrophoneBuiltIn",
//     uid: "Built-In Microphone",
//     hasHardwareVoiceCallProcessing: true,
//     channels: 1
//   },
//   {
//     portName: "AirPods Pro",
//     portType: "BluetoothHFP",
//     uid: "00:00:00:00:00:00",
//     hasHardwareVoiceCallProcessing: false,
//     channels: 1
//   }
// ]

await AudioStream.initialize({
  // iOS Features (Future)
  enableRecording: true,           // Enable recording support
  voiceProcessing: true,           // Enable voice processing
  spokenAudio: true,              // Optimize for podcasts/audiobooks
  longFormAudio: true,            // Enable long-form audio routing
  enableAirPodsHighQuality: true, // AirPods high-quality recording (when available)
  enableEnhancedBuffering: true,  // AirPlay 2 enhanced buffering
  enableSpatialAudio: true,       // Spatial audio support (when available)
});

// Enable AirPlay 2 enhanced buffering
await AudioStream.enableEnhancedBuffering(true);

// Enable spatial audio with head tracking
await AudioStream.enableSpatialAudio(true);

// Use AVQueuePlayer for enhanced features
await AudioStream.useQueuePlayer(true);

// Create a route picker view (returns view tag for React Native)
const routePickerTag = await AudioStream.createRoutePickerView();

// ElevenLabs direct streaming with POST body
await AudioStream.startStream('https://api.elevenlabs.io/v1/text-to-speech/voice-id/stream', {
  method: 'POST',
  headers: {
    'xi-api-key': ELEVEN_LABS_KEY,
    'Content-Type': 'application/json',
  },
  body: {
    text: 'Hello world',
    model_id: 'eleven_multilingual_v2',
    voice_settings: {
      stability: 0.5,
      similarity_boost: 0.5,
      style: 0,
      use_speaker_boost: true,
    },
  },
  autoPlay: true,
});

// For true streaming without waiting for complete data
async function streamTTS(text: string) {
  // Start with empty stream
  await AudioStream.startStream('', { autoPlay: true });
  
  // Fetch TTS data
  const response = await fetch('https://api.elevenlabs.io/v1/text-to-speech/voice-id/stream', {
    method: 'POST',
    headers: {
      'xi-api-key': ELEVEN_LABS_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      text: text,
      model_id: 'eleven_multilingual_v2',
      voice_settings: {
        stability: 0.5,
        similarity_boost: 0.5,
      },
    }),
  });

  // Stream chunks as they arrive
  const reader = response.body?.getReader();
  if (!reader) throw new Error('Stream not available');

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    
    // Convert chunk to base64
    const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
    
    // Append to audio buffer - playback starts automatically when enough data is buffered
    await AudioStream.appendToBuffer(base64Chunk);
  }
}

// Usage
await streamTTS("This text will start playing as soon as enough data is buffered!");

// For TTS services that return complete binary audio data
const response = await fetch('https://api.tts-service.com/synthesize', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${API_KEY}` },
  body: JSON.stringify({ 
    text: 'Hello world',
    voice: 'en-US-Neural2-A'
  })
});

// Wait for complete data
const audioBlob = await response.blob();
const base64 = await blobToBase64(audioBlob);
await AudioStream.playFromData(base64, { autoPlay: true });

async function speakWithElevenLabsStreaming(text: string) {
  const voiceId = 'your-voice-id';
  const apiKey = 'your-api-key';
  
  try {
    // Initialize empty stream
    await AudioStream.startStream('', {
      autoPlay: true,
      enableBackgroundMode: true,
      bufferSize: 16, // Small buffer for low latency
    });

    // Start TTS request
    const response = await fetch(
      `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}/stream`,
      {
        method: 'POST',
        headers: {
          'Accept': 'audio/mpeg',
          'xi-api-key': apiKey,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          text: text,
          model_id: 'eleven_multilingual_v2',
          voice_settings: {
            stability: 0.75,
            similarity_boost: 0.75,
            style: 0.5,
            use_speaker_boost: true,
          },
          // Enable streaming optimizations
          optimize_streaming_latency: 3, // 0-4, higher = lower latency
          output_format: 'mp3_44100_128', // High quality streaming format
        }),
      }
    );

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    // Process stream in real-time
    const reader = response.body?.getReader();
    if (!reader) throw new Error('Stream not available');

    let firstChunkReceived = false;
    const startTime = Date.now();

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      if (!firstChunkReceived) {
        firstChunkReceived = true;
        console.log(`First audio chunk received in ${Date.now() - startTime}ms`);
      }
      
      // Convert Uint8Array to base64
      const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
      
      // Append to buffer - audio starts playing automatically when ready
      await AudioStream.appendToBuffer(base64Chunk);
    }
    
    console.log('Streaming completed');
  } catch (error) {
    console.error('TTS Streaming Error:', error);
    await AudioStream.stop();
  }
}

// Convert blob to base64 (for non-streaming approach)
function blobToBase64(blob: Blob): Promise<string> {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onloadend = () => {
      const base64 = reader.result?.toString().split(',')[1] || '';
      resolve(base64);
    };
    reader.onerror = reject;
    reader.readAsDataURL(blob);
  });
}

// Stream with progress tracking
async function streamWithProgress(
  url: string, 
  onProgress?: (received: number, total?: number) => void
) {
  await AudioStream.startStream('', { autoPlay: true });
  
  const response = await fetch(url);
  const reader = response.body?.getReader();
  const contentLength = response.headers.get('Content-Length');
  const total = contentLength ? parseInt(contentLength, 10) : undefined;
  
  if (!reader) throw new Error('Stream not available');
  
  let received = 0;
  
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    
    received += value.length;
    onProgress?.(received, total);
    
    const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
    await AudioStream.appendToBuffer(base64Chunk);
  }
}

// Deepgram with streaming
async function speakWithDeepgram(text: string) {
  const response = await fetch('https://api.deepgram.com/v1/speak', {
    method: 'POST',
    headers: {
      'Authorization': `Token ${DEEPGRAM_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: text,
      model: 'aura-asteria-en',
      encoding: 'mp3',
      // Streaming optimizations
      container: 'mp3',
      sample_rate: 44100,
    })
  });
  
  if (response.headers.get('Content-Type')?.includes('audio')) {
    // Direct streaming response
    await AudioStream.startStream('', { autoPlay: true });
    
    const reader = response.body?.getReader();
    if (!reader) throw new Error('Stream not available');
    
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
      await AudioStream.appendToBuffer(base64Chunk);
    }
  } else {
    // URL response
    const { url } = await response.json();
    await AudioStream.startStream(url);
  }
}

await AudioStream.initialize({
  // Optimize for streaming
  bufferSize: 16,        // Small buffer for low latency (KB)
  prebufferThreshold: 8, // Start playback with less data (KB)
  chunkSize: 4,          // Small chunks for smooth streaming (KB)
  
  // Network settings
  reconnectAttempts: 3,
  reconnectDelay: 1000,
  timeout: 30000,
});

// Set audio session category
await AudioStream.setAudioSessionCategory('playback');

// Request audio focus
const granted = await AudioStream.requestAudioFocus();

interface AudioStreamConfig {
  bufferSize?: number;
  prebufferThreshold?: number;
  maxBufferSize?: number;
  chunkSize?: number;
  protocol?: StreamingProtocol;
  reconnectAttempts?: number;
  reconnectDelay?: number;
  timeout?: number;
  format?: AudioFormat;
  sampleRate?: number;
  channels?: number;
  bitRate?: number;
  autoPlay?: boolean;
  enableBackgroundMode?: boolean;
  maintainAudioFocus?: boolean;
  enableCache?: boolean;
  cacheSize?: number;
  cachePath?: string;
  logLevel?: LogLevel;
  headers?: Record<string, string>;
}

enum PlaybackState {
  IDLE = 'idle',
  LOADING = 'loading',
  BUFFERING = 'buffering',
  PLAYING = 'playing',
  PAUSED = 'paused',
  STOPPED = 'stopped',
  ERROR = 'error',
  COMPLETED = 'completed',
}

interface PlaybackStats {
  bufferedDuration: number;    // Seconds of buffered content
  playedDuration: number;      // Seconds played
  totalDuration: number;       // Total duration if known
  networkSpeed: number;        // KB/s
  latency: number;            // Network latency in ms
  bufferHealth: number;       // 0-100 percentage
  droppedFrames: number;      // Dropped audio frames
  bitRate: number;           // Actual bitrate in kbps
  bufferedPosition: number;   // End position of buffer in seconds
  currentPosition: number;    // Current playback position
  bufferedPercentage: number; // Percentage of total duration buffered
  isBuffering: boolean;       // Currently buffering
  playWhenReady: boolean;     // Will play when buffer is ready
}

import React, { useEffect, useState } from 'react';
import { View, Button, Text } from 'react-native';
import AudioStream, { PlaybackState, LogLevel } from '@mustafakarali/react-native-audio-stream';

export default function AudioPlayer() {
  const [state, setState] = useState<PlaybackState>(PlaybackState.IDLE);
  const [progress, setProgress] = useState({ current: 0, total: 0 });
  const [metadata, setMetadata] = useState({ title: '', artist: '' });

  useEffect(() => {
    // Initialize audio stream (optional)
    AudioStream.initialize({
      enableBackgroundMode: true,
      enableCache: true,
      logLevel: LogLevel.INFO,
    });

    // Setup event listeners
    AudioStream.addEventListener('onStateChange', setState);
    AudioStream.addEventListener('onProgress', (data) => {
      setProgress({ current: data.currentTime, total: data.duration });
    });
    AudioStream.addEventListener('onMetadata', (data) => {
      setMetadata({ title: data.title || '', artist: data.artist || '' });
    });

    return () => {
      AudioStream.removeAllEventListeners();
      AudioStream.destroy();
    };
  }, []);

  const handlePlay = async () => {
    if (state === PlaybackState.IDLE) {
      await AudioStream.startStream('https://example.com/stream.mp3');
    } else {
      await AudioStream.play();
    }
  };

  return (
    <View>
      <Text>State: {state}</Text>
      <Text>Progress: {progress.current.toFixed(1)}s / {progress.total.toFixed(1)}s</Text>
      {metadata.title ? (
        <Text>Now Playing: {metadata.title} - {metadata.artist}</Text>
      ) : null}
      <Button title="Play" onPress={handlePlay} />
      <Button title="Pause" onPress={() => AudioStream.pause()} />
      <Button title="Stop" onPress={() => AudioStream.stop()} />
      <Button title="Cancel" onPress={() => AudioStream.cancelStream()} />
    </View>
  );
}

// HLS streaming
await AudioStream.startStream('https://example.com/playlist.m3u8');

// DASH streaming  
await AudioStream.startStream('https://example.com/manifest.mpd');

// With authentication
await AudioStream.startStream('https://example.com/playlist.m3u8', {
  headers: {
    'Authorization': 'Bearer token',
  },
});

await AudioStream.startStream(url, {
  headers: {
    'Authorization': 'Bearer your-token',
    'X-Custom-Header': 'value',
  },
});

await AudioStream.initialize({
  reconnectAttempts: 5,
  reconnectDelay: 2000,  // 2 seconds
  timeout: 30000,        // 30 seconds
});

AudioStream.addEventListener('onError', (error) => {
  console.error(`Error Code: ${error.code}`);
  console.error(`Error Message: ${error.message}`);
  
  if (error.recoverable) {
    // Implement retry logic
    setTimeout(() => {
      AudioStream.startStream(currentUrl);
    }, 3000);
  }
});

// Show input device picker (Future iOS feature)
await AudioStream.showInputPicker();

// Get list of available input devices
const inputs = await AudioStream.getAvailableInputs();
console.log(inputs);
// [
//   {
//     portName: "iPhone Microphone",
//     portType: "MicrophoneBuiltIn",
//     uid: "Built-In Microphone",
//     hasHardwareVoiceCallProcessing: true,
//     channels: 1
//   },
//   {
//     portName: "AirPods Pro",
//     portType: "BluetoothHFP",
//     uid: "00:00:00:00:00:00",
//     hasHardwareVoiceCallProcessing: false,
//     channels: 1
//   }
// ]

await AudioStream.initialize({
  // iOS Features (Future)
  enableRecording: true,           // Enable recording support
  voiceProcessing: true,           // Enable voice processing
  spokenAudio: true,              // Optimize for podcasts/audiobooks
  longFormAudio: true,            // Enable long-form audio routing
  enableAirPodsHighQuality: true, // AirPods high-quality recording (when available)
  enableEnhancedBuffering: true,  // AirPlay 2 enhanced buffering
  enableSpatialAudio: true,       // Spatial audio support (when available)
});

// Enable AirPlay 2 enhanced buffering
await AudioStream.enableEnhancedBuffering(true);

// Enable spatial audio with head tracking
await AudioStream.enableSpatialAudio(true);

// Use AVQueuePlayer for enhanced features
await AudioStream.useQueuePlayer(true);

// Create a route picker view (returns view tag for React Native)
const routePickerTag = await AudioStream.createRoutePickerView();

// ElevenLabs direct streaming with POST body
await AudioStream.startStream('https://api.elevenlabs.io/v1/text-to-speech/voice-id/stream', {
  method: 'POST',
  headers: {
    'xi-api-key': ELEVEN_LABS_KEY,
    'Content-Type': 'application/json',
  },
  body: {
    text: 'Hello world',
    model_id: 'eleven_multilingual_v2',
    voice_settings: {
      stability: 0.5,
      similarity_boost: 0.5,
      style: 0,
      use_speaker_boost: true,
    },
  },
  autoPlay: true,
});

// For true streaming without waiting for complete data
async function streamTTS(text: string) {
  // Start with empty stream
  await AudioStream.startStream('', { autoPlay: true });
  
  // Fetch TTS data
  const response = await fetch('https://api.elevenlabs.io/v1/text-to-speech/voice-id/stream', {
    method: 'POST',
    headers: {
      'xi-api-key': ELEVEN_LABS_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      text: text,
      model_id: 'eleven_multilingual_v2',
      voice_settings: {
        stability: 0.5,
        similarity_boost: 0.5,
      },
    }),
  });

  // Stream chunks as they arrive
  const reader = response.body?.getReader();
  if (!reader) throw new Error('Stream not available');

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    
    // Convert chunk to base64
    const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
    
    // Append to audio buffer - playback starts automatically when enough data is buffered
    await AudioStream.appendToBuffer(base64Chunk);
  }
}

// Usage
await streamTTS("This text will start playing as soon as enough data is buffered!");

// For TTS services that return complete binary audio data
const response = await fetch('https://api.tts-service.com/synthesize', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${API_KEY}` },
  body: JSON.stringify({ 
    text: 'Hello world',
    voice: 'en-US-Neural2-A'
  })
});

// Wait for complete data
const audioBlob = await response.blob();
const base64 = await blobToBase64(audioBlob);
await AudioStream.playFromData(base64, { autoPlay: true });

async function speakWithElevenLabsStreaming(text: string) {
  const voiceId = 'your-voice-id';
  const apiKey = 'your-api-key';
  
  try {
    // Initialize empty stream
    await AudioStream.startStream('', {
      autoPlay: true,
      enableBackgroundMode: true,
      bufferSize: 16, // Small buffer for low latency
    });

    // Start TTS request
    const response = await fetch(
      `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}/stream`,
      {
        method: 'POST',
        headers: {
          'Accept': 'audio/mpeg',
          'xi-api-key': apiKey,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          text: text,
          model_id: 'eleven_multilingual_v2',
          voice_settings: {
            stability: 0.75,
            similarity_boost: 0.75,
            style: 0.5,
            use_speaker_boost: true,
          },
          // Enable streaming optimizations
          optimize_streaming_latency: 3, // 0-4, higher = lower latency
          output_format: 'mp3_44100_128', // High quality streaming format
        }),
      }
    );

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    // Process stream in real-time
    const reader = response.body?.getReader();
    if (!reader) throw new Error('Stream not available');

    let firstChunkReceived = false;
    const startTime = Date.now();

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      if (!firstChunkReceived) {
        firstChunkReceived = true;
        console.log(`First audio chunk received in ${Date.now() - startTime}ms`);
      }
      
      // Convert Uint8Array to base64
      const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
      
      // Append to buffer - audio starts playing automatically when ready
      await AudioStream.appendToBuffer(base64Chunk);
    }
    
    console.log('Streaming completed');
  } catch (error) {
    console.error('TTS Streaming Error:', error);
    await AudioStream.stop();
  }
}

// Convert blob to base64 (for non-streaming approach)
function blobToBase64(blob: Blob): Promise<string> {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onloadend = () => {
      const base64 = reader.result?.toString().split(',')[1] || '';
      resolve(base64);
    };
    reader.onerror = reject;
    reader.readAsDataURL(blob);
  });
}

// Stream with progress tracking
async function streamWithProgress(
  url: string, 
  onProgress?: (received: number, total?: number) => void
) {
  await AudioStream.startStream('', { autoPlay: true });
  
  const response = await fetch(url);
  const reader = response.body?.getReader();
  const contentLength = response.headers.get('Content-Length');
  const total = contentLength ? parseInt(contentLength, 10) : undefined;
  
  if (!reader) throw new Error('Stream not available');
  
  let received = 0;
  
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    
    received += value.length;
    onProgress?.(received, total);
    
    const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
    await AudioStream.appendToBuffer(base64Chunk);
  }
}

// Deepgram with streaming
async function speakWithDeepgram(text: string) {
  const response = await fetch('https://api.deepgram.com/v1/speak', {
    method: 'POST',
    headers: {
      'Authorization': `Token ${DEEPGRAM_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: text,
      model: 'aura-asteria-en',
      encoding: 'mp3',
      // Streaming optimizations
      container: 'mp3',
      sample_rate: 44100,
    })
  });
  
  if (response.headers.get('Content-Type')?.includes('audio')) {
    // Direct streaming response
    await AudioStream.startStream('', { autoPlay: true });
    
    const reader = response.body?.getReader();
    if (!reader) throw new Error('Stream not available');
    
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
      await AudioStream.appendToBuffer(base64Chunk);
    }
  } else {
    // URL response
    const { url } = await response.json();
    await AudioStream.startStream(url);
  }
}

await AudioStream.initialize({
  // Optimize for streaming
  bufferSize: 16,        // Small buffer for low latency (KB)
  prebufferThreshold: 8, // Start playback with less data (KB)
  chunkSize: 4,          // Small chunks for smooth streaming (KB)
  
  // Network settings
  reconnectAttempts: 3,
  reconnectDelay: 1000,
  timeout: 30000,
});

// Set audio session category
await AudioStream.setAudioSessionCategory('playback');

// Request audio focus
const granted = await AudioStream.requestAudioFocus();

interface AudioStreamConfig {
  bufferSize?: number;
  prebufferThreshold?: number;
  maxBufferSize?: number;
  chunkSize?: number;
  protocol?: StreamingProtocol;
  reconnectAttempts?: number;
  reconnectDelay?: number;
  timeout?: number;
  format?: AudioFormat;
  sampleRate?: number;
  channels?: number;
  bitRate?: number;
  autoPlay?: boolean;
  enableBackgroundMode?: boolean;
  maintainAudioFocus?: boolean;
  enableCache?: boolean;
  cacheSize?: number;
  cachePath?: string;
  logLevel?: LogLevel;
  headers?: Record<string, string>;
}

enum PlaybackState {
  IDLE = 'idle',
  LOADING = 'loading',
  BUFFERING = 'buffering',
  PLAYING = 'playing',
  PAUSED = 'paused',
  STOPPED = 'stopped',
  ERROR = 'error',
  COMPLETED = 'completed',
}

interface PlaybackStats {
  bufferedDuration: number;    // Seconds of buffered content
  playedDuration: number;      // Seconds played
  totalDuration: number;       // Total duration if known
  networkSpeed: number;        // KB/s
  latency: number;            // Network latency in ms
  bufferHealth: number;       // 0-100 percentage
  droppedFrames: number;      // Dropped audio frames
  bitRate: number;           // Actual bitrate in kbps
  bufferedPosition: number;   // End position of buffer in seconds
  currentPosition: number;    // Current playback position
  bufferedPercentage: number; // Percentage of total duration buffered
  isBuffering: boolean;       // Currently buffering
  playWhenReady: boolean;     // Will play when buffer is ready
}

import React, { useEffect, useState } from 'react';
import { View, Button, Text } from 'react-native';
import AudioStream, { PlaybackState, LogLevel } from '@mustafakarali/react-native-audio-stream';

export default function AudioPlayer() {
  const [state, setState] = useState<PlaybackState>(PlaybackState.IDLE);
  const [progress, setProgress] = useState({ current: 0, total: 0 });
  const [metadata, setMetadata] = useState({ title: '', artist: '' });

  useEffect(() => {
    // Initialize audio stream (optional)
    AudioStream.initialize({
      enableBackgroundMode: true,
      enableCache: true,
      logLevel: LogLevel.INFO,
    });

    // Setup event listeners
    AudioStream.addEventListener('onStateChange', setState);
    AudioStream.addEventListener('onProgress', (data) => {
      setProgress({ current: data.currentTime, total: data.duration });
    });
    AudioStream.addEventListener('onMetadata', (data) => {
      setMetadata({ title: data.title || '', artist: data.artist || '' });
    });

    return () => {
      AudioStream.removeAllEventListeners();
      AudioStream.destroy();
    };
  }, []);

  const handlePlay = async () => {
    if (state === PlaybackState.IDLE) {
      await AudioStream.startStream('https://example.com/stream.mp3');
    } else {
      await AudioStream.play();
    }
  };

  return (
    <View>
      <Text>State: {state}</Text>
      <Text>Progress: {progress.current.toFixed(1)}s / {progress.total.toFixed(1)}s</Text>
      {metadata.title ? (
        <Text>Now Playing: {metadata.title} - {metadata.artist}</Text>
      ) : null}
      <Button title="Play" onPress={handlePlay} />
      <Button title="Pause" onPress={() => AudioStream.pause()} />
      <Button title="Stop" onPress={() => AudioStream.stop()} />
      <Button title="Cancel" onPress={() => AudioStream.cancelStream()} />
    </View>
  );
}

// HLS streaming
await AudioStream.startStream('https://example.com/playlist.m3u8');

// DASH streaming  
await AudioStream.startStream('https://example.com/manifest.mpd');

// With authentication
await AudioStream.startStream('https://example.com/playlist.m3u8', {
  headers: {
    'Authorization': 'Bearer token',
  },
});

await AudioStream.startStream(url, {
  headers: {
    'Authorization': 'Bearer your-token',
    'X-Custom-Header': 'value',
  },
});

await AudioStream.initialize({
  reconnectAttempts: 5,
  reconnectDelay: 2000,  // 2 seconds
  timeout: 30000,        // 30 seconds
});

AudioStream.addEventListener('onError', (error) => {
  console.error(`Error Code: ${error.code}`);
  console.error(`Error Message: ${error.message}`);
  
  if (error.recoverable) {
    // Implement retry logic
    setTimeout(() => {
      AudioStream.startStream(currentUrl);
    }, 3000);
  }
});

// Show input device picker (Future iOS feature)
await AudioStream.showInputPicker();

// Get list of available input devices
const inputs = await AudioStream.getAvailableInputs();
console.log(inputs);
// [
//   {
//     portName: "iPhone Microphone",
//     portType: "MicrophoneBuiltIn",
//     uid: "Built-In Microphone",
//     hasHardwareVoiceCallProcessing: true,
//     channels: 1
//   },
//   {
//     portName: "AirPods Pro",
//     portType: "BluetoothHFP",
//     uid: "00:00:00:00:00:00",
//     hasHardwareVoiceCallProcessing: false,
//     channels: 1
//   }
// ]

await AudioStream.initialize({
  // iOS Features (Future)
  enableRecording: true,           // Enable recording support
  voiceProcessing: true,           // Enable voice processing
  spokenAudio: true,              // Optimize for podcasts/audiobooks
  longFormAudio: true,            // Enable long-form audio routing
  enableAirPodsHighQuality: true, // AirPods high-quality recording (when available)
  enableEnhancedBuffering: true,  // AirPlay 2 enhanced buffering
  enableSpatialAudio: true,       // Spatial audio support (when available)
});

// Enable AirPlay 2 enhanced buffering
await AudioStream.enableEnhancedBuffering(true);

// Enable spatial audio with head tracking
await AudioStream.enableSpatialAudio(true);

// Use AVQueuePlayer for enhanced features
await AudioStream.useQueuePlayer(true);

// Create a route picker view (returns view tag for React Native)
const routePickerTag = await AudioStream.createRoutePickerView();

// ElevenLabs direct streaming with POST body
await AudioStream.startStream('https://api.elevenlabs.io/v1/text-to-speech/voice-id/stream', {
  method: 'POST',
  headers: {
    'xi-api-key': ELEVEN_LABS_KEY,
    'Content-Type': 'application/json',
  },
  body: {
    text: 'Hello world',
    model_id: 'eleven_multilingual_v2',
    voice_settings: {
      stability: 0.5,
      similarity_boost: 0.5,
      style: 0,
      use_speaker_boost: true,
    },
  },
  autoPlay: true,
});

// For true streaming without waiting for complete data
async function streamTTS(text: string) {
  // Start with empty stream
  await AudioStream.startStream('', { autoPlay: true });
  
  // Fetch TTS data
  const response = await fetch('https://api.elevenlabs.io/v1/text-to-speech/voice-id/stream', {
    method: 'POST',
    headers: {
      'xi-api-key': ELEVEN_LABS_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      text: text,
      model_id: 'eleven_multilingual_v2',
      voice_settings: {
        stability: 0.5,
        similarity_boost: 0.5,
      },
    }),
  });

  // Stream chunks as they arrive
  const reader = response.body?.getReader();
  if (!reader) throw new Error('Stream not available');

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    
    // Convert chunk to base64
    const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
    
    // Append to audio buffer - playback starts automatically when enough data is buffered
    await AudioStream.appendToBuffer(base64Chunk);
  }
}

// Usage
await streamTTS("This text will start playing as soon as enough data is buffered!");

// For TTS services that return complete binary audio data
const response = await fetch('https://api.tts-service.com/synthesize', {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${API_KEY}` },
  body: JSON.stringify({ 
    text: 'Hello world',
    voice: 'en-US-Neural2-A'
  })
});

// Wait for complete data
const audioBlob = await response.blob();
const base64 = await blobToBase64(audioBlob);
await AudioStream.playFromData(base64, { autoPlay: true });

async function speakWithElevenLabsStreaming(text: string) {
  const voiceId = 'your-voice-id';
  const apiKey = 'your-api-key';
  
  try {
    // Initialize empty stream
    await AudioStream.startStream('', {
      autoPlay: true,
      enableBackgroundMode: true,
      bufferSize: 16, // Small buffer for low latency
    });

    // Start TTS request
    const response = await fetch(
      `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}/stream`,
      {
        method: 'POST',
        headers: {
          'Accept': 'audio/mpeg',
          'xi-api-key': apiKey,
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          text: text,
          model_id: 'eleven_multilingual_v2',
          voice_settings: {
            stability: 0.75,
            similarity_boost: 0.75,
            style: 0.5,
            use_speaker_boost: true,
          },
          // Enable streaming optimizations
          optimize_streaming_latency: 3, // 0-4, higher = lower latency
          output_format: 'mp3_44100_128', // High quality streaming format
        }),
      }
    );

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    // Process stream in real-time
    const reader = response.body?.getReader();
    if (!reader) throw new Error('Stream not available');

    let firstChunkReceived = false;
    const startTime = Date.now();

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      if (!firstChunkReceived) {
        firstChunkReceived = true;
        console.log(`First audio chunk received in ${Date.now() - startTime}ms`);
      }
      
      // Convert Uint8Array to base64
      const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
      
      // Append to buffer - audio starts playing automatically when ready
      await AudioStream.appendToBuffer(base64Chunk);
    }
    
    console.log('Streaming completed');
  } catch (error) {
    console.error('TTS Streaming Error:', error);
    await AudioStream.stop();
  }
}

// Convert blob to base64 (for non-streaming approach)
function blobToBase64(blob: Blob): Promise<string> {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.onloadend = () => {
      const base64 = reader.result?.toString().split(',')[1] || '';
      resolve(base64);
    };
    reader.onerror = reject;
    reader.readAsDataURL(blob);
  });
}

// Stream with progress tracking
async function streamWithProgress(
  url: string, 
  onProgress?: (received: number, total?: number) => void
) {
  await AudioStream.startStream('', { autoPlay: true });
  
  const response = await fetch(url);
  const reader = response.body?.getReader();
  const contentLength = response.headers.get('Content-Length');
  const total = contentLength ? parseInt(contentLength, 10) : undefined;
  
  if (!reader) throw new Error('Stream not available');
  
  let received = 0;
  
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    
    received += value.length;
    onProgress?.(received, total);
    
    const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
    await AudioStream.appendToBuffer(base64Chunk);
  }
}

// Deepgram with streaming
async function speakWithDeepgram(text: string) {
  const response = await fetch('https://api.deepgram.com/v1/speak', {
    method: 'POST',
    headers: {
      'Authorization': `Token ${DEEPGRAM_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      text: text,
      model: 'aura-asteria-en',
      encoding: 'mp3',
      // Streaming optimizations
      container: 'mp3',
      sample_rate: 44100,
    })
  });
  
  if (response.headers.get('Content-Type')?.includes('audio')) {
    // Direct streaming response
    await AudioStream.startStream('', { autoPlay: true });
    
    const reader = response.body?.getReader();
    if (!reader) throw new Error('Stream not available');
    
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      
      const base64Chunk = btoa(String.fromCharCode(...new Uint8Array(value)));
      await AudioStream.appendToBuffer(base64Chunk);
    }
  } else {
    // URL response
    const { url } = await response.json();
    await AudioStream.startStream(url);
  }
}

await AudioStream.initialize({
  // Optimize for streaming
  bufferSize: 16,        // Small buffer for low latency (KB)
  prebufferThreshold: 8, // Start playback with less data (KB)
  chunkSize: 4,          // Small chunks for smooth streaming (KB)
  
  // Network settings
  reconnectAttempts: 3,
  reconnectDelay: 1000,
  timeout: 30000,
});

// Set audio session category
await AudioStream.setAudioSessionCategory('playback');

// Request audio focus
const granted = await AudioStream.requestAudioFocus();

interface AudioStreamConfig {
  bufferSize?: number;
  prebufferThreshold?: number;
  maxBufferSize?: number;
  chunkSize?: number;
  protocol?: StreamingProtocol;
  reconnectAttempts?: number;
  reconnectDelay?: number;
  timeout?: number;
  format?: AudioFormat;
  sampleRate?: number;
  channels?: number;
  bitRate?: number;
  autoPlay?: boolean;
  enableBackgroundMode?: boolean;
  maintainAudioFocus?: boolean;
  enableCache?: boolean;
  cacheSize?: number;
  cachePath?: string;
  logLevel?: LogLevel;
  headers?: Record<string, string>;
}

enum PlaybackState {
  IDLE = 'idle',
  LOADING = 'loading',
  BUFFERING = 'buffering',
  PLAYING = 'playing',
  PAUSED = 'paused',
  STOPPED = 'stopped',
  ERROR = 'error',
  COMPLETED = 'completed',
}

interface PlaybackStats {
  bufferedDuration: number;    // Seconds of buffered content
  playedDuration: number;      // Seconds played
  totalDuration: number;       // Total duration if known
  networkSpeed: number;        // KB/s
  latency: number;            // Network latency in ms
  bufferHealth: number;       // 0-100 percentage
  droppedFrames: number;      // Dropped audio frames
  bitRate: number;           // Actual bitrate in kbps
  bufferedPosition: number;   // End position of buffer in seconds
  currentPosition: number;    // Current playback position
  bufferedPercentage: number; // Percentage of total duration buffered
  isBuffering: boolean;       // Currently buffering
  playWhenReady: boolean;     // Will play when buffer is ready
}

import React, { useEffect, useState } from 'react';
import { View, Button, Text } from 'react-native';
import AudioStream, { PlaybackState, LogLevel } from '@mustafakarali/react-native-audio-stream';

export default function AudioPlayer() {
  const [state, setState] = useState<PlaybackState>(PlaybackState.IDLE);
  const [progress, setProgress] = useState({ current: 0, total: 0 });
  const [metadata, setMetadata] = useState({ title: '', artist: '' });

  useEffect(() => {
    // Initialize audio stream (optional)
    AudioStream.initialize({
      enableBackgroundMode: true,
      enableCache: true,
      logLevel: LogLevel.INFO,
    });

    // Setup event listeners
    AudioStream.addEventListener('onStateChange', setState);
    AudioStream.addEventListener('onProgress', (data) => {
      setProgress({ current: data.currentTime, total: data.duration });
    });
    AudioStream.addEventListener('onMetadata', (data) => {
      setMetadata({ title: data.title || '', artist: data.artist || '' });
    });

    return () => {
      AudioStream.removeAllEventListeners();
      AudioStream.destroy();
    };
  }, []);

  const handlePlay = async () => {
    if (state === PlaybackState.IDLE) {
      await AudioStream.startStream('https://example.com/stream.mp3');
    } else {
      await AudioStream.play();
    }
  };

  return (
    <View>
      <Text>State: {state}</Text>
      <Text>Progress: {progress.current.toFixed(1)}s / {progress.total.toFixed(1)}s</Text>
      {metadata.title ? (
        <Text>Now Playing: {metadata.title} - {metadata.artist}</Text>
      ) : null}
      <Button title="Play" onPress={handlePlay} />
      <Button title="Pause" onPress={() => AudioStream.pause()} />
      <Button title="Stop" onPress={() => AudioStream.stop()} />
      <Button title="Cancel" onPress={() => AudioStream.cancelStream()} />
    </View>
  );
}

// HLS streaming
await AudioStream.startStream('https://example.com/playlist.m3u8');

// DASH streaming  
await AudioStream.startStream('https://example.com/manifest.mpd');

// With authentication
await AudioStream.startStream('https://example.com/playlist.m3u8', {
  headers: {
    'Authorization': 'Bearer token',
  },
});

await AudioStream.startStream(url, {
  headers: {
    'Authorization': 'Bearer your-token',
    'X-Custom-Header': 'value',
  },
});

await AudioStream.initialize({
  reconnectAttempts: 5,
  reconnectDelay: 2000,  // 2 seconds
  timeout: 30000,        // 30 seconds
});