use rsp::playback::{PlaybackState, Player, ShuffleMode, Track};
use std::path::PathBuf;

fn dummy_track(title: &str) -> Track {
    Track {
        path: PathBuf::from(format!("/music/{}", title)),
        title: title.to_string(),
        artist: "Test Artist".to_string(),
        album: "Test Album".to_string(),
        duration: Some(180000),
    }
}

#[test]
fn test_player_default_state() {
    let player = Player::new();
    assert_eq!(player.state(), &PlaybackState::Stopped);
    assert_eq!(player.volume(), 70);
}

#[test]
fn test_player_play_with_track_in_queue() {
    let mut player = Player::new();
    player.queue_track(dummy_track("Test Track"), "last");
    player.play();
    assert_eq!(player.state(), &PlaybackState::Playing);
    assert!(player.current_track.is_some());
    assert!(player.queue.is_empty());
}

#[test]
fn test_player_play_with_no_track() {
    let mut player = Player::new();
    player.play();
    assert_eq!(player.state(), &PlaybackState::Stopped);
}

#[test]
fn test_player_play_track() {
    let mut player = Player::new();
    player.play_track(dummy_track("Test Track"));
    assert_eq!(player.state(), &PlaybackState::Playing);
    assert!(player.current_track.is_some());
}

#[test]
fn test_player_pause() {
    let mut player = Player::new();
    player.play_track(dummy_track("Test Track"));
    player.pause();
    assert_eq!(player.state(), &PlaybackState::Paused);
}

#[test]
fn test_player_pause_when_stopped() {
    let mut player = Player::new();
    player.pause();
    assert_eq!(player.state(), &PlaybackState::Stopped);
}

#[test]
fn test_player_resume() {
    let mut player = Player::new();
    player.play_track(dummy_track("Test Track"));
    player.pause();
    player.resume();
    assert_eq!(player.state(), &PlaybackState::Playing);
}

#[test]
fn test_player_resume_when_stopped() {
    let mut player = Player::new();
    player.resume();
    assert_eq!(player.state(), &PlaybackState::Stopped);
}

#[test]
fn test_player_stop() {
    let mut player = Player::new();
    player.play_track(dummy_track("Test Track"));
    player.stop();
    assert_eq!(player.state(), &PlaybackState::Stopped);
    assert!(player.current_track.is_none());
}

#[test]
fn test_player_next_with_queue() {
    let mut player = Player::new();
    player.queue_track(dummy_track("Track 1"), "last");
    player.queue_track(dummy_track("Track 2"), "last");
    player.next();
    assert_eq!(player.current_track.as_ref().unwrap().title, "Track 1");
}

#[test]
fn test_player_next_empty_queue() {
    let mut player = Player::new();
    player.next();
    assert_eq!(player.state(), &PlaybackState::Stopped);
    assert!(player.current_track.is_none());
}

#[test]
fn test_player_previous() {
    let mut player = Player::new();
    player.play_track(dummy_track("Test Track"));
    player.previous();
    assert_eq!(player.state(), &PlaybackState::Playing);
}

#[test]
fn test_player_set_volume() {
    let mut player = Player::new();
    player.set_volume(50);
    assert_eq!(player.volume(), 50);
}

#[test]
fn test_player_set_volume_caps_at_100() {
    let mut player = Player::new();
    player.set_volume(150);
    assert_eq!(player.volume(), 100);
}

#[test]
fn test_player_set_shuffle() {
    let mut player = Player::new();
    player.set_shuffle(ShuffleMode::All);
    assert_eq!(player.shuffle, ShuffleMode::All);
    player.set_shuffle(ShuffleMode::Albums);
    assert_eq!(player.shuffle, ShuffleMode::Albums);
}

#[test]
fn test_player_queue_track_now() {
    let mut player = Player::new();
    player.queue_track(dummy_track("Track 1"), "now");
    assert_eq!(player.queue.len(), 1);
    assert_eq!(player.queue[0].title, "Track 1");
}

#[test]
fn test_player_queue_track_next() {
    let mut player = Player::new();
    player.queue_track(dummy_track("Track 1"), "last");
    player.queue_track(dummy_track("Track 2"), "next");
    assert_eq!(player.queue.len(), 2);
    assert_eq!(player.queue[0].title, "Track 1");
    assert_eq!(player.queue[1].title, "Track 2");
}

#[test]
fn test_player_queue_track_last() {
    let mut player = Player::new();
    player.queue_track(dummy_track("Track 1"), "last");
    player.queue_track(dummy_track("Track 2"), "last");
    assert_eq!(player.queue.len(), 2);
    assert_eq!(player.queue[0].title, "Track 1");
    assert_eq!(player.queue[1].title, "Track 2");
}

#[test]
fn test_player_dequeue_next() {
    let mut player = Player::new();
    player.queue_track(dummy_track("Track 1"), "last");
    let track = player.dequeue_next();
    assert!(track.is_some());
    assert_eq!(track.unwrap().title, "Track 1");
    assert!(player.queue.is_empty());
}

#[test]
fn test_player_dequeue_next_empty() {
    let mut player = Player::new();
    let track = player.dequeue_next();
    assert!(track.is_none());
}