# Pleroma: A lightweight social networking server
# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only

defmodule Pleroma.Web.ActivityPub.MRF.StealEmojiPolicy do
  require Logger

  alias Pleroma.Config

  @moduledoc "Detect new emojis by their shortcode and steals them"
  @behaviour Pleroma.Web.ActivityPub.MRF.Policy

  defp steal_emoji({shortcode, url}, host, emoji_dir_path, all_emoji_path, emoji_storage_path) do
    url = Pleroma.Web.MediaProxy.url(url)

    with {:ok, %{status: status} = response} when status in 200..299 <- Pleroma.HTTP.get(url) do
      size_limit = Config.get([:mrf_steal_emoji, :size_limit], 50_000)

      if byte_size(response.body) <= size_limit do
        extension =
          url
          |> URI.parse()
          |> Map.get(:path)
          |> Path.basename()
          |> Path.extname()
          || ".png"
        
        file_name = Regex.replace(~r/\s+/, shortcode, "") <> extension
        file_path = Path.join(emoji_dir_path, file_name)
        secs = DateTime.utc_now() |> DateTime.to_unix()
        sym_path = Path.join(all_emoji_path, to_string(secs) <> "_" <> host <> "_" <> file_name)
        hash = :crypto.hash(:md5, response.body) |> Base.encode16() |> String.downcase()
        store_path = Path.join(emoji_storage_path, hash <> extension)

        if File.exists?(store_path) do
          Logger.warn("MRF.StealEmojiPolicy: Already exists #{file_path}: #{hash}")
          nil
        else
          case File.write(store_path, response.body) do
            :ok ->
              File.ln_s(store_path, file_path)
              File.ln_s(store_path, sym_path)
              shortcode

            e ->
              Logger.warn("MRF.StealEmojiPolicy: Failed to write to #{file_path}: #{inspect(e)}")
              nil
          end
        end
      else
        Logger.debug(
          "MRF.StealEmojiPolicy: :#{shortcode}: at #{url} (#{byte_size(response.body)} B) over size limit (#{size_limit} B)"
        )

        nil
      end
    else
      e ->
        Logger.warn("MRF.StealEmojiPolicy: Failed to fetch #{url}: #{inspect(e)}")
        nil
    end
  end

  @impl true
  def filter(%{"object" => %{"emoji" => foreign_emojis, "actor" => actor}} = message) do
    host = URI.parse(actor).host

    if host != Pleroma.Web.Endpoint.host() do
      installed_emoji = Pleroma.Emoji.get_all() |> Enum.map(fn {k, _} -> k end)

      emoji_dir_path =
        Config.get(
          [:mrf_steal_emoji, :path],
          Path.join(Config.get([:instance, :static_dir]), "emoji/stolen/#{host}")
        )

      all_emoji_path = 
        Config.get(
          [:mrf_steal_emoji, :all_path],
          Path.join(Config.get([:instance, :static_dir]), "emoji_all")
        )

      emoji_storage_path = 
        Config.get(
          [:mrf_steal_emoji, :repo_path],
          Path.join(Config.get([:instance, :static_dir]), "emoji_repo")
        )

      tograb_emojis =
        foreign_emojis
        |> Enum.reject(fn {shortcode, url} -> shortcode in installed_emoji || !Regex.match?(~r/\.(jpg|jpeg|png|gif)$/i, url) end)
        |> Enum.filter(fn {shortcode, _url} ->
          reject_emoji? =
            [:mrf_steal_emoji, :rejected_shortcodes]
            |> Config.get([])
            |> Enum.find(false, fn regex -> String.downcase(shortcode) == String.downcase(regex) end)

          !reject_emoji?
        end)

      if !Enum.empty?(tograb_emojis) do
        File.mkdir_p(emoji_dir_path)
        File.mkdir_p(all_emoji_path)
        File.mkdir_p(emoji_storage_path)
      end

      new_emojis =
        tograb_emojis
        |> Enum.map(&steal_emoji(&1, host, emoji_dir_path, all_emoji_path, emoji_storage_path))
        |> Enum.filter(& &1)

      if !Enum.empty?(new_emojis) do
        Logger.info("Stole new emojis: #{inspect(new_emojis)}")
        Pleroma.Emoji.reload()
      end
    end

    {:ok, message}
  end

  def filter(message), do: {:ok, message}

  @impl true
  @spec config_description :: %{
          children: [
            %{
              description: <<_::272, _::_*256>>,
              key: :hosts | :rejected_shortcodes | :size_limit,
              suggestions: [any(), ...],
              type: {:list, :string} | {:list, :string} | :integer
            },
            ...
          ],
          description: <<_::448>>,
          key: :mrf_steal_emoji,
          label: <<_::80>>,
          related_policy: <<_::352>>
        }
  def config_description do
    %{
      key: :mrf_steal_emoji,
      related_policy: "Pleroma.Web.ActivityPub.MRF.StealEmojiPolicy",
      label: "MRF Emojis",
      description: "Steals emojis from selected instances when it sees them.",
      children: [
        %{
          key: :hosts,
          type: {:list, :string},
          description: "List of hosts to steal emojis from",
          suggestions: [""]
        },
        %{
          key: :rejected_shortcodes,
          type: {:list, :string},
          description: """
            A list of patterns or matches to reject shortcodes with.

            Each pattern can be a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
          """,
          suggestions: ["foo", ~r/foo/]
        },
        %{
          key: :size_limit,
          type: :integer,
          description: "File size limit (in bytes), checked before an emoji is saved to the disk",
          suggestions: ["100000"]
        }
      ]
    }
  end

  @impl true
  def describe do
    {:ok, %{}}
  end
end
