blush

-module(blush).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/blush.gleam").
-export([encode/2]).
-export_type([encoding_error/0, image_data/0, components/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 encoding_error() :: {invalid_components_size, binary()} |
    {invalid_image_size, binary()} |
    {invalid_pixel_array_size, binary()} |
    {invalid_pixel_value, binary()}.

-type image_data() :: {image_data, integer(), integer(), list(integer())}.

-type components() :: {components, integer(), integer()}.

-file("src/blush.gleam", 64).
-spec validate_component_size(integer(), binary()) -> {ok, nil} |
    {error, encoding_error()}.
validate_component_size(Value, Label) ->
    case Value of
        Valid when (Valid > 0) andalso (Valid < 10) ->
            {ok, nil};

        _ ->
            Message = <<<<"Invalid component size: "/utf8, Label/binary>>/binary,
                ". Expected an integer value that's between 1 and 9 inclusive."/utf8>>,
            {error, {invalid_components_size, Message}}
    end.

-file("src/blush.gleam", 57).
-spec validate_components(components()) -> {ok, nil} | {error, encoding_error()}.
validate_components(Components) ->
    gleam@result:'try'(
        validate_component_size(erlang:element(2, Components), <<"x"/utf8>>),
        fun(_) ->
            gleam@result:'try'(
                validate_component_size(
                    erlang:element(3, Components),
                    <<"y"/utf8>>
                ),
                fun(_) -> {ok, nil} end
            )
        end
    ).

-file("src/blush.gleam", 94).
-spec validate_image_size(integer(), binary()) -> {ok, nil} |
    {error, encoding_error()}.
validate_image_size(Value, Label) ->
    case Value of
        Valid when Valid > 0 ->
            {ok, nil};

        _ ->
            Message = <<<<"Invalid image size. Expected "/utf8, Label/binary>>/binary,
                " to be greater than zero."/utf8>>,
            {error, {invalid_image_size, Message}}
    end.

-file("src/blush.gleam", 129).
-spec validate_pixel_values(image_data()) -> {ok, nil} |
    {error, encoding_error()}.
validate_pixel_values(Image) ->
    Offending_pixel_value = gleam@list:find(
        erlang:element(4, Image),
        fun(Value) -> case Value of
                Valid when (Valid >= 0) andalso (Valid =< 255) ->
                    false;

                _ ->
                    true
            end end
    ),
    case Offending_pixel_value of
        {ok, Pixel} ->
            Message = <<<<"All pixel values must be integers between 0 and 255 inclusive. Encountered pixel with value "/utf8,
                    (erlang:integer_to_binary(Pixel))/binary>>/binary,
                " which is not valid."/utf8>>,
            {error, {invalid_pixel_value, Message}};

        _ ->
            {ok, nil}
    end.

-file("src/blush.gleam", 106).
-spec validate_pixels(image_data()) -> {ok, nil} | {error, encoding_error()}.
validate_pixels(Image) ->
    Expected_items = (erlang:element(2, Image) * erlang:element(3, Image)) * 3,
    Actual_items = erlang:length(erlang:element(4, Image)),
    case Actual_items =:= Expected_items of
        false ->
            Message = <<<<<<<<<<<<<<<<"Expected "/utf8,
                                            (erlang:integer_to_binary(
                                                erlang:element(2, Image)
                                            ))/binary>>/binary,
                                        " * "/utf8>>/binary,
                                    (erlang:integer_to_binary(
                                        erlang:element(3, Image)
                                    ))/binary>>/binary,
                                " * 3 (r, g, b) = "/utf8>>/binary,
                            (erlang:integer_to_binary(Expected_items))/binary>>/binary,
                        " items in the pixel array, but the pixel array size contains "/utf8>>/binary,
                    (erlang:integer_to_binary(Actual_items))/binary>>/binary,
                " items instead."/utf8>>,
            {error, {invalid_pixel_array_size, Message}};

        true ->
            validate_pixel_values(Image)
    end.

-file("src/blush.gleam", 81).
-spec validate_image_data(image_data()) -> {ok, nil} | {error, encoding_error()}.
validate_image_data(Image) ->
    gleam@result:'try'(
        validate_image_size(erlang:element(2, Image), <<"width"/utf8>>),
        fun(_) ->
            gleam@result:'try'(
                validate_image_size(erlang:element(3, Image), <<"height"/utf8>>),
                fun(_) ->
                    gleam@result:'try'(
                        validate_pixels(Image),
                        fun(_) ->
                            _pipe = [validate_image_size(
                                    erlang:element(2, Image),
                                    <<"width"/utf8>>
                                ),
                                validate_image_size(
                                    erlang:element(3, Image),
                                    <<"height"/utf8>>
                                )],
                            _pipe@1 = gleam@result:all(_pipe),
                            gleam@result:replace(_pipe@1, nil)
                        end
                    )
                end
            )
        end
    ).

-file("src/blush.gleam", 28).
?DOC(" Encodes the provided image into a BlurHash - that can be later decoded into thumbnail image or used with other BlurHash-compatible libraries.\n").
-spec encode(image_data(), components()) -> {ok, binary()} |
    {error, encoding_error()}.
encode(Image, Components) ->
    gleam@result:'try'(
        validate_components(Components),
        fun(_) ->
            gleam@result:'try'(
                validate_image_data(Image),
                fun(_) ->
                    Blurhash = 'Elixir.BlurHash':encode(
                        erlang:element(4, Image),
                        erlang:element(2, Image),
                        erlang:element(3, Image),
                        erlang:element(2, Components),
                        erlang:element(3, Components)
                    ),
                    {ok, Blurhash}
                end
            )
        end
    ).