sunny

-module(sunny@api@forecast@data).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([range_to_current/2, range_to_data_list/2]).
-export_type([time_ranged_data/1, current_data/1, data/0]).

-type time_ranged_data(JJW) :: {time_ranged_data,
        list(birl:time()),
        gleam@dict:dict(JJW, list(sunny@measurement:measurement()))}.

-type current_data(JJX) :: {current_data,
        birl:time(),
        gleam@dict:dict(JJX, sunny@measurement:measurement())}.

-type data() :: {data, birl:time(), sunny@measurement:measurement()}.

-spec range_to_current(time_ranged_data(JJY), birl:time()) -> {ok,
        current_data(JJY)} |
    {error, sunny@errors:sunny_error()}.
range_to_current(Data, Time) ->
    case erlang:element(2, Data) of
        [] ->
            {error,
                {data_error,
                    {data_not_found_error,
                        <<"Invalid time for provided data."/utf8>>}}};

        [Head | Tail] ->
            case Head =:= Time of
                false ->
                    New_data = begin
                        _pipe = erlang:element(3, Data),
                        gleam@dict:map_values(
                            _pipe,
                            fun(_, V) ->
                                [_ | New] = case V of
                                    [_ | _] -> V;
                                    _assert_fail ->
                                        erlang:error(
                                                #{gleam_error => let_assert,
                                                    message => <<"Assertion pattern match failed"/utf8>>,
                                                    value => _assert_fail,
                                                    module => <<"sunny/api/forecast/data"/utf8>>,
                                                    function => <<"range_to_current"/utf8>>,
                                                    line => 58}
                                            )
                                end,
                                New
                            end
                        )
                    end,
                    range_to_current({time_ranged_data, Tail, New_data}, Time);

                true ->
                    {ok,
                        {current_data,
                            Time,
                            gleam@dict:fold(
                                erlang:element(3, Data),
                                gleam@dict:new(),
                                fun(D, K, V@1) ->
                                    gleam@dict:insert(
                                        D,
                                        K,
                                        begin
                                            [Head@1 | _] = case V@1 of
                                                [_ | _] -> V@1;
                                                _assert_fail@1 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Assertion pattern match failed"/utf8>>,
                                                                value => _assert_fail@1,
                                                                module => <<"sunny/api/forecast/data"/utf8>>,
                                                                function => <<"range_to_current"/utf8>>,
                                                                line => 68}
                                                        )
                                            end,
                                            Head@1
                                        end
                                    )
                                end
                            )}}
            end
    end.

-spec do_range_to_data_list(
    list(birl:time()),
    list(sunny@measurement:measurement()),
    list(data())
) -> {ok, list(data())} | {error, sunny@errors:internal_error()}.
do_range_to_data_list(Time, L, Result) ->
    case {Time, L} of
        {[], []} ->
            {ok, Result};

        {[T | T_tail], [M | M_tail]} ->
            _pipe = Result,
            _pipe@1 = lists:append(_pipe, [{data, T, M}]),
            do_range_to_data_list(T_tail, M_tail, _pipe@1);

        {_, _} ->
            {error,
                {internal_error,
                    <<"Please open an issue on Github if you encountered this error."/utf8>>}}
    end.

-spec get_range_var(time_ranged_data(JKO), JKO) -> {ok,
        list(sunny@measurement:measurement())} |
    {error, sunny@errors:data_error()}.
get_range_var(Data, Var) ->
    _pipe = erlang:element(3, Data),
    _pipe@1 = gleam@dict:get(_pipe, Var),
    gleam@result:map_error(
        _pipe@1,
        fun(_) ->
            {data_not_found_error, <<"Could not find variable in data."/utf8>>}
        end
    ).

-spec range_to_data_list(time_ranged_data(JKD), JKD) -> {ok, list(data())} |
    {error, sunny@errors:sunny_error()}.
range_to_data_list(Data, Var) ->
    gleam@result:'try'(
        begin
            _pipe = get_range_var(Data, Var),
            gleam@result:map_error(_pipe, fun(E) -> {data_error, E} end)
        end,
        fun(L) ->
            _pipe@1 = do_range_to_data_list(erlang:element(2, Data), L, []),
            gleam@result:map_error(
                _pipe@1,
                fun(E@1) -> {sunny_internal_error, E@1} end
            )
        end
    ).