-module(glopenai@embedding).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glopenai/embedding.gleam").
-export([new_create_request/2, with_encoding_format/2, with_user/2, with_dimensions/2, encoding_format_to_json/1, embedding_input_to_json/1, create_embedding_request_to_json/1, encoding_format_decoder/0, embedding_input_decoder/0, embedding_decoder/0, embedding_usage_decoder/0, create_request/2, create_response/1]).
-export_type([embedding_input/0, encoding_format/0, create_embedding_request/0, embedding/0, embedding_usage/0, create_embedding_response/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 embedding_input() :: {string_input, binary()} |
    {string_array_input, list(binary())} |
    {integer_array_input, list(integer())} |
    {array_of_integer_array_input, list(list(integer()))}.

-type encoding_format() :: float | base64.

-type create_embedding_request() :: {create_embedding_request,
        binary(),
        embedding_input(),
        gleam@option:option(encoding_format()),
        gleam@option:option(binary()),
        gleam@option:option(integer())}.

-type embedding() :: {embedding, integer(), binary(), list(float())}.

-type embedding_usage() :: {embedding_usage, integer(), integer()}.

-type create_embedding_response() :: {create_embedding_response,
        binary(),
        binary(),
        list(embedding()),
        embedding_usage()}.

-file("src/glopenai/embedding.gleam", 61).
?DOC(" Create a new embedding request with required fields and defaults.\n").
-spec new_create_request(binary(), embedding_input()) -> create_embedding_request().
new_create_request(Model, Input) ->
    {create_embedding_request, Model, Input, none, none, none}.

-file("src/glopenai/embedding.gleam", 75).
?DOC(" Set the encoding format for the request.\n").
-spec with_encoding_format(create_embedding_request(), encoding_format()) -> create_embedding_request().
with_encoding_format(Request, Format) ->
    {create_embedding_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        {some, Format},
        erlang:element(5, Request),
        erlang:element(6, Request)}.

-file("src/glopenai/embedding.gleam", 83).
?DOC(" Set the user identifier.\n").
-spec with_user(create_embedding_request(), binary()) -> create_embedding_request().
with_user(Request, User) ->
    {create_embedding_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        {some, User},
        erlang:element(6, Request)}.

-file("src/glopenai/embedding.gleam", 91).
?DOC(" Set the output dimensions.\n").
-spec with_dimensions(create_embedding_request(), integer()) -> create_embedding_request().
with_dimensions(Request, Dimensions) ->
    {create_embedding_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        {some, Dimensions}}.

-file("src/glopenai/embedding.gleam", 100).
-spec encoding_format_to_json(encoding_format()) -> gleam@json:json().
encoding_format_to_json(Format) ->
    gleam@json:string(case Format of
            float ->
                <<"float"/utf8>>;

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

-file("src/glopenai/embedding.gleam", 107).
-spec embedding_input_to_json(embedding_input()) -> gleam@json:json().
embedding_input_to_json(Input) ->
    case Input of
        {string_input, S} ->
            gleam@json:string(S);

        {string_array_input, Arr} ->
            gleam@json:array(Arr, fun gleam@json:string/1);

        {integer_array_input, Arr@1} ->
            gleam@json:array(Arr@1, fun gleam@json:int/1);

        {array_of_integer_array_input, Arr@2} ->
            gleam@json:array(
                Arr@2,
                fun(Inner) -> gleam@json:array(Inner, fun gleam@json:int/1) end
            )
    end.

-file("src/glopenai/embedding.gleam", 117).
-spec create_embedding_request_to_json(create_embedding_request()) -> gleam@json:json().
create_embedding_request_to_json(Request) ->
    glopenai@internal@codec:object_with_optional(
        [{<<"model"/utf8>>, gleam@json:string(erlang:element(2, Request))},
            {<<"input"/utf8>>,
                embedding_input_to_json(erlang:element(3, Request))}],
        [glopenai@internal@codec:optional_field(
                <<"encoding_format"/utf8>>,
                erlang:element(4, Request),
                fun encoding_format_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"user"/utf8>>,
                erlang:element(5, Request),
                fun gleam@json:string/1
            ),
            glopenai@internal@codec:optional_field(
                <<"dimensions"/utf8>>,
                erlang:element(6, Request),
                fun gleam@json:int/1
            )]
    ).

-file("src/glopenai/embedding.gleam", 139).
-spec encoding_format_decoder() -> gleam@dynamic@decode:decoder(encoding_format()).
encoding_format_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"float"/utf8>> ->
                    gleam@dynamic@decode:success(float);

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

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

-file("src/glopenai/embedding.gleam", 148).
-spec embedding_input_decoder() -> gleam@dynamic@decode:decoder(embedding_input()).
embedding_input_decoder() ->
    gleam@dynamic@decode:one_of(
        begin
            _pipe = {decoder, fun gleam@dynamic@decode:decode_string/1},
            gleam@dynamic@decode:map(
                _pipe,
                fun(Field@0) -> {string_input, Field@0} end
            )
        end,
        [begin
                _pipe@1 = gleam@dynamic@decode:list(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                gleam@dynamic@decode:map(
                    _pipe@1,
                    fun(Field@0) -> {string_array_input, Field@0} end
                )
            end,
            begin
                _pipe@2 = gleam@dynamic@decode:list(
                    gleam@dynamic@decode:list(
                        {decoder, fun gleam@dynamic@decode:decode_int/1}
                    )
                ),
                gleam@dynamic@decode:map(
                    _pipe@2,
                    fun(Field@0) -> {array_of_integer_array_input, Field@0} end
                )
            end,
            begin
                _pipe@3 = gleam@dynamic@decode:list(
                    {decoder, fun gleam@dynamic@decode:decode_int/1}
                ),
                gleam@dynamic@decode:map(
                    _pipe@3,
                    fun(Field@0) -> {integer_array_input, Field@0} end
                )
            end]
    ).

-file("src/glopenai/embedding.gleam", 157).
-spec embedding_decoder() -> gleam@dynamic@decode:decoder(embedding()).
embedding_decoder() ->
    gleam@dynamic@decode:field(
        <<"index"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Index) ->
            gleam@dynamic@decode:field(
                <<"object"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Object) ->
                    gleam@dynamic@decode:field(
                        <<"embedding"/utf8>>,
                        gleam@dynamic@decode:list(
                            {decoder, fun gleam@dynamic@decode:decode_float/1}
                        ),
                        fun(Embedding) ->
                            gleam@dynamic@decode:success(
                                {embedding, Index, Object, Embedding}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glopenai/embedding.gleam", 164).
-spec embedding_usage_decoder() -> gleam@dynamic@decode:decoder(embedding_usage()).
embedding_usage_decoder() ->
    gleam@dynamic@decode:field(
        <<"prompt_tokens"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_int/1},
        fun(Prompt_tokens) ->
            gleam@dynamic@decode:field(
                <<"total_tokens"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_int/1},
                fun(Total_tokens) ->
                    gleam@dynamic@decode:success(
                        {embedding_usage, Prompt_tokens, Total_tokens}
                    )
                end
            )
        end
    ).

-file("src/glopenai/embedding.gleam", 173).
-spec create_embedding_response_decoder() -> gleam@dynamic@decode:decoder(create_embedding_response()).
create_embedding_response_decoder() ->
    gleam@dynamic@decode:field(
        <<"object"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Object) ->
            gleam@dynamic@decode:field(
                <<"model"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Model) ->
                    gleam@dynamic@decode:field(
                        <<"data"/utf8>>,
                        gleam@dynamic@decode:list(embedding_decoder()),
                        fun(Data) ->
                            gleam@dynamic@decode:field(
                                <<"usage"/utf8>>,
                                embedding_usage_decoder(),
                                fun(Usage) ->
                                    gleam@dynamic@decode:success(
                                        {create_embedding_response,
                                            Object,
                                            Model,
                                            Data,
                                            Usage}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glopenai/embedding.gleam", 191).
?DOC(" Build a request to create embeddings.\n").
-spec create_request(glopenai@config:config(), create_embedding_request()) -> gleam@http@request:request(binary()).
create_request(Config, Params) ->
    glopenai@internal:post_request(
        Config,
        <<"/embeddings"/utf8>>,
        create_embedding_request_to_json(Params)
    ).

-file("src/glopenai/embedding.gleam", 203).
?DOC(" Parse the response from creating embeddings.\n").
-spec create_response(gleam@http@response:response(binary())) -> {ok,
        create_embedding_response()} |
    {error, glopenai@error:glopenai_error()}.
create_response(Response) ->
    glopenai@internal:parse_response(
        Response,
        create_embedding_response_decoder()
    ).