use std::process::Command;

use std::sync::Arc;

use regex::Regex;
use symphonia::core::io::{MediaSource, MediaSourceStream, MediaSourceStreamOptions};

use parking_lot::Mutex;
use symphonia::core::io::{MediaSource, MediaSourceStream};

			let source = SoundcloudSource::new(hls);

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

			std::thread::sleep(Duration::SECOND * 2);

// We need a thread that fetches the HLS segments continuously as we stream the audio
// and inserts them into a cache protected by a mutex.
// And the SoundcloudMediaSource needs to pull the segments from the cache.
struct SegmentInfo {
	url: String,
	duration: Duration,
}
struct SegmentCache(Vec<Option<Vec<u8>>>);
struct SoundcloudFetcher {
	duration: Duration,
	segment_infos: Vec<SegmentInfo>,
	segment_cache: Arc<Mutex<SegmentCache>>,
	source_pos: Arc<Mutex<Duration>>,
}
impl SoundcloudFetcher {
	pub fn spawn(hls: &MediaPlaylist) -> (Arc<Mutex<SegmentCache>>, Arc<Mutex<Duration>>) {
		let segment_cache = Arc::new(Mutex::new(SegmentCache(vec![
			None;
			hls.segments.iter().len()
		])));
		let source_pos = Arc::new(Mutex::new(Duration::ZERO));
		let fetcher = SoundcloudFetcher {
			duration: hls.duration(),
			segment_infos: hls
				.segments
				.values()
				.map(|segment| SegmentInfo {
					url: segment.uri().to_string(),
					duration: segment.duration.duration(),
				})
				.collect(),
			segment_cache: segment_cache.clone(),
			source_pos: source_pos.clone(),
		};
		std::thread::spawn(move || {
			fetcher.run();
		});
		(segment_cache, source_pos)
	}

struct SoundcloudSource {

	fn segment_at(&self, time: Duration) -> Option<usize> {
		let mut t = Duration::ZERO;
		for (idx, segment) in self.segment_infos.iter().enumerate() {
			t += segment.duration;
			if t > time {
				return Some(idx);
			}
		}
		return None;
	}
	fn run(self) {
		'outer: loop {
			let curr_time = *self.source_pos.lock();
			let curr_segment = self.segment_at(curr_time).unwrap();
			let target_time = (curr_time + Duration::SECOND * 10).min(self.duration);
			let target_segment = self
				.segment_at(target_time)
				.unwrap_or(self.segment_infos.len());
			for idx in curr_segment..=target_segment {
				if self.segment_cache.lock().0[idx].is_none() {
					println!("fetching next segment: {}", idx);
					let info = &self.segment_infos[idx];
					self.segment_cache.lock().0[idx] = Some(
						ureq::get(&info.url)
							.call()
							.unwrap()
							.into_reader()
							.bytes()
							.collect::<Result<Vec<u8>, std::io::Error>>()
							.unwrap(),
					);
					continue 'outer;
				}
			}
			std::thread::sleep(Duration::SECOND);
		}
	}
}
struct SoundcloudMediaSource {

	urls: Vec<String>,
	// cached_frames: Vec<Option<u8>>,
	curr_segment_idx: usize,

	nb_segments: usize,
	segment_cache: Arc<Mutex<SegmentCache>>,
	curr_pos: Duration,

	curr_segment_idx: usize,

impl SoundcloudSource {
	pub fn new(hls: MediaPlaylist) -> Self {

impl SoundcloudMediaSource {
	pub fn new(
		duration: Duration,
		nb_segments: usize,
		segment_cache: Arc<Mutex<SegmentCache>>,
		curr_pos: Arc<Mutex<Duration>>,
	) -> Self {

			duration: hls.duration(),
			urls: hls.segments.values().map(|s| s.uri().to_string()).collect(),
			// cached_frames: vec![],
			curr_segment_idx: 0,

			duration,
			nb_segments,
			segment_cache,
			curr_pos: Duration::ZERO,

			curr_segment_idx: 0,

	fn fetch_segment(&mut self) {
		println!("fetching segment...");

	fn next_segment(&mut self) {
		println!(
			"grabbing segment {} from the cache...",
			self.curr_segment_idx
		);

			ureq::get(&self.urls[self.curr_segment_idx])
				.call()
				.unwrap()
				.into_reader()
				.bytes()
				.collect::<Result<Vec<u8>, std::io::Error>>()

			self.segment_cache.lock().0[self.curr_segment_idx]
				.clone()

		println!("fetched segment!");

		if self.curr_segment_idx < self.urls.len() {
			self.fetch_segment();

		if self.curr_segment_idx < self.nb_segments {
			self.next_segment();

impl Read for SoundcloudSource {

impl Read for SoundcloudMediaSource {

			self.fetch_segment();

			self.next_segment();

impl Seek for SoundcloudSource {

impl Seek for SoundcloudMediaSource {

impl MediaSource for SoundcloudSource {

impl MediaSource for SoundcloudMediaSource {

		None
		// Some(128_000.0 / self.duration.as_secs_f64())

		Some((128_000.0 * self.duration.as_secs_f64()).ceil() as u64)

soundcloud = ["dep:youtube_dl"]

soundcloud = []

serde = "1.0.137"

serde = { version = "1.0.137", features = ["derive"] }

youtube_dl = { version = "0.7", optional = true }

parking_lot = "0.12.1"

 "parking_lot 0.12.1",

 "youtube_dl",

[[package]]
name = "wait-timeout"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
dependencies = [
 "libc",
]

[[package]]
name = "youtube_dl"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3e3d041033acf677f28d7d79dc1f9207dfadf86ec05b82c5492126254d90a5d"
dependencies = [
 "log",
 "serde",
 "serde_json",
 "wait-timeout",
]