mpdclient 0.2.0

use mpdclient::{ConsumeState, Position, SingleState, State};

use crate::common::setup_mpd;

mod common;

#[test]
fn current() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;
            conn.player().play()?;
            assert_eq!(conn.player().current()?.uri(), "song.mp3");
            Ok(())
        },
    )
}

#[test]
fn play_pause() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;

            conn.player().play()?;
            assert_eq!(conn.status()?.state(), State::Play);
            conn.player().pause(true)?;
            assert_eq!(conn.status()?.state(), State::Pause);
            Ok(())
        },
    )
}

#[test]
fn play_id() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            conn.queue().add("song.mp3")?;

            let id = conn
                .queue()
                .add_id_position("song2.mp3", 0, Position::Absolute)?;
            conn.player().play_id(id)?;
            assert_eq!(conn.player().current()?.uri(), "song2.mp3");
            Ok(())
        },
    )
}

#[test]
fn stop() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;

            conn.player().play()?;
            conn.player().stop()?;
            assert_eq!(conn.status()?.state(), State::Stop);
            Ok(())
        },
    )
}

#[test]
fn next() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            conn.queue().add("song.mp3")?;
            conn.queue().add("song2.mp3")?;

            let player = conn.player();
            player.play()?;
            player.next()?;
            player.pause(true)?;
            assert_eq!(player.current()?.uri(), "song2.mp3");
            Ok(())
        },
    )
}

#[test]
fn previous() -> eyre::Result<()> {
    setup_mpd(
        |setup| {
            setup.song("song")?;
            setup.song("song2")
        },
        |conn| {
            conn.queue().add("song.mp3")?;
            conn.queue().add("song2.mp3")?;

            let player = conn.player();
            player.play_id(1)?;
            player.previous()?;
            player.pause(true)?;
            assert_eq!(player.current()?.uri(), "song.mp3");
            Ok(())
        },
    )
}

#[test]
fn seek_pos() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;

            conn.player().seek_pos(0, 10)?;
            assert_eq!(conn.status()?.elapsed_ms(), 10000);
            Ok(())
        },
    )
}

#[test]
fn seek_id() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;

            conn.player().seek_id(1, 20)?;
            assert_eq!(conn.status()?.elapsed_ms(), 20000);
            Ok(())
        },
    )
}

#[test]
fn seek_id_f() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;

            conn.player().seek_id_f(1, 13.546)?;
            assert_eq!(conn.status()?.elapsed_ms(), 13544);
            Ok(())
        },
    )
}

#[test]
fn seek_current_abs() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            conn.player().seek_current(11.345, false)?;
            assert_eq!(conn.status()?.elapsed_ms(), 11344);
            Ok(())
        },
    )
}

#[test]
fn seek_current_rel() -> eyre::Result<()> {
    setup_mpd(
        |setup| setup.song("song"),
        |conn| {
            conn.queue().add("song.mp3")?;
            conn.player().play()?;
            conn.player().pause(true)?;

            conn.player().seek_current(10.0, false)?;
            conn.player().seek_current(-1.1, true)?;
            assert_eq!(conn.status()?.elapsed_ms(), 8900);
            Ok(())
        },
    )
}

#[test]
fn repeat() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            conn.player().repeat(true)?;
            assert!(conn.status()?.repeat());
            conn.player().repeat(false)?;
            assert!(!conn.status()?.repeat());
            Ok(())
        },
    )
}

#[test]
fn random() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            conn.player().random(true)?;
            assert!(conn.status()?.random());
            conn.player().random(false)?;
            assert!(!conn.status()?.random());
            Ok(())
        },
    )
}

#[test]
fn single() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            conn.player().single(SingleState::On)?;
            assert_eq!(conn.status()?.single_state(), SingleState::On);
            conn.player().single(SingleState::Oneshot)?;
            assert_eq!(conn.status()?.single_state(), SingleState::Oneshot);
            conn.player().single(SingleState::Off)?;
            assert_eq!(conn.status()?.single_state(), SingleState::Off);
            Ok(())
        },
    )
}

#[test]
fn consume_bool() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            conn.player().consume_bool(true)?;
            assert_eq!(conn.status()?.consume_state(), ConsumeState::On);
            conn.player().consume_bool(false)?;
            assert_eq!(conn.status()?.consume_state(), ConsumeState::Off);
            Ok(())
        },
    )
}

#[cfg(feature = "protocol_0_24")]
#[test]
fn consume() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            conn.player().consume(ConsumeState::On)?;
            assert_eq!(conn.status()?.consume_state(), ConsumeState::On);
            conn.player().consume(ConsumeState::Oneshot)?;
            assert_eq!(conn.status()?.consume_state(), ConsumeState::Oneshot);
            conn.player().consume(ConsumeState::Off)?;
            assert_eq!(conn.status()?.consume_state(), ConsumeState::Off);
            Ok(())
        },
    )
}

#[test]
fn crossfade() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            conn.player().crossfade(2)?;
            assert_eq!(conn.status()?.crossfade(), Some(2));
            conn.player().crossfade(0)?;
            assert_eq!(conn.status()?.crossfade(), None);
            Ok(())
        },
    )
}

#[test]
fn mixrampdb() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            conn.player().mixrampdb(-15.0)?;
            assert_eq!(conn.status()?.mixrampdb(), Some(-15.0));
            conn.player().mixrampdb(0.0)?;
            assert_eq!(conn.status()?.mixrampdb(), None);
            Ok(())
        },
    )
}

#[test]
fn mixrampdelay() -> eyre::Result<()> {
    setup_mpd(
        |_| Ok(()),
        |conn| {
            conn.player().mixrampdelay(1.0)?;
            assert_eq!(conn.status()?.mixrampdelay(), Some(1.0));
            conn.player().mixrampdelay(0.0)?;
            assert_eq!(conn.status()?.mixrampdelay(), None);
            Ok(())
        },
    )
}