-module(bright).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([init/2, update/2, compute/2, schedule/2, unwrap/1, data/1, computed/1, step/2, start/2, lazy_compute/3, lazy_schedule/3]).
-export_type([bright/2]).

-opaque bright(MRH, MRI) :: {bright,
        MRH,
        MRI,
        list(gleam@dynamic:dynamic_()),
        list(gleam@dynamic:dynamic_())}.

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 21).
-spec init(MRJ, MRK) -> bright(MRJ, MRK).
init(Data, Computed) ->
    {bright, Data, Computed, [], []}.

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 60).
-spec update(
    {bright(MSA, MSB), lustre@effect:effect(MSE)},
    fun((MSA) -> {MSA, lustre@effect:effect(MSE)})
) -> {bright(MSA, MSB), lustre@effect:effect(MSE)}.
update(Bright, Update_) ->
    {Bright@1, Effects} = Bright,
    {Data, Effect} = Update_(erlang:element(2, Bright@1)),
    {erlang:setelement(2, Bright@1, Data),
        lustre@effect:batch([Effects, Effect])}.

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 83).
-spec compute(
    {bright(MSK, MSL), lustre@effect:effect(MSO)},
    fun((MSK, MSL) -> MSL)
) -> {bright(MSK, MSL), lustre@effect:effect(MSO)}.
compute(Bright, Compute_) ->
    gleam@pair:map_first(
        Bright,
        fun(Bright@1) ->
            _pipe = Compute_(
                erlang:element(2, Bright@1),
                erlang:element(3, Bright@1)
            ),
            (fun(Computed) -> erlang:setelement(3, Bright@1, Computed) end)(
                _pipe
            )
        end
    ).

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 109).
-spec schedule(
    {bright(MST, MSU), lustre@effect:effect(MSX)},
    fun((MST, MSU) -> lustre@effect:effect(MSX))
) -> {bright(MST, MSU), lustre@effect:effect(MSX)}.
schedule(Bright, Schedule_) ->
    {Bright@1, Effects} = Bright,
    Effect = Schedule_(erlang:element(2, Bright@1), erlang:element(3, Bright@1)),
    {Bright@1, lustre@effect:batch([Effects, Effect])}.

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 196).
-spec unwrap(bright(MTY, MTZ)) -> {MTY, MTZ}.
unwrap(Bright) ->
    {erlang:element(2, Bright), erlang:element(3, Bright)}.

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 210).
-spec data(bright(MUC, any())) -> MUC.
data(Bright) ->
    erlang:element(2, Bright).

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 224).
-spec computed(bright(any(), MUH)) -> MUH.
computed(Bright) ->
    erlang:element(3, Bright).

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 246).
-spec step(
    {bright(MUK, MUL), lustre@effect:effect(MUO)},
    fun((bright(MUK, MUL)) -> {MUS, lustre@effect:effect(MUO)})
) -> {MUS, lustre@effect:effect(MUO)}.
step(Bright, Next) ->
    {Bright@1, Effs} = Bright,
    {Model, Effs_} = Next(Bright@1),
    {Model, lustre@effect:batch([Effs, Effs_])}.

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 281).
-spec panic_if_different_computations_count(list(any()), list(any())) -> nil.
panic_if_different_computations_count(Old_computations, Computations) ->
    Count = erlang:length(Old_computations),
    gleam@bool:guard(
        Count =:= 0,
        nil,
        fun() ->
            Is_same_count = Count =:= erlang:length(Computations),
            gleam@bool:guard(
                Is_same_count,
                nil,
                fun() -> erlang:error(#{gleam_error => panic,
                            message => <<"Memoized computed should be consistent over time, otherwise memo can not work."/utf8>>,
                            module => <<"bright"/utf8>>,
                            function => <<"panic_if_different_computations_count"/utf8>>,
                            line => 289}) end
            )
        end
    ).

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 38).
-spec start(
    bright(MRM, MRN),
    fun(({bright(MRM, MRN), lustre@effect:effect(MRS)}) -> {bright(MRM, MRN),
        lustre@effect:effect(MRS)})
) -> {bright(MRM, MRN), lustre@effect:effect(MRS)}.
start(Bright, Next) ->
    Old_computations = erlang:element(5, Bright),
    gleam@pair:map_first(
        Next({Bright, lustre@effect:none()}),
        fun(New_data) ->
            panic_if_different_computations_count(
                Old_computations,
                erlang:element(4, New_data)
            ),
            Past_selections = lists:reverse(erlang:element(4, New_data)),
            erlang:setelement(
                4,
                erlang:setelement(5, New_data, Past_selections),
                []
            )
        end
    ).

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 296).
-spec are_dependencies_equal(any(), any()) -> boolean().
are_dependencies_equal(A, B) ->
    gleam_stdlib:identity(A) =:= gleam_stdlib:identity(B).

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 255).
-spec lazy_wrap(
    {bright(MUV, MUW), lustre@effect:effect(MUZ)},
    fun((MUV) -> MVB),
    fun(({bright(MUV, MUW), lustre@effect:effect(MUZ)}, fun((MUV, MUW) -> MVF)) -> {bright(MUV, MUW),
        lustre@effect:effect(MUZ)}),
    fun((MUV, MUW, MVB) -> MVF)
) -> {bright(MUV, MUW), lustre@effect:effect(MUZ)}.
lazy_wrap(Bright, Selector, Setter, Compute_) ->
    Selected_data = Selector(erlang:element(2, (erlang:element(1, Bright)))),
    Selections = [gleam_stdlib:identity(Selected_data) |
        erlang:element(4, (erlang:element(1, Bright)))],
    Compute_@1 = fun(Data, Computed) ->
        Compute_(Data, Computed, Selected_data)
    end,
    Bright@1 = {erlang:setelement(4, erlang:element(1, Bright), Selections),
        erlang:element(2, Bright)},
    case erlang:element(5, (erlang:element(1, Bright@1))) of
        [] ->
            Setter(Bright@1, Compute_@1);

        [Value | Past_selections] ->
            _pipe = {erlang:setelement(
                    5,
                    erlang:element(1, Bright@1),
                    Past_selections
                ),
                erlang:element(2, Bright@1)},
            case are_dependencies_equal(Value, Selected_data) of
                true ->
                    fun gleam@function:identity/1;

                false ->
                    fun(_capture) -> Setter(_capture, Compute_@1) end
            end(_pipe)
    end.

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 142).
-spec lazy_compute(
    {bright(MTD, MTE), lustre@effect:effect(MTH)},
    fun((MTD) -> MTJ),
    fun((MTD, MTE, MTJ) -> MTE)
) -> {bright(MTD, MTE), lustre@effect:effect(MTH)}.
lazy_compute(Bright, Selector, Compute_) ->
    lazy_wrap(Bright, Selector, fun compute/2, Compute_).

-file("/Users/doctor/Workspace/bright/src/bright.gleam", 178).
-spec lazy_schedule(
    {bright(MTN, MTO), lustre@effect:effect(MTR)},
    fun((MTN) -> MTT),
    fun((MTN, MTO, MTT) -> lustre@effect:effect(MTR))
) -> {bright(MTN, MTO), lustre@effect:effect(MTR)}.
lazy_schedule(Bright, Selector, Schedule_) ->
    lazy_wrap(Bright, Selector, fun schedule/2, Schedule_).