gtempo

-module(tempo@naive_datetime).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new/2, to_string/1, get_date/1, get_time/1, drop_time/1, set_offset/2, set_utc/1, to_second_precision/1, from_string/1, literal/1, to_milli_precision/1, to_micro_precision/1, to_nano_precision/1, compare/2, is_earlier/2, is_earlier_or_equal/2, is_equal/2, is_later/2, is_later_or_equal/2, to_period/2, difference/2, time_left_in_day/1, subtract/2, add/2]).

-spec new(tempo:date(), tempo:time()) -> tempo:naive_date_time().
new(Date, Time) ->
    {naive_date_time, Date, Time}.

-spec to_string(tempo:naive_date_time()) -> binary().
to_string(Datetime) ->
    <<<<(begin
                _pipe = erlang:element(2, Datetime),
                tempo@date:to_string(_pipe)
            end)/binary,
            "T"/utf8>>/binary,
        (begin
            _pipe@1 = erlang:element(3, Datetime),
            tempo@time:to_string(_pipe@1)
        end)/binary>>.

-spec get_date(tempo:naive_date_time()) -> tempo:date().
get_date(Datetime) ->
    erlang:element(2, Datetime).

-spec get_time(tempo:naive_date_time()) -> tempo:time().
get_time(Datetime) ->
    erlang:element(3, Datetime).

-spec drop_time(tempo:naive_date_time()) -> tempo:naive_date_time().
drop_time(Datetime) ->
    {naive_date_time, erlang:element(2, Datetime), {time, 0, 0, 0, 0}}.

-spec set_offset(tempo:naive_date_time(), tempo:offset()) -> tempo:date_time().
set_offset(Datetime, Offset) ->
    {date_time, Datetime, Offset}.

-spec set_utc(tempo:naive_date_time()) -> tempo:date_time().
set_utc(Datetime) ->
    set_offset(Datetime, {offset, 0}).

-spec to_second_precision(tempo:naive_date_time()) -> tempo:naive_date_time().
to_second_precision(Naive_datetime) ->
    new(
        erlang:element(2, Naive_datetime),
        begin
            _pipe = erlang:element(3, Naive_datetime),
            tempo@time:to_second_precision(_pipe)
        end
    ).

-spec from_string(binary()) -> {ok, tempo:naive_date_time()} |
    {error, tempo:error()}.
from_string(Datetime) ->
    gleam@result:try_recover(case gleam@string:split(Datetime, <<"T"/utf8>>) of
            [Date, Time] ->
                gleam@result:'try'(
                    tempo@date:from_string(Date),
                    fun(Date@1) ->
                        gleam@result:map(
                            tempo@time:from_string(Time),
                            fun(Time@1) -> {naive_date_time, Date@1, Time@1} end
                        )
                    end
                );

            [Date@2] ->
                gleam@result:map(
                    tempo@date:from_string(Date@2),
                    fun(Date@3) ->
                        _pipe = {naive_date_time, Date@3, {time, 0, 0, 0, 0}},
                        to_second_precision(_pipe)
                    end
                );

            _ ->
                {error, naive_date_time_invalid_format}
        end, fun(_) -> case gleam@string:split(Datetime, <<" "/utf8>>) of
                [Date@4, Time@2] ->
                    gleam@result:'try'(
                        tempo@date:from_string(Date@4),
                        fun(Date@5) ->
                            gleam@result:map(
                                tempo@time:from_string(Time@2),
                                fun(Time@3) ->
                                    {naive_date_time, Date@5, Time@3}
                                end
                            )
                        end
                    );

                [Date@6] ->
                    gleam@result:map(
                        tempo@date:from_string(Date@6),
                        fun(Date@7) ->
                            {naive_date_time, Date@7, {time, 0, 0, 0, 0}}
                        end
                    );

                _ ->
                    {error, naive_date_time_invalid_format}
            end end).

-spec literal(binary()) -> tempo:naive_date_time().
literal(Naive_datetime) ->
    case from_string(Naive_datetime) of
        {ok, Naive_datetime@1} ->
            Naive_datetime@1;

        {error, naive_date_time_invalid_format} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid naive datetime literal format"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 49});

        {error, naive_date_time_out_of_bounds} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid naive datetime literal value"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 51});

        {error, _} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"Invalid naive datetime literal"/utf8>>,
                    module => <<"tempo/naive_datetime"/utf8>>,
                    function => <<"literal"/utf8>>,
                    line => 52})
    end.

-spec to_milli_precision(tempo:naive_date_time()) -> tempo:naive_date_time().
to_milli_precision(Naive_datetime) ->
    new(
        erlang:element(2, Naive_datetime),
        begin
            _pipe = erlang:element(3, Naive_datetime),
            tempo@time:to_milli_precision(_pipe)
        end
    ).

-spec to_micro_precision(tempo:naive_date_time()) -> tempo:naive_date_time().
to_micro_precision(Naive_datetime) ->
    new(
        erlang:element(2, Naive_datetime),
        begin
            _pipe = erlang:element(3, Naive_datetime),
            tempo@time:to_micro_precision(_pipe)
        end
    ).

-spec to_nano_precision(tempo:naive_date_time()) -> tempo:naive_date_time().
to_nano_precision(Naive_datetime) ->
    new(
        erlang:element(2, Naive_datetime),
        begin
            _pipe = erlang:element(3, Naive_datetime),
            tempo@time:to_nano_precision(_pipe)
        end
    ).

-spec compare(tempo:naive_date_time(), tempo:naive_date_time()) -> gleam@order:order().
compare(A, B) ->
    case tempo@date:compare(erlang:element(2, A), erlang:element(2, B)) of
        eq ->
            tempo@time:compare(erlang:element(3, A), erlang:element(3, B));

        Od ->
            Od
    end.

-spec is_earlier(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_earlier(A, B) ->
    compare(A, B) =:= lt.

-spec is_earlier_or_equal(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_earlier_or_equal(A, B) ->
    (compare(A, B) =:= lt) orelse (compare(A, B) =:= eq).

-spec is_equal(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_equal(A, B) ->
    compare(A, B) =:= eq.

-spec is_later(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_later(A, B) ->
    compare(A, B) =:= gt.

-spec is_later_or_equal(tempo:naive_date_time(), tempo:naive_date_time()) -> boolean().
is_later_or_equal(A, B) ->
    (compare(A, B) =:= gt) orelse (compare(A, B) =:= eq).

-spec to_period(tempo:naive_date_time(), tempo:naive_date_time()) -> tempo:period().
to_period(Start, End) ->
    {Start@1, End@1} = case begin
        _pipe = Start,
        is_earlier_or_equal(_pipe, End)
    end of
        true ->
            {Start, End};

        false ->
            {End, Start}
    end,
    {period, Start@1, End@1}.

-spec difference(tempo:naive_date_time(), tempo:naive_date_time()) -> tempo:period().
difference(A, B) ->
    to_period(A, B).

-spec time_left_in_day(tempo:naive_date_time()) -> tempo:time().
time_left_in_day(Naive_datetime) ->
    _pipe = erlang:element(3, Naive_datetime),
    tempo@time:left_in_day(_pipe).

-spec subtract(tempo:naive_date_time(), tempo:duration()) -> tempo:naive_date_time().
subtract(Datetime, Duration_to_subtract) ->
    gleam@bool:lazy_guard(
        erlang:element(2, Duration_to_subtract) < 0,
        fun() -> _pipe = Datetime,
            add(_pipe, tempo@duration:absolute(Duration_to_subtract)) end,
        fun() ->
            Days_to_sub = tempo@duration:as_days(Duration_to_subtract),
            Time_to_sub = tempo@duration:decrease(
                Duration_to_subtract,
                tempo@duration:days(Days_to_sub)
            ),
            New_time_as_ns = begin
                _pipe@1 = erlang:element(3, Datetime),
                _pipe@2 = tempo@time:to_duration(_pipe@1),
                _pipe@3 = tempo@duration:decrease(_pipe@2, Time_to_sub),
                tempo@duration:as_nanoseconds(_pipe@3)
            end,
            {New_time_as_ns@1, Days_to_sub@1} = case New_time_as_ns < 0 of
                true ->
                    {New_time_as_ns + 86400000000000, Days_to_sub + 1};

                false ->
                    {New_time_as_ns, Days_to_sub}
            end,
            Time_to_sub@1 = tempo@duration:nanoseconds(
                tempo@time:to_nanoseconds(erlang:element(3, Datetime)) - New_time_as_ns@1
            ),
            New_date = begin
                _pipe@4 = erlang:element(2, Datetime),
                tempo@date:subtract(_pipe@4, Days_to_sub@1)
            end,
            New_time = begin
                _pipe@5 = erlang:element(3, Datetime),
                tempo@time:subtract(_pipe@5, Time_to_sub@1)
            end,
            {naive_date_time, New_date, New_time}
        end
    ).

-spec add(tempo:naive_date_time(), tempo:duration()) -> tempo:naive_date_time().
add(Datetime, Duration_to_add) ->
    gleam@bool:lazy_guard(
        erlang:element(2, Duration_to_add) < 0,
        fun() -> _pipe = Datetime,
            subtract(_pipe, tempo@duration:absolute(Duration_to_add)) end,
        fun() ->
            Days_to_add = tempo@duration:as_days(Duration_to_add),
            Time_to_add = tempo@duration:decrease(
                Duration_to_add,
                tempo@duration:days(Days_to_add)
            ),
            New_time_as_ns = begin
                _pipe@1 = erlang:element(3, Datetime),
                _pipe@2 = tempo@time:to_duration(_pipe@1),
                _pipe@3 = tempo@duration:increase(_pipe@2, Time_to_add),
                tempo@duration:as_nanoseconds(_pipe@3)
            end,
            {New_time_as_ns@1, Days_to_add@1} = case New_time_as_ns >= 86400000000000 of
                true ->
                    {New_time_as_ns - 86400000000000, Days_to_add + 1};

                false ->
                    {New_time_as_ns, Days_to_add}
            end,
            Time_to_add@1 = tempo@duration:nanoseconds(
                New_time_as_ns@1 - tempo@time:to_nanoseconds(
                    erlang:element(3, Datetime)
                )
            ),
            New_date = begin
                _pipe@4 = erlang:element(2, Datetime),
                tempo@date:add(_pipe@4, Days_to_add@1)
            end,
            New_time = begin
                _pipe@5 = erlang:element(3, Datetime),
                tempo@time:add(_pipe@5, Time_to_add@1)
            end,
            {naive_date_time, New_date, New_time}
        end
    ).