-module(gleam@string).
-compile(no_auto_import).

-export([is_empty/1, length/1, reverse/1, replace/3, lowercase/1, uppercase/1, compare/2, slice/3, crop/2, drop_left/2, drop_right/2, contains/2, starts_with/2, ends_with/2, split/2, split_once/2, append/2, concat/1, repeat/2, join/2, pad_left/3, pad_right/3, trim/1, trim_left/1, trim_right/1, pop_grapheme/1, to_graphemes/1, utf_codepoint/1]).
-export_type([direction/0]).

-type direction() :: leading | trailing | both.

-spec is_empty(binary()) -> boolean().
is_empty(Str) ->
    Str =:= <<""/utf8>>.

-spec length(binary()) -> integer().
length(A) ->
    string:length(A).

-spec reverse(binary()) -> binary().
reverse(String) ->
    gleam@string_builder:to_string(
        gleam@string_builder:reverse(gleam@string_builder:from_string(String))
    ).

-spec replace(binary(), binary(), binary()) -> binary().
replace(String, Pattern, Substitute) ->
    gleam@string_builder:to_string(
        gleam@string_builder:replace(
            gleam@string_builder:from_string(String),
            Pattern,
            Substitute
        )
    ).

-spec lowercase(binary()) -> binary().
lowercase(A) ->
    string:lowercase(A).

-spec uppercase(binary()) -> binary().
uppercase(A) ->
    string:uppercase(A).

-spec compare(binary(), binary()) -> gleam@order:order().
compare(A, B) ->
    gleam_stdlib:compare_strings(A, B).

-spec slice(binary(), integer(), integer()) -> binary().
slice(String, Idx, Len) ->
    case Len < 0 of
        true ->
            <<""/utf8>>;

        false ->
            case Idx < 0 of
                true ->
                    Translated_idx = string:length(String) + Idx,
                    case Translated_idx < 0 of
                        true ->
                            <<""/utf8>>;

                        false ->
                            string:slice(String, Translated_idx, Len)
                    end;

                false ->
                    string:slice(String, Idx, Len)
            end
    end.

-spec crop(binary(), binary()) -> binary().
crop(String, Substring) ->
    gleam@result:unwrap(
        gleam@dynamic:string(string:find(String, Substring)),
        String
    ).

-spec drop_left(binary(), integer()) -> binary().
drop_left(String, Num_graphemes) ->
    case Num_graphemes < 0 of
        true ->
            String;

        false ->
            slice(String, Num_graphemes, string:length(String) - Num_graphemes)
    end.

-spec drop_right(binary(), integer()) -> binary().
drop_right(String, Num_graphemes) ->
    case Num_graphemes < 0 of
        true ->
            String;

        false ->
            slice(String, 0, string:length(String) - Num_graphemes)
    end.

-spec contains(binary(), binary()) -> boolean().
contains(Haystack, Needle) ->
    gleam@result:is_error(gleam@dynamic:atom(string:find(Haystack, Needle))).

-spec starts_with(binary(), binary()) -> boolean().
starts_with(A, B) ->
    gleam_stdlib:string_starts_with(A, B).

-spec ends_with(binary(), binary()) -> boolean().
ends_with(A, B) ->
    gleam_stdlib:string_ends_with(A, B).

-spec split(binary(), binary()) -> list(binary()).
split(X, Substring) ->
    gleam@list:map(
        gleam@string_builder:split(
            gleam@string_builder:from_string(X),
            Substring
        ),
        fun gleam@string_builder:to_string/1
    ).

-spec split_once(binary(), binary()) -> {ok, {binary(), binary()}} |
    {error, nil}.
split_once(X, Substring) ->
    case string:split(X, Substring) of
        [First, Rest] ->
            {ok, {First, Rest}};

        _ ->
            {error, nil}
    end.

-spec append(binary(), binary()) -> binary().
append(First, Second) ->
    gleam@string_builder:to_string(
        gleam@string_builder:append(
            gleam@string_builder:from_string(First),
            Second
        )
    ).

-spec concat(list(binary())) -> binary().
concat(Strings) ->
    gleam@string_builder:to_string(gleam@string_builder:from_strings(Strings)).

-spec repeat(binary(), integer()) -> binary().
repeat(String, Times) ->
    concat(
        gleam@iterator:to_list(
            gleam@iterator:take(gleam@iterator:repeat(String), Times)
        )
    ).

-spec join(list(binary()), binary()) -> binary().
join(Strings, Separator) ->
    concat(gleam@list:intersperse(Strings, Separator)).

-spec pad_left(binary(), integer(), binary()) -> binary().
pad_left(String, Length, Pad_string) ->
    gleam_stdlib:string_pad(String, Length, leading, Pad_string).

-spec pad_right(binary(), integer(), binary()) -> binary().
pad_right(String, Length, Pad_string) ->
    gleam_stdlib:string_pad(String, Length, trailing, Pad_string).

-spec trim(binary()) -> binary().
trim(String) ->
    string:trim(String, both).

-spec trim_left(binary()) -> binary().
trim_left(String) ->
    string:trim(String, leading).

-spec trim_right(binary()) -> binary().
trim_right(String) ->
    string:trim(String, trailing).

-spec pop_grapheme(binary()) -> {ok, {binary(), binary()}} | {error, nil}.
pop_grapheme(A) ->
    gleam_stdlib:string_pop_grapheme(A).

-spec to_graphemes(binary()) -> list(binary()).
to_graphemes(String) ->
    case gleam_stdlib:string_pop_grapheme(String) of
        {ok, {Grapheme, Rest}} ->
            [Grapheme | to_graphemes(Rest)];

        _ ->
            []
    end.

-spec utf_codepoint(integer()) -> {ok, integer()} | {error, nil}.
utf_codepoint(Value) ->
    case Value of
        I when I > 1114111 ->
            {error, nil};

        65534 ->
            {error, nil};

        65535 ->
            {error, nil};

        I@1 when (I@1 >= 55296) andalso (I@1 =< 57343) ->
            {error, nil};

        I@2 ->
            {ok, gleam_stdlib:identity(I@2)}
    end.