Yep
The task is to find duplicate entries and delete everything and spare the most optimal one

defmodule Mix.Tasks.App.CleanUpDuplicateAccounts do
  use Mix.Task

  import Ecto.Query, only: [where: 3, from: 2]

  alias App.Data.{....
  }

  require Logger

  def run(_args) do
    Logger.info("Starting task to clean up duplicate accounts...")

    {:ok, _} = Application.ensure_all_started(:data)

    query =
      from(u in User,
        where:
          fragment(
            "exists (
                select 1
                from users inner
                where inner.id != ?
                and lower(inner.email) = lower(?)
              )",
            u.id,
            u.email
          ),
        order_by: u.email
      )

    query
    |> Repo.all()
    |> Enum.group_by(&String.downcase(&1.email))
    |> Enum.each(fn {_k, duplicates} ->
      comparing_statuses(duplicates)
    end)
  end

  defp get_tasks_for_users(id) do
        # Logic return tasks
  end

  defp check_and_remove_account(user) do
    if !user.is_email_verified ||
         is_nil(user.encrypted_password) do
      tasks = get_tasks_for_user(user.id)

      case tasks do
        [] ->
          Logger.info("Deleting user: id #{user.id} with email #{user.email}")
          Users.delete(user)

        _ ->
          Logger.info("Unable to delete - user: id #{user.id} has active tasks")
      end
    end
  end

  defp mass_deletion_check(duplicates) do
    are_all_duplicates_not_verified =
      Enum.all?(duplicates, &(!&1.is_email_verified || is_nil(&1.encrypted_password)))

    if are_all_duplicates_not_verified do
      [_ | duplicates_to_delete] = duplicates

      Enum.each(
        duplicates_to_delete,
        fn index ->
          check_and_remove_account(index)
        end
      )
    else
      Enum.each(duplicates, fn index ->
        if !index.is_email_verified or is_nil(index.encrypted_password) do
          check_and_remove_account(index)
        else
          Logger.info(
            "Not deleting - user: id #{index.id} has email is verified or password is set"
          )
        end
      end)
    end
  end

  defp get_handle_for_user(id) do
        # logic to return handles
  end

  # If handles are the same then start mass_deletion_check for the duplicates
  # If handles are different then delete email from accounts except one
  defp handle_or_email_deletion_check(duplicates) do
    duplicates_with_handle =
      duplicates
      |> Enum.reduce([], fn user, acc ->
        acc ++ [Map.put(user, :handle, get_handle_for_user(user.id))]
      end)

    handle_group = Enum.group_by(duplicates_with_handle, & &1.handle)

    if Enum.count(handle_group) < 2 do
      mass_deletion_check(duplicates)
    else
      [_ | handle_group_to_delete_email] = Enum.to_list(handle_group)

      Enum.each(handle_group_to_delete_email, fn {_k, duplicates} ->
        remove_email_except_one(duplicates)
      end)
    end
  end

  defp remove_email_except_one(duplicates) do
    Enum.each(duplicates, fn user ->
      Users.update(user, %{email: nil})
    end)
  end

  defp count_with_status(duplicates, status) when not is_list(status) do
    count_with_status(duplicates, [status])
  end

  defp count_with_status(duplicates, status) do
    Enum.count(
      duplicates,
      &(&1.user_status_id in UserStatuses.get_id_by_code(status))
    )
  end

  defp accumulating(duplicates, status) do
    duplicates
    |> Enum.reduce([], fn user, acc ->
      if user.user_status_id in UserStatuses.get_id_by_code(status) do
        acc ++ [user]
      else
        check_and_remove_account(user)
        acc
      end
    end)
  end

  defp accumulating_accounts_with_required_status(duplicates, status)
       when status == "approval_requested" do
    duplicates_account_with_approval_requested = accumulating(duplicates, [status])

    delete_all_and_update_first_one(duplicates_account_with_approval_requested)
  end

  defp accumulating_accounts_with_required_status(duplicates, status) when not is_list(status) do
    duplicates_to_delete = accumulating(duplicates, [status])

    mass_deletion_check(duplicates_to_delete)
  end

  defp accumulating_accounts_with_required_status(duplicates, status) do
    duplicates_to_delete = accumulating(duplicates, status)

    mass_deletion_check(duplicates_to_delete)
  end

  defp iterate_and_remove(duplicates, status)
       when not is_list(status) do
    iterate_and_remove(duplicates, [status])
  end

  defp iterate_and_remove(duplicates, status) do
    Enum.each(duplicates, fn user ->
      if user.user_status_id not in UserStatuses.get_id_by_code(status) do
        check_and_remove_account(user)
      end
    end)
  end

  defp iterate_and_update(duplicates, status) do
    Enum.each(duplicates, fn user ->
      if user.user_status_id ==
           UserStatuses.get_id_by_code(status) do
        Users.update(user, %{email: nil})
      end
    end)
  end

  defp iterate_and_update(duplicates, status_one, status_two) do
    Enum.each(duplicates, fn user ->
      if user.user_status_id !==
           UserStatuses.get_id_by_code(status_one) do
        check_and_remove_account(user)
      else
        Users.update(user, %{
          user_status_id: UserStatuses.get_id_by_code(status_two)
        })
      end
    end)
  end

  defp deleting_with_approached_and_approved_case(duplicates) do
    duplicates_approved_and_approached =
      Enum.reduce(duplicates, [], fn user, acc ->
        if user.user_status_id !== UserStatuses.get_id_by_code("approved") and
             user.user_status_id !==
               UserStatuses.get_id_by_code("approached") do
          check_and_remove_account(user)
          acc
        else
          acc ++ [user]
        end
      end)

    handle_from_approved =
      get_handle_for_user(Enum.at(duplicates_approved_and_approached, 0).id)

    handle_from_approached =
      get_handle_for_user(Enum.at(duplicates_approved_and_approached, 1).id)

    case {handle_from_approved, handle_from_approached} do
      {handle_from_approved, handle_from_approached}
      when handle_from_approved == handle_from_approached and not is_nil(handle_from_approved) and
             not is_nil(handle_from_approached) ->
        iterate_and_remove(
          duplicates_approved_and_approached,
          "approached"
        )

      _ ->
        iterate_and_update(
          duplicates_approved_and_approached,
          "approached"
        )
    end
  end

  defp delete_all_and_update_first_one(duplicates) do
    [user_to_update | duplicates_to_delete] = duplicates
    Enum.each(duplicates_to_delete, fn user -> check_and_remove_account(user) end)

    Users.update(user_to_update, %{
      user_status_id: UserStatuses.get_id_by_code("approved")
    })
  end

  defp count_duplicates_statuses(duplicates) do
    approved_count = count_with_status(duplicates, "approved")

    invalid_count =
      count_with_status(duplicates, [
        "invalid",
        "under_investigation",
        "suspended"
      ])

    approached_count = count_with_status(duplicates, "approached")

    rejected_count = count_with_status(duplicates, "rejected")

    external_count = count_with_status(duplicates, "external")

    approval_requested_count = count_with_status(duplicates, "approval_requested")

    {approved_count, invalid_count, approached_count, rejected_count, external_count,
     approval_requested_count}
  end

  defp comparing_statuses(duplicates) do
    statuses = count_duplicates_statuses(duplicates)
    handle_statuses(statuses, duplicates)
  end

  defp handle_statuses({1, _, 0, _, _, _}, duplicates) do
    iterate_and_remove(duplicates, "approved")
  end

  defp handle_statuses({1, _, 1, _, _, _}, duplicates) do
    deleting_with_approached_and_approved_case(duplicates)
  end

  defp handle_statuses(
         {approved_count, _, 0, _, _, _},
         duplicates
       )
       when approved_count >= 2 do
    accumulating_accounts_with_required_status(duplicates, "approved")
  end

  defp handle_statuses({0, 1, _, _, _, _}, duplicates) do
    iterate_and_remove(duplicates, [
      "invalid",
      "under_investigation",
      "suspended"
    ])
  end

  defp handle_statuses({0, invalid_count, _, _, _, _}, duplicates) when invalid_count >= 2 do
    accumulating_accounts_with_required_status(duplicates, [
      "invalid",
      "under_investigation",
      "suspended"
    ])
  end

  defp handle_statuses({0, 0, 1, _, _, 0}, duplicates) do
    iterate_and_remove(duplicates, "approached")
  end

  defp handle_statuses({0, 0, 1, _, _, 1}, duplicates) do
    iterate_and_update(
      duplicates,
      "approval_requested",
      "approved"
    )
  end

  defp handle_statuses({0, 0, approached_count, _, _, approval_requested_count}, duplicates)
       when approached_count >= 2 and approval_requested_count >= 2 do
    accumulating_accounts_with_required_status(duplicates, "approval_requested")
  end

  defp handle_statuses({0, 0, approached_count, _, _, 0}, duplicates)
       when approached_count >= 2 do
    iterate_and_remove(duplicates, "approached")

    handle_or_email_deletion_check(duplicates)
  end

  defp handle_statuses({0, 0, 0, 1, _, _}, duplicates) do
    iterate_and_remove(duplicates, "rejected")
  end

  defp handle_statuses({0, 0, 0, rejected_count, _, _}, duplicates) when rejected_count >= 2 do
    accumulating_accounts_with_required_status(duplicates, "rejected")
  end

  defp handle_statuses({0, 0, 0, 0, 1, _}, duplicates) do
    iterate_and_remove(duplicates, "external")
  end

  defp handle_statuses({0, 0, 0, 0, external_count, _}, duplicates) when external_count >= 2 do
    accumulating_accounts_with_required_status(duplicates, "external")
  end

  defp handle_statuses({0, 0, 0, 0, 0, approval_requested_count}, duplicates)
       when approval_requested_count >= 2 do
    mass_deletion_check(duplicates)
  end
end