def change_user_profile(user, attrs \\ %{}) do

    User.profile_changeset(user, attrs)

  end

  def update_user_profile(user, attrs) do

    user

    |> User.profile_changeset(attrs)

    |> Repo.update()

  end

    Repo.one(query) |> Repo.preload(:profile_image)

  alias MyApp.Storage.Object

    field :name, :string

    belongs_to :profile_image, MyApp.Storage.Object, on_replace: :nilify

  @doc """

  A user changeset for changing profile information.

  """

  def profile_changeset(user, attrs) do

    user

    |> cast(attrs, [:name])

    |> validate_length(:name, max: 50)

  end

  @doc """

  Updates a user `:profile_image` assoc, marking the previous object as deleted if

  there was one.

  """

  def update_profile_image_multi(multi, user) do

    multi

    |> Ecto.Multi.run(:user_preload, fn repo, _multi ->

      {:ok, repo.preload(user, :profile_image)}

    end)

    |> Ecto.Multi.update(:user_updated, fn %{user_preload: user, object: object} ->

      put_assoc(change(user), :profile_image, object)

    end)

    |> Ecto.Multi.merge(fn %{user_preload: user} ->

      if user.profile_image do

        Object.delete_multi(Ecto.Multi.new(), user.profile_image)

      else

        Ecto.Multi.new()

      end

    end)

  end

  @doc """

  Creates an object given an `upload` typle and performs a direct upload.

  """

  def direct_upload({_entry, _meta} = upload, opts) do

    Ecto.Multi.new()

    |> Object.insert_from_upload_multi(upload, normalize_filename: true)

    |> Object.insert_assocs_multi(opts, [:user_profile_image])

    |> Ecto.Multi.run(:upload, fn _repo, %{object: object} ->

      Buckets.put(Buckets.Upload.new(upload), object, bucket_config())

    end)

    |> Repo.transaction()

  end

defmodule MyApp.Storage.ImageTools do

  alias Phoenix.LiveView, as: LV

  @doc """

  Resizes the file in an `UploadEntry`, provided some metadata and dimensions for resizing.

  Assumes the file is an image that can be resized by FFmpeg.

  Returns a modified `UploadEntry` with the new file information.

  """

  def resize_upload_as_png({%LV.UploadEntry{} = entry, %{path: path} = _meta}, dimensions) do

    resized_path = resize_as_png(path, dimensions)

    entry = %{

      entry

      | client_name: "image.png",

        client_type: "image/png",

        client_size: File.stat!(resized_path).size

    }

    {entry, %{path: resized_path}}

  end

  @doc """

  Resizes an image at `path` with FFmpeg to the dimensions specified by a tuple of `{width, height}`.

  Returns the path of the resized png image.

  """

  def resize_as_png(path, {w, h}) do

    output_path = Path.join(Path.dirname(path), "resized_#{:os.system_time()}.png")

    filter_part =

      ~s|crop=min(iw\\,ih):min(iw\\,ih):(iw-min(iw\\,ih))/2:(ih-min(iw\\,ih))/2,scale=#{w}:#{h}|

    {_out, 0} =

      System.cmd("ffmpeg", ["-i", path, "-vf", filter_part, "-loglevel", "quiet", output_path])

    output_path

  end

end

  alias MyApp.Accounts

  def insert_from_upload_multi(multi, {_entry, meta} = upload, opts \\ []) do

    config = Storage.bucket_config()

    filename =

      if opts[:normalize_filename] do

        normalize_file_name(upload.filename)

      else

        upload.filename

      end

    path =

      case meta do

        %{url: %Buckets.SignedURL{} = url} -> url.path

        _otherwise -> Buckets.Util.build_object_path(filename, upload.uuid, config)

      end

      filename: filename,

      path: path,

        {:user_profile_image, user} ->

          Accounts.User.update_profile_image_multi(multi, user)

  @doc """

  Marks an object as deleted.

  """

  def delete_multi(multi, object) do

    Ecto.Multi.update(multi, :delete_object, delete_changeset(object))

  end

  attr :id, :string, required: true

  attr :upload, Phoenix.LiveView.UploadConfig, required: true

  slot :preview, required: true

  slot :inner_block, required: true

  def profile_image_upload(assigns) do

    ~H"""

    <div>

      <div class="size-24 rounded-lg overflow-hidden">

        <label id={@id} for={@upload.ref} class="relative">

          <%= case @upload.entries do %>

            <% [] -> %>

              <%= render_slot(@inner_block) %>

            <% [entry] -> %>

              <%= render_slot(@preview, entry) %>

          <% end %>

          <div class="absolute right-0 bottom-0 size-5 bg-zinc-100 rounded-tl flex items-center justify-center">

            <.icon name="hero-pencil-square-mini" class="size-3 text-zinc-900" />

          </div>

          <.live_file_input upload={@upload} class="sr-only" />

        </label>

      </div>

      <%= if entry = List.first(@upload.entries) do %>

        <p :for={error <- upload_errors(@upload, entry)} class="mt-2 text-sm text-rose-600">

          <%= error_for(error) %>

        </p>

      <% end %>

    </div>

    """

  end

  require Size

  alias MyApp.Storage

  import MyAppWeb.StorageLive.Components

  import MyAppWeb.UserSettingsLive.Components

      <div>

        <.simple_form for={@profile_form} phx-submit="update_profile" phx-change="validate_profile">

          <.profile_image_upload id="profile_image_upload" upload={@uploads.profile}>

            <.user_profile user={@current_user} size={:lg} />

            <:preview :let={entry}>

              <.live_img_preview entry={entry} class="size-24 rounded-lg object-cover" />

            </:preview>

          </.profile_image_upload>

          <.input field={@profile_form[:name]} label="Name" />

          <:actions>

            <.button phx-disable-with="Updating...">Update Profile</.button>

          </:actions>

        </.simple_form>

      </div>

    profile_changeset = Accounts.change_user_profile(user)

      |> assign(:profile_form, to_form(profile_changeset))

      |> allow_upload(:profile,

        accept: ~w(.png .jpg .jpeg),

        max_file_size: Size.megabytes(10)

      )

  def handle_event("validate_profile", params, socket) do

    %{"user" => user_params} = params

    profile_form =

      socket.assigns.current_user

      |> Accounts.change_user_profile(user_params)

      |> Map.put(:action, :validate)

      |> to_form()

    {:noreply, assign(socket, :profile_form, profile_form)}

  end

  def handle_event("update_profile", params, socket) do

    %{"user" => user_params} = params

    user = socket.assigns.current_user

    consume_uploaded_entries(socket, :profile, fn meta, entry ->

      {entry, meta} = Storage.ImageTools.resize_upload_as_png({entry, meta}, {256, 256})

      {:ok, _object} = Storage.direct_upload({entry, meta}, user_profile_image: user)

    end)

    case Accounts.update_user_profile(user, user_params) do

      {:ok, _user} ->

        info = "Your profile information was updated."

        {:noreply, socket |> put_flash(:info, info) |> push_navigate(to: ~p"/users/settings")}

      {:error, changeset} ->

        {:noreply, assign(socket, :profile_form, to_form(changeset))}

    end

  end

defmodule MyAppWeb.UserSettingsLive.Components do

  use MyAppWeb, :html

  alias MyAppWeb.StorageController

  attr :user, MyApp.Accounts.User, required: true

  attr :class, :string, default: nil

  attr :size, :atom, default: :md, values: ~w(xs sm md lg)a

  def user_profile(assigns) do

    bg_style =

      case assigns.user.profile_image do

        nil ->

          "background-color: lightgray;"

        %MyApp.Storage.Object{} = profile_image ->

          "background-image: url('#{StorageController.download_path(profile_image)}');"

      end

    size_class =

      case assigns.size do

        :xs -> "size-4 rounded"

        :sm -> "size-6 rounded-lg"

        :md -> "size-8 rounded-lg"

        :lg -> "size-24 rounded-lg"

      end

    assigns = assign(assigns, bg_style: bg_style, size_class: size_class)

    ~H"""

    <div style={@bg_style} class={[@class, @size_class, "relative cursor-default bg-cover"]} />

    """

  end

end

defmodule MyApp.Repo.Migrations.AlterUsersAddNameProfileImageId do

  use Ecto.Migration

  def change do

    alter table(:users) do

      add :name, :string, null: true

      add :profile_image_id,

          references(:storage_objects, type: :binary_id, on_delete: :nilify_all),

          null: true

    end

  end

end