path: root/lib/lsg_irc/link_plugin.ex

defmodule LSG.IRC.LinkPlugin do
  @moduledoc """
  # Link Previewer

  An extensible link previewer for IRC.

  To extend the supported sites, create a new handler implementing the callbacks.

  See `link_plugin/` directory for examples. The first in list handler that returns true to the `match/2` callback will be used,
  and if the handler returns `:error` or crashes, will fallback to the default preview.

  Unsupported websites will use the default link preview method, which is for html document the title, otherwise it'll use
  the mimetype and size.

  ## Configuration:

  ```
  config :lsg, LSG.IRC.LinkPlugin,
    handlers: [
      LSG.IRC.LinkPlugin.Youtube: [
        invidious: true
      ],
      LSG.IRC.LinkPlugin.Twitter: [],
      LSG.IRC.LinkPlugin.Imgur: [],
    ]
  ```

  """

  @ircdoc """
  # Link preview

  Previews links (just post a link!).

  Announces real URL after redirections and provides extended support for YouTube, Twitter and Imgur.
  """
  def short_irc_doc, do: false
  def irc_doc, do: @ircdoc
  require Logger

  def start_link() do
    GenServer.start_link(__MODULE__, [], name: __MODULE__)
  end

  @callback match(uri :: URI.t, options :: Keyword.t) :: {true, params :: Map.t} | false
  @callback expand(uri :: URI.t, params :: Map.t, options :: Keyword.t) :: {:ok, lines :: [] | String.t} | :error

  defstruct [:client]

  def init([]) do
    {:ok, _} = Registry.register(IRC.PubSub, "message", [])
    #{:ok, _} = Registry.register(IRC.PubSub, "message:telegram", [])
    Logger.info("Link handler started")
    {:ok, %__MODULE__{}}
  end

  def handle_info({:irc, :text, message = %{text: text}}, state) do
    String.split(text)
    |> Enum.map(fn(word) ->
      if String.starts_with?(word, "http://") || String.starts_with?(word, "https://") do
        uri = URI.parse(word)
        if uri.scheme && uri.host do
          spawn(fn() ->
            case expand_link([uri]) do
              {:ok, uris, text} ->
                text = case uris do
                  [uri] -> text
                  [uri | _] -> ["-> #{URI.to_string(uri)}", text]
                end
                IO.inspect(text)
                if is_list(text) do
                  for line <- text, do: message.replyfun.(line)
                else
                  message.replyfun.(text)
                end
              _ -> nil
            end
          end)
        end
      end
    end)
    {:noreply, state}
  end

  def handle_info(msg, state) do
    {:noreply, state}
  end

  def terminate(_reason, state) do
    :ok
  end

  # 1. Match the first valid handler
  # 2. Try to run the handler
  # 3. If :error or crash, default link.
  #    If :skip, nothing
  # 4. ?

  # Over five redirections: cancel.
  def expand_link(acc = [_, _, _, _, _ | _]) do
    {:ok, acc, "link redirects more than five times"}
  end

  def expand_link(acc=[uri | _]) do
    handlers = Keyword.get(Application.get_env(:lsg, __MODULE__, [handlers: []]), :handlers)
    handler = Enum.reduce_while(handlers, nil, fn({module, opts}, acc) ->
      module = Module.concat([module])
      case module.match(uri, opts) do
        {true, params} -> {:halt, {module, params, opts}}
        false -> {:cont, acc}
      end
    end)
    run_expand(acc, handler)
  end

  def run_expand(acc, nil) do
    expand_default(acc)
  end

  def run_expand(acc=[uri|_], {module, params, opts}) do
    case module.expand(uri, params, opts) do
      {:ok, data} -> {:ok, acc, data}
      :error -> expand_default(acc)
      :skip -> nil
    end
  rescue
    e ->
      Logger.error(inspect(e))
      expand_default(acc)
  catch
    e, b ->
      Logger.error(inspect({b}))
      expand_default(acc)
  end

  defp get(url, headers \\ [], options \\ []) do
    get_req(url, :hackney.get(url, headers, <<>>, options))
  end

  defp get_req(_, {:error, reason}) do
    {:error, reason}
  end

  defp get_req(url, {:ok, 200, headers, client}) do
    headers = Enum.reduce(headers, %{}, fn({key, value}, acc) ->
      Map.put(acc, String.downcase(key), value)
    end)
    content_type = Map.get(headers, "content-type", "application/octect-stream")
    length = Map.get(headers, "content-length", "0")
    {length, _} = Integer.parse(length)

    cond do
      String.starts_with?(content_type, "text/html") && length <= 30_000_000 ->
        get_body(url, 30_000_000, client, <<>>)
      true ->
        :hackney.close(client)
        {:ok, "file: #{content_type}, size: #{length} bytes"}
    end
  end

  defp get_req(_, {:ok, redirect, headers, client}) when redirect in 300..399 do
    headers = Enum.reduce(headers, %{}, fn({key, value}, acc) ->
      Map.put(acc, String.downcase(key), value)
    end)
    location = Map.get(headers, "location")

    :hackney.close(client)
    {:redirect, location}
  end

  defp get_req(_, {:ok, status, headers, client}) do
    :hackney.close(client)
    {:error, status, headers}
  end

  defp get_body(url, len, client, acc) when len >= byte_size(acc) do
    case :hackney.stream_body(client) do
      {:ok, data} ->
        get_body(url, len, client, << acc::binary, data::binary >>)
      :done ->
        html = Floki.parse(acc)
        title = collect_title(html)
        opengraph = collect_open_graph(html)
        itemprops = collect_itemprops(html)
        Logger.debug("OG: #{inspect opengraph}")
        text = if Map.has_key?(opengraph, "title") && Map.has_key?(opengraph, "description") do
          sitename = if sn = Map.get(opengraph, "site_name") do
            "#{sn}"
          else
            ""
          end
          paywall? = if Map.get(opengraph, "article:content_tier", Map.get(itemprops, "article:content_tier", "free")) == "free" do
            ""
          else
            "[paywall] "
          end
          section = if section = Map.get(opengraph, "article:section", Map.get(itemprops, "article:section", nil)) do
            ": #{section}"
          else
            ""
          end
          date = case DateTime.from_iso8601(Map.get(opengraph, "article:published_time", Map.get(itemprops, "article:published_time", ""))) do
            {:ok, date, _} ->
              "#{Timex.format!(date, "%d/%m/%y", :strftime)}. "
            _ ->
              ""
          end
          uri = URI.parse(url)

          prefix = "#{paywall?}#{Map.get(opengraph, "site_name", uri.host)}#{section}"
          prefix = unless prefix == "" do
            "#{prefix} — "
          else
              ""
          end
          [clean_text("#{prefix}#{Map.get(opengraph, "title")}")] ++ IRC.splitlong(clean_text("#{date}#{Map.get(opengraph, "description")}"))
        else
          clean_text(title)
        end
        {:ok, text}
      {:error, reason} ->
        {:ok, "failed to fetch body: #{inspect reason}"}
    end
  end

  defp clean_text(text) do
    text
    |> String.replace("\n", " ")
    |> HtmlEntities.decode()
  end

  defp get_body(len, client, _acc) do
    :hackney.close(client)
    {:ok, "Error: file over 30"}
  end

  def expand_default(acc = [uri = %URI{scheme: scheme} | _]) when scheme in ["http", "https"] do
    headers = []
    options = [follow_redirect: false, max_body_length: 30_000_000]
    case get(URI.to_string(uri), headers, options) do
      {:ok, text} ->
        {:ok, acc, text}
      {:redirect, link} ->
        new_uri = URI.parse(link)
        new_uri = %URI{new_uri | scheme: scheme, authority: uri.authority, host: uri.host, port: uri.port}
        expand_link([new_uri | acc])
      {:error, status, _headers} ->
        text = Plug.Conn.Status.reason_phrase(status)
        {:ok, acc, "Error: HTTP #{text} (#{status})"}
      {:error, reason} ->
        {:ok, acc, "Error: #{to_string(reason)}"}
    end
  end

  # Unsupported scheme, came from a redirect.
  def expand_default(acc = [uri | _]) do
    {:ok, [uri], "-> #{URI.to_string(uri)}"}
  end

  defp collect_title(html) do
    case Floki.find(html, "title") do
    [{"title", [], [title]} | _] ->
      String.trim(title)
    _ ->
      nil
    end
  end

  defp collect_open_graph(html) do
    Enum.reduce(Floki.find(html, "head meta"), %{}, fn(tag, acc) ->
      case tag do
        {"meta", values, []} ->
          name = List.keyfind(values, "property", 0, {nil, nil}) |> elem(1)
          content = List.keyfind(values, "content", 0, {nil, nil}) |> elem(1)
          case name do
           "og:" <> key ->
              Map.put(acc, key, content)
            "article:"<>_ ->
              Map.put(acc, name, content)
            _other -> acc
          end
        _other -> acc
      end
    end)
  end

  defp collect_itemprops(html) do
    Enum.reduce(Floki.find(html, "[itemprop]"), %{}, fn(tag, acc) ->
      case tag do
        {"meta", values, []} ->
          name = List.keyfind(values, "itemprop", 0, {nil, nil}) |> elem(1)
          content = List.keyfind(values, "content", 0, {nil, nil}) |> elem(1)
          case name do
           "article:" <> key ->
              Map.put(acc, name, content)
            _other -> acc
          end
        _other -> acc
      end
    end)
  end

end