rockbox

-module(rockbox@playlist).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/rockbox/playlist.gleam").
-export([current/1, amount/1, insert_tracks/4, insert_directory/4, insert_album/3, remove_track/2, clear/1, shuffle/1, create/3, start_options/0, at_index/2, at_elapsed/2, at_offset/2, start/2, resume/1]).
-export_type([start_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(
    " The current/active playback queue (Mopidy-style \"tracklist\").\n"
    "\n"
    " For named, persisted playlists see `rockbox/saved_playlists`.\n"
).

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

-file("src/rockbox/playlist.gleam", 24).
?DOC(" Snapshot of the active queue.\n").
-spec current(rockbox:client()) -> {ok, rockbox@types:playlist()} |
    {error, rockbox@error:error()}.
current(Client) ->
    Decoder = begin
        gleam@dynamic@decode:field(
            <<"playlistGetCurrent"/utf8>>,
            rockbox@types:playlist_decoder(),
            fun(Playlist) -> gleam@dynamic@decode:success(Playlist) 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 CurrentPlaylist {
      playlistGetCurrent {
        amount index maxPlaylistSize firstIndex
        lastInsertPos seed lastShuffledStart
        tracks { ...TrackFields }
      }
    }
  "/utf8>>,
    rockbox:'query'(Client, Q, gleam@json:object([]), Decoder).

-file("src/rockbox/playlist.gleam", 45).
?DOC(" Number of tracks currently queued.\n").
-spec amount(rockbox:client()) -> {ok, integer()} |
    {error, rockbox@error:error()}.
amount(Client) ->
    Decoder = begin
        gleam@dynamic@decode:field(
            <<"playlistAmount"/utf8>>,
            {decoder, fun gleam@dynamic@decode:decode_int/1},
            fun(N) -> gleam@dynamic@decode:success(N) end
        )
    end,
    rockbox:'query'(
        Client,
        <<"query PlaylistAmount { playlistAmount }"/utf8>>,
        gleam@json:object([]),
        Decoder
    ).

-file("src/rockbox/playlist.gleam", 65).
?DOC(
    " Insert a list of paths or track IDs into the queue at the given position.\n"
    "\n"
    " Pass `option.None` for `playlist_id` to target the active queue.\n"
).
-spec insert_tracks(
    rockbox:client(),
    list(binary()),
    rockbox@types:insert_position(),
    gleam@option:option(binary())
) -> {ok, nil} | {error, rockbox@error:error()}.
insert_tracks(Client, Paths, Position, Playlist_id) ->
    Vars = rockbox@internal@transport:variables(
        [{<<"playlistId"/utf8>>,
                gleam@option:map(Playlist_id, fun gleam@json:string/1)},
            {<<"position"/utf8>>,
                {some,
                    gleam@json:int(
                        rockbox@types:insert_position_to_int(Position)
                    )}},
            {<<"tracks"/utf8>>,
                {some, gleam@json:array(Paths, fun gleam@json:string/1)}}]
    ),
    rockbox:execute(
        Client,
        <<"mutation InsertTracks($playlistId: String, $position: Int!, $tracks: [String!]!) {
       insertTracks(playlistId: $playlistId, position: $position, tracks: $tracks)
     }"/utf8>>,
        Vars
    ).

-file("src/rockbox/playlist.gleam", 90).
?DOC(" Append every track in a directory (optionally recursive) to the queue.\n").
-spec insert_directory(
    rockbox:client(),
    binary(),
    rockbox@types:insert_position(),
    gleam@option:option(binary())
) -> {ok, nil} | {error, rockbox@error:error()}.
insert_directory(Client, Directory, Position, Playlist_id) ->
    Vars = rockbox@internal@transport:variables(
        [{<<"playlistId"/utf8>>,
                gleam@option:map(Playlist_id, fun gleam@json:string/1)},
            {<<"position"/utf8>>,
                {some,
                    gleam@json:int(
                        rockbox@types:insert_position_to_int(Position)
                    )}},
            {<<"directory"/utf8>>, {some, gleam@json:string(Directory)}}]
    ),
    rockbox:execute(
        Client,
        <<"mutation InsertDirectory($playlistId: String, $position: Int!, $directory: String!) {
       insertDirectory(playlistId: $playlistId, position: $position, directory: $directory)
     }"/utf8>>,
        Vars
    ).

-file("src/rockbox/playlist.gleam", 112).
?DOC(" Append every track on an album to the queue.\n").
-spec insert_album(rockbox:client(), binary(), rockbox@types:insert_position()) -> {ok,
        nil} |
    {error, rockbox@error:error()}.
insert_album(Client, Album_id, Position) ->
    rockbox:execute(
        Client,
        <<"mutation InsertAlbum($albumId: String!, $position: Int!) {
       insertAlbum(albumId: $albumId, position: $position)
     }"/utf8>>,
        gleam@json:object(
            [{<<"albumId"/utf8>>, gleam@json:string(Album_id)},
                {<<"position"/utf8>>,
                    gleam@json:int(
                        rockbox@types:insert_position_to_int(Position)
                    )}]
        )
    ).

-file("src/rockbox/playlist.gleam", 129).
-spec remove_track(rockbox:client(), integer()) -> {ok, nil} |
    {error, rockbox@error:error()}.
remove_track(Client, Index) ->
    rockbox:execute(
        Client,
        <<"mutation RemoveTrack($index: Int!) { playlistRemoveTrack(index: $index) }"/utf8>>,
        gleam@json:object([{<<"index"/utf8>>, gleam@json:int(Index)}])
    ).

-file("src/rockbox/playlist.gleam", 138).
?DOC(" Empty the active queue.\n").
-spec clear(rockbox:client()) -> {ok, nil} | {error, rockbox@error:error()}.
clear(Client) ->
    rockbox:execute(
        Client,
        <<"mutation ClearPlaylist { playlistRemoveAllTracks }"/utf8>>,
        gleam@json:object([])
    ).

-file("src/rockbox/playlist.gleam", 147).
?DOC(" Shuffle the active queue in place.\n").
-spec shuffle(rockbox:client()) -> {ok, nil} | {error, rockbox@error:error()}.
shuffle(Client) ->
    rockbox:execute(
        Client,
        <<"mutation ShufflePlaylist { shufflePlaylist }"/utf8>>,
        gleam@json:object([])
    ).

-file("src/rockbox/playlist.gleam", 156).
?DOC(" Replace the queue with a new ad-hoc playlist and start playing it.\n").
-spec create(rockbox:client(), binary(), list(binary())) -> {ok, nil} |
    {error, rockbox@error:error()}.
create(Client, Name, Tracks) ->
    rockbox:execute(
        Client,
        <<"mutation CreatePlaylist($name: String!, $tracks: [String!]!) {
       playlistCreate(name: $name, tracks: $tracks)
     }"/utf8>>,
        gleam@json:object(
            [{<<"name"/utf8>>, gleam@json:string(Name)},
                {<<"tracks"/utf8>>,
                    gleam@json:array(Tracks, fun gleam@json:string/1)}]
        )
    ).

-file("src/rockbox/playlist.gleam", 182).
-spec start_options() -> start_options().
start_options() ->
    {start_options, none, none, none}.

-file("src/rockbox/playlist.gleam", 186).
-spec at_index(start_options(), integer()) -> start_options().
at_index(Opts, Value) ->
    {start_options,
        {some, Value},
        erlang:element(3, Opts),
        erlang:element(4, Opts)}.

-file("src/rockbox/playlist.gleam", 190).
-spec at_elapsed(start_options(), integer()) -> start_options().
at_elapsed(Opts, Value) ->
    {start_options,
        erlang:element(2, Opts),
        {some, Value},
        erlang:element(4, Opts)}.

-file("src/rockbox/playlist.gleam", 194).
-spec at_offset(start_options(), integer()) -> start_options().
at_offset(Opts, Value) ->
    {start_options,
        erlang:element(2, Opts),
        erlang:element(3, Opts),
        {some, Value}}.

-file("src/rockbox/playlist.gleam", 199).
?DOC(" Start playing the active queue from the given position.\n").
-spec start(rockbox:client(), start_options()) -> {ok, nil} |
    {error, rockbox@error:error()}.
start(Client, Options) ->
    Pairs = [{<<"startIndex"/utf8>>,
            gleam@option:map(erlang:element(2, Options), fun gleam@json:int/1)},
        {<<"elapsed"/utf8>>,
            gleam@option:map(erlang:element(3, Options), fun gleam@json:int/1)},
        {<<"offset"/utf8>>,
            gleam@option:map(erlang:element(4, Options), fun gleam@json:int/1)}],
    rockbox:execute(
        Client,
        <<"mutation PlaylistStart($startIndex: Int, $elapsed: Int, $offset: Int) {
       playlistStart(startIndex: $startIndex, elapsed: $elapsed, offset: $offset)
     }"/utf8>>,
        rockbox@internal@transport:variables(Pairs)
    ).

-file("src/rockbox/playlist.gleam", 215).
?DOC(" Resume an interrupted queue from the saved position.\n").
-spec resume(rockbox:client()) -> {ok, nil} | {error, rockbox@error:error()}.
resume(Client) ->
    rockbox:execute(
        Client,
        <<"mutation PlaylistResume { playlistResume }"/utf8>>,
        gleam@json:object([])
    ).