rockbox

-module(rockbox).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/rockbox.gleam").
-export([new/0, host/2, port/2, url/2, connect/1, build/1, default_client/0, at/2, transport/1, 'query'/4, execute/3, http_url/1]).
-export_type([client/0, builder/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(
    " Rockbox Gleam SDK — pipe-friendly client for the rockboxd GraphQL API.\n"
    "\n"
    " ```gleam\n"
    " import rockbox\n"
    " import rockbox/playback\n"
    "\n"
    " pub fn main() {\n"
    "   let client = rockbox.connect()\n"
    "\n"
    "   let assert Ok(track) = playback.current_track(client)\n"
    "   let assert Ok(_) = playback.pause(client)\n"
    " }\n"
    " ```\n"
    "\n"
    " Customise the connection with the builder:\n"
    "\n"
    " ```gleam\n"
    " let client =\n"
    "   rockbox.new()\n"
    "   |> rockbox.host(\"rockbox.local\")\n"
    "   |> rockbox.port(8080)\n"
    "   |> rockbox.connect\n"
    " ```\n"
).

-opaque client() :: {client, rockbox@internal@transport:transport()}.

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

-file("src/rockbox.gleam", 59).
?DOC(" Start a new client builder with sensible defaults (`localhost:6062`).\n").
-spec new() -> builder().
new() ->
    {builder, <<"localhost"/utf8>>, 6062, none}.

-file("src/rockbox.gleam", 64).
?DOC(" Override the hostname (default `\"localhost\"`). Ignored if `url` is set.\n").
-spec host(builder(), binary()) -> builder().
host(Builder, Value) ->
    {builder, Value, erlang:element(3, Builder), erlang:element(4, Builder)}.

-file("src/rockbox.gleam", 69).
?DOC(" Override the port (default `6062`). Ignored if `url` is set.\n").
-spec port(builder(), integer()) -> builder().
port(Builder, Value) ->
    {builder, erlang:element(2, Builder), Value, erlang:element(4, Builder)}.

-file("src/rockbox.gleam", 74).
?DOC(" Override the full GraphQL HTTP URL. Takes precedence over `host` / `port`.\n").
-spec url(builder(), binary()) -> builder().
url(Builder, Value) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        {some, Value}}.

-file("src/rockbox.gleam", 79).
?DOC(" Finalise the builder and return a usable `Client`.\n").
-spec connect(builder()) -> client().
connect(Builder) ->
    Http_url = case erlang:element(4, Builder) of
        {some, Value} ->
            Value;

        none ->
            <<<<<<<<"http://"/utf8, (erlang:element(2, Builder))/binary>>/binary,
                        ":"/utf8>>/binary,
                    (erlang:integer_to_binary(erlang:element(3, Builder)))/binary>>/binary,
                "/graphql"/utf8>>
    end,
    {client, {transport, Http_url}}.

-file("src/rockbox.gleam", 93).
?DOC(" Alias for `connect`. Use whichever name reads better in your code.\n").
-spec build(builder()) -> client().
build(Builder) ->
    connect(Builder).

-file("src/rockbox.gleam", 102).
?DOC(" Shortcut for `new() |> connect()` — a client pointed at `localhost:6062`.\n").
-spec default_client() -> client().
default_client() ->
    _pipe = new(),
    connect(_pipe).

-file("src/rockbox.gleam", 107).
?DOC(" Shortcut for `new() |> host(host) |> port(port) |> connect()`.\n").
-spec at(binary(), integer()) -> client().
at(H, P) ->
    _pipe = new(),
    _pipe@1 = host(_pipe, H),
    _pipe@2 = port(_pipe@1, P),
    connect(_pipe@2).

-file("src/rockbox.gleam", 158).
?DOC(false).
-spec transport(client()) -> rockbox@internal@transport:transport().
transport(Client) ->
    erlang:element(2, Client).

-file("src/rockbox.gleam", 132).
?DOC(
    " Run a raw GraphQL operation against the server, decoding the `data` field\n"
    " with the supplied decoder. Useful if you need an endpoint the SDK doesn't\n"
    " expose directly yet.\n"
    "\n"
    " ```gleam\n"
    " import gleam/dynamic/decode\n"
    " import gleam/json\n"
    "\n"
    " let decoder = {\n"
    "   use version <- decode.field(\"rockboxVersion\", decode.string)\n"
    "   decode.success(version)\n"
    " }\n"
    "\n"
    " let assert Ok(version) =\n"
    "   client\n"
    "   |> rockbox.query(\"query { rockboxVersion }\", json.object([]), decoder)\n"
    " ```\n"
).
-spec 'query'(
    client(),
    binary(),
    gleam@json:json(),
    gleam@dynamic@decode:decoder(FIF)
) -> {ok, FIF} | {error, rockbox@error:error()}.
'query'(Client, Gql, Variables, Decoder) ->
    rockbox@internal@transport:execute(
        erlang:element(2, Client),
        Gql,
        Variables,
        Decoder
    ).

-file("src/rockbox.gleam", 143).
?DOC(
    " Like `query` but discards the response body — handy for fire-and-forget\n"
    " mutations that return a boolean status flag you don't care about.\n"
).
-spec execute(client(), binary(), gleam@json:json()) -> {ok, nil} |
    {error, rockbox@error:error()}.
execute(Client, Gql, Variables) ->
    rockbox@internal@transport:execute_unit(
        erlang:element(2, Client),
        Gql,
        Variables
    ).

-file("src/rockbox.gleam", 152).
?DOC(" Return the underlying GraphQL HTTP URL. Useful for diagnostics & tests.\n").
-spec http_url(client()) -> binary().
http_url(Client) ->
    erlang:element(2, erlang:element(2, Client)).