import { AudioHeadless, type MediaTrack, type PlayerConfiguration } from 'audiotoolheadless';

// Create audio player instance
const player = new AudioHeadless();

// Initialize with configuration
const config: PlayerConfiguration = {
  mode: 'VANILLA',
  useDefaultEventListeners: true,
  enableHls: true,           // Enable HLS streaming support
  enableEqualizer: true,     // Enable 10-band equalizer
  showNotificationActions: true, // OS-level media controls
  autoPlay: false,
  preloadStrategy: 'auto',
  crossOrigin: 'anonymous'
};

await player.initialize(config);

// Create a media track
const track: MediaTrack = {
  id: '1',
  title: 'My Song',
  source: 'https://example.com/audio.mp3',
  artist: 'Artist Name',
  album: 'Album Name',
  artwork: [{ src: 'https://example.com/artwork.jpg' }]
};

// Load and play audio
await player.loadTrack(track);
await player.play();

// HLS streaming (works on all browsers)
const hlsTrack: MediaTrack = {
  id: '2',
  title: 'Live Stream',
  source: 'https://example.com/stream.m3u8',
  artist: 'Live Artist',
  artwork: null
};

await player.loadAndPlay(hlsTrack);

// State management
player.onStateChange((state) => {
  console.log('Player state:', state.playbackState);
  console.log('Current track:', state.currentTrack?.title);
});

// Playback controls
player.pause();
player.setVolume(75);        // 0-100
player.seekToTime(30);       // Seek to 30 seconds
player.setPlaybackRate(1.5); // 1.5x speed

// Queue management
const playlist = [track, hlsTrack];
player.setQueue(playlist);
player.playNext();
player.enableShuffle(true);
player.setLoopMode('QUEUE');

// Equalizer controls
player.setEqualizerPreset('ROCK');
player.setCustomEqualizer([1, 2, 0, -1, 3, 0, 2, 1, 0, -1]);

class AudioHeadless {
  constructor();
  
  // Core lifecycle methods
  initialize(config: PlayerConfiguration): Promise<void>;
  destroy(): Promise<void>;
  reset(): Promise<void>;
  
  // Media loading and playback
  loadTrack(track: MediaTrack, fetchFn?: (track: MediaTrack) => Promise<void>): Promise<void>;
  loadAndPlay(track: MediaTrack, fetchFn?: (track: MediaTrack) => Promise<void>): Promise<void>;
  play(): Promise<void>;
  pause(): void;
  stop(): void;
  
  // Playback controls
  setVolume(volume: number): void; // 0-100
  getVolume(): number;
  setPlaybackRate(rate: PlaybackRate): void;
  getPlaybackRate(): PlaybackRate;
  seekToTime(seconds: number): void;
  seekByTime(seconds: number): void;
  mute(): void;
  unmute(): void;
  isMuted(): boolean;
  
  // Queue management
  setQueue(tracks: MediaTrack[], playbackType?: QueuePlaybackType): void;
  addToQueue(tracks: MediaTrack | MediaTrack[]): void;
  removeFromQueue(trackId: string): void;
  clearQueue(): void;
  getQueue(): MediaTrack[];
  getCurrentTrackIndex(): number;
  playNext(): void;
  playPrevious(): void;
  playTrackAt(index: number): void;
  
  // Shuffle and Loop controls
  enableShuffle(enabled: boolean): void;
  isShuffleEnabled(): boolean;
  setLoopMode(mode: LoopMode): void;
  getLoopMode(): LoopMode;
  
  // Equalizer controls
  initializeEqualizer(): void;
  getEqualizerPresets(): EqualizerPresets;
  setEqualizerPreset(presetName: keyof EqualizerPresets): void;
  setCustomEqualizer(gains: number[]): void;
  enableBassBoost(enabled: boolean, boost?: number): void;
  getEqualizerState(): EqualizerStatus;
  
  // State and event handling
  onStateChange(callback: (state: PlayerState) => void): () => void;
  getCurrentState(): PlayerState;
  addEventListener(event: keyof HTMLMediaElementEventMap, callback: EventListener): void;
  removeEventListener(event: keyof HTMLMediaElementEventMap, callback: EventListener): void;
  
  // Static utilities
  static getInstance(): AudioHeadless;
  static getAudioElement(): HTMLAudioElement;
}

interface PlayerConfiguration {
  mode: InitMode; // 'REACT' | 'VANILLA'
  useDefaultEventListeners: boolean;
  showNotificationActions?: boolean;
  preloadStrategy?: PreloadStrategy; // 'none' | 'metadata' | 'auto'
  playbackRate?: PlaybackRate;
  customEventListeners?: EventCallbackMap | null;
  autoPlay?: boolean;
  enablePlayLog?: boolean;
  enableHls?: boolean;        // Enable HLS streaming support
  enableEqualizer?: boolean;  // Enable 10-band equalizer
  crossOrigin?: CrossOriginValue; // 'anonymous' | 'use-credentials' | null
  hlsConfig?: HlsConfig;      // HLS.js configuration options
}

interface MediaTrack {
  id: string;
  title: string;
  source: string; // URL to audio file or HLS stream (.m3u8)
  artwork: MediaArtwork[] | null;
  duration?: number;
  genre?: string;
  album?: string;
  comment?: string;
  year?: number | string;
  artist?: string;
}

interface MediaArtwork {
  src: string;
  name?: string;
  sizes?: string;
}

const unsubscribe = audioPlayer.subscribe('AUDIO_STATE', (state) => {
  console.log('State changed:', state.playbackState);
});

// Unsubscribe when done
unsubscribe();