wisp_inertia

-module(internal@ssr).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/internal/ssr.gleam").
-export([client_error_to_string/1, server_render/2]).
-export_type([client_error/0, s_s_r_render_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 client_error() :: {http_error, integer()} |
    json_parse_error |
    network_error.

-type s_s_r_render_response() :: {s_s_r_render_response,
        list(binary()),
        binary()}.

-file("src/internal/ssr.gleam", 18).
-spec client_error_to_string(client_error()) -> binary().
client_error_to_string(Err) ->
    case Err of
        json_parse_error ->
            <<"JSON parse error"/utf8>>;

        network_error ->
            <<"Network error"/utf8>>;

        {http_error, Code} ->
            <<"HTTP error code "/utf8, (erlang:integer_to_binary(Code))/binary>>
    end.

-file("src/internal/ssr.gleam", 31).
-spec reponse_decoder() -> gleam@dynamic@decode:decoder(s_s_r_render_response()).
reponse_decoder() ->
    gleam@dynamic@decode:field(
        <<"head"/utf8>>,
        gleam@dynamic@decode:list(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        fun(Head) ->
            gleam@dynamic@decode:field(
                <<"body"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Body) ->
                    gleam@dynamic@decode:success(
                        {s_s_r_render_response, Head, Body}
                    )
                end
            )
        end
    ).

-file("src/internal/ssr.gleam", 64).
-spec parse_response(gleam@http@response:response(binary())) -> {ok,
        s_s_r_render_response()} |
    {error, client_error()}.
parse_response(Res) ->
    case erlang:element(2, Res) of
        200 ->
            _pipe = gleam@json:parse(erlang:element(4, Res), reponse_decoder()),
            gleam@result:map_error(_pipe, fun(_) -> json_parse_error end);

        Status ->
            {error, {http_error, Status}}
    end.

-file("src/internal/ssr.gleam", 46).
-spec post_request(binary(), binary()) -> {ok, s_s_r_render_response()} |
    {error, client_error()}.
post_request(Url, Body) ->
    Base_req@1 = case gleam@http@request:to(Url) of
        {ok, Base_req} -> Base_req;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"internal/ssr"/utf8>>,
                        function => <<"post_request"/utf8>>,
                        line => 50,
                        value => _assert_fail,
                        start => 1146,
                        'end' => 1187,
                        pattern_start => 1157,
                        pattern_end => 1169})
    end,
    Req = begin
        _pipe = Base_req@1,
        _pipe@1 = gleam@http@request:set_method(_pipe, post),
        _pipe@2 = gleam@http@request:set_header(
            _pipe@1,
            <<"Content-Type"/utf8>>,
            <<"application/json"/utf8>>
        ),
        _pipe@3 = gleam@http@request:set_header(
            _pipe@2,
            <<"Accept"/utf8>>,
            <<"application/json"/utf8>>
        ),
        gleam@http@request:set_body(_pipe@3, Body)
    end,
    case gleam@httpc:send(Req) of
        {ok, Resp} ->
            parse_response(Resp);

        {error, _} ->
            {error, network_error}
    end.

-file("src/internal/ssr.gleam", 39).
?DOC(" Sends a POST request to the Node process to get the SSR content\n").
-spec server_render(binary(), binary()) -> {ok, s_s_r_render_response()} |
    {error, client_error()}.
server_render(Url, Body) ->
    post_request(Url, Body).