use hls_m3u8::MediaPlaylist;

		println!("hls: {:#?}", hls);

		let segment_infos = SegmentInfos::from_hls(&hls);
		let cache = fetcher::SoundcloudFetcher::spawn(hls.duration(), segment_infos.clone())?;
		let source = source::SoundcloudMediaSource::new(hls.duration(), segment_infos, cache);

		let cache = fetcher::SoundcloudFetcher::spawn(&hls)?;
		let source =
			source::SoundcloudMediaSource::new(hls.duration(), hls.segments.iter().len(), cache);

#[derive(Clone)]

#[derive(Clone)]
pub struct SegmentInfos(pub Vec<SegmentInfo>);
impl SegmentInfos {
	pub fn from_hls(hls: &MediaPlaylist) -> Self {
		Self(
			hls.segments
				.values()
				.map(|segment| SegmentInfo {
					url: segment.uri().to_string(),
					duration: segment.duration.duration(),
				})
				.collect(),
		)
	}
	fn segment_at(&self, time: Duration) -> Option<usize> {
		let mut t = Duration::ZERO;
		for (idx, segment) in self.0.iter().enumerate() {
			t += segment.duration;
			if t > time {
				return Some(idx);
			}
		}
		return None;
	}
	fn time_at_position(&self, segment_idx: usize, byte_idx: usize) -> Duration {
		let mut t = Duration::ZERO;
		for (idx, segment) in self.0.iter().enumerate() {
			if segment_idx == idx {
				t += Duration::from_secs_f64(byte_idx as f64 / 128_000.0);
				break;
			}
			t += segment.duration;
		}
		return t;
	}
}

use anyhow::Result;

use anyhow::{Context, Result};

	formats::FormatReader,

	formats::{FormatReader, SeekMode, SeekTo},

	units::Time,

use crate::{plugin::SongInfo, SongSource, Source, SourcePlugin};

use crate::{plugin::SongInfo, SongSource, Source, SourceError, SourcePlugin};

	ended: bool,
	empty: bool,

	buffering: bool,

			ended: false,
			empty: false,

			buffering: false,

	fn handle_messages(&mut self) {}

		self.handle_messages();

				self.empty = false;

				self.buffering = false;

				self.empty = true;
				println!("{}", e);

				self.buffering = true;
				println!("error while decoding next packed {}", e);

		self.i = 0;

		let packet = format.next_packet()?;

		let packet = format.next_packet().context("Couldn't fetch next packet")?;

	let audio_buf = decoder.decode(&packet)?;

	let audio_buf = decoder
		.decode(&packet)
		.context("Couldn't decode next packet")?;

	fn next(&mut self, buf: &mut [[f32; 2]]) {
		if self.empty || self.ended {
			return;

	fn seek(&mut self, pos: Duration) {
		if let Err(_) = self.format.seek(
			SeekMode::Coarse,
			SeekTo::Time {
				time: Time {
					seconds: pos.as_secs(),
					frac: pos.as_secs_f64().fract(),
				},
				track_id: None,
			},
		) {
			self.buffering = true;

		self.decode_next();
		self.i = 0;
	}
	fn next(&mut self, buf: &mut [[f32; 2]]) -> Result<(), SourceError> {

			if self.i >= self.sample_buf.len() as u32 {
				self.decode_next();
				if self.buffering {
					return Err(SourceError::Buffering);
				}
			}

			if self.i == self.sample_buf.len() as u32 {
				self.decode_next();
				self.i = 0;
			}

		Ok(())

// impl Signal for LocalSource {
// 	type Frame = Stereo<f32>;
// 	fn is_exhausted(&self) -> bool {
// 		self.ended
// 	}
// 	fn next(&mut self) -> Self::Frame {
// 		if self.empty || self.ended {
// 			return [0.0, 0.0];
// 		}
// 		let frame = [
// 			self.sample_buf.samples()[(self.i + 0) as usize],
// 			self.sample_buf.samples()[(self.i + 1) as usize],
// 		];
// 		self.i += 2;
// 		if self.i == self.sample_buf.len() as u32 {
// 			self.decode_next();
// 			self.i = 0;
// 		}
// 		frame
// 	}
// }

#[derive(Debug)]
pub enum SourceError {
	Buffering,
}

	fn next(&mut self, buf: &mut [[f32; 2]]);

	fn seek(&mut self, pos: Duration);
	fn next(&mut self, buf: &mut [[f32; 2]]) -> Result<(), SourceError>;

thiserror = "1.0"

use std::{rc::Rc, time::Instant};

use std::{
	rc::Rc,
	time::{Duration, Instant},
};

			_ if cmd.is(command::PLAYER_SEEK) => {
				let pos = cmd.get::<Duration>(command::PLAYER_SEEK).unwrap();
				self.player.seek(*pos).unwrap();
				druid::Handled::Yes
			}

 "thiserror",