/* PIKA - Photo and Image Kooker Application
 * a rebranding of The GNU Image Manipulation Program (created with heckimp)
 * A derived work which may be trivial. However, any changes may be (C)2023 by Aldercone Studio
 *
 * Original copyright, applying to most contents (license remains unchanged): 
 * Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
 *
 * pikataggedcontainer.c
 * Copyright (C) 2008 Aurimas Juška <aurisj@svn.gnome.org>
 *
 * 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/>.
 */

#include "config.h"

#include <gio/gio.h>

#include "core-types.h"

#include "pika.h"
#include "pikatag.h"
#include "pikatagged.h"
#include "pikataggedcontainer.h"


enum
{
  TAG_COUNT_CHANGED,
  LAST_SIGNAL
};


static void      pika_tagged_container_dispose            (GObject               *object);
static gint64    pika_tagged_container_get_memsize        (PikaObject            *object,
                                                           gint64                *gui_size);

static void      pika_tagged_container_clear              (PikaContainer         *container);

static void      pika_tagged_container_src_add            (PikaFilteredContainer *filtered_container,
                                                           PikaObject            *object);
static void      pika_tagged_container_src_remove         (PikaFilteredContainer *filtered_container,
                                                           PikaObject            *object);
static void      pika_tagged_container_src_freeze         (PikaFilteredContainer *filtered_container);
static void      pika_tagged_container_src_thaw           (PikaFilteredContainer *filtered_container);

static gboolean  pika_tagged_container_object_matches     (PikaTaggedContainer   *tagged_container,
                                                           PikaObject            *object);

static void      pika_tagged_container_tag_added          (PikaTagged            *tagged,
                                                           PikaTag               *tag,
                                                           PikaTaggedContainer   *tagged_container);
static void      pika_tagged_container_tag_removed        (PikaTagged            *tagged,
                                                           PikaTag               *tag,
                                                           PikaTaggedContainer   *tagged_container);
static void      pika_tagged_container_ref_tag            (PikaTaggedContainer   *tagged_container,
                                                           PikaTag               *tag);
static void      pika_tagged_container_unref_tag          (PikaTaggedContainer   *tagged_container,
                                                           PikaTag               *tag);
static void      pika_tagged_container_tag_count_changed  (PikaTaggedContainer   *tagged_container,
                                                           gint                   tag_count);


G_DEFINE_TYPE (PikaTaggedContainer, pika_tagged_container,
               PIKA_TYPE_FILTERED_CONTAINER)

#define parent_class pika_tagged_container_parent_class

static guint pika_tagged_container_signals[LAST_SIGNAL] = { 0, };


static void
pika_tagged_container_class_init (PikaTaggedContainerClass *klass)
{
  GObjectClass               *g_object_class    = G_OBJECT_CLASS (klass);
  PikaObjectClass            *pika_object_class = PIKA_OBJECT_CLASS (klass);
  PikaContainerClass         *container_class   = PIKA_CONTAINER_CLASS (klass);
  PikaFilteredContainerClass *filtered_class    = PIKA_FILTERED_CONTAINER_CLASS (klass);

  g_object_class->dispose        = pika_tagged_container_dispose;

  pika_object_class->get_memsize = pika_tagged_container_get_memsize;

  container_class->clear         = pika_tagged_container_clear;

  filtered_class->src_add        = pika_tagged_container_src_add;
  filtered_class->src_remove     = pika_tagged_container_src_remove;
  filtered_class->src_freeze     = pika_tagged_container_src_freeze;
  filtered_class->src_thaw       = pika_tagged_container_src_thaw;

  klass->tag_count_changed       = pika_tagged_container_tag_count_changed;

  pika_tagged_container_signals[TAG_COUNT_CHANGED] =
    g_signal_new ("tag-count-changed",
                  PIKA_TYPE_TAGGED_CONTAINER,
                  G_SIGNAL_RUN_LAST,
                  G_STRUCT_OFFSET (PikaTaggedContainerClass, tag_count_changed),
                  NULL, NULL, NULL,
                  G_TYPE_NONE, 1,
                  G_TYPE_INT);
}

static void
pika_tagged_container_init (PikaTaggedContainer *tagged_container)
{
  tagged_container->tag_ref_counts =
    g_hash_table_new_full ((GHashFunc) pika_tag_get_hash,
                           (GEqualFunc) pika_tag_equals,
                           (GDestroyNotify) g_object_unref,
                           (GDestroyNotify) NULL);
}

static void
pika_tagged_container_dispose (GObject *object)
{
  PikaTaggedContainer *tagged_container = PIKA_TAGGED_CONTAINER (object);

  if (tagged_container->filter)
    {
      g_list_free_full (tagged_container->filter,
                        (GDestroyNotify) pika_tag_or_null_unref);
      tagged_container->filter = NULL;
    }

  g_clear_pointer (&tagged_container->tag_ref_counts, g_hash_table_unref);

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

static gint64
pika_tagged_container_get_memsize (PikaObject *object,
                                   gint64     *gui_size)
{
  gint64 memsize = 0;

  /* FIXME take members into account */

  return memsize + PIKA_OBJECT_CLASS (parent_class)->get_memsize (object,
                                                                  gui_size);
}

static void
pika_tagged_container_clear (PikaContainer *container)
{
  PikaFilteredContainer *filtered_container = PIKA_FILTERED_CONTAINER (container);
  PikaTaggedContainer   *tagged_container   = PIKA_TAGGED_CONTAINER (container);
  GList                 *list;

  for (list = PIKA_LIST (filtered_container->src_container)->queue->head;
       list;
       list = g_list_next (list))
    {
      g_signal_handlers_disconnect_by_func (list->data,
                                            pika_tagged_container_tag_added,
                                            tagged_container);
      g_signal_handlers_disconnect_by_func (list->data,
                                            pika_tagged_container_tag_removed,
                                            tagged_container);
    }

  if (tagged_container->tag_ref_counts)
    {
      g_hash_table_remove_all (tagged_container->tag_ref_counts);
      tagged_container->tag_count = 0;
    }

  PIKA_CONTAINER_CLASS (parent_class)->clear (container);
}

static void
pika_tagged_container_src_add (PikaFilteredContainer *filtered_container,
                               PikaObject            *object)
{
  PikaTaggedContainer *tagged_container = PIKA_TAGGED_CONTAINER (filtered_container);
  GList               *list;

  for (list = pika_tagged_get_tags (PIKA_TAGGED (object));
       list;
       list = g_list_next (list))
    {
      pika_tagged_container_ref_tag (tagged_container, list->data);
    }

  g_signal_connect (object, "tag-added",
                    G_CALLBACK (pika_tagged_container_tag_added),
                    tagged_container);
  g_signal_connect (object, "tag-removed",
                    G_CALLBACK (pika_tagged_container_tag_removed),
                    tagged_container);

  if (pika_tagged_container_object_matches (tagged_container, object))
    {
      pika_container_add (PIKA_CONTAINER (tagged_container), object);
    }
}

static void
pika_tagged_container_src_remove (PikaFilteredContainer *filtered_container,
                                  PikaObject            *object)
{
  PikaTaggedContainer *tagged_container = PIKA_TAGGED_CONTAINER (filtered_container);
  GList               *list;

  g_signal_handlers_disconnect_by_func (object,
                                        pika_tagged_container_tag_added,
                                        tagged_container);
  g_signal_handlers_disconnect_by_func (object,
                                        pika_tagged_container_tag_removed,
                                        tagged_container);

  for (list = pika_tagged_get_tags (PIKA_TAGGED (object));
       list;
       list = g_list_next (list))
    {
      pika_tagged_container_unref_tag (tagged_container, list->data);
    }

  if (pika_tagged_container_object_matches (tagged_container, object))
    {
      pika_container_remove (PIKA_CONTAINER (tagged_container), object);
    }
}

static void
pika_tagged_container_src_freeze (PikaFilteredContainer *filtered_container)
{
  pika_container_clear (PIKA_CONTAINER (filtered_container));
}

static void
pika_tagged_container_src_thaw (PikaFilteredContainer *filtered_container)
{
  GList *list;

  for (list = PIKA_LIST (filtered_container->src_container)->queue->head;
       list;
       list = g_list_next (list))
    {
      pika_tagged_container_src_add (filtered_container, list->data);
    }
}

/**
 * pika_tagged_container_new:
 * @src_container: container to be filtered.
 *
 * Creates a new #PikaTaggedContainer object which creates filtered
 * data view of #PikaTagged objects. It filters @src_container for
 * objects containing all of the filtering tags. Synchronization with
 * @src_container data is performed automatically.
 *
 * Returns: a new #PikaTaggedContainer object.
 **/
PikaContainer *
pika_tagged_container_new (PikaContainer *src_container)
{
  PikaTaggedContainer *tagged_container;
  GType                children_type;
  GCompareFunc         sort_func;

  g_return_val_if_fail (PIKA_IS_LIST (src_container), NULL);

  children_type = pika_container_get_children_type (src_container);
  sort_func     = pika_list_get_sort_func (PIKA_LIST (src_container));

  tagged_container = g_object_new (PIKA_TYPE_TAGGED_CONTAINER,
                                   "sort-func",     sort_func,
                                   "children-type", children_type,
                                   "policy",        PIKA_CONTAINER_POLICY_WEAK,
                                   "unique-names",  FALSE,
                                   "src-container", src_container,
                                   NULL);

  return PIKA_CONTAINER (tagged_container);
}

/**
 * pika_tagged_container_set_filter:
 * @tagged_container: a #PikaTaggedContainer object.
 * @tags:             list of #PikaTag objects.
 *
 * Sets list of tags to be used for filtering. Only objects which have
 * all of the tags assigned match filtering criteria.
 **/
void
pika_tagged_container_set_filter (PikaTaggedContainer *tagged_container,
                                  GList               *tags)
{
  GList *new_filter;

  g_return_if_fail (PIKA_IS_TAGGED_CONTAINER (tagged_container));

  if (tags)
    {
      GList *list;

      for (list = tags; list; list = g_list_next (list))
        g_return_if_fail (list->data == NULL || PIKA_IS_TAG (list->data));
    }

  if (! pika_container_frozen (PIKA_FILTERED_CONTAINER (tagged_container)->src_container))
    {
      pika_tagged_container_src_freeze (PIKA_FILTERED_CONTAINER (tagged_container));
    }

  /*  ref new tags first, they could be the same as the old ones  */
  new_filter = g_list_copy (tags);
  g_list_foreach (new_filter, (GFunc) pika_tag_or_null_ref, NULL);

  g_list_free_full (tagged_container->filter,
                    (GDestroyNotify) pika_tag_or_null_unref);
  tagged_container->filter = new_filter;

  if (! pika_container_frozen (PIKA_FILTERED_CONTAINER (tagged_container)->src_container))
    {
      pika_tagged_container_src_thaw (PIKA_FILTERED_CONTAINER (tagged_container));
    }
}

/**
 * pika_tagged_container_get_filter:
 * @tagged_container: a #PikaTaggedContainer object.
 *
 * Returns current tag filter. Tag filter is a list of PikaTag objects, which
 * must be contained by each object matching filter criteria.
 *
 * Returns: a list of PikaTag objects used as filter. This value should
 *               not be modified or freed.
 **/
const GList *
pika_tagged_container_get_filter (PikaTaggedContainer *tagged_container)
{
  g_return_val_if_fail (PIKA_IS_TAGGED_CONTAINER (tagged_container), NULL);

  return tagged_container->filter;
}

static gboolean
pika_tagged_container_object_matches (PikaTaggedContainer *tagged_container,
                                      PikaObject          *object)
{
  GList *filter_tags;

  for (filter_tags = tagged_container->filter;
       filter_tags;
       filter_tags = g_list_next (filter_tags))
    {
      if (! filter_tags->data)
        {
          /* invalid tag - does not match */
          return FALSE;
        }

      if (! pika_tagged_has_tag (PIKA_TAGGED (object),
                                 filter_tags->data))
        {
          /* match for the tag was not found.
           * since query is of type AND, it whole fails.
           */
          return FALSE;
        }
    }

  return TRUE;
}

static void
pika_tagged_container_tag_added (PikaTagged          *tagged,
                                 PikaTag             *tag,
                                 PikaTaggedContainer *tagged_container)
{
  pika_tagged_container_ref_tag (tagged_container, tag);

  if (pika_tagged_container_object_matches (tagged_container,
                                            PIKA_OBJECT (tagged)) &&
      ! pika_container_have (PIKA_CONTAINER (tagged_container),
                             PIKA_OBJECT (tagged)))
    {
      pika_container_add (PIKA_CONTAINER (tagged_container),
                          PIKA_OBJECT (tagged));
    }
}

static void
pika_tagged_container_tag_removed (PikaTagged          *tagged,
                                   PikaTag             *tag,
                                   PikaTaggedContainer *tagged_container)
{
  pika_tagged_container_unref_tag (tagged_container, tag);

  if (! pika_tagged_container_object_matches (tagged_container,
                                              PIKA_OBJECT (tagged)) &&
      pika_container_have (PIKA_CONTAINER (tagged_container),
                           PIKA_OBJECT (tagged)))
    {
      pika_container_remove (PIKA_CONTAINER (tagged_container),
                             PIKA_OBJECT (tagged));
    }
}

static void
pika_tagged_container_ref_tag (PikaTaggedContainer *tagged_container,
                               PikaTag             *tag)
{
  gint ref_count;

  ref_count = GPOINTER_TO_INT (g_hash_table_lookup (tagged_container->tag_ref_counts,
                                                    tag));
  ref_count++;
  g_hash_table_insert (tagged_container->tag_ref_counts,
                       g_object_ref (tag),
                       GINT_TO_POINTER (ref_count));

  if (ref_count == 1)
    {
      tagged_container->tag_count++;
      g_signal_emit (tagged_container,
                     pika_tagged_container_signals[TAG_COUNT_CHANGED], 0,
                     tagged_container->tag_count);
    }
}

static void
pika_tagged_container_unref_tag (PikaTaggedContainer *tagged_container,
                                 PikaTag             *tag)
{
  gint ref_count;

  ref_count = GPOINTER_TO_INT (g_hash_table_lookup (tagged_container->tag_ref_counts,
                                                    tag));
  ref_count--;

  if (ref_count > 0)
    {
      g_hash_table_insert (tagged_container->tag_ref_counts,
                           g_object_ref (tag),
                           GINT_TO_POINTER (ref_count));
    }
  else
    {
      if (g_hash_table_remove (tagged_container->tag_ref_counts, tag))
        {
          tagged_container->tag_count--;
          g_signal_emit (tagged_container,
                         pika_tagged_container_signals[TAG_COUNT_CHANGED], 0,
                         tagged_container->tag_count);
        }
    }
}

static void
pika_tagged_container_tag_count_changed (PikaTaggedContainer *container,
                                         gint                 tag_count)
{
}

/**
 * pika_tagged_container_get_tag_count:
 * @container:  a #PikaTaggedContainer object.
 *
 * Get number of distinct tags that are currently assigned to all
 * objects in the container. The count is independent of currently
 * used filter, it is provided for all available objects (ie. empty
 * filter).
 *
 * Returns: number of distinct tags assigned to all objects in the
 *               container.
 **/
gint
pika_tagged_container_get_tag_count (PikaTaggedContainer *container)
{
  g_return_val_if_fail (PIKA_IS_TAGGED_CONTAINER (container), 0);

  return container->tag_count;
}