curr_offset -= 5000; // safety to avoid not having enough data for symphonia

				curr_offset = curr_offset.saturating_sub(5000); // safety to avoid not having enough data for symphonia

#[derive(Debug, Clone, Copy, PartialEq)]

#[derive(Debug, Clone, PartialEq)]

pub trait SourcePlugin {

pub trait SourcePlugin: Send {

			paused: true,

			paused: false,

	collections::VecDeque,

	sync::Arc,

	sync::{
		atomic::{self, AtomicUsize},
		Arc,
	},

use cpal::StreamConfig;

use cpal::{
	traits::{DeviceTrait, HostTrait},
	StreamConfig,
};

use tracing::debug;

use crate::{SongSource, SourceError};

use crate::{PlayerController, SongSource, SourceError};

	QueueSong(SongSource),

	SetSource(SongSource),

	pub state: Arc<RwLock<State>>,

	state: Arc<RwLock<State>>,
	source_queue: VecDeque<SongSource>,
	nb_queued: Arc<AtomicUsize>, // invariant: nb_queued == source_queue.len()

	pub fn new(config: StreamConfig, receiver: crossbeam_channel::Receiver<Event>) -> Self {
		Self {
			receiver,
			config,

	pub fn new() -> anyhow::Result<PlayerController> {
		let host = cpal::default_host();
		let device = host
			.default_output_device()
			.expect("no output device available");
		let config = device.default_output_config().expect("error while configs");
		debug!("playing... {:?}", config);
		let (to_player, from_controller) = crossbeam_channel::unbounded();
		let nb_queued = Arc::new(AtomicUsize::new(0));
		let mut player = Player {
			receiver: from_controller,
			config: config.config(),

			source_queue: VecDeque::new(),
			nb_queued: nb_queued.clone(),

		}

		};
		let player_state = player.state.clone();
		let stream = device.build_output_stream(
			&config.into(),
			move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
				player.process(data);
			},
			move |err| {
				println!("{err:?}");
			},
		)?;
		PlayerController::new(player_state, to_player, stream, nb_queued)

				Event::QueueSong(source) => {
					self.source_queue.push_back(source);
					self.nb_queued
						.store(self.source_queue.len(), atomic::Ordering::Relaxed);
				}

					self.state.write().play().unwrap();

					self.state.write().play().ok();

					self.state.write().pause().unwrap();

					self.state.write().pause().ok();

					match self.source.as_mut().unwrap().signal.seek(position) {
						Err(SourceError::Buffering) => {

					match self.source.as_mut().map(|s| s.signal.seek(position)) {
						Some(Err(SourceError::Buffering)) => {

				}
				Event::SetSource(mut source) => {
					let source_sample_rate = source.sample_rate;
					let mut resampler =
						Resampler::new((self.config.sample_rate.0 as f64) / source_sample_rate)
							.unwrap();
					resampler.process(&mut source).ok();
					self.resampler = Some(resampler);
					self.state.write().set_song(source.info);
					self.source = Some(source);

		}
	}
	pub fn next_source(&mut self) {
		if *self.state.read() != State::Idle {
			return;
		}
		if let Some(mut source) = self.source_queue.pop_front() {
			let source_sample_rate = source.sample_rate;
			let mut resampler =
				Resampler::new((self.config.sample_rate.0 as f64) / source_sample_rate).unwrap();
			resampler.process(&mut source).ok();
			self.resampler = Some(resampler);
			self.state.write().set_song(source.info.clone());
			self.source = Some(source);
			self.nb_queued
				.store(self.source_queue.len(), atomic::Ordering::Relaxed);

		self.next_source();

						self.resampler = None;
						self.source = None;

						self.next_source();

use std::{sync::Arc, time::Duration};

use std::{
	sync::{
		atomic::{self, AtomicUsize},
		Arc,
	},
	time::Duration,
};

use cpal::traits::{DeviceTrait, HostTrait};

use tracing::debug;

use crate::player::Player;

	plugins: Vec<Box<dyn SourcePlugin>>,
	_stream: cpal::Stream,

	plugins: Vec<Box<dyn SourcePlugin>>,
	_stream: cpal::Stream,
	nb_queued: Arc<AtomicUsize>,

	pub fn new() -> Result<Self> {
		let host = cpal::default_host();
		let device = host
			.default_output_device()
			.expect("no output device available");
		let config = device.default_output_config().expect("error while configs");
		debug!("playing... {:?}", config);
		let (to_player, from_controller) = crossbeam_channel::unbounded();
		let mut player = Player::new(config.config(), from_controller);
		let player_state = player.state.clone();
		let stream = device.build_output_stream(
			&config.into(),
			move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
				player.process(data);
			},
			move |err| {
				println!("{err:?}");
			},
		)?;

	pub fn new(
		state: Arc<RwLock<player::State>>,
		sender: crossbeam_channel::Sender<Event>,
		stream: cpal::Stream,
		nb_queued: Arc<AtomicUsize>,
	) -> Result<Self> {

			_stream: stream,
			state: player_state,
			sender: to_player,

			state,
			sender,

			_stream: stream,
			nb_queued,

	pub fn set_song(&mut self, url: &Url) -> Result<()> {

	fn create_source(&self, url: &Url) -> Result<SongSource> {

			if let Some(source) = plugin.handle_url(url) {

			if let Some(source) = plugin.handle_url(&url) {

				self.sender.send(Event::SetSource(source)).unwrap();
				return Ok(());

				return Ok(source);

	pub fn queue_song(&mut self, url: Url) -> Result<()> {
		let source = self.create_source(&url)?;
		if let Err(e) = self.sender.send(Event::QueueSong(source)) {
			panic!("{:?}", e);
		}
		Ok(())
	}

		// self.stream.play()?;

		// self.stream.pause()?;

	pub fn nb_queued(&self) -> usize {
		self.nb_queued.load(atomic::Ordering::Relaxed)
	}

use druid::{
};
/// Converts a `Widget<String>` to a `Widget<T>`, not modifying the data if the input is invalid
pub struct ParseLazy<W> {
	widget: W,
	state: String,
}
impl<W> ParseLazy<W> {
	pub fn new(widget: W) -> Self {
		Self {
			widget,
			state: String::new(),
		}
	}
}
impl<T: FromStr + Display + Data, W: Widget<String>> Widget<T> for ParseLazy<W> {
	fn event(&mut self, ctx: &mut EventCtx, event: &Event, data: &mut T, env: &Env) {
		self.widget.event(ctx, event, &mut self.state, env);
		if let Ok(res) = self.state.parse() {
			*data = res;
		}
	}
	fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle, data: &T, env: &Env) {
		if let LifeCycle::WidgetAdded = event {
			self.state = data.to_string();
		}
		self.widget.lifecycle(ctx, event, &self.state, env)
	}
	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &T, data: &T, env: &Env) {
		let old = mem::replace(&mut self.state, data.to_string());
		self.widget.update(ctx, &old, &self.state, env)
	}
	fn layout(&mut self, ctx: &mut LayoutCtx, bc: &BoxConstraints, _data: &T, env: &Env) -> Size {
		self.widget.layout(ctx, bc, &self.state, env)
	}
	fn paint(&mut self, paint: &mut PaintCtx, _data: &T, env: &Env) {
		self.widget.paint(paint, &self.state, env)
	}
	fn id(&self) -> Option<WidgetId> {
		self.widget.id()
	}
}
	kurbo::Size, BoxConstraints, Data, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx,
	PaintCtx, UpdateCtx, Widget, WidgetId,
use std::{fmt::Display, mem, str::FromStr};

use std::f64::consts::TAU;
pub struct Knob {
	initial_data: f32,
	value_preview: f32,
	click: Point,
}
impl Knob {
	pub fn new() -> Self {
		Self {
			initial_data: 0.0,
			value_preview: 0.0,
			click: Point::ORIGIN,
		}
	}
}
const SPEED: f32 = 10e-3;
impl Widget<f32> for Knob {
	fn event(&mut self, ctx: &mut EventCtx, event: &Event, data: &mut f32, _env: &Env) {
		match event {
			Event::MouseDown(evt) => {
				if !ctx.is_disabled() {
					ctx.set_active(true);
					self.click = evt.pos;
					self.value_preview = *data;
					self.initial_data = *data;
					ctx.request_paint();
				}
			}
			Event::MouseMove(evt) => {
				if ctx.is_active() {
					let off = evt.pos - self.click;
					self.value_preview = (self.initial_data + (off.x - off.y) as f32 * SPEED)
						.min(1.0)
						.max(0.0);
					ctx.request_paint();
				}
			}
			Event::MouseUp(evt) => {
				if ctx.is_active() && !ctx.is_disabled() {
					let off = evt.pos - self.click;
					*data = (self.initial_data + (off.x - off.y) as f32 * SPEED)
						.min(1.0)
						.max(0.0);
					ctx.request_paint();
				}
				ctx.set_active(false);
			}
			_ => (),
		}
	}
	fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle, _data: &f32, _env: &Env) {
		if let LifeCycle::HotChanged(_) | LifeCycle::DisabledChanged(_) = event {
			ctx.request_paint();
		}
	}
		ctx.request_paint();
	}
	fn layout(
		&mut self,
		_ctx: &mut LayoutCtx,
		bc: &BoxConstraints,
		_data: &f32,
		_env: &Env,
	) -> Size {
		bc.max()
	}
	fn paint(&mut self, ctx: &mut PaintCtx, data: &f32, env: &Env) {
		let size = ctx.size();
		let center = (size / 2.0).to_vec2().to_point();
		let radius = size.width / 2.0 - 2.0;
			center,
			radii: Vec2::new(radius, radius),
			start_angle: 0.0,
			sweep_angle: if ctx.is_active() {
				self.value_preview as f64 * TAU
			} else {
				*data as f64 * TAU
			},
			x_rotation: -TAU / 4.0,
		}
		.into_path(0.1);
	}
}
		ctx.fill(wheel, &env.get(crate::theme::ACCENT));
		ctx.stroke(arc_path, &env.get(crate::theme::ACCENT_DIM), 2.0);
		let mut wheel = arc_path.clone();
		wheel.line_to(center);
		wheel.line_to(center - Vec2::new(0.0, radius));
		let arc_path: BezPath = kurbo::Arc {
	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &f32, _data: &f32, _env: &Env) {
use druid::{
	kurbo::{self, BezPath, Shape, Size},
	piet::RenderContext,
	widget::prelude::*,
	Point, Vec2,
};

use super::knob::Knob;

use super::common::knob::Knob;

			Event::Command(c) if c.is(command::SONG_PLAY) => {

			Event::Command(c) if c.is(command::SONG_PLAY) || c.is(command::QUERY_PLAY) => {

use crate::state::State;
use druid::{
	BoxConstraints, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx, Point,
	Rect, Selector, Size, UpdateCtx, Widget, WidgetPod,
};
type ChildBuilder = Box<dyn Fn(&Env) -> Box<dyn Widget<State>>>;
pub const SHOW_AT: Selector<(Point, BoxConstraints, ChildBuilder)> =
	Selector::new("dropdown.show-at");
pub const SHOW_MIDDLE: Selector<(BoxConstraints, ChildBuilder)> =
	Selector::new("dropdown.show-middle");
pub const HIDE: Selector = Selector::new("dropdown.hide");
pub struct Child {
	origin: Option<Point>,
	bc: BoxConstraints,
	widget: WidgetPod<State, Box<dyn Widget<State>>>,
}
pub struct Overlay {
	child: Option<Child>,
}
impl Overlay {
	pub fn new() -> Overlay {
		Overlay { child: None }
	}
}
impl Widget<State> for Overlay {
	fn event(&mut self, ctx: &mut EventCtx, event: &Event, data: &mut State, env: &Env) {
		let mut remove_child = false;
		if let Some(child) = &mut self.child {
			child.widget.event(ctx, event, data, env);
			match event {
				Event::MouseDown(mouse) => {
					if !child.widget.layout_rect().contains(mouse.pos) {
						ctx.set_active(true);
					}
					ctx.set_handled();
				}
				Event::MouseUp(mouse) => {
					if ctx.is_active() && !child.widget.layout_rect().contains(mouse.pos) {
						remove_child = true;
						ctx.set_active(false);
					}
					ctx.set_handled();
				}
				Event::MouseMove(_) => {
					ctx.set_handled();
				}
				_ => {}
			}
		}
		match event {
			Event::Command(cmd) if cmd.is(SHOW_AT) => {
				let (pos, bc, child_builder) = cmd.get_unchecked(SHOW_AT);
				self.child = Some(Child {
					origin: Some(*pos),
					bc: *bc,
					widget: WidgetPod::new(child_builder(env)),
				});
				ctx.children_changed();
			}
			Event::Command(cmd) if cmd.is(SHOW_MIDDLE) => {
				let (bc, child_builder) = cmd.get_unchecked(SHOW_MIDDLE);
				self.child = Some(Child {
					origin: None,
					bc: *bc,
					widget: WidgetPod::new(child_builder(env)),
				});
				ctx.children_changed();
			}
			Event::Command(cmd) if cmd.is(HIDE) => {
				remove_child = true;
			}
			_ => {}
		}
		if remove_child {
			self.child = None;
			ctx.request_layout();
			ctx.request_paint();
		}
	}
	fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle, data: &State, env: &Env) {
		if let Some(child) = &mut self.child {
			child.widget.lifecycle(ctx, event, data, env);
		}
	}
	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &State, data: &State, env: &Env) {
		if let Some(child) = &mut self.child {
			child.widget.update(ctx, data, env);
		}
	}
	fn layout(
		&mut self,
		ctx: &mut LayoutCtx,
		bc: &BoxConstraints,
		data: &State,
		env: &Env,
	) -> Size {
		if let Some(child) = &mut self.child {
			let size = child.widget.layout(ctx, &child.bc, data, env);
			let origin = child
				.origin
				.unwrap_or_else(|| (bc.max().to_vec2() / 2.0 - size.to_vec2() / 2.0).to_point());
			child
				.widget
				.set_layout_rect(ctx, data, env, Rect::from_origin_size(origin, size));
		}
		bc.max()
	}
	fn paint(&mut self, ctx: &mut PaintCtx, data: &State, env: &Env) {
		if let Some(child) = &mut self.child {
			child.widget.paint(ctx, data, env);
		}
	}
}

pub mod parse_lazy;

pub mod common;

pub mod knob;

pub mod overlay;

use druid::kurbo::{Point, Rect, Size};
use druid::{
	BoxConstraints, Data, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx,
	UpdateCtx, Widget, WidgetPod,
};
pub struct Stack<T: Data> {
	children: Vec<WidgetPod<T, Box<dyn Widget<T>>>>,
}
impl<T: Data> Stack<T> {
	pub fn new() -> Self {
		Stack {
			children: Vec::new(),
		}
	}
	pub fn with_child(mut self, child: impl Widget<T> + 'static) -> Self {
		self.add_child(child);
		self
	}
	pub fn add_child(&mut self, child: impl Widget<T> + 'static) {
		self.children.push(WidgetPod::new(child).boxed());
	}
}
impl<T: Data> Widget<T> for Stack<T> {
	fn event(&mut self, ctx: &mut EventCtx, event: &Event, data: &mut T, env: &Env) {
		self.children.reverse();
		for child in &mut self.children {
			child.event(ctx, event, data, env);
			if ctx.is_handled() {
				break;
			}
		}
		self.children.reverse()
	}
	fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle, data: &T, env: &Env) {
		for child in &mut self.children {
			child.lifecycle(ctx, event, data, env);
		}
	}
	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &T, data: &T, env: &Env) {
		for child in &mut self.children {
			child.update(ctx, data, env);
		}
	}
	fn layout(&mut self, ctx: &mut LayoutCtx, bc: &BoxConstraints, data: &T, env: &Env) -> Size {
		for child in &mut self.children {
			child.layout(ctx, bc, data, env);
			child.set_layout_rect(
				ctx,
				data,
				env,
				Rect::from_origin_size(Point::ORIGIN, bc.max()),
			)
		}
		bc.max()
	}
	fn paint(&mut self, ctx: &mut PaintCtx, data: &T, env: &Env) {
		for child in &mut self.children {
			child.paint(ctx, data, env);
		}
	}
}

use std::{fmt::Display, mem, str::FromStr};
use druid::{
	kurbo::Size, BoxConstraints, Data, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx,
	PaintCtx, UpdateCtx, Widget, WidgetId,
};
/// Converts a `Widget<String>` to a `Widget<T>`, not modifying the data if the input is invalid
pub struct ParseLazy<W> {
	widget: W,
	state: String,
}
impl<W> ParseLazy<W> {
	pub fn new(widget: W) -> Self {
		Self {
			widget,
			state: String::new(),
		}
	}
}
impl<T: FromStr + Display + Data, W: Widget<String>> Widget<T> for ParseLazy<W> {
	fn event(&mut self, ctx: &mut EventCtx, event: &Event, data: &mut T, env: &Env) {
		self.widget.event(ctx, event, &mut self.state, env);
		if let Ok(res) = self.state.parse() {
			*data = res;
		}
	}
	fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle, data: &T, env: &Env) {
		if let LifeCycle::WidgetAdded = event {
			self.state = data.to_string();
		}
		self.widget.lifecycle(ctx, event, &self.state, env)
	}
	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &T, data: &T, env: &Env) {
		let old = mem::replace(&mut self.state, data.to_string());
		self.widget.update(ctx, &old, &self.state, env)
	}
	fn layout(&mut self, ctx: &mut LayoutCtx, bc: &BoxConstraints, _data: &T, env: &Env) -> Size {
		self.widget.layout(ctx, bc, &self.state, env)
	}
	fn paint(&mut self, paint: &mut PaintCtx, _data: &T, env: &Env) {
		self.widget.paint(paint, &self.state, env)
	}
	fn id(&self) -> Option<WidgetId> {
		self.widget.id()
	}
}

pub mod knob;
pub mod parse_lazy;
pub mod stack;

use std::f64::consts::TAU;
use druid::{
	kurbo::{self, BezPath, Shape, Size},
	piet::RenderContext,
	widget::prelude::*,
	Point, Vec2,
};
pub struct Knob {
	initial_data: f32,
	value_preview: f32,
	click: Point,
}
impl Knob {
	pub fn new() -> Self {
		Self {
			initial_data: 0.0,
			value_preview: 0.0,
			click: Point::ORIGIN,
		}
	}
}
const SPEED: f32 = 10e-3;
impl Widget<f32> for Knob {
	fn event(&mut self, ctx: &mut EventCtx, event: &Event, data: &mut f32, _env: &Env) {
		match event {
			Event::MouseDown(evt) => {
				if !ctx.is_disabled() {
					ctx.set_active(true);
					self.click = evt.pos;
					self.value_preview = *data;
					self.initial_data = *data;
					ctx.request_paint();
				}
			}
			Event::MouseMove(evt) => {
				if ctx.is_active() {
					let off = evt.pos - self.click;
					self.value_preview = (self.initial_data + (off.x - off.y) as f32 * SPEED)
						.min(1.0)
						.max(0.0);
					ctx.request_paint();
				}
			}
			Event::MouseUp(evt) => {
				if ctx.is_active() && !ctx.is_disabled() {
					let off = evt.pos - self.click;
					*data = (self.initial_data + (off.x - off.y) as f32 * SPEED)
						.min(1.0)
						.max(0.0);
					ctx.request_paint();
				}
				ctx.set_active(false);
			}
			_ => (),
		}
	}
	fn lifecycle(&mut self, ctx: &mut LifeCycleCtx, event: &LifeCycle, _data: &f32, _env: &Env) {
		if let LifeCycle::HotChanged(_) | LifeCycle::DisabledChanged(_) = event {
			ctx.request_paint();
		}
	}
	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &f32, _data: &f32, _env: &Env) {
		ctx.request_paint();
	}
	fn layout(
		&mut self,
		_ctx: &mut LayoutCtx,
		bc: &BoxConstraints,
		_data: &f32,
		_env: &Env,
	) -> Size {
		bc.max()
	}
	fn paint(&mut self, ctx: &mut PaintCtx, data: &f32, env: &Env) {
		let size = ctx.size();
		let center = (size / 2.0).to_vec2().to_point();
		let radius = size.width / 2.0 * 0.7;
		let arc_path: BezPath = kurbo::Arc {
			center,
			radii: Vec2::new(radius, radius),
			start_angle: 0.0,
			sweep_angle: if ctx.is_active() {
				self.value_preview as f64 * TAU
			} else {
				*data as f64 * TAU
			},
			x_rotation: -TAU / 4.0,
		}
		.into_path(0.1);
		let mut wheel = arc_path.clone();
		wheel.line_to(center);
		wheel.line_to(center - Vec2::new(0.0, radius));
		ctx.fill(wheel, &env.get(crate::theme::ACCENT));
		ctx.stroke(arc_path, &env.get(crate::theme::ACCENT_DIM), 2.0);
	}
}

	widget::{controllers::Enter, player_tick::PlayerTick, tag_edit::TagEdit},

	widget::{
		common::stack::Stack, controllers::Enter, overlay::Overlay, player_tick::PlayerTick,
		tag_edit::TagEdit,
	},

use self::media_bar::MediaBarState;

	let query_box = query_box().lens(State::query);

	let query_box = query_box();

		Maybe::new(|| media_bar::ui(), || SizedBox::empty())
			.lens(Map::new(
				|s: &Rc<player::State>| s.get_playing().map(|s| Rc::new(s.clone())),
				|s: &mut Rc<player::State>, inner: Option<Rc<player::state::Playing>>| {
					*s = Rc::new(
						inner
							.map(|s| player::State::Playing((*s).clone()))
							.unwrap_or(player::State::Idle),
					);
				},
			))
			.lens(State::player_state),

		Maybe::new(|| media_bar::ui(), || SizedBox::empty()).lens(Map::new(
			|s: &State| {
				s.player_state.get_playing().map(|p| MediaBarState {
					playing: Rc::new(p.clone()),
					current_song: s.current_song.clone(),
				})
			},
			|s: &mut State, inner: Option<MediaBarState>| {
				s.player_state = Rc::new(
					inner
						.map(|s| player::State::Playing((*s.playing).clone()))
						.unwrap_or(player::State::Idle),
				);
			},
		)),

	ControllerHost::new(root.padding(10.0).expand_width(), PlayerTick::default())

	ControllerHost::new(
		Stack::new()
			.with_child(root.padding(10.0).expand_width())
			.with_child(Overlay::new()),
		PlayerTick::default(),
	)

			.with_child(play_button())

			.with_child(play_song_button())

fn query_box() -> impl Widget<String> {
	ControllerHost::new(
		TextBox::new()
			.with_placeholder("*")
			.with_text_alignment(TextAlignment::Center),
		Enter::new(|ctx, _, _| ctx.submit_command(command::QUERY_RUN)),
	)
	.expand_width()

fn query_box() -> impl Widget<State> {
	Flex::row()
		.with_child(play_query_button())
		.with_default_spacer()
		.with_flex_child(
			ControllerHost::new(
				TextBox::new()
					.with_placeholder("*")
					.with_text_alignment(TextAlignment::Center),
				Enter::new(|ctx, _, _| ctx.submit_command(command::QUERY_RUN)),
			)
			.expand_width()
			.lens(State::query),
			1.0,
		)

fn play_button() -> impl Widget<SongListItem> {

fn play_query_button() -> impl Widget<State> {
	Painter::new(|ctx, _: &State, env| draw_icon_button(ctx, env, ICON_PLAY))
		.fix_size(36.0, 36.0)
		.on_click(|ctx: &mut EventCtx, _, _| {
			ctx.submit_command(command::QUERY_PLAY);
		})
}
fn play_song_button() -> impl Widget<SongListItem> {

	widget::{Flex, Label, Painter},
	EventCtx, Widget, WidgetExt,

	widget::{Button, Container, Flex, Label, List, Maybe, Painter, SizedBox},
	BoxConstraints, Data, EventCtx, Lens, Size, Widget, WidgetExt,

use tf_player::player::{self, state::Playing};

use tf_db::Song;
use tf_player::player::state::Playing;

use crate::{command, widget::player_bar::PlayerBar};

use crate::{
	command, theme,
	widget::{overlay, player_bar::PlayerBar},
	State,
};
#[derive(Clone, Data, Lens)]
pub struct MediaBarState {
	pub playing: Rc<Playing>,
	pub current_song: Option<Rc<Song>>,
}

pub fn ui() -> impl Widget<Rc<player::state::Playing>> {

pub fn ui() -> impl Widget<MediaBarState> {

	let right_buttons = Flex::row()
		.with_flex_spacer(1.0)
		.with_child(Button::new("☰").on_click(
			move |ctx: &mut EventCtx, _: &mut MediaBarState, _| {
				ctx.submit_command(overlay::SHOW_MIDDLE.with((
					BoxConstraints::tight(Size::new(300.0, 300.0)),
					Box::new(move |env| {
						Box::new(
							Container::new(
								Flex::column()
									.with_child(
										Maybe::new(
											|| {
												Label::new(|data: &Rc<Song>, _: &_| {
													data.title.clone()
												})
											},
											|| SizedBox::empty(),
										)
										.lens(State::current_song),
									)
									.with_flex_child(
										List::new(|| {
											Label::new(|data: &Rc<Song>, _: &_| data.title.clone())
										})
										.lens(State::queue),
										1.0,
									),
							)
							.border(env.get(theme::FOREGROUND), 1.0),
						)
					}),
				)))
			},
		));
	let song_info = Maybe::new(
		|| Label::new(|data: &Rc<Song>, _: &_| data.title.clone()),
		|| SizedBox::empty(),
	)
	.expand_width();

		.with_child(buttons)

				.with_flex_child(song_info.lens(MediaBarState::current_song), 1.0)
				.with_child(buttons.lens(MediaBarState::playing))
				.with_flex_child(right_buttons, 1.0),
		)
		.with_child(
			Flex::row()

				})),

				}))
				.lens(MediaBarState::playing),

pub const FOREGROUND: Key<Color> = Key::new("theme.foreground");

	pub const ACCENT: Color = color(0x98c379);
	pub const ACCENT_DIM: Color = color(0x8bb16e);

	pub const ACCENT: Color = color(0x98c379);
	pub const ACCENT_DIM: Color = color(0x8bb16e);

	pub const FOREGROUND: Color = color(0xffffff);

	env.set(FOREGROUND, colors::FOREGROUND);

		env.set(TEXT_COLOR, color(0xFFFFFF));
		env.set(CURSOR_COLOR, color(0xFFFFFF));

		env.set(TEXT_COLOR, colors::FOREGROUND);
		env.set(CURSOR_COLOR, colors::FOREGROUND);

	pub queue: im::Vector<Rc<Song>>,

	pub current_song: Option<Rc<Song>>,

			queue: im::Vector::new(),

			current_song: None,

	// pub fn playing_lens() -> druid::lens::Map<
	// 	impl Fn(&Rc<player::State>) -> Option<Rc<player::state::Playing>>,
	// 	impl Fn(&mut Rc<player::State>, Option<Rc<player::state::Playing>>),
	// > {
	// 	druid::lens::Map::new(
	// 		|s: &Rc<player::State>| s.get_playing().map(|s| Rc::new(s.clone())),
	// 		|s: &mut Rc<player::State>, inner: Option<Rc<player::state::Playing>>| {
	// 			*s = Rc::new(
	// 				inner
	// 					.map(|s| player::State::Playing((*s).clone()))
	// 					.unwrap_or(player::State::Idle),
	// 			);
	// 		},
	// 	)
	// }

use druid::AppDelegate;
use tf_player::PlayerController;

use druid::{im, AppDelegate};
use tf_db::Song;
use tf_player::{player::Player, PlayerController};

			player: PlayerController::new()?,

			player: Player::new()?,

			}
			_ if cmd.is(command::QUERY_PLAY) => {
				let db = data.db.write();
				let mut queue: im::Vector<Rc<Song>> = data
					.songs
					.iter()
					.filter_map(|item| db.get_song(item.song.id).ok())
					.map(|s| Rc::new(s))
					.collect();
				if let Some(song) = queue.pop_front() {
					self.player
						.queue_song(Url::parse(&song.source).unwrap())
						.unwrap();
					data.current_song = Some(song);
				}
				data.queue = queue;
				druid::Handled::No

				// update player bar

				// queue next song
				let until_empty = ps
					.get_playing()
					.map(|p| p.song.duration - p.offset)
					.unwrap_or_default() + Duration::from_secs(
					self.player.nb_queued() as u64 * 10000000,
				);
				if until_empty < Duration::from_secs(1) {
					if let Some(song) = data.queue.pop_front() {
						self.player
							.queue_song(Url::parse(&song.source).unwrap())
							.unwrap();
						data.current_song = Some(song);
					} else {
						data.current_song = None;
					}
				}

				if let Ok(song) = data.db.read().get_song(*id) {
					match Url::parse(&song.source) {
						Ok(url) => {
							self.player.set_song(&url).unwrap();
							self.player.play().unwrap();
						}
						Err(e) => {
							panic!("{} {}", e, song.source);
						}
					}
				}

				let db = data.db.read();
				let song = db.get_song(*id).unwrap();
				let url = Url::parse(&song.source).unwrap();
				self.player.queue_song(url).unwrap();
				data.current_song = Some(Rc::new(song.clone()));
				self.player.play().unwrap();

pub const QUERY_PLAY: Selector = Selector::new("query.play");

pub const SONG_ADD: Selector<NewSong> = Selector::new("song-add");
pub const SONG_DELETE: Selector<Uuid> = Selector::new("song-delete");

pub const SONG_ADD: Selector<NewSong> = Selector::new("song.add");
pub const SONG_DELETE: Selector<Uuid> = Selector::new("song.delete");

pub const TAG_ADD: Selector<Uuid> = Selector::new("tag-add");
pub const TAG_RENAME: Selector<(String, String)> = Selector::new("tag-rename");
pub const TAG_TWEAK: Selector<(String, f32)> = Selector::new("tag-tweak");
pub const TAG_DELETE: Selector<String> = Selector::new("tag-delete");

pub const TAG_ADD: Selector<Uuid> = Selector::new("tag.add");
pub const TAG_RENAME: Selector<(String, String)> = Selector::new("tag.rename");
pub const TAG_TWEAK: Selector<(String, f32)> = Selector::new("tag.tweak");
pub const TAG_DELETE: Selector<String> = Selector::new("tag.delete");