use std::io::{Read, Seek};
use std::sync::Arc;
use std::{convert::TryFrom, time::Duration};

use std::{
	convert::TryFrom,
	io::{Read, Seek},
	sync::Arc,
	time::Duration,
};

use dasp::frame::Stereo;
use dasp::signal::Signal;

use dasp::{frame::Stereo, signal::Signal};

#[derive(Clone, Copy)]

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

#[derive(Debug, Clone, PartialEq)]

impl Default for PlayerState {
	fn default() -> Self {
		Idle
	}
}

	pub fn current_song(&self) -> Option<&SongInfo> {
		match self {
			Paused { song, .. } | Playing { song, .. } => Some(song),
			_ => None,
		}
	}
	pub fn current_time(&self) -> Option<&Duration> {
		match self {
			Paused { offset, .. } | Playing { offset, .. } => Some(offset),
			_ => None,
		}
	}

	pub fn current_song(&self) -> Option<&SongInfo> {
		match &self.state {
			Paused { song, .. } | Playing { song, .. } => Some(song),
			_ => None,
		}
	}

use super::knob::Knob;

use super::knob::Knob;

use druid::widget::prelude::*;
use druid::WidgetPod;

use druid::{widget::prelude::*, WidgetPod};

use std::cell::RefCell;

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

use druid::kurbo::{self, BezPath, Line, Shape, Size};
use druid::piet::{Brush, LineCap, LineJoin, RenderContext, StrokeStyle};
use druid::widget::prelude::*;
use druid::{Point, TimerToken};
use tf_player::{PlayerController, PlayerState};

use druid::{
	kurbo::{Line, Size},
	piet::{LineCap, LineJoin, RenderContext, StrokeStyle},
	widget::prelude::*,
	Point,
};
use tf_player::PlayerState;

	timer: Option<TimerToken>,

type Data = Rc<RefCell<PlayerController>>;

type Data = Rc<PlayerState>;

			Event::MouseDown(evt) => {
				let data = data.borrow();

			Event::MouseDown(_) => {

					let mut data = data.borrow_mut();

						data.seek(position).unwrap();

						ctx.submit_command(command::PLAYER_SEEK.with(position));

			Event::Timer(t) if Some(*t) == self.timer => {
				if let PlayerState::Playing { .. } = data.borrow().state() {
					println!("TIMER TICK");
					ctx.request_paint();
					self.timer = Some(ctx.request_timer(Duration::SECOND));
				}
			}
			Event::Command(c) if c.is(command::SONG_PLAY) => {
				println!("TIMER START");
				self.timer = Some(ctx.request_timer(Duration::SECOND));
			}

	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &Data, data: &Data, _env: &Env) {

	fn update(&mut self, ctx: &mut UpdateCtx, _old_data: &Data, _data: &Data, _env: &Env) {

		let player = data.borrow();

		if let Some((position, song)) = match player.state() {
			PlayerState::Playing {
				offset,
				playing_since,
				song,
			} => Some((
				*offset + Instant::now().duration_since(*playing_since),
				song,
			)),
			PlayerState::Paused { offset, song } => Some((*offset, song)),

		if let Some((position, song)) = match data.as_ref() {
			PlayerState::Playing { offset, song, .. } | PlayerState::Paused { offset, song } => {
				Some((offset, song))
			}

			println!(
				"{:.2?} {:.2?} {progress:.2?}",
				position.as_secs_f64(),
				song.duration.as_secs_f64()
			);

use std::fmt::Display;
use std::mem;
use std::str::FromStr;

use std::{fmt::Display, mem, str::FromStr};

use druid::kurbo::Size;

	BoxConstraints, Data, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx, PaintCtx,
	UpdateCtx, Widget, WidgetId,

	kurbo::Size, BoxConstraints, Data, Env, Event, EventCtx, LayoutCtx, LifeCycle, LifeCycleCtx,
	PaintCtx, UpdateCtx, Widget, WidgetId,

pub mod player_tick;

use druid::kurbo::{self, BezPath, Shape, Size};
use druid::piet::RenderContext;
use druid::widget::prelude::*;
use druid::{Point, Vec2};

use druid::{
	kurbo::{self, BezPath, Shape, Size},
	piet::RenderContext,
	widget::prelude::*,
	Point, Vec2,
};

use std::{cell::RefCell, rc::Rc, time::Duration};

		Button, Container, CrossAxisAlignment, EnvScope, Flex, Label, List, Maybe, Parse, RawLabel,
		Scroll, SizedBox, Slider, TextBox, ViewSwitcher,

		Button, Container, ControllerHost, CrossAxisAlignment, EnvScope, Flex, Label, List, Maybe,
		Scroll, SizedBox, TextBox,

use tf_player::{PlayerController, PlayerState};

	widget::{parse_lazy::ParseLazy, player_bar::PlayerBar, square::Square, tag_edit::TagEdit},

	widget::{player_bar::PlayerBar, player_tick::PlayerTick, tag_edit::TagEdit},

	root.padding(10.0).expand_width()

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

		.with_default_spacer()

		.with_child(Button::new("⏯").on_click(|ctx, _, _| ctx.submit_command(command::PLAY_PAUSE)))

		.with_default_spacer()
		.with_child(
			Button::new("⏯").on_click(|ctx, _, _| ctx.submit_command(command::PLAYER_PLAY_PAUSE)),
		)
		.with_default_spacer()

		.with_default_spacer()

	let bar = PlayerBar::default().lens(State::player);

		.with_child(bar)

		.with_child(
			Flex::row()
				.with_child(Label::new(|data: &Rc<PlayerState>, _: &_| {
					format_duration(data.current_time().unwrap_or(&Duration::ZERO))
				}))
				.with_default_spacer()
				.with_flex_child(PlayerBar::default(), 1.0)
				.with_default_spacer()
				.with_child(Label::new(|data: &Rc<PlayerState>, _: &_| {
					format_duration(
						data.current_song()
							.map(|s| &s.duration)
							.unwrap_or(&Duration::ZERO),
					)
				})),
		)

		.lens(State::player_state)

fn format_duration(d: &Duration) -> String {
	format!("{:02}:{:02}", d.as_secs() / 60, d.as_secs() % 60)
}

use tf_player::PlayerController;

use tf_player::{PlayerController, PlayerState};

	pub player: Rc<RefCell<PlayerController>>,

	#[data(same_fn = "PartialEq::eq")]
	pub player_state: Rc<PlayerState>,

// struct PlayerControls {
// }

		let player = PlayerController::new()?;

		// let player = PlayerController::new()?;

			player: Rc::new(RefCell::new(player)),

			player_state: Rc::new(PlayerState::default()),

use std::fmt::Debug;
use std::rc::Rc;

use std::{fmt::Debug, rc::Rc};

use druid::{im, AppDelegate, Size};
use druid::{AppLauncher, WindowDesc};

use druid::{im, AppDelegate, AppLauncher, Size, WindowDesc};

pub use state::NewSong;

pub use state::State;

pub use state::{NewSong, State};

		.delegate(delegate::Delegate)

		.delegate(delegate::Delegate::new()?)

use std::rc::Rc;

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

use anyhow::Result;

use tf_player::{PlayerController, PlayerState};

pub struct Delegate;

pub struct Delegate {
	player: PlayerController,
}
impl Delegate {
	pub fn new() -> Result<Self> {
		Ok(Self {
			player: PlayerController::new()?,
		})
	}
}

		_ctx: &mut druid::DelegateCtx,

		ctx: &mut druid::DelegateCtx,

			_ if cmd.is(command::PLAYER_TICK) => {
				let mut ps = self.player.state().clone();
				if let PlayerState::Playing {
					offset,
					playing_since,
					..
				} = &mut ps
				{
					*offset += Instant::now() - *playing_since;
				}
				data.player_state = Rc::new(ps);
				druid::Handled::No
			}

					let mut player = data.player.borrow_mut();

							player.set_song(&url).unwrap();
							player.play().unwrap();

							self.player.set_song(&url).unwrap();
							self.player.play().unwrap();

			_ if cmd.is(command::PLAY_PAUSE) => {
				data.player.borrow_mut().play_pause().unwrap();

			_ if cmd.is(command::PLAYER_PLAY_PAUSE) => {
				self.player.play_pause().unwrap();

use std::time::Duration;

pub const PLAY_PAUSE: Selector = Selector::new("play-pause");

pub const PLAYER_PLAY_PAUSE: Selector = Selector::new("player.play-pause");
pub const PLAYER_TICK: Selector = Selector::new("player.tick");
pub const PLAYER_SEEK: Selector<Duration> = Selector::new("player.seek");

const MOCKUP: bool = false;

const MOCKUP: bool = true;

imports_granularity = "Crate"
group_imports = "StdExternalCrate"