defmodule Mobilizon.GraphQL.Resolvers.Admin do
  @moduledoc """
  Handles the report-related GraphQL calls.
  """

  import Mobilizon.Users.Guards

  alias Mobilizon.{Actors, Admin, Config, Events}
  alias Mobilizon.Actors.Actor
  alias Mobilizon.Admin.{ActionLog, Setting}
  alias Mobilizon.Config
  alias Mobilizon.Conversations.Comment
  alias Mobilizon.Events.Event
  alias Mobilizon.Federation.ActivityPub.Relay
  alias Mobilizon.Reports.{Note, Report}
  alias Mobilizon.Service.Statistics
  alias Mobilizon.Storage.Page
  alias Mobilizon.Users.User
  require Logger

  def list_action_logs(
        _parent,
        %{page: page, limit: limit},
        %{context: %{current_user: %User{role: role}}}
      )
      when is_moderator(role) do
    with action_logs <- Mobilizon.Admin.list_action_logs(page, limit) do
      action_logs =
        action_logs
        |> Enum.map(fn %ActionLog{
                         target_type: target_type,
                         action: action,
                         actor: actor,
                         id: id,
                         inserted_at: inserted_at
                       } = action_log ->
          with data when is_map(data) <-
                 transform_action_log(String.to_existing_atom(target_type), action, action_log) do
            Map.merge(data, %{actor: actor, id: id, inserted_at: inserted_at})
          end
        end)
        |> Enum.filter(& &1)

      {:ok, action_logs}
    end
  end

  def list_action_logs(_parent, _args, _resolution) do
    {:error, "You need to be logged-in and a moderator to list action logs"}
  end

  defp transform_action_log(
         Report,
         :update,
         %ActionLog{} = action_log
       ) do
    with %Report{} = report <- Mobilizon.Reports.get_report(action_log.target_id) do
      action =
        case action_log do
          %ActionLog{changes: %{"status" => "closed"}} -> :report_update_closed
          %ActionLog{changes: %{"status" => "open"}} -> :report_update_opened
          %ActionLog{changes: %{"status" => "resolved"}} -> :report_update_resolved
        end

      %{
        action: action,
        object: report
      }
    end
  end

  defp transform_action_log(Note, :create, %ActionLog{changes: changes}) do
    %{
      action: :note_creation,
      object: convert_changes_to_struct(Note, changes)
    }
  end

  defp transform_action_log(Note, :delete, %ActionLog{changes: changes}) do
    %{
      action: :note_deletion,
      object: convert_changes_to_struct(Note, changes)
    }
  end

  defp transform_action_log(Event, :delete, %ActionLog{changes: changes}) do
    %{
      action: :event_deletion,
      object: convert_changes_to_struct(Event, changes)
    }
  end

  defp transform_action_log(Comment, :delete, %ActionLog{changes: changes}) do
    %{
      action: :comment_deletion,
      object: convert_changes_to_struct(Comment, changes)
    }
  end

  defp transform_action_log(Actor, :suspend, %ActionLog{changes: changes}) do
    %{
      action: :actor_suspension,
      object: convert_changes_to_struct(Actor, changes)
    }
  end

  defp transform_action_log(Actor, :unsuspend, %ActionLog{changes: changes}) do
    %{
      action: :actor_unsuspension,
      object: convert_changes_to_struct(Actor, changes)
    }
  end

  defp transform_action_log(User, :delete, %ActionLog{changes: changes}) do
    %{
      action: :user_deletion,
      object: convert_changes_to_struct(User, changes)
    }
  end

  # Changes are stored as %{"key" => "value"} so we need to convert them back as struct
  defp convert_changes_to_struct(struct, %{"report_id" => _report_id} = changes) do
    with data <- for({key, val} <- changes, into: %{}, do: {String.to_atom(key), val}),
         data <- Map.put(data, :report, Mobilizon.Reports.get_report(data.report_id)) do
      struct(struct, data)
    end
  end

  defp convert_changes_to_struct(struct, changes) do
    with data <- for({key, val} <- changes, into: %{}, do: {String.to_atom(key), val}) do
      struct(struct, data)
    end
  end

  def get_dashboard(_parent, _args, %{context: %{current_user: %User{role: role}}})
      when is_admin(role) do
    last_public_event_published =
      case Events.list_events(1, 1, :inserted_at, :desc) do
        [event | _] -> event
        _ -> nil
      end

    {:ok,
     %{
       number_of_users: Statistics.get_cached_value(:local_users),
       number_of_events: Statistics.get_cached_value(:local_events),
       number_of_comments: Statistics.get_cached_value(:local_comments),
       number_of_reports: Mobilizon.Reports.count_opened_reports(),
       last_public_event_published: last_public_event_published
     }}
  end

  def get_dashboard(_parent, _args, _resolution) do
    {:error, "You need to be logged-in and an administrator to access dashboard statistics"}
  end

  def get_settings(_parent, _args, %{
        context: %{current_user: %User{role: role}}
      })
      when is_admin(role) do
    {:ok,
     %{
       instance_description: Config.instance_description(),
       instance_long_description: Config.instance_long_description(),
       instance_name: Config.instance_name(),
       registrations_open: Config.instance_registrations_open?(),
       contact: Config.contact(),
       instance_terms: Config.instance_terms(),
       instance_terms_type: Config.instance_terms_type(),
       instance_terms_url: Config.instance_terms_url(),
       instance_privacy_policy: Config.instance_privacy(),
       instance_privacy_policy_type: Config.instance_privacy_type(),
       instance_privacy_policy_url: Config.instance_privacy_url(),
       instance_rules: Config.instance_rules()
     }}
  end

  def get_settings(_parent, _args, _resolution) do
    {:error, "You need to be logged-in and an administrator to access admin settings"}
  end

  def save_settings(_parent, args, %{
        context: %{current_user: %User{role: role}}
      })
      when is_admin(role) do
    with {:ok, res} <- Admin.save_settings("instance", args) do
      res =
        res
        |> Enum.map(fn {key, %Setting{value: value}} ->
          case value do
            "true" -> {key, true}
            "false" -> {key, false}
            value -> {key, value}
          end
        end)
        |> Enum.into(%{})

      Config.clear_config_cache()

      {:ok, res}
    end
  end

  def save_settings(_parent, _args, _resolution) do
    {:error, "You need to be logged-in and an administrator to save admin settings"}
  end

  def list_relay_followers(
        _parent,
        %{page: page, limit: limit},
        %{context: %{current_user: %User{role: role}}}
      )
      when is_admin(role) do
    with %Actor{} = relay_actor <- Relay.get_actor() do
      %Page{} =
        page = Actors.list_external_followers_for_actor_paginated(relay_actor, page, limit)

      {:ok, page}
    end
  end

  def list_relay_followings(
        _parent,
        %{page: page, limit: limit},
        %{context: %{current_user: %User{role: role}}}
      )
      when is_admin(role) do
    with %Actor{} = relay_actor <- Relay.get_actor() do
      %Page{} =
        page = Actors.list_external_followings_for_actor_paginated(relay_actor, page, limit)

      {:ok, page}
    end
  end

  def create_relay(_parent, %{address: address}, %{context: %{current_user: %User{role: role}}})
      when is_admin(role) do
    case Relay.follow(address) do
      {:ok, _activity, follow} ->
        {:ok, follow}

      {:error, {:error, err}} when is_bitstring(err) ->
        {:error, err}
    end
  end

  def remove_relay(_parent, %{address: address}, %{context: %{current_user: %User{role: role}}})
      when is_admin(role) do
    case Relay.unfollow(address) do
      {:ok, _activity, follow} ->
        {:ok, follow}

      {:error, {:error, err}} when is_bitstring(err) ->
        {:error, err}
    end
  end

  def accept_subscription(
        _parent,
        %{address: address},
        %{context: %{current_user: %User{role: role}}}
      )
      when is_admin(role) do
    case Relay.accept(address) do
      {:ok, _activity, follow} ->
        {:ok, follow}

      {:error, {:error, err}} when is_bitstring(err) ->
        {:error, err}
    end
  end

  def reject_subscription(
        _parent,
        %{address: address},
        %{context: %{current_user: %User{role: role}}}
      )
      when is_admin(role) do
    case Relay.reject(address) do
      {:ok, _activity, follow} ->
        {:ok, follow}

      {:error, {:error, err}} when is_bitstring(err) ->
        {:error, err}
    end
  end
end