glopenai

-module(glopenai@audio).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glopenai/audio.gleam").
-export([new_create_speech_request/3, with_instructions/2, with_response_format/2, with_speed/2, with_stream_format/2, voice_to_json/1, speech_response_format_to_json/1, speech_model_to_json/1, stream_format_to_json/1, create_speech_request_to_json/1, voice_decoder/0, speech_response_format_decoder/0, speech_model_decoder/0, stream_format_decoder/0, create_speech_request/2, create_speech_response/1]).
-export_type([voice/0, speech_response_format/0, speech_model/0, stream_format/0, create_speech_request/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.

-type voice() :: alloy |
    ash |
    ballad |
    coral |
    echo |
    fable |
    onyx |
    nova |
    sage |
    shimmer |
    verse |
    marin |
    cedar |
    {custom_voice, binary()} |
    {other_voice, binary()}.

-type speech_response_format() :: mp3 | opus | aac | flac | pcm | wav.

-type speech_model() :: tts1 |
    tts1_hd |
    gpt4o_mini_tts |
    {other_speech_model, binary()}.

-type stream_format() :: sse | audio.

-type create_speech_request() :: {create_speech_request,
        binary(),
        speech_model(),
        voice(),
        gleam@option:option(binary()),
        gleam@option:option(speech_response_format()),
        gleam@option:option(float()),
        gleam@option:option(stream_format())}.

-file("src/glopenai/audio.gleam", 77).
?DOC(" Create a new speech request with the required fields.\n").
-spec new_create_speech_request(binary(), speech_model(), voice()) -> create_speech_request().
new_create_speech_request(Input, Model, Voice) ->
    {create_speech_request, Input, Model, Voice, none, none, none, none}.

-file("src/glopenai/audio.gleam", 93).
-spec with_instructions(create_speech_request(), binary()) -> create_speech_request().
with_instructions(Request, Instructions) ->
    {create_speech_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        {some, Instructions},
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request)}.

-file("src/glopenai/audio.gleam", 100).
-spec with_response_format(create_speech_request(), speech_response_format()) -> create_speech_request().
with_response_format(Request, Format) ->
    {create_speech_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        {some, Format},
        erlang:element(7, Request),
        erlang:element(8, Request)}.

-file("src/glopenai/audio.gleam", 107).
-spec with_speed(create_speech_request(), float()) -> create_speech_request().
with_speed(Request, Speed) ->
    {create_speech_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        {some, Speed},
        erlang:element(8, Request)}.

-file("src/glopenai/audio.gleam", 114).
-spec with_stream_format(create_speech_request(), stream_format()) -> create_speech_request().
with_stream_format(Request, Format) ->
    {create_speech_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        {some, Format}}.

-file("src/glopenai/audio.gleam", 123).
-spec voice_to_json(voice()) -> gleam@json:json().
voice_to_json(Voice) ->
    case Voice of
        {custom_voice, Id} ->
            gleam@json:object([{<<"id"/utf8>>, gleam@json:string(Id)}]);

        _ ->
            gleam@json:string(case Voice of
                    alloy ->
                        <<"alloy"/utf8>>;

                    ash ->
                        <<"ash"/utf8>>;

                    ballad ->
                        <<"ballad"/utf8>>;

                    coral ->
                        <<"coral"/utf8>>;

                    echo ->
                        <<"echo"/utf8>>;

                    fable ->
                        <<"fable"/utf8>>;

                    onyx ->
                        <<"onyx"/utf8>>;

                    nova ->
                        <<"nova"/utf8>>;

                    sage ->
                        <<"sage"/utf8>>;

                    shimmer ->
                        <<"shimmer"/utf8>>;

                    verse ->
                        <<"verse"/utf8>>;

                    marin ->
                        <<"marin"/utf8>>;

                    cedar ->
                        <<"cedar"/utf8>>;

                    {other_voice, Name} ->
                        Name;

                    {custom_voice, _} ->
                        <<""/utf8>>
                end)
    end.

-file("src/glopenai/audio.gleam", 148).
-spec speech_response_format_to_json(speech_response_format()) -> gleam@json:json().
speech_response_format_to_json(Format) ->
    gleam@json:string(case Format of
            mp3 ->
                <<"mp3"/utf8>>;

            opus ->
                <<"opus"/utf8>>;

            aac ->
                <<"aac"/utf8>>;

            flac ->
                <<"flac"/utf8>>;

            pcm ->
                <<"pcm"/utf8>>;

            wav ->
                <<"wav"/utf8>>
        end).

-file("src/glopenai/audio.gleam", 159).
-spec speech_model_to_json(speech_model()) -> gleam@json:json().
speech_model_to_json(Model) ->
    gleam@json:string(case Model of
            tts1 ->
                <<"tts-1"/utf8>>;

            tts1_hd ->
                <<"tts-1-hd"/utf8>>;

            gpt4o_mini_tts ->
                <<"gpt-4o-mini-tts"/utf8>>;

            {other_speech_model, Name} ->
                Name
        end).

-file("src/glopenai/audio.gleam", 168).
-spec stream_format_to_json(stream_format()) -> gleam@json:json().
stream_format_to_json(Format) ->
    gleam@json:string(case Format of
            sse ->
                <<"sse"/utf8>>;

            audio ->
                <<"audio"/utf8>>
        end).

-file("src/glopenai/audio.gleam", 175).
-spec create_speech_request_to_json(create_speech_request()) -> gleam@json:json().
create_speech_request_to_json(Request) ->
    glopenai@internal@codec:object_with_optional(
        [{<<"input"/utf8>>, gleam@json:string(erlang:element(2, Request))},
            {<<"model"/utf8>>, speech_model_to_json(erlang:element(3, Request))},
            {<<"voice"/utf8>>, voice_to_json(erlang:element(4, Request))}],
        [glopenai@internal@codec:optional_field(
                <<"instructions"/utf8>>,
                erlang:element(5, Request),
                fun gleam@json:string/1
            ),
            glopenai@internal@codec:optional_field(
                <<"response_format"/utf8>>,
                erlang:element(6, Request),
                fun speech_response_format_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"speed"/utf8>>,
                erlang:element(7, Request),
                fun gleam@json:float/1
            ),
            glopenai@internal@codec:optional_field(
                <<"stream_format"/utf8>>,
                erlang:element(8, Request),
                fun stream_format_to_json/1
            )]
    ).

-file("src/glopenai/audio.gleam", 201).
-spec voice_decoder() -> gleam@dynamic@decode:decoder(voice()).
voice_decoder() ->
    gleam@dynamic@decode:one_of(
        begin
            gleam@dynamic@decode:then(
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Value) -> case Value of
                        <<"alloy"/utf8>> ->
                            gleam@dynamic@decode:success(alloy);

                        <<"ash"/utf8>> ->
                            gleam@dynamic@decode:success(ash);

                        <<"ballad"/utf8>> ->
                            gleam@dynamic@decode:success(ballad);

                        <<"coral"/utf8>> ->
                            gleam@dynamic@decode:success(coral);

                        <<"echo"/utf8>> ->
                            gleam@dynamic@decode:success(echo);

                        <<"fable"/utf8>> ->
                            gleam@dynamic@decode:success(fable);

                        <<"onyx"/utf8>> ->
                            gleam@dynamic@decode:success(onyx);

                        <<"nova"/utf8>> ->
                            gleam@dynamic@decode:success(nova);

                        <<"sage"/utf8>> ->
                            gleam@dynamic@decode:success(sage);

                        <<"shimmer"/utf8>> ->
                            gleam@dynamic@decode:success(shimmer);

                        <<"verse"/utf8>> ->
                            gleam@dynamic@decode:success(verse);

                        <<"marin"/utf8>> ->
                            gleam@dynamic@decode:success(marin);

                        <<"cedar"/utf8>> ->
                            gleam@dynamic@decode:success(cedar);

                        Other ->
                            gleam@dynamic@decode:success({other_voice, Other})
                    end end
            )
        end,
        [begin
                gleam@dynamic@decode:field(
                    <<"id"/utf8>>,
                    {decoder, fun gleam@dynamic@decode:decode_string/1},
                    fun(Id) ->
                        gleam@dynamic@decode:success({custom_voice, Id})
                    end
                )
            end]
    ).

-file("src/glopenai/audio.gleam", 232).
-spec speech_response_format_decoder() -> gleam@dynamic@decode:decoder(speech_response_format()).
speech_response_format_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"mp3"/utf8>> ->
                    gleam@dynamic@decode:success(mp3);

                <<"opus"/utf8>> ->
                    gleam@dynamic@decode:success(opus);

                <<"aac"/utf8>> ->
                    gleam@dynamic@decode:success(aac);

                <<"flac"/utf8>> ->
                    gleam@dynamic@decode:success(flac);

                <<"pcm"/utf8>> ->
                    gleam@dynamic@decode:success(pcm);

                <<"wav"/utf8>> ->
                    gleam@dynamic@decode:success(wav);

                _ ->
                    gleam@dynamic@decode:failure(
                        mp3,
                        <<"SpeechResponseFormat"/utf8>>
                    )
            end end
    ).

-file("src/glopenai/audio.gleam", 245).
-spec speech_model_decoder() -> gleam@dynamic@decode:decoder(speech_model()).
speech_model_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"tts-1"/utf8>> ->
                    gleam@dynamic@decode:success(tts1);

                <<"tts-1-hd"/utf8>> ->
                    gleam@dynamic@decode:success(tts1_hd);

                <<"gpt-4o-mini-tts"/utf8>> ->
                    gleam@dynamic@decode:success(gpt4o_mini_tts);

                Other ->
                    gleam@dynamic@decode:success({other_speech_model, Other})
            end end
    ).

-file("src/glopenai/audio.gleam", 255).
-spec stream_format_decoder() -> gleam@dynamic@decode:decoder(stream_format()).
stream_format_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"sse"/utf8>> ->
                    gleam@dynamic@decode:success(sse);

                <<"audio"/utf8>> ->
                    gleam@dynamic@decode:success(audio);

                _ ->
                    gleam@dynamic@decode:failure(sse, <<"StreamFormat"/utf8>>)
            end end
    ).

-file("src/glopenai/audio.gleam", 269).
?DOC(
    " Build a request to generate speech audio from text.\n"
    " The response body is raw audio bytes — the user's HTTP client should\n"
    " return the body as a BitArray (not String) for binary audio data.\n"
).
-spec create_speech_request(glopenai@config:config(), create_speech_request()) -> gleam@http@request:request(binary()).
create_speech_request(Config, Params) ->
    glopenai@internal:post_request(
        Config,
        <<"/audio/speech"/utf8>>,
        create_speech_request_to_json(Params)
    ).

-file("src/glopenai/audio.gleam", 283).
?DOC(
    " The speech endpoint returns raw audio bytes, not JSON. The user should\n"
    " read the response body directly from their HTTP client. This function\n"
    " is provided only for checking error responses (non-2xx status codes).\n"
).
-spec create_speech_response(gleam@http@response:response(binary())) -> {ok,
        binary()} |
    {error, glopenai@error:glopenai_error()}.
create_speech_response(Response) ->
    case (erlang:element(2, Response) >= 200) andalso (erlang:element(
        2,
        Response
    )
    < 300) of
        true ->
            {ok, erlang:element(4, Response)};

        false ->
            case gleam@json:parse(
                erlang:element(4, Response),
                glopenai@error:wrapped_error_decoder()
            ) of
                {ok, Api_error} ->
                    {error,
                        {api_response_error,
                            erlang:element(2, Response),
                            Api_error}};

                {error, _} ->
                    {error,
                        {unexpected_response,
                            erlang:element(2, Response),
                            erlang:element(4, Response)}}
            end
    end.