-module(blah@fa@string).
-compile(no_auto_import).

-export([alpha/1, numeric/1, alphanumeric/1, with_pattern/1, pronounceable/0]).

-spec alpha(integer()) -> binary().
alpha(Length) ->
    alpha_internal(gleam@string_builder:new(), Length).

-spec numeric(integer()) -> binary().
numeric(Length) ->
    numeric_internal(gleam@string_builder:new(), Length).

-spec alphanumeric(integer()) -> binary().
alphanumeric(Length) ->
    alphanumeric_internal(gleam@string_builder:new(), Length).

-spec with_pattern(binary()) -> binary().
with_pattern(Given_pattern) ->
    with_pattern_internal(gleam@string_builder:new(), Given_pattern).

-spec pronounceable() -> binary().
pronounceable() ->
    Nonce = gleam@int:random(4, 2048),
    Length = gleam@int:random(2, 4) * 2,
    case Nonce rem 2 of
        0 ->
            {ok, First@1} = case begin
                _pipe = [<<"آ"/utf8>>, <<"او"/utf8>>],
                blah@utils:get_random_item(_pipe)
            end of
                {ok, First} -> {ok, First};
                _try ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try,
                                   module => <<"blah/fa/string"/utf8>>,
                                   function => <<"pronounceable"/utf8>>,
                                   line => 65})
            end,
            {ok, Second@1} = case begin
                _pipe@1 = [<<"ب"/utf8>>,
                           <<"پ"/utf8>>,
                           <<"ت"/utf8>>,
                           <<"ث"/utf8>>,
                           <<"ج"/utf8>>,
                           <<"چ"/utf8>>,
                           <<"ح"/utf8>>,
                           <<"خ"/utf8>>,
                           <<"د"/utf8>>,
                           <<"ذ"/utf8>>,
                           <<"ر"/utf8>>,
                           <<"ز"/utf8>>,
                           <<"ژ"/utf8>>,
                           <<"س"/utf8>>,
                           <<"ش"/utf8>>,
                           <<"ص"/utf8>>,
                           <<"ض"/utf8>>,
                           <<"ط"/utf8>>,
                           <<"ظ"/utf8>>,
                           <<"ع"/utf8>>,
                           <<"غ"/utf8>>,
                           <<"ف"/utf8>>,
                           <<"ق"/utf8>>,
                           <<"ک"/utf8>>,
                           <<"گ"/utf8>>,
                           <<"ل"/utf8>>,
                           <<"م"/utf8>>,
                           <<"ن"/utf8>>,
                           <<"ه"/utf8>>,
                           <<"ی"/utf8>>],
                blah@utils:get_random_item(_pipe@1)
            end of
                {ok, Second} -> {ok, Second};
                _try@1 ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try@1,
                                   module => <<"blah/fa/string"/utf8>>,
                                   function => <<"pronounceable"/utf8>>,
                                   line => 68})
            end,
            pronounceable_internal(
                gleam@string_builder:from_strings([First@1, Second@1]),
                Length
                - 2
            );

        1 ->
            pronounceable_internal(gleam@string_builder:new(), Length)
    end.

-spec pronounceable_internal(gleam@string_builder:string_builder(), integer()) -> binary().
pronounceable_internal(State, Remaining) ->
    case Remaining =:= 0 of
        true ->
            _pipe = State,
            gleam@string_builder:to_string(_pipe);

        false ->
            Nonce = gleam@int:random(4, 2048),
            Letters = case Nonce rem 2 of
                0 ->
                    {ok, First@1} = case begin
                        _pipe@1 = [<<"ا"/utf8>>, <<"و"/utf8>>],
                        blah@utils:get_random_item(_pipe@1)
                    end of
                        {ok, First} -> {ok, First};
                        _try ->
                            erlang:error(#{gleam_error => assert,
                                           message => <<"Assertion pattern match failed"/utf8>>,
                                           value => _try,
                                           module => <<"blah/fa/string"/utf8>>,
                                           function => <<"pronounceable_internal"/utf8>>,
                                           line => 90})
                    end,
                    {ok, Second@1} = case begin
                        _pipe@2 = [<<"ب"/utf8>>,
                                   <<"پ"/utf8>>,
                                   <<"ت"/utf8>>,
                                   <<"ث"/utf8>>,
                                   <<"ج"/utf8>>,
                                   <<"چ"/utf8>>,
                                   <<"ح"/utf8>>,
                                   <<"خ"/utf8>>,
                                   <<"د"/utf8>>,
                                   <<"ذ"/utf8>>,
                                   <<"ر"/utf8>>,
                                   <<"ز"/utf8>>,
                                   <<"ژ"/utf8>>,
                                   <<"س"/utf8>>,
                                   <<"ش"/utf8>>,
                                   <<"ص"/utf8>>,
                                   <<"ض"/utf8>>,
                                   <<"ط"/utf8>>,
                                   <<"ظ"/utf8>>,
                                   <<"ع"/utf8>>,
                                   <<"غ"/utf8>>,
                                   <<"ف"/utf8>>,
                                   <<"ق"/utf8>>,
                                   <<"ک"/utf8>>,
                                   <<"گ"/utf8>>,
                                   <<"ل"/utf8>>,
                                   <<"م"/utf8>>,
                                   <<"ن"/utf8>>,
                                   <<"ه"/utf8>>,
                                   <<"ی"/utf8>>],
                        blah@utils:get_random_item(_pipe@2)
                    end of
                        {ok, Second} -> {ok, Second};
                        _try@1 ->
                            erlang:error(#{gleam_error => assert,
                                           message => <<"Assertion pattern match failed"/utf8>>,
                                           value => _try@1,
                                           module => <<"blah/fa/string"/utf8>>,
                                           function => <<"pronounceable_internal"/utf8>>,
                                           line => 93})
                    end,
                    _pipe@3 = [First@1, Second@1],
                    gleam@list:map(
                        _pipe@3,
                        fun(S) ->
                            _pipe@4 = S,
                            gleam@string_builder:from_string(_pipe@4)
                        end
                    );

                1 ->
                    {ok, First@3} = case begin
                        _pipe@5 = [<<"ب"/utf8>>,
                                   <<"پ"/utf8>>,
                                   <<"ت"/utf8>>,
                                   <<"ث"/utf8>>,
                                   <<"ج"/utf8>>,
                                   <<"چ"/utf8>>,
                                   <<"ح"/utf8>>,
                                   <<"خ"/utf8>>,
                                   <<"د"/utf8>>,
                                   <<"ذ"/utf8>>,
                                   <<"ر"/utf8>>,
                                   <<"ز"/utf8>>,
                                   <<"ژ"/utf8>>,
                                   <<"س"/utf8>>,
                                   <<"ش"/utf8>>,
                                   <<"ص"/utf8>>,
                                   <<"ض"/utf8>>,
                                   <<"ط"/utf8>>,
                                   <<"ظ"/utf8>>,
                                   <<"ع"/utf8>>,
                                   <<"غ"/utf8>>,
                                   <<"ف"/utf8>>,
                                   <<"ق"/utf8>>,
                                   <<"ک"/utf8>>,
                                   <<"گ"/utf8>>,
                                   <<"ل"/utf8>>,
                                   <<"م"/utf8>>,
                                   <<"ن"/utf8>>,
                                   <<"ه"/utf8>>,
                                   <<"ی"/utf8>>],
                        blah@utils:get_random_item(_pipe@5)
                    end of
                        {ok, First@2} -> {ok, First@2};
                        _try@2 ->
                            erlang:error(#{gleam_error => assert,
                                           message => <<"Assertion pattern match failed"/utf8>>,
                                           value => _try@2,
                                           module => <<"blah/fa/string"/utf8>>,
                                           function => <<"pronounceable_internal"/utf8>>,
                                           line => 103})
                    end,
                    {ok, Second@3} = case begin
                        _pipe@6 = [<<"ا"/utf8>>, <<"و"/utf8>>],
                        blah@utils:get_random_item(_pipe@6)
                    end of
                        {ok, Second@2} -> {ok, Second@2};
                        _try@3 ->
                            erlang:error(#{gleam_error => assert,
                                           message => <<"Assertion pattern match failed"/utf8>>,
                                           value => _try@3,
                                           module => <<"blah/fa/string"/utf8>>,
                                           function => <<"pronounceable_internal"/utf8>>,
                                           line => 106})
                    end,
                    _pipe@7 = [First@3, Second@3],
                    gleam@list:map(
                        _pipe@7,
                        fun(S@1) ->
                            _pipe@8 = S@1,
                            gleam@string_builder:from_string(_pipe@8)
                        end
                    )
            end,
            pronounceable_internal(
                gleam@string_builder:concat([State | Letters]),
                Remaining
                - 2
            )
    end.

-spec alpha_internal(gleam@string_builder:string_builder(), integer()) -> binary().
alpha_internal(State, Remaining) ->
    case Remaining =:= 0 of
        true ->
            _pipe = State,
            gleam@string_builder:to_string(_pipe);

        false ->
            {ok, Letter@1} = case blah@utils:get_random_item(
                [<<"آ"/utf8>>,
                 <<"ا"/utf8>>,
                 <<"ب"/utf8>>,
                 <<"پ"/utf8>>,
                 <<"ت"/utf8>>,
                 <<"ث"/utf8>>,
                 <<"ج"/utf8>>,
                 <<"چ"/utf8>>,
                 <<"ح"/utf8>>,
                 <<"خ"/utf8>>,
                 <<"د"/utf8>>,
                 <<"ذ"/utf8>>,
                 <<"ر"/utf8>>,
                 <<"ز"/utf8>>,
                 <<"ژ"/utf8>>,
                 <<"س"/utf8>>,
                 <<"ش"/utf8>>,
                 <<"ص"/utf8>>,
                 <<"ض"/utf8>>,
                 <<"ط"/utf8>>,
                 <<"ظ"/utf8>>,
                 <<"ع"/utf8>>,
                 <<"غ"/utf8>>,
                 <<"ف"/utf8>>,
                 <<"ق"/utf8>>,
                 <<"ک"/utf8>>,
                 <<"گ"/utf8>>,
                 <<"ل"/utf8>>,
                 <<"م"/utf8>>,
                 <<"ن"/utf8>>,
                 <<"و"/utf8>>,
                 <<"ه"/utf8>>,
                 <<"ی"/utf8>>]
            ) of
                {ok, Letter} -> {ok, Letter};
                _try ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try,
                                   module => <<"blah/fa/string"/utf8>>,
                                   function => <<"alpha_internal"/utf8>>,
                                   line => 131})
            end,
            alpha_internal(
                begin
                    _pipe@1 = State,
                    gleam@string_builder:append(_pipe@1, Letter@1)
                end,
                Remaining
                - 1
            )
    end.

-spec numeric_internal(gleam@string_builder:string_builder(), integer()) -> binary().
numeric_internal(State, Remaining) ->
    case Remaining =:= 0 of
        true ->
            _pipe = State,
            gleam@string_builder:to_string(_pipe);

        false ->
            {ok, Digit@1} = case blah@utils:get_random_item(
                [<<"۰"/utf8>>,
                 <<"۱"/utf8>>,
                 <<"۲"/utf8>>,
                 <<"۳"/utf8>>,
                 <<"۴"/utf8>>,
                 <<"۵"/utf8>>,
                 <<"۶"/utf8>>,
                 <<"۷"/utf8>>,
                 <<"۸"/utf8>>,
                 <<"۹"/utf8>>]
            ) of
                {ok, Digit} -> {ok, Digit};
                _try ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try,
                                   module => <<"blah/fa/string"/utf8>>,
                                   function => <<"numeric_internal"/utf8>>,
                                   line => 148})
            end,
            numeric_internal(
                begin
                    _pipe@1 = State,
                    gleam@string_builder:append(_pipe@1, Digit@1)
                end,
                Remaining
                - 1
            )
    end.

-spec alphanumeric_internal(gleam@string_builder:string_builder(), integer()) -> binary().
alphanumeric_internal(State, Remaining) ->
    case Remaining =:= 0 of
        true ->
            _pipe = State,
            gleam@string_builder:to_string(_pipe);

        false ->
            {ok, Character@1} = case blah@utils:get_random_item(
                [<<"آ"/utf8>>,
                 <<"ا"/utf8>>,
                 <<"ب"/utf8>>,
                 <<"پ"/utf8>>,
                 <<"ت"/utf8>>,
                 <<"ث"/utf8>>,
                 <<"ج"/utf8>>,
                 <<"چ"/utf8>>,
                 <<"ح"/utf8>>,
                 <<"خ"/utf8>>,
                 <<"د"/utf8>>,
                 <<"ذ"/utf8>>,
                 <<"ر"/utf8>>,
                 <<"ز"/utf8>>,
                 <<"ژ"/utf8>>,
                 <<"س"/utf8>>,
                 <<"ش"/utf8>>,
                 <<"ص"/utf8>>,
                 <<"ض"/utf8>>,
                 <<"ط"/utf8>>,
                 <<"ظ"/utf8>>,
                 <<"ع"/utf8>>,
                 <<"غ"/utf8>>,
                 <<"ف"/utf8>>,
                 <<"ق"/utf8>>,
                 <<"ک"/utf8>>,
                 <<"گ"/utf8>>,
                 <<"ل"/utf8>>,
                 <<"م"/utf8>>,
                 <<"ن"/utf8>>,
                 <<"و"/utf8>>,
                 <<"ه"/utf8>>,
                 <<"ی"/utf8>>,
                 <<"۰"/utf8>>,
                 <<"۱"/utf8>>,
                 <<"۲"/utf8>>,
                 <<"۳"/utf8>>,
                 <<"۴"/utf8>>,
                 <<"۵"/utf8>>,
                 <<"۶"/utf8>>,
                 <<"۷"/utf8>>,
                 <<"۸"/utf8>>,
                 <<"۹"/utf8>>]
            ) of
                {ok, Character} -> {ok, Character};
                _try ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try,
                                   module => <<"blah/fa/string"/utf8>>,
                                   function => <<"alphanumeric_internal"/utf8>>,
                                   line => 165})
            end,
            alphanumeric_internal(
                begin
                    _pipe@1 = State,
                    gleam@string_builder:append(_pipe@1, Character@1)
                end,
                Remaining
                - 1
            )
    end.

-spec with_pattern_internal(gleam@string_builder:string_builder(), binary()) -> binary().
with_pattern_internal(State, Given_pattern) ->
    case begin
        _pipe = Given_pattern,
        gleam@string:first(_pipe)
    end of
        {ok, <<"%"/utf8>>} ->
            {ok, To_append@1} = case case begin
                _pipe@1 = Given_pattern,
                gleam@string:slice(_pipe@1, 0, 2)
            end of
                <<"%d"/utf8>> ->
                    blah@utils:get_random_item(
                        [<<"۰"/utf8>>,
                         <<"۱"/utf8>>,
                         <<"۲"/utf8>>,
                         <<"۳"/utf8>>,
                         <<"۴"/utf8>>,
                         <<"۵"/utf8>>,
                         <<"۶"/utf8>>,
                         <<"۷"/utf8>>,
                         <<"۸"/utf8>>,
                         <<"۹"/utf8>>]
                    );

                <<"%w"/utf8>> ->
                    blah@utils:get_random_item(
                        [<<"آ"/utf8>>,
                         <<"ا"/utf8>>,
                         <<"ب"/utf8>>,
                         <<"پ"/utf8>>,
                         <<"ت"/utf8>>,
                         <<"ث"/utf8>>,
                         <<"ج"/utf8>>,
                         <<"چ"/utf8>>,
                         <<"ح"/utf8>>,
                         <<"خ"/utf8>>,
                         <<"د"/utf8>>,
                         <<"ذ"/utf8>>,
                         <<"ر"/utf8>>,
                         <<"ز"/utf8>>,
                         <<"ژ"/utf8>>,
                         <<"س"/utf8>>,
                         <<"ش"/utf8>>,
                         <<"ص"/utf8>>,
                         <<"ض"/utf8>>,
                         <<"ط"/utf8>>,
                         <<"ظ"/utf8>>,
                         <<"ع"/utf8>>,
                         <<"غ"/utf8>>,
                         <<"ف"/utf8>>,
                         <<"ق"/utf8>>,
                         <<"ک"/utf8>>,
                         <<"گ"/utf8>>,
                         <<"ل"/utf8>>,
                         <<"م"/utf8>>,
                         <<"ن"/utf8>>,
                         <<"و"/utf8>>,
                         <<"ه"/utf8>>,
                         <<"ی"/utf8>>]
                    );

                <<"%c"/utf8>> ->
                    blah@utils:get_random_item(
                        [<<"آ"/utf8>>,
                         <<"ا"/utf8>>,
                         <<"ب"/utf8>>,
                         <<"پ"/utf8>>,
                         <<"ت"/utf8>>,
                         <<"ث"/utf8>>,
                         <<"ج"/utf8>>,
                         <<"چ"/utf8>>,
                         <<"ح"/utf8>>,
                         <<"خ"/utf8>>,
                         <<"د"/utf8>>,
                         <<"ذ"/utf8>>,
                         <<"ر"/utf8>>,
                         <<"ز"/utf8>>,
                         <<"ژ"/utf8>>,
                         <<"س"/utf8>>,
                         <<"ش"/utf8>>,
                         <<"ص"/utf8>>,
                         <<"ض"/utf8>>,
                         <<"ط"/utf8>>,
                         <<"ظ"/utf8>>,
                         <<"ع"/utf8>>,
                         <<"غ"/utf8>>,
                         <<"ف"/utf8>>,
                         <<"ق"/utf8>>,
                         <<"ک"/utf8>>,
                         <<"گ"/utf8>>,
                         <<"ل"/utf8>>,
                         <<"م"/utf8>>,
                         <<"ن"/utf8>>,
                         <<"و"/utf8>>,
                         <<"ه"/utf8>>,
                         <<"ی"/utf8>>,
                         <<"۰"/utf8>>,
                         <<"۱"/utf8>>,
                         <<"۲"/utf8>>,
                         <<"۳"/utf8>>,
                         <<"۴"/utf8>>,
                         <<"۵"/utf8>>,
                         <<"۶"/utf8>>,
                         <<"۷"/utf8>>,
                         <<"۸"/utf8>>,
                         <<"۹"/utf8>>]
                    );

                <<"%n"/utf8>> ->
                    blah@utils:get_random_item(
                        [<<"۱"/utf8>>,
                         <<"۲"/utf8>>,
                         <<"۳"/utf8>>,
                         <<"۴"/utf8>>,
                         <<"۵"/utf8>>,
                         <<"۶"/utf8>>,
                         <<"۷"/utf8>>,
                         <<"۸"/utf8>>,
                         <<"۹"/utf8>>]
                    );

                Characters ->
                    {ok, Characters}
            end of
                {ok, To_append} -> {ok, To_append};
                _try ->
                    erlang:error(#{gleam_error => assert,
                                   message => <<"Assertion pattern match failed"/utf8>>,
                                   value => _try,
                                   module => <<"blah/fa/string"/utf8>>,
                                   function => <<"with_pattern_internal"/utf8>>,
                                   line => 181})
            end,
            with_pattern_internal(
                begin
                    _pipe@2 = State,
                    gleam@string_builder:append(_pipe@2, To_append@1)
                end,
                begin
                    _pipe@3 = Given_pattern,
                    gleam@string:drop_left(_pipe@3, 2)
                end
            );

        {ok, To_append@2} ->
            with_pattern_internal(
                begin
                    _pipe@4 = State,
                    gleam@string_builder:append(_pipe@4, To_append@2)
                end,
                begin
                    _pipe@5 = Given_pattern,
                    gleam@string:drop_left(_pipe@5, 1)
                end
            );

        {error, nil} ->
            _pipe@6 = State,
            gleam@string_builder:to_string(_pipe@6)
    end.