-module(galchemy@schema@diff).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src\\galchemy\\schema\\diff.gleam").
-export([diff/2]).
-export_type([table_ref/0, schema_operation/0]).

-type table_ref() :: {table_ref, binary(), binary()}.

-type schema_operation() :: {create_table, galchemy@schema@model:table_schema()} |
    {drop_table, table_ref()} |
    {add_column, table_ref(), galchemy@schema@model:column_schema()} |
    {drop_column, table_ref(), binary()} |
    {alter_column,
        table_ref(),
        binary(),
        galchemy@schema@model:column_schema(),
        galchemy@schema@model:column_schema()} |
    {add_primary_key, table_ref(), galchemy@schema@model:primary_key()} |
    {drop_primary_key, table_ref(), binary()} |
    {add_unique_constraint,
        table_ref(),
        galchemy@schema@model:unique_constraint()} |
    {drop_unique_constraint, table_ref(), binary()} |
    {add_foreign_key, table_ref(), galchemy@schema@model:foreign_key()} |
    {drop_foreign_key, table_ref(), binary()} |
    {add_index, table_ref(), galchemy@schema@model:index_schema()} |
    {drop_index, table_ref(), binary()}.

-file("src\\galchemy\\schema\\diff.gleam", 247).
-spec diff_primary_key(
    gleam@option:option(galchemy@schema@model:primary_key()),
    gleam@option:option(galchemy@schema@model:primary_key()),
    table_ref()
) -> list(schema_operation()).
diff_primary_key(Current, Target, Ref) ->
    case {Current, Target} of
        {none, none} ->
            [];

        {{some, Current_primary_key}, none} ->
            [{drop_primary_key, Ref, erlang:element(2, Current_primary_key)}];

        {none, {some, _}} ->
            [];

        {{some, Current_primary_key@1}, {some, Target_primary_key}} ->
            case Current_primary_key@1 =:= Target_primary_key of
                true ->
                    [];

                false ->
                    [{drop_primary_key,
                            Ref,
                            erlang:element(2, Current_primary_key@1)}]
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 269).
-spec diff_primary_key_additions(
    gleam@option:option(galchemy@schema@model:primary_key()),
    gleam@option:option(galchemy@schema@model:primary_key()),
    table_ref()
) -> list(schema_operation()).
diff_primary_key_additions(Current, Target, Ref) ->
    case {Current, Target} of
        {none, none} ->
            [];

        {{some, _}, none} ->
            [];

        {none, {some, Target_primary_key}} ->
            [{add_primary_key, Ref, Target_primary_key}];

        {{some, Current_primary_key}, {some, Target_primary_key@1}} ->
            case Current_primary_key =:= Target_primary_key@1 of
                true ->
                    [];

                false ->
                    [{add_primary_key, Ref, Target_primary_key@1}]
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 473).
-spec find_table(list(galchemy@schema@model:table_schema()), binary(), binary()) -> gleam@option:option(galchemy@schema@model:table_schema()).
find_table(Tables, Schema_name, Table_name) ->
    case Tables of
        [] ->
            none;

        [Table | Rest] ->
            case (erlang:element(2, Table) =:= Schema_name) andalso (erlang:element(
                3,
                Table
            )
            =:= Table_name) of
                true ->
                    {some, Table};

                false ->
                    find_table(Rest, Schema_name, Table_name)
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 489).
-spec find_column(list(galchemy@schema@model:column_schema()), binary()) -> gleam@option:option(galchemy@schema@model:column_schema()).
find_column(Columns, Column_name) ->
    case Columns of
        [] ->
            none;

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

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

-file("src\\galchemy\\schema\\diff.gleam", 504).
-spec find_unique_constraint(
    list(galchemy@schema@model:unique_constraint()),
    binary()
) -> gleam@option:option(galchemy@schema@model:unique_constraint()).
find_unique_constraint(Constraints, Constraint_name) ->
    case Constraints of
        [] ->
            none;

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

                false ->
                    find_unique_constraint(Rest, Constraint_name)
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 519).
-spec find_foreign_key(list(galchemy@schema@model:foreign_key()), binary()) -> gleam@option:option(galchemy@schema@model:foreign_key()).
find_foreign_key(Foreign_keys, Foreign_key_name) ->
    case Foreign_keys of
        [] ->
            none;

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

                false ->
                    find_foreign_key(Rest, Foreign_key_name)
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 534).
-spec find_index(list(galchemy@schema@model:index_schema()), binary()) -> gleam@option:option(galchemy@schema@model:index_schema()).
find_index(Indexes, Index_name) ->
    case Indexes of
        [] ->
            none;

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

                false ->
                    find_index(Rest, Index_name)
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 549).
-spec table_ref(binary(), binary()) -> table_ref().
table_ref(Schema_name, Table_name) ->
    {table_ref, Schema_name, Table_name}.

-file("src\\galchemy\\schema\\diff.gleam", 557).
-spec reverse_loop(list(NWX), list(NWX)) -> list(NWX).
reverse_loop(Items, Acc) ->
    case Items of
        [] ->
            Acc;

        [Item | Rest] ->
            reverse_loop(Rest, [Item | Acc])
    end.

-file("src\\galchemy\\schema\\diff.gleam", 553).
-spec reverse(list(NWU)) -> list(NWU).
reverse(Items) ->
    reverse_loop(Items, []).

-file("src\\galchemy\\schema\\diff.gleam", 48).
-spec diff_removed_tables(
    list(galchemy@schema@model:table_schema()),
    list(galchemy@schema@model:table_schema()),
    list(schema_operation())
) -> list(schema_operation()).
diff_removed_tables(Current_tables, Target_tables, Acc) ->
    case Current_tables of
        [] ->
            reverse(Acc);

        [Table | Rest] ->
            case find_table(
                Target_tables,
                erlang:element(2, Table),
                erlang:element(3, Table)
            ) of
                {some, _} ->
                    diff_removed_tables(Rest, Target_tables, Acc);

                none ->
                    diff_removed_tables(
                        Rest,
                        Target_tables,
                        [{drop_table,
                                table_ref(
                                    erlang:element(2, Table),
                                    erlang:element(3, Table)
                                )} |
                            Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 68).
-spec diff_created_tables(
    list(galchemy@schema@model:table_schema()),
    list(galchemy@schema@model:table_schema()),
    list(schema_operation())
) -> list(schema_operation()).
diff_created_tables(Current_tables, Target_tables, Acc) ->
    case Target_tables of
        [] ->
            reverse(Acc);

        [Table | Rest] ->
            case find_table(
                Current_tables,
                erlang:element(2, Table),
                erlang:element(3, Table)
            ) of
                {some, _} ->
                    diff_created_tables(Current_tables, Rest, Acc);

                none ->
                    diff_created_tables(
                        Current_tables,
                        Rest,
                        [{create_table, Table} | Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 173).
-spec diff_removed_columns(
    table_ref(),
    list(galchemy@schema@model:column_schema()),
    list(galchemy@schema@model:column_schema()),
    list(schema_operation())
) -> list(schema_operation()).
diff_removed_columns(Ref, Current_columns, Target_columns, Acc) ->
    case Current_columns of
        [] ->
            reverse(Acc);

        [Column | Rest] ->
            case find_column(Target_columns, erlang:element(2, Column)) of
                {some, _} ->
                    diff_removed_columns(Ref, Rest, Target_columns, Acc);

                none ->
                    diff_removed_columns(
                        Ref,
                        Rest,
                        Target_columns,
                        [{drop_column, Ref, erlang:element(2, Column)} | Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 194).
-spec diff_changed_columns(
    table_ref(),
    list(galchemy@schema@model:column_schema()),
    list(galchemy@schema@model:column_schema()),
    list(schema_operation())
) -> list(schema_operation()).
diff_changed_columns(Ref, Current_columns, Target_columns, Acc) ->
    case Current_columns of
        [] ->
            reverse(Acc);

        [Column | Rest] ->
            case find_column(Target_columns, erlang:element(2, Column)) of
                none ->
                    diff_changed_columns(Ref, Rest, Target_columns, Acc);

                {some, Target_column} ->
                    Next_acc = case Column =:= Target_column of
                        true ->
                            Acc;

                        false ->
                            [{alter_column,
                                    Ref,
                                    erlang:element(2, Column),
                                    Column,
                                    Target_column} |
                                Acc]
                    end,
                    diff_changed_columns(Ref, Rest, Target_columns, Next_acc)
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 226).
-spec diff_added_columns(
    table_ref(),
    list(galchemy@schema@model:column_schema()),
    list(galchemy@schema@model:column_schema()),
    list(schema_operation())
) -> list(schema_operation()).
diff_added_columns(Ref, Current_columns, Target_columns, Acc) ->
    case Target_columns of
        [] ->
            reverse(Acc);

        [Column | Rest] ->
            case find_column(Current_columns, erlang:element(2, Column)) of
                {some, _} ->
                    diff_added_columns(Ref, Current_columns, Rest, Acc);

                none ->
                    diff_added_columns(
                        Ref,
                        Current_columns,
                        Rest,
                        [{add_column, Ref, Column} | Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 289).
-spec diff_removed_unique_constraints(
    table_ref(),
    list(galchemy@schema@model:unique_constraint()),
    list(galchemy@schema@model:unique_constraint()),
    list(schema_operation())
) -> list(schema_operation()).
diff_removed_unique_constraints(
    Ref,
    Current_constraints,
    Target_constraints,
    Acc
) ->
    case Current_constraints of
        [] ->
            reverse(Acc);

        [Constraint | Rest] ->
            case find_unique_constraint(
                Target_constraints,
                erlang:element(2, Constraint)
            ) of
                {some, Target_constraint} ->
                    Next_acc = case Constraint =:= Target_constraint of
                        true ->
                            Acc;

                        false ->
                            [{drop_unique_constraint,
                                    Ref,
                                    erlang:element(2, Constraint)} |
                                Acc]
                    end,
                    diff_removed_unique_constraints(
                        Ref,
                        Rest,
                        Target_constraints,
                        Next_acc
                    );

                none ->
                    diff_removed_unique_constraints(
                        Ref,
                        Rest,
                        Target_constraints,
                        [{drop_unique_constraint,
                                Ref,
                                erlang:element(2, Constraint)} |
                            Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 324).
-spec diff_added_unique_constraints(
    table_ref(),
    list(galchemy@schema@model:unique_constraint()),
    list(galchemy@schema@model:unique_constraint()),
    list(schema_operation())
) -> list(schema_operation()).
diff_added_unique_constraints(Ref, Current_constraints, Target_constraints, Acc) ->
    case Target_constraints of
        [] ->
            reverse(Acc);

        [Constraint | Rest] ->
            case find_unique_constraint(
                Current_constraints,
                erlang:element(2, Constraint)
            ) of
                {some, Current_constraint} ->
                    Next_acc = case Current_constraint =:= Constraint of
                        true ->
                            Acc;

                        false ->
                            [{add_unique_constraint, Ref, Constraint} | Acc]
                    end,
                    diff_added_unique_constraints(
                        Ref,
                        Current_constraints,
                        Rest,
                        Next_acc
                    );

                none ->
                    diff_added_unique_constraints(
                        Ref,
                        Current_constraints,
                        Rest,
                        [{add_unique_constraint, Ref, Constraint} | Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 359).
-spec diff_removed_foreign_keys(
    table_ref(),
    list(galchemy@schema@model:foreign_key()),
    list(galchemy@schema@model:foreign_key()),
    list(schema_operation())
) -> list(schema_operation()).
diff_removed_foreign_keys(Ref, Current_foreign_keys, Target_foreign_keys, Acc) ->
    case Current_foreign_keys of
        [] ->
            reverse(Acc);

        [Foreign_key | Rest] ->
            case find_foreign_key(
                Target_foreign_keys,
                erlang:element(2, Foreign_key)
            ) of
                {some, Target_foreign_key} ->
                    Next_acc = case Foreign_key =:= Target_foreign_key of
                        true ->
                            Acc;

                        false ->
                            [{drop_foreign_key,
                                    Ref,
                                    erlang:element(2, Foreign_key)} |
                                Acc]
                    end,
                    diff_removed_foreign_keys(
                        Ref,
                        Rest,
                        Target_foreign_keys,
                        Next_acc
                    );

                none ->
                    diff_removed_foreign_keys(
                        Ref,
                        Rest,
                        Target_foreign_keys,
                        [{drop_foreign_key, Ref, erlang:element(2, Foreign_key)} |
                            Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 389).
-spec diff_added_foreign_keys(
    table_ref(),
    list(galchemy@schema@model:foreign_key()),
    list(galchemy@schema@model:foreign_key()),
    list(schema_operation())
) -> list(schema_operation()).
diff_added_foreign_keys(Ref, Current_foreign_keys, Target_foreign_keys, Acc) ->
    case Target_foreign_keys of
        [] ->
            reverse(Acc);

        [Foreign_key | Rest] ->
            case find_foreign_key(
                Current_foreign_keys,
                erlang:element(2, Foreign_key)
            ) of
                {some, Current_foreign_key} ->
                    Next_acc = case Current_foreign_key =:= Foreign_key of
                        true ->
                            Acc;

                        false ->
                            [{add_foreign_key, Ref, Foreign_key} | Acc]
                    end,
                    diff_added_foreign_keys(
                        Ref,
                        Current_foreign_keys,
                        Rest,
                        Next_acc
                    );

                none ->
                    diff_added_foreign_keys(
                        Ref,
                        Current_foreign_keys,
                        Rest,
                        [{add_foreign_key, Ref, Foreign_key} | Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 419).
-spec diff_removed_indexes(
    table_ref(),
    list(galchemy@schema@model:index_schema()),
    list(galchemy@schema@model:index_schema()),
    list(schema_operation())
) -> list(schema_operation()).
diff_removed_indexes(Ref, Current_indexes, Target_indexes, Acc) ->
    case Current_indexes of
        [] ->
            reverse(Acc);

        [Index | Rest] ->
            case find_index(Target_indexes, erlang:element(2, Index)) of
                {some, Target_index} ->
                    Next_acc = case Index =:= Target_index of
                        true ->
                            Acc;

                        false ->
                            [{drop_index, Ref, erlang:element(2, Index)} | Acc]
                    end,
                    diff_removed_indexes(Ref, Rest, Target_indexes, Next_acc);

                none ->
                    diff_removed_indexes(
                        Ref,
                        Rest,
                        Target_indexes,
                        [{drop_index, Ref, erlang:element(2, Index)} | Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 446).
-spec diff_added_indexes(
    table_ref(),
    list(galchemy@schema@model:index_schema()),
    list(galchemy@schema@model:index_schema()),
    list(schema_operation())
) -> list(schema_operation()).
diff_added_indexes(Ref, Current_indexes, Target_indexes, Acc) ->
    case Target_indexes of
        [] ->
            reverse(Acc);

        [Index | Rest] ->
            case find_index(Current_indexes, erlang:element(2, Index)) of
                {some, Current_index} ->
                    Next_acc = case Current_index =:= Index of
                        true ->
                            Acc;

                        false ->
                            [{add_index, Ref, Index} | Acc]
                    end,
                    diff_added_indexes(Ref, Current_indexes, Rest, Next_acc);

                none ->
                    diff_added_indexes(
                        Ref,
                        Current_indexes,
                        Rest,
                        [{add_index, Ref, Index} | Acc]
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 108).
-spec diff_table(
    galchemy@schema@model:table_schema(),
    galchemy@schema@model:table_schema()
) -> list(schema_operation()).
diff_table(Current, Target) ->
    Ref = table_ref(erlang:element(2, Current), erlang:element(3, Current)),
    Drop_constraint_operations = lists:append(
        lists:append(
            diff_removed_foreign_keys(
                Ref,
                erlang:element(7, Current),
                erlang:element(7, Target),
                []
            ),
            diff_removed_unique_constraints(
                Ref,
                erlang:element(6, Current),
                erlang:element(6, Target),
                []
            )
        ),
        lists:append(
            diff_removed_indexes(
                Ref,
                erlang:element(8, Current),
                erlang:element(8, Target),
                []
            ),
            diff_primary_key(
                erlang:element(5, Current),
                erlang:element(5, Target),
                Ref
            )
        )
    ),
    Column_operations = lists:append(
        lists:append(
            diff_removed_columns(
                Ref,
                erlang:element(4, Current),
                erlang:element(4, Target),
                []
            ),
            diff_changed_columns(
                Ref,
                erlang:element(4, Current),
                erlang:element(4, Target),
                []
            )
        ),
        diff_added_columns(
            Ref,
            erlang:element(4, Current),
            erlang:element(4, Target),
            []
        )
    ),
    Add_constraint_operations = lists:append(
        lists:append(
            diff_primary_key_additions(
                erlang:element(5, Current),
                erlang:element(5, Target),
                Ref
            ),
            diff_added_unique_constraints(
                Ref,
                erlang:element(6, Current),
                erlang:element(6, Target),
                []
            )
        ),
        lists:append(
            diff_added_foreign_keys(
                Ref,
                erlang:element(7, Current),
                erlang:element(7, Target),
                []
            ),
            diff_added_indexes(
                Ref,
                erlang:element(8, Current),
                erlang:element(8, Target),
                []
            )
        )
    ),
    lists:append(
        lists:append(Drop_constraint_operations, Column_operations),
        Add_constraint_operations
    ).

-file("src\\galchemy\\schema\\diff.gleam", 85).
-spec diff_existing_tables(
    list(galchemy@schema@model:table_schema()),
    list(galchemy@schema@model:table_schema()),
    list(schema_operation())
) -> list(schema_operation()).
diff_existing_tables(Current_tables, Target_tables, Acc) ->
    case Current_tables of
        [] ->
            Acc;

        [Current_table | Rest] ->
            case find_table(
                Target_tables,
                erlang:element(2, Current_table),
                erlang:element(3, Current_table)
            ) of
                none ->
                    diff_existing_tables(Rest, Target_tables, Acc);

                {some, Target_table} ->
                    Table_operations = diff_table(Current_table, Target_table),
                    diff_existing_tables(
                        Rest,
                        Target_tables,
                        lists:append(Acc, Table_operations)
                    )
            end
    end.

-file("src\\galchemy\\schema\\diff.gleam", 30).
-spec diff(
    galchemy@schema@model:schema_snapshot(),
    galchemy@schema@model:schema_snapshot()
) -> list(schema_operation()).
diff(Current, Target) ->
    {schema_snapshot, Current_tables} = Current,
    {schema_snapshot, Target_tables} = Target,
    Drop_operations = diff_removed_tables(Current_tables, Target_tables, []),
    Change_operations = diff_existing_tables(Current_tables, Target_tables, []),
    Create_operations = diff_created_tables(Current_tables, Target_tables, []),
    lists:append(
        lists:append(Drop_operations, Change_operations),
        Create_operations
    ).