discord_gleam

-module(discord_gleam@http@channels).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/discord_gleam/http/channels.gleam").
-export([send_message/3, reply/3, delete_message/4, edit_message/4, get_message/3]).

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

-file("src/discord_gleam/http/channels.gleam", 12).
?DOC(" Send a message to a channel\n").
-spec send_message(
    binary(),
    discord_gleam@discord@snowflake:snowflake(discord_gleam@discord@snowflake:channel()),
    discord_gleam@types@message:message()
) -> {ok, discord_gleam@types@message_send_response:message_send_response()} |
    {error, discord_gleam@internal@error:discord_error()}.
send_message(Token, Channel_id, Message) ->
    Data = discord_gleam@types@message:to_string(Message),
    logging:log(debug, <<"Sending message: "/utf8, Data/binary>>),
    Request = discord_gleam@http@request:new_auth_with_body(
        post,
        <<<<"/channels/"/utf8,
                (discord_gleam@discord@snowflake:to_string(Channel_id))/binary>>/binary,
            "/messages"/utf8>>,
        Token,
        Data
    ),
    case gleam@httpc:send(Request) of
        {ok, Resp} ->
            case erlang:element(2, Resp) of
                200 ->
                    logging:log(debug, <<"Message sent"/utf8>>),
                    discord_gleam@types@message_send_response:from_json_string(
                        erlang:element(4, Resp)
                    );

                429 ->
                    logging:log(
                        error,
                        <<"Failed to send message: rate limited"/utf8>>
                    ),
                    {error,
                        discord_gleam@http@request:extract_ratelimit_error(Resp)};

                _ ->
                    logging:log(error, <<"Failed to send message"/utf8>>),
                    {error,
                        {api_error,
                            erlang:element(2, Resp),
                            erlang:element(4, Resp)}}
            end;

        {error, Err} ->
            logging:log(error, <<"Failed to send message"/utf8>>),
            {error, {http_error, Err}}
    end.

-file("src/discord_gleam/http/channels.gleam", 61).
?DOC(" Reply to a message\n").
-spec reply(
    binary(),
    discord_gleam@discord@snowflake:snowflake(discord_gleam@discord@snowflake:channel()),
    discord_gleam@types@reply:reply()
) -> {ok, discord_gleam@types@message_send_response:message_send_response()} |
    {error, discord_gleam@internal@error:discord_error()}.
reply(Token, Channel_id, Message) ->
    Data = discord_gleam@types@reply:to_string(Message),
    logging:log(debug, <<"Replying: "/utf8, Data/binary>>),
    Request = discord_gleam@http@request:new_auth_with_body(
        post,
        <<<<"/channels/"/utf8,
                (discord_gleam@discord@snowflake:to_string(Channel_id))/binary>>/binary,
            "/messages"/utf8>>,
        Token,
        Data
    ),
    case gleam@httpc:send(Request) of
        {ok, Resp} ->
            case erlang:element(2, Resp) of
                200 ->
                    logging:log(debug, <<"Reply sent"/utf8>>),
                    discord_gleam@types@message_send_response:from_json_string(
                        erlang:element(4, Resp)
                    );

                429 ->
                    logging:log(
                        error,
                        <<"Failed to send reply: rate limited"/utf8>>
                    ),
                    {error,
                        discord_gleam@http@request:extract_ratelimit_error(Resp)};

                _ ->
                    logging:log(error, <<"Failed to send reply"/utf8>>),
                    {error,
                        {api_error,
                            erlang:element(2, Resp),
                            erlang:element(4, Resp)}}
            end;

        {error, Err} ->
            logging:log(error, <<"Failed to send reply"/utf8>>),
            {error, {http_error, Err}}
    end.

-file("src/discord_gleam/http/channels.gleam", 110).
?DOC(" Delete a message by channel id and message id\n").
-spec delete_message(
    binary(),
    discord_gleam@discord@snowflake:snowflake(discord_gleam@discord@snowflake:channel()),
    discord_gleam@discord@snowflake:snowflake(discord_gleam@discord@snowflake:message()),
    binary()
) -> {ok, nil} | {error, discord_gleam@internal@error:discord_error()}.
delete_message(Token, Channel_id, Message_id, Reason) ->
    Request = discord_gleam@http@request:new_auth_with_header(
        delete,
        <<<<<<"/channels/"/utf8,
                    (discord_gleam@discord@snowflake:to_string(Channel_id))/binary>>/binary,
                "/messages/"/utf8>>/binary,
            (discord_gleam@discord@snowflake:to_string(Message_id))/binary>>,
        Token,
        {<<"X-Audit-Log-Reason"/utf8>>, Reason}
    ),
    case gleam@httpc:send(Request) of
        {ok, Resp} ->
            case erlang:element(2, Resp) of
                204 ->
                    logging:log(debug, <<"Deleted Message"/utf8>>),
                    {ok, nil};

                429 ->
                    logging:log(
                        error,
                        <<"Failed to delete message: rate limited"/utf8>>
                    ),
                    {error,
                        discord_gleam@http@request:extract_ratelimit_error(Resp)};

                _ ->
                    logging:log(error, <<"Failed to delete message"/utf8>>),
                    {error,
                        {api_error,
                            erlang:element(2, Resp),
                            erlang:element(4, Resp)}}
            end;

        {error, Err} ->
            logging:log(error, <<"Failed to delete message"/utf8>>),
            {error, {http_error, Err}}
    end.

-file("src/discord_gleam/http/channels.gleam", 159).
?DOC(" Edit a message by channel id and message id\n").
-spec edit_message(
    binary(),
    discord_gleam@discord@snowflake:snowflake(discord_gleam@discord@snowflake:channel()),
    discord_gleam@discord@snowflake:snowflake(discord_gleam@discord@snowflake:message()),
    discord_gleam@types@message:message()
) -> {ok, nil} | {error, discord_gleam@internal@error:discord_error()}.
edit_message(Token, Channel_id, Message_id, Message) ->
    Data = discord_gleam@types@message:to_string(Message),
    logging:log(debug, <<"Editing message: "/utf8, Data/binary>>),
    Request = discord_gleam@http@request:new_auth_with_body(
        patch,
        <<<<<<"/channels/"/utf8,
                    (discord_gleam@discord@snowflake:to_string(Channel_id))/binary>>/binary,
                "/messages/"/utf8>>/binary,
            (discord_gleam@discord@snowflake:to_string(Message_id))/binary>>,
        Token,
        Data
    ),
    case gleam@httpc:send(Request) of
        {ok, Resp} ->
            case erlang:element(2, Resp) of
                200 ->
                    logging:log(debug, <<"Message edited"/utf8>>),
                    {ok, nil};

                429 ->
                    logging:log(
                        error,
                        <<"Failed to edit message: rate limited"/utf8>>
                    ),
                    {error,
                        discord_gleam@http@request:extract_ratelimit_error(Resp)};

                _ ->
                    logging:log(error, <<"Failed to edit message"/utf8>>),
                    {error,
                        {api_error,
                            erlang:element(2, Resp),
                            erlang:element(4, Resp)}}
            end;

        {error, Err} ->
            logging:log(error, <<"Failed to edit message"/utf8>>),
            {error, {http_error, Err}}
    end.

-file("src/discord_gleam/http/channels.gleam", 211).
-spec get_message(
    binary(),
    discord_gleam@discord@snowflake:snowflake(discord_gleam@discord@snowflake:channel()),
    discord_gleam@discord@snowflake:snowflake(discord_gleam@discord@snowflake:message())
) -> {ok, discord_gleam@types@message_send_response:message_send_response()} |
    {error, discord_gleam@internal@error:discord_error()}.
get_message(Token, Channel_id, Message_id) ->
    Request = discord_gleam@http@request:new_auth(
        get,
        <<<<<<"/channels/"/utf8,
                    (discord_gleam@discord@snowflake:to_string(Channel_id))/binary>>/binary,
                "/messages/"/utf8>>/binary,
            (discord_gleam@discord@snowflake:to_string(Message_id))/binary>>,
        Token
    ),
    case gleam@httpc:send(Request) of
        {ok, Resp} ->
            case erlang:element(2, Resp) of
                200 ->
                    logging:log(debug, <<"Got message"/utf8>>),
                    discord_gleam@types@message_send_response:from_json_string(
                        erlang:element(4, Resp)
                    );

                429 ->
                    logging:log(
                        error,
                        <<"Failed to get message: rate limited"/utf8>>
                    ),
                    {error,
                        discord_gleam@http@request:extract_ratelimit_error(Resp)};

                _ ->
                    logging:log(error, <<"Failed to get message"/utf8>>),
                    {error,
                        {api_error,
                            erlang:element(2, Resp),
                            erlang:element(4, Resp)}}
            end;

        {error, Err} ->
            logging:log(error, <<"Failed to get message"/utf8>>),
            {error, {http_error, Err}}
    end.