crossbar

-module(crossbar@internal@field).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([validate_required/1, validate_min_length/2, validate_max_length/2, validate_eq/2, validate_not_eq/2, validate_regex/2, use_validator_function/2, validate_min_value/2, validate_max_value/2]).
-export_type([rule/1, field/1]).

-type rule(FTC) :: required |
    {min_size, float()} |
    {max_size, float()} |
    {min_length, integer()} |
    {max_length, integer()} |
    {eq, binary(), FTC} |
    {not_eq, binary(), FTC} |
    {regex, binary(), gleam@regex:regex(), binary()} |
    {validator_function, binary(), fun((FTC) -> boolean()), binary()}.

-type field(FTD) :: {int_field, binary(), integer(), list(rule(FTD))} |
    {float_field, binary(), float(), list(rule(FTD))} |
    {string_field, binary(), binary(), list(rule(FTD))} |
    {bool_field, binary(), boolean(), list(rule(FTD))}.

-spec validate_required(field(any())) -> boolean().
validate_required(Field) ->
    case Field of
        {int_field, _, Value, _} ->
            Value /= 0;

        {float_field, _, Value@1, _} ->
            Value@1 /= +0.0;

        {string_field, _, Value@2, _} ->
            gleam@string:trim(Value@2) /= <<""/utf8>>;

        {bool_field, _, _, _} ->
            true
    end.

-spec validate_min_length(field(any()), integer()) -> boolean().
validate_min_length(Field, Min_length) ->
    Field_length = begin
        _pipe = case Field of
            {int_field, _, Value, _} ->
                gleam@int:to_string(Value);

            {float_field, _, Value@1, _} ->
                gleam@float:to_string(Value@1);

            {string_field, _, Value@2, _} ->
                Value@2;

            {bool_field, _, Value@3, _} ->
                gleam@bool:to_string(Value@3)
        end,
        _pipe@1 = gleam@string:trim(_pipe),
        gleam@string:length(_pipe@1)
    end,
    Field_length >= Min_length.

-spec validate_max_length(field(any()), integer()) -> boolean().
validate_max_length(Field, Max_length) ->
    Field_length = begin
        _pipe = case Field of
            {int_field, _, Value, _} ->
                gleam@int:to_string(Value);

            {float_field, _, Value@1, _} ->
                gleam@float:to_string(Value@1);

            {string_field, _, Value@2, _} ->
                Value@2;

            {bool_field, _, Value@3, _} ->
                gleam@bool:to_string(Value@3)
        end,
        _pipe@1 = gleam@string:trim(_pipe),
        gleam@string:length(_pipe@1)
    end,
    Field_length =< Max_length.

-spec validate_eq(field(FTO), FTO) -> boolean().
validate_eq(Field, Other_value) ->
    case Field of
        {int_field, _, Value, _} ->
            gleam@int:compare(Value, crossbar@internal@cast:int(Other_value))
            =:= eq;

        {float_field, _, Value@1, _} ->
            gleam@float:compare(
                Value@1,
                crossbar@internal@cast:float(Other_value)
            )
            =:= eq;

        {string_field, _, Value@2, _} ->
            gleam@string:compare(
                Value@2,
                crossbar@internal@cast:string(Other_value)
            )
            =:= eq;

        {bool_field, _, Value@3, _} ->
            gleam@bool:compare(
                Value@3,
                crossbar@internal@cast:bool(Other_value)
            )
            =:= eq
    end.

-spec validate_not_eq(field(FTQ), FTQ) -> boolean().
validate_not_eq(Field, Other_value) ->
    case Field of
        {int_field, _, Value, _} ->
            gleam@int:compare(Value, crossbar@internal@cast:int(Other_value)) /= eq;

        {float_field, _, Value@1, _} ->
            gleam@float:compare(
                Value@1,
                crossbar@internal@cast:float(Other_value)
            )
            /= eq;

        {string_field, _, Value@2, _} ->
            gleam@string:compare(
                Value@2,
                crossbar@internal@cast:string(Other_value)
            )
            /= eq;

        {bool_field, _, Value@3, _} ->
            gleam@bool:compare(
                Value@3,
                crossbar@internal@cast:bool(Other_value)
            )
            /= eq
    end.

-spec validate_regex(field(any()), gleam@regex:regex()) -> boolean().
validate_regex(Field, Regex) ->
    _pipe = case Field of
        {int_field, _, Value, _} ->
            gleam@int:to_string(Value);

        {float_field, _, Value@1, _} ->
            gleam@float:to_string(Value@1);

        {string_field, _, Value@2, _} ->
            Value@2;

        {bool_field, _, Value@3, _} ->
            gleam@bool:to_string(Value@3)
    end,
    gleam@regex:check(Regex, _pipe).

-spec use_validator_function(field(FTU), fun((FTU) -> boolean())) -> boolean().
use_validator_function(Field, Validate) ->
    _pipe = case Field of
        {int_field, _, Value, _} ->
            gleam@dynamic:from(Value);

        {float_field, _, Value@1, _} ->
            gleam@dynamic:from(Value@1);

        {string_field, _, Value@2, _} ->
            gleam@dynamic:from(Value@2);

        {bool_field, _, Value@3, _} ->
            gleam@dynamic:from(Value@3)
    end,
    _pipe@1 = gleam@dynamic:unsafe_coerce(_pipe),
    Validate(_pipe@1).

-spec string_to_float_byte_size(binary()) -> float().
string_to_float_byte_size(Value) ->
    _pipe = Value,
    _pipe@1 = gleam_stdlib:identity(_pipe),
    _pipe@2 = erlang:byte_size(_pipe@1),
    gleam@int:to_float(_pipe@2).

-spec bool_to_float(boolean()) -> float().
bool_to_float(Value) ->
    case Value of
        true ->
            1.0;

        false ->
            +0.0
    end.

-spec validate_min_value(field(any()), float()) -> boolean().
validate_min_value(Field, Min) ->
    Value@4 = case Field of
        {int_field, _, Value, _} ->
            gleam@int:to_float(Value);

        {float_field, _, Value@1, _} ->
            Value@1;

        {string_field, _, Value@2, _} ->
            string_to_float_byte_size(Value@2);

        {bool_field, _, Value@3, _} ->
            bool_to_float(Value@3)
    end,
    gleam@float:min(Min, Value@4) =:= Min.

-spec validate_max_value(field(any()), float()) -> boolean().
validate_max_value(Field, Max) ->
    Value@4 = case Field of
        {int_field, _, Value, _} ->
            gleam@int:to_float(Value);

        {float_field, _, Value@1, _} ->
            Value@1;

        {string_field, _, Value@2, _} ->
            string_to_float_byte_size(Value@2);

        {bool_field, _, Value@3, _} ->
            bool_to_float(Value@3)
    end,
    gleam@float:max(Max, Value@4) =:= Max.