-module(l4u@bif_string).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([bif_string_def/0]).

-spec bif_string_split(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_split(Exprs, Env) ->
    Retexpr = case Exprs of
        [{string, S}, {string, D}] ->
            {list,
                begin
                    _pipe = gleam@string:split(S, D),
                    gleam@list:map(_pipe, fun(Field@0) -> {string, Field@0} end)
                end};

        _ ->
            l4u@sys_bridge_ffi:throw_err(
                <<"str-split: wrong number of arguments"/utf8>>
            ),
            undefined
    end,
    {with_env, Retexpr, Env}.

-spec bif_string_join(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_join(Exprs, Env) ->
    [{list, Src}, {string, U}] = case Exprs of
        [{list, _}, {string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_join"/utf8>>,
                        line => 51})
    end,
    {with_env,
        {string,
            gleam@string:join(
                gleam@list:map(Src, fun(X) -> l4u@l4u_core:show(X) end),
                U
            )},
        Env}.

-spec bif_string_replace(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_replace(Exprs, Env) ->
    [{string, Src}, {string, U}, {string, V}] = case Exprs of
        [{string, _}, {string, _}, {string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_replace"/utf8>>,
                        line => 57})
    end,
    {with_env, {string, gleam@string:replace(Src, U, V)}, Env}.

-spec bif_string_length(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_length(Exprs, Env) ->
    [{string, Src}] = case Exprs of
        [{string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_length"/utf8>>,
                        line => 73})
    end,
    {with_env, {int, gleam@string:length(Src)}, Env}.

-spec bif_string_lower(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_lower(Exprs, Env) ->
    [{string, Src}] = case Exprs of
        [{string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_lower"/utf8>>,
                        line => 79})
    end,
    {with_env, {string, gleam@string:lowercase(Src)}, Env}.

-spec bif_string_upper(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_upper(Exprs, Env) ->
    [{string, Src}] = case Exprs of
        [{string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_upper"/utf8>>,
                        line => 85})
    end,
    {with_env, {string, gleam@string:uppercase(Src)}, Env}.

-spec bif_string_trim(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_trim(Exprs, Env) ->
    [{string, Src}] = case Exprs of
        [{string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_trim"/utf8>>,
                        line => 91})
    end,
    {with_env, {string, gleam@string:trim(Src)}, Env}.

-spec bif_string_starts_with(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_starts_with(Exprs, Env) ->
    [{string, Src}, {string, U}] = case Exprs of
        [{string, _}, {string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_starts_with"/utf8>>,
                        line => 97})
    end,
    {with_env, l4u@l4u_core:to_l4u_bool(gleam@string:starts_with(Src, U)), Env}.

-spec bif_string_ends_with(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_ends_with(Exprs, Env) ->
    [{string, Src}, {string, U}] = case Exprs of
        [{string, _}, {string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_ends_with"/utf8>>,
                        line => 103})
    end,
    {with_env, l4u@l4u_core:to_l4u_bool(gleam@string:ends_with(Src, U)), Env}.

-spec bif_string_contains(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_contains(Exprs, Env) ->
    [{string, Src}, {string, U}] = case Exprs of
        [{string, _}, {string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_contains"/utf8>>,
                        line => 109})
    end,
    {with_env,
        l4u@l4u_core:to_l4u_bool(gleam_stdlib:contains_string(Src, U)),
        Env}.

-spec bif_string_reverse(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_reverse(Exprs, Env) ->
    [{string, Src}] = case Exprs of
        [{string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_reverse"/utf8>>,
                        line => 115})
    end,
    {with_env, {string, gleam@string:reverse(Src)}, Env}.

-spec bif_string_repeat(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_repeat(Exprs, Env) ->
    [{string, Src}, {int, U}] = case Exprs of
        [{string, _}, {int, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_repeat"/utf8>>,
                        line => 121})
    end,
    {with_env, {string, gleam@string:repeat(Src, U)}, Env}.

-spec bif_string_pad_left(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_pad_left(Exprs, Env) ->
    [{string, Src}, {int, U}, {string, V}] = case Exprs of
        [{string, _}, {int, _}, {string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_pad_left"/utf8>>,
                        line => 127})
    end,
    {with_env, {string, gleam@string:pad_left(Src, U, V)}, Env}.

-spec bif_string_pad_right(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_pad_right(Exprs, Env) ->
    [{string, Src}, {int, U}, {string, V}] = case Exprs of
        [{string, _}, {int, _}, {string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_pad_right"/utf8>>,
                        line => 133})
    end,
    {with_env, {string, gleam@string:pad_right(Src, U, V)}, Env}.

-spec bif_string_replace_all(list(l4u@l4u_type:expr()), l4u@l4u_type:env()) -> l4u@l4u_type:expr().
bif_string_replace_all(Exprs, Env) ->
    [{string, Src}, {string, U}, {string, V}] = case Exprs of
        [{string, _}, {string, _}, {string, _}] -> Exprs;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"l4u/bif_string"/utf8>>,
                        function => <<"bif_string_replace_all"/utf8>>,
                        line => 139})
    end,
    {with_env, {string, gleam@string:replace(Src, U, V)}, Env}.

-spec bif_string_def() -> list({binary(), l4u@l4u_type:expr()}).
bif_string_def() ->
    Bif = fun(Name, F) -> {Name, {bif, l4u@l4u_core:description(Name), F}} end,
    Bsf = fun(Name@1, F@1) ->
        {Name@1, {bispform, l4u@l4u_core:description(Name@1), F@1}}
    end,
    [Bif(<<"string-split"/utf8>>, fun bif_string_split/2),
        Bif(<<"string-join"/utf8>>, fun bif_string_join/2),
        Bif(<<"string-replace"/utf8>>, fun bif_string_replace/2),
        Bif(<<"string-length"/utf8>>, fun bif_string_length/2),
        Bif(<<"string-lower"/utf8>>, fun bif_string_lower/2),
        Bif(<<"string-upper"/utf8>>, fun bif_string_upper/2),
        Bif(<<"string-trim"/utf8>>, fun bif_string_trim/2),
        Bif(<<"string-starts-with?"/utf8>>, fun bif_string_starts_with/2),
        Bif(<<"string-ends-with?"/utf8>>, fun bif_string_ends_with/2),
        Bif(<<"string-contains"/utf8>>, fun bif_string_contains/2),
        Bif(<<"string-reverse"/utf8>>, fun bif_string_reverse/2),
        Bif(<<"string-repeat"/utf8>>, fun bif_string_repeat/2),
        Bif(<<"string-pad-left"/utf8>>, fun bif_string_pad_left/2),
        Bif(<<"string-pad-right"/utf8>>, fun bif_string_pad_right/2),
        Bif(<<"string-replace-all"/utf8>>, fun bif_string_replace_all/2)].