-module(galchemy@session@cascade).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\session\\cascade.gleam").
-export([rule/2, persist_rule/1, delete_rule/1, related/2, node/2, delete/3, stage/3]).
-export_type([cascade_action/0, cascade_rule/0, cascade_relation/0, cascade_node/0, cascade_error/0]).

-type cascade_action() :: persist | delete.

-type cascade_rule() :: {cascade_rule, binary(), list(cascade_action())}.

-type cascade_relation() :: {cascade_relation, binary(), list(cascade_node())}.

-type cascade_node() :: {cascade_node,
        galchemy@orm@entity:entity(),
        list(cascade_relation())}.

-type cascade_error() :: {runtime_error, galchemy@session@runtime:track_error()} |
    {unknown_relation, galchemy@schema@relation:table_ref(), binary()}.

-file("src\\galchemy\\session\\cascade.gleam", 29).
-spec rule(binary(), list(cascade_action())) -> cascade_rule().
rule(Relation_name, Actions) ->
    {cascade_rule, Relation_name, Actions}.

-file("src\\galchemy\\session\\cascade.gleam", 33).
-spec persist_rule(binary()) -> cascade_rule().
persist_rule(Relation_name) ->
    rule(Relation_name, [persist]).

-file("src\\galchemy\\session\\cascade.gleam", 37).
-spec delete_rule(binary()) -> cascade_rule().
delete_rule(Relation_name) ->
    rule(Relation_name, [delete]).

-file("src\\galchemy\\session\\cascade.gleam", 41).
-spec related(binary(), list(cascade_node())) -> cascade_relation().
related(Name, Children) ->
    {cascade_relation, Name, Children}.

-file("src\\galchemy\\session\\cascade.gleam", 45).
-spec node(galchemy@orm@entity:entity(), list(cascade_relation())) -> cascade_node().
node(Next_entity, Relations) ->
    {cascade_node, Next_entity, Relations}.

-file("src\\galchemy\\session\\cascade.gleam", 152).
-spec relation_metadata(galchemy@orm@metadata:model_metadata(), binary()) -> {ok,
        galchemy@schema@relation:relation()} |
    {error, cascade_error()}.
relation_metadata(Next_metadata, Relation_name) ->
    case galchemy@orm@metadata:relation_named(Next_metadata, Relation_name) of
        {some, Next_relation} ->
            {ok, Next_relation};

        none ->
            {error,
                {unknown_relation,
                    erlang:element(2, Next_metadata),
                    Relation_name}}
    end.

-file("src\\galchemy\\session\\cascade.gleam", 182).
-spec contains_action(list(cascade_action()), cascade_action()) -> boolean().
contains_action(Actions, Target) ->
    case Actions of
        [] ->
            false;

        [Next_action | Rest] ->
            case Next_action =:= Target of
                true ->
                    true;

                false ->
                    contains_action(Rest, Target)
            end
    end.

-file("src\\galchemy\\session\\cascade.gleam", 166).
-spec allows_action(list(cascade_rule()), binary(), cascade_action()) -> boolean().
allows_action(Rules, Relation_name, Action) ->
    case Rules of
        [] ->
            false;

        [Next_rule | Rest] ->
            case erlang:element(2, Next_rule) =:= Relation_name of
                true ->
                    contains_action(erlang:element(3, Next_rule), Action);

                false ->
                    allows_action(Rest, Relation_name, Action)
            end
    end.

-file("src\\galchemy\\session\\cascade.gleam", 194).
-spec map_runtime_error(
    {ok, galchemy@session@runtime:session()} |
        {error, galchemy@session@runtime:track_error()}
) -> {ok, galchemy@session@runtime:session()} | {error, cascade_error()}.
map_runtime_error(Value) ->
    case Value of
        {ok, Inner} ->
            {ok, Inner};

        {error, Error} ->
            {error, {runtime_error, Error}}
    end.

-file("src\\galchemy\\session\\cascade.gleam", 130).
-spec persist_entity(
    galchemy@session@runtime:session(),
    galchemy@orm@entity:entity()
) -> {ok, galchemy@session@runtime:session()} | {error, cascade_error()}.
persist_entity(Session, Next_entity) ->
    case galchemy@orm@entity:status(Next_entity) of
        clean ->
            _pipe = galchemy@session@runtime:attach(Session, Next_entity),
            map_runtime_error(_pipe);

        _ ->
            _pipe@1 = galchemy@session@runtime:stage(Session, Next_entity),
            map_runtime_error(_pipe@1)
    end.

-file("src\\galchemy\\session\\cascade.gleam", 144).
-spec delete_entity(
    galchemy@session@runtime:session(),
    galchemy@orm@entity:entity()
) -> {ok, galchemy@session@runtime:session()} | {error, cascade_error()}.
delete_entity(Session, Next_entity) ->
    _pipe = galchemy@session@runtime:stage(
        Session,
        galchemy@orm@entity:mark_deleted(Next_entity)
    ),
    map_runtime_error(_pipe).

-file("src\\galchemy\\session\\cascade.gleam", 203).
-spec result_try(
    {ok, PIA} | {error, PIB},
    fun((PIA) -> {ok, PIE} | {error, PIB})
) -> {ok, PIE} | {error, PIB}.
result_try(Value, Next) ->
    case Value of
        {ok, Inner} ->
            Next(Inner);

        {error, Error} ->
            {error, Error}
    end.

-file("src\\galchemy\\session\\cascade.gleam", 118).
-spec cascade_child(
    galchemy@session@runtime:session(),
    cascade_node(),
    list(cascade_rule()),
    cascade_action()
) -> {ok, galchemy@session@runtime:session()} | {error, cascade_error()}.
cascade_child(Session, Child, Rules, Action) ->
    case Action of
        persist ->
            stage(Session, Child, Rules);

        delete ->
            delete(Session, Child, Rules)
    end.

-file("src\\galchemy\\session\\cascade.gleam", 61).
-spec delete(
    galchemy@session@runtime:session(),
    cascade_node(),
    list(cascade_rule())
) -> {ok, galchemy@session@runtime:session()} | {error, cascade_error()}.
delete(Session, Root, Rules) ->
    result_try(
        delete_entity(Session, erlang:element(2, Root)),
        fun(Next_session) ->
            cascade_relations(
                Next_session,
                erlang:element(2, Root),
                erlang:element(3, Root),
                Rules,
                delete
            )
        end
    ).

-file("src\\galchemy\\session\\cascade.gleam", 70).
-spec cascade_relations(
    galchemy@session@runtime:session(),
    galchemy@orm@entity:entity(),
    list(cascade_relation()),
    list(cascade_rule()),
    cascade_action()
) -> {ok, galchemy@session@runtime:session()} | {error, cascade_error()}.
cascade_relations(Session, Parent, Relations, Rules, Action) ->
    case Relations of
        [] ->
            {ok, Session};

        [Next_relation | Rest] ->
            result_try(
                relation_metadata(
                    erlang:element(2, Parent),
                    erlang:element(2, Next_relation)
                ),
                fun(Metadata_relation) ->
                    Next_session = case allows_action(
                        Rules,
                        erlang:element(2, Metadata_relation),
                        Action
                    ) of
                        true ->
                            cascade_children(
                                Session,
                                erlang:element(3, Next_relation),
                                Rules,
                                Action
                            );

                        false ->
                            {ok, Session}
                    end,
                    result_try(
                        Next_session,
                        fun(Updated_session) ->
                            cascade_relations(
                                Updated_session,
                                Parent,
                                Rest,
                                Rules,
                                Action
                            )
                        end
                    )
                end
            )
    end.

-file("src\\galchemy\\session\\cascade.gleam", 98).
-spec cascade_children(
    galchemy@session@runtime:session(),
    list(cascade_node()),
    list(cascade_rule()),
    cascade_action()
) -> {ok, galchemy@session@runtime:session()} | {error, cascade_error()}.
cascade_children(Session, Children, Rules, Action) ->
    case Children of
        [] ->
            {ok, Session};

        [Child | Rest] ->
            result_try(
                cascade_child(Session, Child, Rules, Action),
                fun(Updated_session) ->
                    cascade_children(Updated_session, Rest, Rules, Action)
                end
            )
    end.

-file("src\\galchemy\\session\\cascade.gleam", 52).
-spec stage(
    galchemy@session@runtime:session(),
    cascade_node(),
    list(cascade_rule())
) -> {ok, galchemy@session@runtime:session()} | {error, cascade_error()}.
stage(Session, Root, Rules) ->
    result_try(
        persist_entity(Session, erlang:element(2, Root)),
        fun(Next_session) ->
            cascade_relations(
                Next_session,
                erlang:element(2, Root),
                erlang:element(3, Root),
                Rules,
                persist
            )
        end
    ).