# frozen_string_literal: true

# Gestiona acciones de moderación
class ActivityPubsController < ApplicationController
  include ModerationConcern

  ActivityPub.events.each do |event|
    define_method(event) do
      authorize activity_pub

      activity_pub.update(remote_flag_params(activity_pub)) if event == :report
      activity_pub.public_send(:"#{event}!") if activity_pub.public_send(:"may_#{event}?")

      redirect_to_moderation_queue!
    end
  end

  def action_on_several
    activity_pubs = site.activity_pubs.where(id: params[:activity_pub])

    authorize activity_pubs

    action = params[:activity_pub_action].to_sym
    method = :"#{action}!"
    may    = :"may_#{action}?"

    redirect_to_moderation_queue!

    return unless ActivityPub.events.include? action

    # Crear una sola remote flag por autore
    if action == :report
      message = remote_flag_params(activity_pubs.first).dig(:remote_flag_attributes, :message)

      activity_pubs.distinct.pluck(:actor_id).each do |actor_id|
        remote_flag = ActivityPub::RemoteFlag.find_or_initialize_by(actor_id: actor_id, site_id: site.id)
        remote_flag.message = message
        # Lo estamos actualizando, con lo que lo vamos a volver a enviar
        remote_flag.requeue if remote_flag.persisted?
        remote_flag.save
        # XXX: Idealmente todas las ActivityPub que enviamos pueden
        # cambiar de estado, pero chequeamos de todas formas.
        remote_flag.activity_pubs << (activity_pubs.where(actor_id: actor_id).to_a.select { |a| a.public_send(may) })
      end
    end

    ActivityPub.transaction do
      activity_pubs.find_each do |activity_pub|
        next unless activity_pub.public_send(may)

        activity_pub.public_send(method)
      end
    end
  end

  private

  def activity_pub
    @activity_pub ||= site.activity_pubs.find(params[:activity_pub_id])
  end
end