-module(rockbox@playback).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/rockbox/playback.gleam").
-export([raw_status/1, status/1, current_track/1, next_track/1, file_position/1, play/3, pause/1, resume/1, next/1, previous/1, seek/2, stop/1, flush_and_reload/1, play_track/2, play_options/0, with_shuffle/2, with_position/2, play_album/3, play_artist/3, play_playlist/3, play_directory/4, play_liked_tracks/2, play_all_tracks/2]).
-export_type([play_options/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(
    " Transport controls and \"play this thing\" shortcuts.\n"
    "\n"
    " ```gleam\n"
    " import rockbox\n"
    " import rockbox/playback\n"
    "\n"
    " let client = rockbox.connect(rockbox.new())\n"
    "\n"
    " let _ = playback.play_track(client, \"/Music/Miles Davis/Kind of Blue/01.flac\")\n"
    " let _ = playback.pause(client)\n"
    " let _ = playback.next(client)\n"
    " ```\n"
).

-opaque play_options() :: {play_options,
        gleam@option:option(boolean()),
        gleam@option:option(integer())}.

-file("src/rockbox/playback.gleam", 37).
?DOC(" Raw numeric playback status as the firmware reports it.\n").
-spec raw_status(rockbox:client()) -> {ok, integer()} |
    {error, rockbox@error:error()}.
raw_status(Client) ->
    Decoder = begin
        gleam@dynamic@decode:field(
            <<"status"/utf8>>,
            {decoder, fun gleam@dynamic@decode:decode_int/1},
            fun(Status) -> gleam@dynamic@decode:success(Status) end
        )
    end,
    rockbox:'query'(
        Client,
        <<"query PlaybackStatus { status }"/utf8>>,
        gleam@json:object([]),
        Decoder
    ).

-file("src/rockbox/playback.gleam", 46).
?DOC(" Typed playback status (`Stopped`, `Playing`, `Paused`, …).\n").
-spec status(rockbox:client()) -> {ok, rockbox@types:playback_status()} |
    {error, rockbox@error:error()}.
status(Client) ->
    case raw_status(Client) of
        {ok, Value} ->
            {ok, rockbox@types:playback_status_from_int(Value)};

        {error, Err} ->
            {error, Err}
    end.

-file("src/rockbox/playback.gleam", 55).
?DOC(
    " The track currently loaded for playback (may not be playing). Returns\n"
    " `Ok(None)` if no track is queued.\n"
).
-spec current_track(rockbox:client()) -> {ok,
        gleam@option:option(rockbox@types:track())} |
    {error, rockbox@error:error()}.
current_track(Client) ->
    Decoder = begin
        gleam@dynamic@decode:field(
            <<"currentTrack"/utf8>>,
            gleam@dynamic@decode:optional(rockbox@types:track_decoder()),
            fun(Track) -> gleam@dynamic@decode:success(Track) end
        )
    end,
    Q = <<"
  fragment TrackFields on Track {
    id title artist album genre disc trackString yearString
    composer comment albumArtist grouping
    discnum tracknum layer year bitrate frequency
    filesize length elapsed path
    albumId artistId genreId albumArt
  }
"/utf8,
        "
    query CurrentTrack { currentTrack { ...TrackFields } }
  "/utf8>>,
    rockbox:'query'(Client, Q, gleam@json:object([]), Decoder).

-file("src/rockbox/playback.gleam", 71).
?DOC(
    " The track that will play after the current one finishes. `Ok(None)` if the\n"
    " queue ends with the current track.\n"
).
-spec next_track(rockbox:client()) -> {ok,
        gleam@option:option(rockbox@types:track())} |
    {error, rockbox@error:error()}.
next_track(Client) ->
    Decoder = begin
        gleam@dynamic@decode:field(
            <<"nextTrack"/utf8>>,
            gleam@dynamic@decode:optional(rockbox@types:track_decoder()),
            fun(Track) -> gleam@dynamic@decode:success(Track) end
        )
    end,
    Q = <<"
  fragment TrackFields on Track {
    id title artist album genre disc trackString yearString
    composer comment albumArtist grouping
    discnum tracknum layer year bitrate frequency
    filesize length elapsed path
    albumId artistId genreId albumArt
  }
"/utf8,
        "
    query NextTrack { nextTrack { ...TrackFields } }
  "/utf8>>,
    rockbox:'query'(Client, Q, gleam@json:object([]), Decoder).

-file("src/rockbox/playback.gleam", 86).
?DOC(" Position of the audio file the codec is currently reading from, in bytes.\n").
-spec file_position(rockbox:client()) -> {ok, integer()} |
    {error, rockbox@error:error()}.
file_position(Client) ->
    Decoder = begin
        gleam@dynamic@decode:field(
            <<"getFilePosition"/utf8>>,
            {decoder, fun gleam@dynamic@decode:decode_int/1},
            fun(Pos) -> gleam@dynamic@decode:success(Pos) end
        )
    end,
    rockbox:'query'(
        Client,
        <<"query FilePosition { getFilePosition }"/utf8>>,
        gleam@json:object([]),
        Decoder
    ).

-file("src/rockbox/playback.gleam", 105).
?DOC(
    " Start playback at `elapsed` ms with the codec offset set to `offset` bytes.\n"
    " Pass `0, 0` to start from the beginning.\n"
).
-spec play(rockbox:client(), integer(), integer()) -> {ok, nil} |
    {error, rockbox@error:error()}.
play(Client, Elapsed, Offset) ->
    rockbox:execute(
        Client,
        <<"mutation Play($elapsed: Long!, $offset: Long!) { play(elapsed: $elapsed, offset: $offset) }"/utf8>>,
        gleam@json:object(
            [{<<"elapsed"/utf8>>, gleam@json:int(Elapsed)},
                {<<"offset"/utf8>>, gleam@json:int(Offset)}]
        )
    ).

-file("src/rockbox/playback.gleam", 117).
?DOC(" Pause playback.\n").
-spec pause(rockbox:client()) -> {ok, nil} | {error, rockbox@error:error()}.
pause(Client) ->
    rockbox:execute(
        Client,
        <<"mutation Pause { pause }"/utf8>>,
        gleam@json:object([])
    ).

-file("src/rockbox/playback.gleam", 122).
?DOC(" Resume playback after a pause.\n").
-spec resume(rockbox:client()) -> {ok, nil} | {error, rockbox@error:error()}.
resume(Client) ->
    rockbox:execute(
        Client,
        <<"mutation Resume { resume }"/utf8>>,
        gleam@json:object([])
    ).

-file("src/rockbox/playback.gleam", 127).
?DOC(" Skip to the next track in the queue.\n").
-spec next(rockbox:client()) -> {ok, nil} | {error, rockbox@error:error()}.
next(Client) ->
    rockbox:execute(
        Client,
        <<"mutation Next { next }"/utf8>>,
        gleam@json:object([])
    ).

-file("src/rockbox/playback.gleam", 132).
?DOC(" Go back to the previous track.\n").
-spec previous(rockbox:client()) -> {ok, nil} | {error, rockbox@error:error()}.
previous(Client) ->
    rockbox:execute(
        Client,
        <<"mutation Previous { previous }"/utf8>>,
        gleam@json:object([])
    ).

-file("src/rockbox/playback.gleam", 137).
?DOC(" Seek the current track to an absolute position in milliseconds.\n").
-spec seek(rockbox:client(), integer()) -> {ok, nil} |
    {error, rockbox@error:error()}.
seek(Client, Position_ms) ->
    rockbox:execute(
        Client,
        <<"mutation Seek($newTime: Int!) { fastForwardRewind(newTime: $newTime) }"/utf8>>,
        gleam@json:object([{<<"newTime"/utf8>>, gleam@json:int(Position_ms)}])
    ).

-file("src/rockbox/playback.gleam", 146).
?DOC(" Stop playback and tear down the audio engine.\n").
-spec stop(rockbox:client()) -> {ok, nil} | {error, rockbox@error:error()}.
stop(Client) ->
    rockbox:execute(
        Client,
        <<"mutation Stop { hardStop }"/utf8>>,
        gleam@json:object([])
    ).

-file("src/rockbox/playback.gleam", 151).
?DOC(" Flush the codec buffer and reload the queue from disk.\n").
-spec flush_and_reload(rockbox:client()) -> {ok, nil} |
    {error, rockbox@error:error()}.
flush_and_reload(Client) ->
    rockbox:execute(
        Client,
        <<"mutation FlushReload { flushAndReloadTracks }"/utf8>>,
        gleam@json:object([])
    ).

-file("src/rockbox/playback.gleam", 164).
?DOC(" Play a single file by absolute path.\n").
-spec play_track(rockbox:client(), binary()) -> {ok, nil} |
    {error, rockbox@error:error()}.
play_track(Client, Path) ->
    rockbox:execute(
        Client,
        <<"mutation PlayTrack($path: String!) { playTrack(path: $path) }"/utf8>>,
        gleam@json:object([{<<"path"/utf8>>, gleam@json:string(Path)}])
    ).

-file("src/rockbox/playback.gleam", 189).
?DOC(" Default play options — no shuffle, append at the end.\n").
-spec play_options() -> play_options().
play_options() ->
    {play_options, none, none}.

-file("src/rockbox/playback.gleam", 194).
?DOC(" Toggle shuffle for the resulting queue.\n").
-spec with_shuffle(play_options(), boolean()) -> play_options().
with_shuffle(Opts, Value) ->
    {play_options, {some, Value}, erlang:element(3, Opts)}.

-file("src/rockbox/playback.gleam", 199).
?DOC(" Set the queue position to start playback at.\n").
-spec with_position(play_options(), integer()) -> play_options().
with_position(Opts, Value) ->
    {play_options, erlang:element(2, Opts), {some, Value}}.

-file("src/rockbox/playback.gleam", 203).
-spec play_options_pairs(play_options()) -> list({binary(),
    gleam@option:option(gleam@json:json())}).
play_options_pairs(Opts) ->
    [{<<"shuffle"/utf8>>,
            gleam@option:map(erlang:element(2, Opts), fun gleam@json:bool/1)},
        {<<"position"/utf8>>,
            gleam@option:map(erlang:element(3, Opts), fun gleam@json:int/1)}].

-file("src/rockbox/playback.gleam", 213).
?DOC(" Replace the queue with every track on an album and start playing.\n").
-spec play_album(rockbox:client(), binary(), play_options()) -> {ok, nil} |
    {error, rockbox@error:error()}.
play_album(Client, Album_id, Options) ->
    Vars = rockbox@internal@transport:variables(
        [{<<"albumId"/utf8>>, {some, gleam@json:string(Album_id)}} |
            play_options_pairs(Options)]
    ),
    rockbox:execute(
        Client,
        <<"mutation PlayAlbum($albumId: String!, $shuffle: Boolean, $position: Int) {
       playAlbum(albumId: $albumId, shuffle: $shuffle, position: $position)
     }"/utf8>>,
        Vars
    ).

-file("src/rockbox/playback.gleam", 233).
?DOC(" Replace the queue with every track an artist has and start playing.\n").
-spec play_artist(rockbox:client(), binary(), play_options()) -> {ok, nil} |
    {error, rockbox@error:error()}.
play_artist(Client, Artist_id, Options) ->
    Vars = rockbox@internal@transport:variables(
        [{<<"artistId"/utf8>>, {some, gleam@json:string(Artist_id)}} |
            play_options_pairs(Options)]
    ),
    rockbox:execute(
        Client,
        <<"mutation PlayArtist($artistId: String!, $shuffle: Boolean, $position: Int) {
       playArtistTracks(artistId: $artistId, shuffle: $shuffle, position: $position)
     }"/utf8>>,
        Vars
    ).

-file("src/rockbox/playback.gleam", 253).
?DOC(" Play a saved playlist by ID.\n").
-spec play_playlist(rockbox:client(), binary(), play_options()) -> {ok, nil} |
    {error, rockbox@error:error()}.
play_playlist(Client, Playlist_id, Options) ->
    Vars = rockbox@internal@transport:variables(
        [{<<"playlistId"/utf8>>, {some, gleam@json:string(Playlist_id)}} |
            play_options_pairs(Options)]
    ),
    rockbox:execute(
        Client,
        <<"mutation PlayPlaylist($playlistId: String!, $shuffle: Boolean, $position: Int) {
       playPlaylist(playlistId: $playlistId, shuffle: $shuffle, position: $position)
     }"/utf8>>,
        Vars
    ).

-file("src/rockbox/playback.gleam", 273).
?DOC(" Queue and play every audio file in a directory.\n").
-spec play_directory(rockbox:client(), binary(), boolean(), play_options()) -> {ok,
        nil} |
    {error, rockbox@error:error()}.
play_directory(Client, Path, Recurse, Options) ->
    Vars = rockbox@internal@transport:variables(
        [{<<"path"/utf8>>, {some, gleam@json:string(Path)}},
            {<<"recurse"/utf8>>, {some, gleam@json:bool(Recurse)}} |
            play_options_pairs(Options)]
    ),
    rockbox:execute(
        Client,
        <<"mutation PlayDirectory($path: String!, $recurse: Boolean, $shuffle: Boolean, $position: Int) {
       playDirectory(path: $path, recurse: $recurse, shuffle: $shuffle, position: $position)
     }"/utf8>>,
        Vars
    ).

-file("src/rockbox/playback.gleam", 295).
?DOC(" Play every liked track.\n").
-spec play_liked_tracks(rockbox:client(), play_options()) -> {ok, nil} |
    {error, rockbox@error:error()}.
play_liked_tracks(Client, Options) ->
    Vars = rockbox@internal@transport:variables(play_options_pairs(Options)),
    rockbox:execute(
        Client,
        <<"mutation PlayLikedTracks($shuffle: Boolean, $position: Int) {
       playLikedTracks(shuffle: $shuffle, position: $position)
     }"/utf8>>,
        Vars
    ).

-file("src/rockbox/playback.gleam", 310).
?DOC(" Play the entire library.\n").
-spec play_all_tracks(rockbox:client(), play_options()) -> {ok, nil} |
    {error, rockbox@error:error()}.
play_all_tracks(Client, Options) ->
    Vars = rockbox@internal@transport:variables(play_options_pairs(Options)),
    rockbox:execute(
        Client,
        <<"mutation PlayAllTracks($shuffle: Boolean, $position: Int) {
       playAllTracks(shuffle: $shuffle, position: $position)
     }"/utf8>>,
        Vars
    ).