-module(glugify@config).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/glugify/config.gleam").
-export([default/0, with_separator/2, validate_config/1, with_lowercase/2, with_max_length/2, with_word_boundary/2, with_transliterate/2, with_allow_unicode/2, with_custom_replacements/2, with_stop_words/2, with_trim/2]).
-export_type([config/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 config() :: {config,
        binary(),
        boolean(),
        gleam@option:option(integer()),
        boolean(),
        boolean(),
        boolean(),
        list({binary(), binary()}),
        boolean(),
        boolean(),
        list(binary()),
        boolean()}.

-file("src/glugify/config.gleam", 56).
?DOC(
    " Creates a default configuration with sensible defaults for most use cases.\n"
    " \n"
    " ## Default values:\n"
    " \n"
    " - Separator: `-`\n"
    " - Lowercase: `True`\n"
    " - Max length: `None` (unlimited)\n"
    " - Word boundary: `False`\n"
    " - Transliterate: `True`\n"
    " - Allow unicode: `False`\n"
    " - Custom replacements: `[]`\n"
    " - Preserve leading underscore: `False`\n"
    " - Preserve trailing dash: `False`\n"
    " - Stop words: `[]`\n"
    " - Trim: `True`\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " let config = default()\n"
    " ```\n"
).
-spec default() -> config().
default() ->
    {config,
        <<"-"/utf8>>,
        true,
        none,
        false,
        true,
        false,
        [],
        false,
        false,
        [],
        true}.

-file("src/glugify/config.gleam", 81).
?DOC(
    " Sets the separator character(s) used between words.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " default()\n"
    " |> with_separator(\"_\")\n"
    " // Results in: \"hello_world\" instead of \"hello-world\"\n"
    " ```\n"
).
-spec with_separator(config(), binary()) -> config().
with_separator(Config, Separator) ->
    _record = Config,
    {config,
        Separator,
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record),
        erlang:element(12, _record)}.

-file("src/glugify/config.gleam", 91).
?DOC(
    " Validates configuration parameters and returns an error if invalid.\n"
    " \n"
    " Currently validates:\n"
    " - Separator length must be <= 10 characters\n"
    " \n"
    " Returns the same config if valid, or an error message if invalid.\n"
).
-spec validate_config(config()) -> {ok, config()} | {error, binary()}.
validate_config(Config) ->
    case string:length(erlang:element(2, Config)) > 10 of
        true ->
            {error, <<"Separator too long (max 10 characters)"/utf8>>};

        false ->
            {ok, Config}
    end.

-file("src/glugify/config.gleam", 107).
?DOC(
    " Sets whether the output should be converted to lowercase.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " default()\n"
    " |> with_lowercase(False)\n"
    " // Results in: \"Hello-World\" instead of \"hello-world\"\n"
    " ```\n"
).
-spec with_lowercase(config(), boolean()) -> config().
with_lowercase(Config, Lowercase) ->
    _record = Config,
    {config,
        erlang:element(2, _record),
        Lowercase,
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record),
        erlang:element(12, _record)}.

-file("src/glugify/config.gleam", 123).
?DOC(
    " Sets the maximum length for the generated slug.\n"
    " \n"
    " If the value is negative, the config remains unchanged.\n"
    " Use with `with_word_boundary(True)` to truncate at word boundaries.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " default()\n"
    " |> with_max_length(10)\n"
    " // Will truncate slugs to 10 characters maximum\n"
    " ```\n"
).
-spec with_max_length(config(), integer()) -> config().
with_max_length(Config, Max_length) ->
    case Max_length < 0 of
        true ->
            Config;

        false ->
            _record = Config,
            {config,
                erlang:element(2, _record),
                erlang:element(3, _record),
                {some, Max_length},
                erlang:element(5, _record),
                erlang:element(6, _record),
                erlang:element(7, _record),
                erlang:element(8, _record),
                erlang:element(9, _record),
                erlang:element(10, _record),
                erlang:element(11, _record),
                erlang:element(12, _record)}
    end.

-file("src/glugify/config.gleam", 143).
?DOC(
    " Sets whether truncation should respect word boundaries.\n"
    " \n"
    " When `True`, truncation will not cut words in half.\n"
    " Only applies when `max_length` is set.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " default()\n"
    " |> with_max_length(10)\n"
    " |> with_word_boundary(True)\n"
    " // \"hello world test\" -> \"hello\" (not \"hello worl\")\n"
    " ```\n"
).
-spec with_word_boundary(config(), boolean()) -> config().
with_word_boundary(Config, Word_boundary) ->
    _record = Config,
    {config,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        Word_boundary,
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record),
        erlang:element(12, _record)}.

-file("src/glugify/config.gleam", 160).
?DOC(
    " Sets whether Unicode characters should be transliterated to ASCII.\n"
    " \n"
    " When `True`, characters like \"café\" become \"cafe\".\n"
    " When `False`, Unicode characters are preserved or cause an error.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " default()\n"
    " |> with_transliterate(False)\n"
    " |> with_allow_unicode(True)\n"
    " // Preserves Unicode: \"café\" -> \"café\"\n"
    " ```\n"
).
-spec with_transliterate(config(), boolean()) -> config().
with_transliterate(Config, Transliterate) ->
    _record = Config,
    {config,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        Transliterate,
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record),
        erlang:element(12, _record)}.

-file("src/glugify/config.gleam", 177).
?DOC(
    " Sets whether Unicode characters are allowed in the output.\n"
    " \n"
    " When `True`, Unicode characters are preserved in the output.\n"
    " When `False`, only ASCII characters are allowed.\n"
    " Usually used with `transliterate: False`.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " default()\n"
    " |> with_transliterate(False)\n"
    " |> with_allow_unicode(True)\n"
    " ```\n"
).
-spec with_allow_unicode(config(), boolean()) -> config().
with_allow_unicode(Config, Allow_unicode) ->
    _record = Config,
    {config,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        Allow_unicode,
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record),
        erlang:element(12, _record)}.

-file("src/glugify/config.gleam", 197).
?DOC(
    " Sets custom string replacements to apply before other processing.\n"
    " \n"
    " Each tuple contains `#(from, to)` where `from` is replaced with `to`.\n"
    " Replacements are applied in the order provided.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " default()\n"
    " |> with_custom_replacements([\n"
    "   #(\"&\", \" and \"),\n"
    "   #(\"@\", \" at \"),\n"
    "   #(\"%\", \" percent \")\n"
    " ])\n"
    " // \"Cats & Dogs @ 100%\" -> \"cats-and-dogs-at-100-percent\"\n"
    " ```\n"
).
-spec with_custom_replacements(config(), list({binary(), binary()})) -> config().
with_custom_replacements(Config, Replacements) ->
    _record = Config,
    {config,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        Replacements,
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record),
        erlang:element(12, _record)}.

-file("src/glugify/config.gleam", 216).
?DOC(
    " Sets a list of stop words to remove from the slug.\n"
    " \n"
    " Stop words are removed after other processing but before final cleanup.\n"
    " Matching is case-insensitive.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " default()\n"
    " |> with_stop_words([\"the\", \"a\", \"an\", \"and\", \"or\"])\n"
    " // \"The Quick Brown Fox and the Lazy Dog\" -> \"quick-brown-fox-lazy-dog\"\n"
    " ```\n"
).
-spec with_stop_words(config(), list(binary())) -> config().
with_stop_words(Config, Stop_words) ->
    _record = Config,
    {config,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        Stop_words,
        erlang:element(12, _record)}.

-file("src/glugify/config.gleam", 231).
?DOC(
    " Sets whether to trim leading and trailing whitespace from the input.\n"
    " \n"
    " This is applied early in the processing pipeline.\n"
    " \n"
    " ## Examples\n"
    " \n"
    " ```gleam\n"
    " default()\n"
    " |> with_trim(False)\n"
    " // Preserves leading/trailing spaces in processing\n"
    " ```\n"
).
-spec with_trim(config(), boolean()) -> config().
with_trim(Config, Trim) ->
    _record = Config,
    {config,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        erlang:element(7, _record),
        erlang:element(8, _record),
        erlang:element(9, _record),
        erlang:element(10, _record),
        erlang:element(11, _record),
        Trim}.