galchemy

-module(galchemy@orm@entity).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\orm\\entity.gleam").
-export([mark_deleted/1, mark_clean/1, relation_loaded/2, fields/1, status/1, materialize/2, new_/2, change/2, mark_relation_loaded/2, identity/1, stage/2]).
-export_type([entity_status/0, entity/0, entity_error/0]).

-type entity_status() :: clean |
    new |
    {dirty, list(galchemy@session@unit_of_work:field_value())} |
    deleted.

-type entity() :: {entity,
        galchemy@orm@metadata:model_metadata(),
        list(galchemy@session@unit_of_work:field_value()),
        list(binary()),
        entity_status()}.

-type entity_error() :: {unknown_column,
        galchemy@schema@relation:table_ref(),
        binary()} |
    {unknown_relation, galchemy@schema@relation:table_ref(), binary()} |
    {missing_identity_field, galchemy@schema@relation:table_ref(), binary()} |
    {deleted_entity, galchemy@schema@relation:table_ref()}.

-file("src\\galchemy\\orm\\entity.gleam", 99).
-spec mark_deleted(entity()) -> entity().
mark_deleted(Entity) ->
    {entity,
        erlang:element(2, Entity),
        erlang:element(3, Entity),
        erlang:element(4, Entity),
        deleted}.

-file("src\\galchemy\\orm\\entity.gleam", 103).
-spec mark_clean(entity()) -> entity().
mark_clean(Entity) ->
    {entity,
        erlang:element(2, Entity),
        erlang:element(3, Entity),
        erlang:element(4, Entity),
        clean}.

-file("src\\galchemy\\orm\\entity.gleam", 130).
-spec relation_loaded(entity(), binary()) -> boolean().
relation_loaded(Entity, Relation_name) ->
    gleam@list:contains(erlang:element(4, Entity), Relation_name).

-file("src\\galchemy\\orm\\entity.gleam", 177).
-spec fields(entity()) -> list(galchemy@session@unit_of_work:field_value()).
fields(Entity) ->
    erlang:element(3, Entity).

-file("src\\galchemy\\orm\\entity.gleam", 181).
-spec status(entity()) -> entity_status().
status(Entity) ->
    erlang:element(5, Entity).

-file("src\\galchemy\\orm\\entity.gleam", 185).
-spec validate_fields(
    galchemy@orm@metadata:model_metadata(),
    list(galchemy@session@unit_of_work:field_value())
) -> {ok, nil} | {error, entity_error()}.
validate_fields(Metadata, Fields) ->
    case Fields of
        [] ->
            {ok, nil};

        [Field_value | Rest] ->
            case galchemy@orm@metadata:has_column(
                Metadata,
                erlang:element(2, Field_value)
            ) of
                true ->
                    validate_fields(Metadata, Rest);

                false ->
                    {error,
                        {unknown_column,
                            erlang:element(2, Metadata),
                            erlang:element(2, Field_value)}}
            end
    end.

-file("src\\galchemy\\orm\\entity.gleam", 30).
-spec materialize(
    galchemy@orm@metadata:model_metadata(),
    list(galchemy@session@unit_of_work:field_value())
) -> {ok, entity()} | {error, entity_error()}.
materialize(Metadata, Fields) ->
    case validate_fields(Metadata, Fields) of
        {error, Error} ->
            {error, Error};

        {ok, _} ->
            {ok, {entity, Metadata, Fields, [], clean}}
    end.

-file("src\\galchemy\\orm\\entity.gleam", 46).
-spec new_(
    galchemy@orm@metadata:model_metadata(),
    list(galchemy@session@unit_of_work:field_value())
) -> {ok, entity()} | {error, entity_error()}.
new_(Metadata, Fields) ->
    case validate_fields(Metadata, Fields) of
        {error, Error} ->
            {error, Error};

        {ok, _} ->
            {ok, {entity, Metadata, Fields, [], new}}
    end.

-file("src\\galchemy\\orm\\entity.gleam", 213).
-spec upsert_field(
    list(galchemy@session@unit_of_work:field_value()),
    galchemy@session@unit_of_work:field_value()
) -> list(galchemy@session@unit_of_work:field_value()).
upsert_field(Fields, Next_field) ->
    case Fields of
        [] ->
            [Next_field];

        [Field_value | Rest] ->
            case erlang:element(2, Field_value) =:= erlang:element(
                2,
                Next_field
            ) of
                true ->
                    [Next_field | Rest];

                false ->
                    [Field_value | upsert_field(Rest, Next_field)]
            end
    end.

-file("src\\galchemy\\orm\\entity.gleam", 201).
-spec merge_fields(
    list(galchemy@session@unit_of_work:field_value()),
    list(galchemy@session@unit_of_work:field_value())
) -> list(galchemy@session@unit_of_work:field_value()).
merge_fields(Current, Changes) ->
    case Changes of
        [] ->
            Current;

        [Change | Rest] ->
            merge_fields(upsert_field(Current, Change), Rest)
    end.

-file("src\\galchemy\\orm\\entity.gleam", 62).
-spec change(entity(), list(galchemy@session@unit_of_work:field_value())) -> {ok,
        entity()} |
    {error, entity_error()}.
change(Entity, Changes) ->
    case validate_fields(erlang:element(2, Entity), Changes) of
        {error, Error} ->
            {error, Error};

        {ok, _} ->
            case erlang:element(5, Entity) of
                deleted ->
                    {error,
                        {deleted_entity,
                            erlang:element(2, erlang:element(2, Entity))}};

                new ->
                    {ok,
                        {entity,
                            erlang:element(2, Entity),
                            merge_fields(erlang:element(3, Entity), Changes),
                            erlang:element(4, Entity),
                            new}};

                clean ->
                    {ok,
                        {entity,
                            erlang:element(2, Entity),
                            merge_fields(erlang:element(3, Entity), Changes),
                            erlang:element(4, Entity),
                            {dirty, Changes}}};

                {dirty, Existing_changes} ->
                    {ok,
                        {entity,
                            erlang:element(2, Entity),
                            merge_fields(erlang:element(3, Entity), Changes),
                            erlang:element(4, Entity),
                            {dirty, merge_fields(Existing_changes, Changes)}}}
            end
    end.

-file("src\\galchemy\\orm\\entity.gleam", 228).
-spec append_unique(list(binary()), binary()) -> list(binary()).
append_unique(Items, Item) ->
    case gleam@list:contains(Items, Item) of
        true ->
            Items;

        false ->
            lists:append(Items, [Item])
    end.

-file("src\\galchemy\\orm\\entity.gleam", 107).
-spec mark_relation_loaded(entity(), binary()) -> {ok, entity()} |
    {error, entity_error()}.
mark_relation_loaded(Entity, Relation_name) ->
    case galchemy@orm@metadata:has_relation(
        erlang:element(2, Entity),
        Relation_name
    ) of
        false ->
            {error,
                {unknown_relation,
                    erlang:element(2, erlang:element(2, Entity)),
                    Relation_name}};

        true ->
            {ok,
                {entity,
                    erlang:element(2, Entity),
                    erlang:element(3, Entity),
                    append_unique(erlang:element(4, Entity), Relation_name),
                    erlang:element(5, Entity)}}
    end.

-file("src\\galchemy\\orm\\entity.gleam", 254).
-spec find_field(list(galchemy@session@unit_of_work:field_value()), binary()) -> gleam@option:option(galchemy@session@unit_of_work:field_value()).
find_field(Fields, Column_name) ->
    case Fields of
        [] ->
            none;

        [Field_value | Rest] ->
            case erlang:element(2, Field_value) =:= Column_name of
                true ->
                    {some, Field_value};

                false ->
                    find_field(Rest, Column_name)
            end
    end.

-file("src\\galchemy\\orm\\entity.gleam", 235).
-spec identity_fields(
    galchemy@orm@metadata:model_metadata(),
    list(galchemy@session@unit_of_work:field_value()),
    list(binary()),
    list(galchemy@session@unit_of_work:field_value())
) -> {ok, galchemy@session@unit_of_work:identity()} | {error, entity_error()}.
identity_fields(Metadata, Fields, Identity_columns, Acc) ->
    case Identity_columns of
        [] ->
            {ok, galchemy@session@unit_of_work:identity(lists:reverse(Acc))};

        [Column_name | Rest] ->
            case find_field(Fields, Column_name) of
                {some, Field_value} ->
                    identity_fields(Metadata, Fields, Rest, [Field_value | Acc]);

                none ->
                    {error,
                        {missing_identity_field,
                            erlang:element(2, Metadata),
                            Column_name}}
            end
    end.

-file("src\\galchemy\\orm\\entity.gleam", 134).
-spec identity(entity()) -> {ok, galchemy@session@unit_of_work:identity()} |
    {error, entity_error()}.
identity(Entity) ->
    identity_fields(
        erlang:element(2, Entity),
        erlang:element(3, Entity),
        erlang:element(3, erlang:element(2, Entity)),
        []
    ).

-file("src\\galchemy\\orm\\entity.gleam", 269).
-spec result_try(
    {ok, JMA} | {error, JMB},
    fun((JMA) -> {ok, JME} | {error, JMB})
) -> {ok, JME} | {error, JMB}.
result_try(Value, Next) ->
    case Value of
        {ok, Inner} ->
            Next(Inner);

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

-file("src\\galchemy\\orm\\entity.gleam", 143).
-spec stage(galchemy@session@unit_of_work:session(), entity()) -> {ok,
        galchemy@session@unit_of_work:session()} |
    {error, entity_error()}.
stage(Session, Entity) ->
    case erlang:element(5, Entity) of
        clean ->
            {ok, Session};

        new ->
            {ok,
                galchemy@session@unit_of_work:register_new(
                    Session,
                    erlang:element(2, erlang:element(2, Entity)),
                    erlang:element(3, Entity)
                )};

        {dirty, Changes} ->
            result_try(
                identity(Entity),
                fun(Next_identity) ->
                    {ok,
                        galchemy@session@unit_of_work:register_dirty(
                            Session,
                            erlang:element(2, erlang:element(2, Entity)),
                            Next_identity,
                            Changes
                        )}
                end
            );

        deleted ->
            result_try(
                identity(Entity),
                fun(Next_identity@1) ->
                    {ok,
                        galchemy@session@unit_of_work:register_deleted(
                            Session,
                            erlang:element(2, erlang:element(2, Entity)),
                            Next_identity@1
                        )}
                end
            )
    end.