gloom

-module(gleam_value).
-compile([no_auto_import, nowarn_unused_vars]).

-export([from_list/1, empty_number/0, empty_string/0, empty_map/0, from_string/1, from_float/1, from_int/1, empty_value/1, gloom_type/1, length/1, nothing/1, something/1, everything/1, insert/3, ensure_map_value/1, get/2, set_property/3, ensure_object_value/1, get_property/2, insert_value/2, nothing_value/1, something_value/1, everything_value/1]).
-export_type([gloom_object/0, gleam_value/0]).

-type gloom_object() :: {gloom_object,
        binary(),
        dtype:gloom_type(),
        affinity:gloom_affinity(),
        gleam_value()}.

-type gleam_value() :: {int_value, integer()} |
    {float_value, float()} |
    {string_value, binary()} |
    {map_value, gleam@map:map_(gleam_value(), gleam_value())} |
    {object_value, gloom_object()}.

-spec from_list(list({gleam_value(), gleam_value()})) -> gleam_value().
from_list(List) ->
    {map_value, gleam@map:from_list(List)}.

-spec empty_number() -> gleam_value().
empty_number() ->
    {float_value, 0.0}.

-spec empty_string() -> gleam_value().
empty_string() ->
    {string_value, <<""/utf8>>}.

-spec empty_map() -> gleam_value().
empty_map() ->
    {map_value, gleam@map:new()}.

-spec from_string(binary()) -> gleam_value().
from_string(String) ->
    {string_value, String}.

-spec from_float(float()) -> gleam_value().
from_float(Float) ->
    {float_value, Float}.

-spec from_int(integer()) -> gleam_value().
from_int(Int) ->
    {int_value, Int}.

-spec empty_value(dtype:gloom_type()) -> gleam_value().
empty_value(Datatype) ->
    case Datatype of
        number ->
            empty_number();

        string ->
            empty_string();

        table ->
            empty_map()
    end.

-spec gloom_type(gleam_value()) -> dtype:gloom_type().
gloom_type(Gleam_value) ->
    case Gleam_value of
        {int_value, _} ->
            number;

        {float_value, _} ->
            number;

        {string_value, _} ->
            string;

        {map_value, _} ->
            table;

        {object_value, Object} ->
            erlang:element(3, Object)
    end.

-spec length(gleam_value()) -> integer().
length(Value) ->
    case Value of
        {int_value, Gleam_value} ->
            _pipe = Gleam_value,
            _pipe@1 = gleam@int:to_string(_pipe),
            gleam@string:length(_pipe@1);

        {float_value, Gleam_value@1} ->
            _pipe@2 = Gleam_value@1,
            _pipe@3 = gleam@float:to_string(_pipe@2),
            gleam@string:length(_pipe@3);

        {string_value, Gleam_value@2} ->
            _pipe@4 = Gleam_value@2,
            gleam@string:length(_pipe@4);

        {map_value, Gleam_value@3} ->
            _pipe@5 = Gleam_value@3,
            gleam@map:size(_pipe@5);

        {object_value, Object} ->
            _pipe@6 = erlang:element(5, Object),
            length(_pipe@6)
    end.

-spec nothing(dtype:gloom_type()) -> gloom_object().
nothing(Datatype) ->
    {gloom_object, <<"object"/utf8>>, Datatype, nothing, empty_map()}.

-spec something(dtype:gloom_type()) -> gloom_object().
something(Datatype) ->
    {gloom_object, <<"object"/utf8>>, Datatype, something, empty_map()}.

-spec everything(dtype:gloom_type()) -> gloom_object().
everything(Datatype) ->
    {gloom_object, <<"object"/utf8>>, Datatype, everything, empty_map()}.

-spec insert(gleam_value(), gleam_value(), gleam_value()) -> gleam_value().
insert(Maybe_map, Key, Value) ->
    case Maybe_map of
        {map_value, Gleam_map} ->
            {map_value, gleam@map:insert(Gleam_map, Key, Value)};

        _ ->
            _pipe = ensure_map_value(Maybe_map),
            insert(_pipe, Key, Value)
    end.

-spec ensure_map_value(gleam_value()) -> gleam_value().
ensure_map_value(Value) ->
    case Value of
        {map_value, _} ->
            Value;

        _ ->
            Empty_gloom_value = begin
                _pipe = Value,
                _pipe@1 = gloom_type(_pipe),
                empty_value(_pipe@1)
            end,
            _pipe@2 = empty_map(),
            insert(_pipe@2, Empty_gloom_value, Value)
    end.

-spec get(gleam_value(), gleam_value()) -> gleam_value().
get(Maybe_map, Key) ->
    _assert_subject = ensure_map_value(Maybe_map),
    {map_value, Gleam_map} = case _assert_subject of
        {map_value, _} -> _assert_subject;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Assertion pattern match failed"/utf8>>,
                        value => _assert_fail,
                        module => <<"gleam_value"/utf8>>,
                        function => <<"get"/utf8>>,
                        line => 149})
    end,
    case gleam@map:get(Gleam_map, Key) of
        {ok, Value} ->
            Value;

        {error, nil} ->
            empty_number()
    end.

-spec set_property(gloom_object(), gleam_value(), gleam_value()) -> gloom_object().
set_property(Object, Key, Value) ->
    erlang:setelement(
        5,
        Object,
        begin
            _pipe = erlang:element(5, Object),
            insert(_pipe, Key, Value)
        end
    ).

-spec ensure_object_value(gleam_value()) -> gleam_value().
ensure_object_value(Value) ->
    case Value of
        {object_value, _} ->
            Value;

        _ ->
            _pipe = Value,
            _pipe@1 = gloom_type(_pipe),
            _pipe@2 = something(_pipe@1),
            _pipe@4 = set_property(
                _pipe@2,
                begin
                    _pipe@3 = <<"value"/utf8>>,
                    from_string(_pipe@3)
                end,
                Value
            ),
            {object_value, _pipe@4}
    end.

-spec get_property(gloom_object(), gleam_value()) -> gloom_object().
get_property(Object, Key) ->
    Raw_value = begin
        _pipe = erlang:element(5, Object),
        get(_pipe, Key)
    end,
    case Raw_value of
        {object_value, Value} ->
            Value;

        _ ->
            nothing(erlang:element(3, Object))
    end.

-spec insert_value(gleam_value(), gleam_value()) -> gleam_value().
insert_value(Hopefully_map, Value) ->
    Key = {string_value, <<"value"/utf8>>},
    _pipe = Hopefully_map,
    insert(_pipe, Key, Value).

-spec nothing_value(gleam_value()) -> gloom_object().
nothing_value(Value) ->
    {gloom_object,
        <<"object"/utf8>>,
        begin
            _pipe = Value,
            gloom_type(_pipe)
        end,
        nothing,
        begin
            _pipe@1 = empty_map(),
            insert_value(_pipe@1, Value)
        end}.

-spec something_value(gleam_value()) -> gloom_object().
something_value(Value) ->
    {gloom_object,
        <<"object"/utf8>>,
        begin
            _pipe = Value,
            gloom_type(_pipe)
        end,
        something,
        begin
            _pipe@1 = empty_map(),
            insert_value(_pipe@1, Value)
        end}.

-spec everything_value(gleam_value()) -> gloom_object().
everything_value(Value) ->
    {gloom_object,
        <<"object"/utf8>>,
        begin
            _pipe = Value,
            gloom_type(_pipe)
        end,
        everything,
        begin
            _pipe@1 = empty_map(),
            insert_value(_pipe@1, Value)
        end}.