{:buckets, "~> 0.1"},

      {:size, "~> 0.1"},

import * as uploaders from "./uploaders"

  uploaders,

export { default as GCS } from "./uploaders/gcs"

export default function (entries, onViewError) {

  entries.forEach((entry) => {

    let { url } = entry.meta;

    let xhr = new XMLHttpRequest();

    onViewError(() => xhr.abort());

    xhr.onload = () => xhr.status === 200 ? entry.progress(100) : entry.error();

    xhr.onerror = () => entry.error();

    xhr.upload.addEventListener("progress", (event) => {

      if (event.lengthComputable) {

        let percent = Math.round((event.loaded / event.total) * 100);

        if (percent < 100) entry.progress(percent);

      }

    });

    xhr.open("PUT", url, true);

    xhr.send(entry.file);

  });

}

defmodule MyApp.Storage do

  import Ecto.Query

  alias MyApp.Repo

  alias MyApp.Storage.Object

  alias MyApp.Storage.ObjectUploadedByUser

  @doc """

  Configuration for accessing a bucket.

  """

  def bucket_config(override_opts \\ []) do

    default_config =

      [

        strategy: Buckets.Strategy.Volume,

        base_url: MyAppWeb.Endpoint.url(),

        bucket: "tmp/buckets_volume",

        path: "objects"

      ]

    Keyword.merge(default_config, override_opts)

  end

  def get!(object_id) do

    Repo.get!(Object, object_id)

  end

  @doc """

  Gets an object if it was uploaded by the provided user.

  """

  def get_uploaded_by_user(object_id, user) do

    Object

    |> Object.present_query()

    |> ObjectUploadedByUser.uploaded_by_user_query(user)

    |> Repo.get(object_id)

  end

  @doc """

  Lists objects uploaded by a particular user.

  """

  def list_uploaded_by_user(user) do

    Object

    |> Object.present_query()

    |> ObjectUploadedByUser.uploaded_by_user_query(user)

    |> order_by(desc: :inserted_at)

    |> Repo.all()

  end

  @doc """

  Creates an object given an `upload` tuple consisting of the uploaded entry

  and upload metadata.

  """

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

    Ecto.Multi.new()

    |> Object.insert_from_upload_multi(upload)

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

    |> Repo.transaction()

  end

  @doc """

  Sets the deleted_at field on an object.

  """

  def mark_as_deleted!(object) do

    object

    |> Object.delete_changeset()

    |> Repo.update!()

  end

  @doc """

  Permanently deletes objects that were marked as deleted before some

  time given duration opts.

  """

  def delete_marked_permanently(opts \\ []) do

    marked_objects =

      Object

      |> Object.deleted_query(opts)

      |> Repo.all()

    Enum.each(marked_objects, &delete_permanently/1)

  end

  @doc """

  Permanently deletes an object.

  """

  def delete_permanently(object) do

    object.filename

    |> Object.normalize_file_name()

    |> Buckets.delete(object, bucket_config())

    |> case do

      :ok -> Repo.delete!(object)

    end

  end

end

defmodule MyApp.Storage.Object do

  use Ecto.Schema

  import Ecto.Changeset

  import Ecto.Query

  alias MyApp.Storage

  @primary_key {:id, :binary_id, autogenerate: false}

  schema "storage_objects" do

    field :filename, :string

    field :path, :string

    field :deleted_at, :utc_datetime

    embeds_one :metadata, Metadata do

      field :content_type, :string

      field :content_size, :integer

    end

    timestamps()

  end

  ## Changesets

  def insert_changeset(object, attrs) do

    object

    |> cast(attrs, [:id, :filename, :path])

    |> cast_embed(:metadata, with: &metadata_changeset/2)

    |> validate_required([:id, :filename, :path])

  end

  def delete_changeset(object) do

    change(object, deleted_at: DateTime.truncate(DateTime.utc_now(), :second))

  end

  def metadata_changeset(metadata, attrs) do

    cast(metadata, attrs, [:content_type, :content_size])

  end

  @doc """

  Removes invalid characters from a filename for cloud storage.

  """

  def normalize_file_name(filename) do

    filename

    |> String.replace(~r/\s/, "_")

    |> String.replace(~r/[^\.a-zA-Z0-9_-]/, "")

  end

  ## Queries

  def present_query(query) do

    from object in query, where: is_nil(object.deleted_at)

  end

  def deleted_query(query, []) do

    from object in query, where: not is_nil(object.deleted_at)

  end

  def deleted_query(query, opts) do

    threshold =

      DateTime.shift(

        DateTime.utc_now(),

        Duration.negate(Duration.new!(opts))

      )

    from object in query, where: object.deleted_at < ^threshold

  end

  ## Multis

  def insert_from_upload_multi(multi, {_entry, meta} = upload) do

    upload = Buckets.Upload.new(upload)

    attrs = %{

      id: upload.uuid,

      filename: upload.filename,

      path: meta.url.path,

      metadata: %{

        content_type: upload.content_type,

        content_size: upload.content_size

      }

    }

    Ecto.Multi.insert(multi, :object, insert_changeset(%__MODULE__{}, attrs))

  end

  @doc """

  Inserts object association records given a keyword list. Will raise if passed

  an association that is not explicitly allowed.

  ## Options

      * `:uploaded_by_user` - inserts a `ObjectUploadedByUser` association

  """

  def insert_assocs_multi(multi, opts, allowed) do

    Enum.reduce(opts, multi, fn {key, _value} = assoc, multi ->

      if key not in allowed,

        do: raise("`insert_assocs_multi/3` received invalid key `#{inspect(key)}`.")

      case assoc do

        {:uploaded_by_user, user} ->

          Storage.ObjectUploadedByUser.insert_for_user_multi(multi, user)

      end

    end)

  end

end

defmodule MyApp.Storage.ObjectUploadedByUser do

  use Ecto.Schema

  import Ecto.Query

  alias MyApp.Accounts

  alias MyApp.Storage

  @primary_key false

  @foreign_key_type :binary_id

  schema "storage_objects_uploaded_by_users" do

    belongs_to :object, Storage.Object

    belongs_to :uploaded_by_user, Accounts.User

  end

  ## Queries

  def uploaded_by_user_query(query, user) do

    from object in query,

      join: object_uploaded_by_user in __MODULE__,

      on: [object_id: object.id, uploaded_by_user_id: ^user.id]

  end

  ## Multis

  def insert_for_user_multi(multi, user) do

    Ecto.Multi.insert(multi, :object_uploaded_by_user, fn %{object: object} ->

      %__MODULE__{object: object, uploaded_by_user: user}

    end)

  end

end

defmodule MyAppWeb.StorageController do

  use MyAppWeb, :controller

  alias MyApp.Storage

  @cache_control_max_age :timer.hours(72)

  def download(conn, %{"id" => object_id, "sig" => sig}) do

    case deterministic_hash(object_id) do

      ^sig ->

        object = Storage.get!(object_id)

        filename = Storage.Object.normalize_file_name(object.filename)

        case Buckets.get(filename, object, Storage.bucket_config()) do

          {:ok, binary} ->

            conn

            |> put_resp_header("cache-control", "max-age=#{@cache_control_max_age}")

            |> send_download({:binary, binary}, filename: object.filename)

          {:error, _reason} ->

            send_resp(conn, 500, "Failed to read file")

        end

      _otherwise ->

        send_resp(conn, 401, "Unauthorized")

    end

  end

  def download_path(%Storage.Object{} = object) do

    ~p"/storage/download/#{object}?sig=#{deterministic_hash(object.id)}"

  end

  def deterministic_hash(object_id) do

    config = Application.get_env(:my_app, MyAppWeb.Endpoint)

    secret_key_base = Keyword.fetch!(config, :secret_key_base)

    hash = :crypto.mac(:hmac, :sha256, secret_key_base, object_id)

    Base.url_encode64(hash, padding: false)

  end

end

defmodule MyAppWeb.StorageLive do

  use MyAppWeb, :live_view

  import MyAppWeb.StorageLive.Components

  alias MyApp.Storage

  alias MyAppWeb.StorageController

  def render(assigns) do

    ~H"""

    <.form for={%{}} as={:f} phx-change="validate">

      <.file_upload id="my-file-upload" upload={@uploads.upload} />

    </.form>

    <div class="-mx-32">

      <.table id="objects_table" rows={@streams.objects}>

        <:col :let={{_id, object}} label="Filename">

          <%= object.filename %>

        </:col>

        <:col :let={{_id, object}} label="Content type">

          <%= object.metadata.content_type %>

        </:col>

        <:col :let={{_id, object}} label="Size">

          <%= Size.humanize!(object.metadata.content_size) %>

        </:col>

        <:col :let={{_id, object}} label="Inserted at">

          <%= Calendar.strftime(object.inserted_at, "%c") %>

        </:col>

        <:action :let={{_id, object}}>

          <.link phx-click="delete" phx-value-id={object.id}>Delete</.link>

        </:action>

        <:action :let={{_id, object}}>

          <.link href={StorageController.download_path(object)} target="_blank">Download</.link>

        </:action>

      </.table>

    </div>

    """

  end

  def mount(_params, _session, socket) do

    {:ok,

     socket

     |> stream_configure(:objects, [])

     |> stream(:objects, Storage.list_uploaded_by_user(socket.assigns.current_user))

     |> allow_upload(:upload,

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

       max_file_size: 100_000_000,

       max_entries: 10,

       external: &presign_upload/2,

       progress: &handle_progress/3,

       auto_upload: true

     )}

  end

  # By default, this app is configured for use with `Buckets.Strategy.Volume`.

  #

  # For direct uploads to GCS, you must specify additional parameters for signing the upload URL:

  #

  #     Storage.bucket_config(gcs_signed_url: [verb: "PUT", expires: 900])

  #

  def presign_upload(entry, socket) do

    {:ok, url} =

      entry.client_name

      |> Storage.Object.normalize_file_name()

      |> Buckets.url(entry.uuid, Storage.bucket_config())

    {:ok, %{uploader: "GCS", url: url}, socket}

  end

  def handle_progress(_type, entry, socket) do

    if entry.done? do

      %{object: object} =

        consume_uploaded_entry(socket, entry, fn meta ->

          Storage.create_from_upload({entry, meta}, uploaded_by_user: socket.assigns.current_user)

        end)

      {:noreply, stream_insert(socket, :objects, object, at: 0)}

    else

      {:noreply, socket}

    end

  end

  # Required for uploads

  def handle_event("validate", _params, socket) do

    {:noreply, socket}

  end

  def handle_event("delete", %{"id" => object_id}, socket) do

    case Storage.get_uploaded_by_user(object_id, socket.assigns.current_user) do

      nil ->

        {:noreply, put_flash(socket, :info, "Unable to delete object.")}

      object ->

        Storage.mark_as_deleted!(object)

        {:noreply,

         socket

         |> stream_delete(:objects, object)

         |> put_flash(:info, "Deleted object.")}

    end

  end

end

defmodule MyAppWeb.StorageLive.Components do

  use MyAppWeb, :html

  @doc """

  Renders a file upload input for live uploading files.

  """

  attr :id, :string, required: true

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

  def file_upload(assigns) do

    ~H"""

    <div class="bg-zinc-900 rounded-2xl p-4 grid grid-cols-1 gap-2">

      <label

        id={@id}

        for={@upload.ref}

        phx-drop-target={@upload.ref}

        class={[

          "sm:h-48",

          "col-span-1 lg:col-span-2 relative",

          "flex flex-col items-center justify-center rounded-lg p-6",

          "border-2 border-dashed border-white drop:border-zinc-400 hover:border-zinc-400",

          "text-white drop:text-zinc-300 hover:text-zinc-300"

        ]}

      >

        <p class="text-center hidden sm:inline-block">

          Drag & drop files here.

        </p>

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

          <%= error_for(error) %>

        </p>

        <div class="sm:absolute sm:right-2 sm:bottom-2">

          <.button

            type="button"

            class="flex gap-2 items-center"

            onclick={"document.getElementById(#{inspect(@id)}).click()"}

          >

            <.icon name="hero-cloud-arrow-up-mini" class="h-5 w-5 text-zinc-900 dark:text-zinc-100" />

            Browse files

          </.button>

        </div>

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

      </label>

      <div :if={@upload.entries != []} class="col-span-1 relative">

        <div>

          <div class="flex-1 overflow-y-scroll">

            <.file_upload_entry

              :for={entry <- @upload.entries}

              entry={entry}

              errors={upload_errors(@upload, entry)}

            />

          </div>

        </div>

      </div>

    </div>

    """

  end

  @doc """

  Renders a file upload entry.

  """

  attr :entry, Phoenix.LiveView.UploadEntry, required: true

  attr :errors, :list, default: []

  def file_upload_entry(assigns) do

    ~H"""

    <div class="border border-white dark:border-zinc-800 rounded mt-2 p-2">

      <div class="flex gap-2">

        <div class="h-5 flex items-center">

          <.icon name="hero-document" class="h-5 w-5 text-white" />

        </div>

        <div class="flex-1 min-w-0">

          <div class="h-5 flex w-full items-center gap-4">

            <span class="text-sm text-white truncate"><%= @entry.client_name %></span>

            <span class="text-sm text-white whitespace-nowrap">

              <%= Size.humanize!(@entry.client_size) %>

            </span>

          </div>

        </div>

      </div>

      <div class="mt-2">

        <.progress :if={@entry.progress not in [0, 100]} class="w-32" value={@entry.progress} />

        <span :for={error <- @errors} class="text-sm text-rose-600"><%= error_for(error) %></span>

      </div>

    </div>

    """

  end

  defp error_for(:too_large), do: "File is too large."

  defp error_for(:not_accepted), do: "File type not allowed."

  defp error_for(:too_many_files), do: "Too many files."

  defp error_for(error), do: to_string(error)

  @doc """

  Renders a small progress bar.

  """

  attr :value, :integer, required: true

  attr :class, :string, default: nil

  def progress(assigns) do

    ~H"""

    <div class={["h-2 overflow-hidden rounded-full border border-white", @class]}>

      <div class="h-full transition-[width] bg-white" style={"width: #{@value}%;"} />

    </div>

    """

  end

end

    import Buckets.Router

    # Here, we are defining a volume to accept files for the purpose of

    # local development. However, you may use this same approach to save files

    # to a persistent volume in production.

    buckets_volume(path: "tmp/buckets_volume")

    get "/storage/download/:id", StorageController, :download

      live "/storage", StorageLive

defmodule MyApp.Repo.Migrations.CreateStorageObjects do

  use Ecto.Migration

  def change do

    create table(:storage_objects, primary_key: false) do

      add :id, :binary_id, primary_key: true

      add :filename, :string, null: false

      add :path, :string, null: false

      add :metadata, :map, null: false

      add :deleted_at, :utc_datetime, null: true

      timestamps()

    end

    create table(:storage_objects_uploaded_by_users, primary_key: false) do

      add :object_id, references(:storage_objects, type: :binary_id, on_delete: :delete_all),

        primary_key: true

      add :uploaded_by_user_id, references(:users, type: :binary_id, on_delete: :nothing),

        null: false

    end

    create index(:storage_objects_uploaded_by_users, [:uploaded_by_user_id])

  end

end