/* bz-malcontent-service.c
 *
 * Copyright 2026 Alexander Vanhee
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 */

#include "config.h"

#include <appstream.h>
#include <libmalcontent/malcontent.h>
#include <unistd.h>

#include "bz-malcontent-service.h"

struct _BzMalcontentService
{
  GObject          parent_instance;
  MctManager      *manager;
  BzStateInfo     *state;
  GDBusConnection *bus;
  MctAppFilter    *filter;
  gulong           changed_id;
};

G_DEFINE_FINAL_TYPE (BzMalcontentService, bz_malcontent_service, G_TYPE_OBJECT)

static void fetch_blocked_ids (BzMalcontentService *self);
static void apply_filter (BzMalcontentService *self,
                          MctAppFilter        *filter);
static void on_filter_loaded (GObject      *source,
                              GAsyncResult *result,
                              gpointer      user_data);
static void on_filter_changed (MctManager *manager,
                               guint64     user_id,
                               gpointer    user_data);

static void
bz_malcontent_service_dispose (GObject *object)
{
  BzMalcontentService *self = NULL;

  self = BZ_MALCONTENT_SERVICE (object);

  g_signal_handler_disconnect (self->manager, self->changed_id);
  g_clear_object (&self->manager);
  g_clear_object (&self->state);
  g_clear_object (&self->bus);
  g_clear_pointer (&self->filter, mct_app_filter_unref);

  G_OBJECT_CLASS (bz_malcontent_service_parent_class)->dispose (object);
}

static void
bz_malcontent_service_class_init (BzMalcontentServiceClass *klass)
{
  G_OBJECT_CLASS (klass)->dispose = bz_malcontent_service_dispose;
}

static void
bz_malcontent_service_init (BzMalcontentService *self)
{
}

BzMalcontentService *
bz_malcontent_service_new (GDBusConnection *bus,
                           BzStateInfo     *state)
{
  BzMalcontentService *self = NULL;

  self             = g_object_new (BZ_TYPE_MALCONTENT_SERVICE, NULL);
  self->state      = g_object_ref (state);
  self->bus        = g_object_ref (bus);
  self->manager    = mct_manager_new (bus);
  self->changed_id = g_signal_connect (self->manager,
                                       "app-filter-changed",
                                       G_CALLBACK (on_filter_changed),
                                       self);

  return self;
}

void
bz_malcontent_service_start (BzMalcontentService *self)
{
  mct_manager_get_app_filter_async (self->manager,
                                    getuid (),
                                    MCT_MANAGER_GET_VALUE_FLAGS_INTERACTIVE,
                                    NULL,
                                    on_filter_loaded,
                                    self);
}

static void
fetch_blocked_ids (BzMalcontentService *self)
{
  g_autoptr (GError) local_error    = NULL;
  g_autoptr (GVariant) result       = NULL;
  g_autoptr (GVariant) prop         = NULL;
  g_autoptr (GVariant) filter_tuple = NULL;
  g_autoptr (GtkStringList) blocked = NULL;
  g_autofree char *object_path      = NULL;
  gboolean         is_allowlist     = FALSE;
  GVariantIter    *iter             = NULL;
  const char      *ref              = NULL;

  object_path = g_strdup_printf ("/org/freedesktop/Accounts/User%d", (int) getuid ());

  result = g_dbus_connection_call_sync (
      self->bus,
      "org.freedesktop.Accounts",
      object_path,
      "org.freedesktop.DBus.Properties",
      "Get",
      g_variant_new ("(ss)",
                     "com.endlessm.ParentalControls.AppFilter",
                     "AppFilter"),
      G_VARIANT_TYPE ("(v)"),
      G_DBUS_CALL_FLAGS_NONE,
      -1,
      NULL,
      &local_error);

  if (result == NULL)
    {
      g_warning ("failed to fetch malcontent AppFilter from D-Bus: %s", local_error->message);
      return;
    }

  prop         = g_variant_get_child_value (result, 0);
  filter_tuple = g_variant_get_variant (prop);

  g_variant_get (filter_tuple, "(bas)", &is_allowlist, &iter);

  blocked = gtk_string_list_new (NULL);
  while (g_variant_iter_next (iter, "s", &ref))
    gtk_string_list_append (blocked, ref);

  g_variant_iter_free (iter);

  bz_state_info_set_parental_blocked_ids (self->state, G_LIST_MODEL (blocked));
}

static void
apply_filter (BzMalcontentService *self,
              MctAppFilter        *filter)
{
  const char *const *oars_sections = NULL;
  int                max_age       = -1;

  g_clear_pointer (&self->filter, mct_app_filter_unref);
  self->filter = mct_app_filter_ref (filter);

  oars_sections = mct_app_filter_get_oars_sections (self->filter);

  for (gsize i = 0; oars_sections[i] != NULL; i++)
    {
      MctAppFilterOarsValue filter_value;
      int                   section_age;

      filter_value = mct_app_filter_get_oars_value (self->filter, oars_sections[i]);

      if (filter_value == MCT_APP_FILTER_OARS_VALUE_UNKNOWN)
        continue;

      section_age = as_content_rating_attribute_to_csm_age (oars_sections[i],
                                                            (AsContentRatingValue) filter_value);

      if (section_age > max_age)
        max_age = section_age;
    }

  bz_state_info_set_parental_age_rating (self->state, max_age);

  fetch_blocked_ids (self);
}

static void
on_filter_loaded (GObject      *source,
                  GAsyncResult *result,
                  gpointer      user_data)
{
  BzMalcontentService *self       = NULL;
  g_autoptr (MctAppFilter) filter = NULL;
  g_autoptr (GError) local_error  = NULL;

  self   = user_data;
  filter = mct_manager_get_app_filter_finish (self->manager, result, &local_error);

  if (filter != NULL)
    apply_filter (self, filter);
  else
    g_warning ("Failed to load malcontent app filter: %s", local_error->message);
}

static void
on_filter_changed (MctManager *manager,
                   guint64     user_id,
                   gpointer    user_data)
{
  BzMalcontentService *self = NULL;

  self = user_data;

  if (user_id != (guint64) getuid ())
    return;

  mct_manager_get_app_filter_async (self->manager,
                                    getuid (),
                                    MCT_MANAGER_GET_VALUE_FLAGS_NONE,
                                    NULL,
                                    on_filter_loaded,
                                    self);
}