/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

/** \file
 * \ingroup bke
 */

#include "BLI_listbase.h"

#include "BKE_callbacks.hh"

#include "MEM_guardedalloc.h"

#include "RNA_access.hh"
#include "RNA_prototypes.hh"

namespace blender {

static ListBaseT<bCallbackFuncStore> callback_slots[BKE_CB_EVT_TOT] = {{nullptr}};

static bool callbacks_initialized = false;

#define ASSERT_CALLBACKS_INITIALIZED() \
  BLI_assert_msg(callbacks_initialized, \
                 "Callbacks should be initialized with BKE_callback_global_init() before using " \
                 "the callback system.")

void BKE_callback_exec(Main *bmain, PointerRNA **pointers, const int pointers_num, eCbEvent evt)
{
  ASSERT_CALLBACKS_INITIALIZED();

  /* Use mutable iteration so handlers are able to remove themselves. */
  ListBaseT<bCallbackFuncStore> *lb = &callback_slots[evt];
  for (bCallbackFuncStore &funcstore : lb->items_mutable()) {
    funcstore.func(bmain, pointers, pointers_num, funcstore.arg);
  }
}

void BKE_callback_exec_null(Main *bmain, eCbEvent evt)
{
  BKE_callback_exec(bmain, nullptr, 0, evt);
}

void BKE_callback_exec_id(Main *bmain, ID *id, eCbEvent evt)
{
  PointerRNA id_ptr = RNA_id_pointer_create(id);

  PointerRNA *pointers[1] = {&id_ptr};

  BKE_callback_exec(bmain, pointers, ARRAY_SIZE(pointers), evt);
}

void BKE_callback_exec_id_depsgraph(Main *bmain, ID *id, Depsgraph *depsgraph, eCbEvent evt)
{
  PointerRNA id_ptr = RNA_id_pointer_create(id);

  PointerRNA depsgraph_ptr = RNA_pointer_create_discrete(nullptr, RNA_Depsgraph, depsgraph);

  PointerRNA *pointers[2] = {&id_ptr, &depsgraph_ptr};

  BKE_callback_exec(bmain, pointers, ARRAY_SIZE(pointers), evt);
}

void BKE_callback_exec_boolean(Main *bmain, bool value, eCbEvent evt)
{
  PrimitiveBooleanRNA data = {};
  data.value = value;
  PointerRNA boolean_ptr = RNA_pointer_create_discrete(nullptr, RNA_PrimitiveBoolean, &data);

  PointerRNA *pointers[1] = {&boolean_ptr};

  BKE_callback_exec(bmain, pointers, ARRAY_SIZE(pointers), evt);
}

void BKE_callback_exec_string(Main *bmain, const char *str, eCbEvent evt)
{
  PrimitiveStringRNA data = {nullptr};
  data.value = str;
  PointerRNA str_ptr = RNA_pointer_create_discrete(nullptr, RNA_PrimitiveString, &data);

  PointerRNA *pointers[1] = {&str_ptr};

  BKE_callback_exec(bmain, pointers, ARRAY_SIZE(pointers), evt);
}

void BKE_callback_add(bCallbackFuncStore *funcstore, eCbEvent evt)
{
  ASSERT_CALLBACKS_INITIALIZED();
  ListBaseT<bCallbackFuncStore> *lb = &callback_slots[evt];
  BLI_addtail(lb, funcstore);
}

void BKE_callback_remove(bCallbackFuncStore *funcstore, eCbEvent evt)
{
  /* The callback may have already been removed by BKE_callback_global_finalize(), for
   * example when removing callbacks in response to a BKE_blender_atexit_register callback
   * function. `BKE_blender_atexit()` runs after `BKE_callback_global_finalize()`. */
  if (!callbacks_initialized) {
    return;
  }

  ListBaseT<bCallbackFuncStore> *lb = &callback_slots[evt];

  /* Be noisy about potential programming errors. */
  BLI_assert_msg(BLI_findindex(lb, funcstore) != -1, "To-be-removed callback not found");

  BLI_remlink(lb, funcstore);

  if (funcstore->alloc) {
    MEM_delete(funcstore);
  }
}

void BKE_callback_global_init()
{
  callbacks_initialized = true;
}

void BKE_callback_global_finalize()
{
  for (int evt_i = 0; evt_i < BKE_CB_EVT_TOT; evt_i++) {
    const eCbEvent evt = eCbEvent(evt_i);
    ListBaseT<bCallbackFuncStore> *lb = &callback_slots[evt];
    bCallbackFuncStore *funcstore;
    bCallbackFuncStore *funcstore_next;
    for (funcstore = static_cast<bCallbackFuncStore *>(lb->first); funcstore;
         funcstore = funcstore_next)
    {
      funcstore_next = funcstore->next;
      BKE_callback_remove(funcstore, evt);
    }
  }

  callbacks_initialized = false;
}

}  // namespace blender