///////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2002-2025, Open Design Alliance (the "Alliance").
// All rights reserved.
//
// This software and its documentation and related materials are owned by
// the Alliance. The software may only be incorporated into application
// programs owned by members of the Alliance, subject to a signed
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable
// trade secrets of the Alliance and its suppliers. The software is also
// protected by copyright law and international treaty provisions. Application
// programs incorporating this software must include the following statement
// with their copyright notices:
//
//   This application incorporates Open Design Alliance software pursuant to a license
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2025 by Open Design Alliance.
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

#include "OdaCommon.h"
#include "OdDbDynBlockAssocEvaluationCallback.h"
#include "DbAssocManager.h"
#include "DbAssocNetwork.h"
#include "DbAssocAction.h"

// Global instance smart pointer
std::unique_ptr<OdDbDynBlockAssocEvaluationCallback> g_pDynBlockAssocCallback;

OdDbDynBlockAssocEvaluationCallback::OdDbDynBlockAssocEvaluationCallback()
  : OdDbAssocEvaluationCallback()
  , m_postponedActions()
{
}

OdDbDynBlockAssocEvaluationCallback::~OdDbDynBlockAssocEvaluationCallback()
{
  m_postponedActions.clear();
}

void OdDbDynBlockAssocEvaluationCallback::addPostponedAction(OdDbBlockPostponedActionPtr pAction)
{
  if (pAction.isNull())
    return;

  m_postponedActions.push_back(pAction);
}

void OdDbDynBlockAssocEvaluationCallback::allDependentActionsMarkedToEvaluate(OdDbAssocNetwork* /*pNetwork*/)
{
}

void OdDbDynBlockAssocEvaluationCallback::beginActionEvaluation(OdDbAssocAction* pAction)
{
  if (m_postponedActions.empty() || !pAction)
    return;

  OdDbDatabase* pDb = pAction->database();
  if (!pDb)
    return;

  OdDbObjectId rootNetworkId = OdDbAssocNetwork::getInstanceFromDatabase(pDb, false);
  if (rootNetworkId.isNull() || pAction->objectId() != rootNetworkId)
    return;
 
  // Execute all postponed actions
  for (auto& pPostponedAction : m_postponedActions)
  {
    if (pPostponedAction.isNull())
      continue;

    // Get and execute the callback
    OdDbBlockPostponedActionCallback callback = pPostponedAction->getCallback();
    if (callback)
    {
      callback(pPostponedAction);
    }
  }
}

void OdDbDynBlockAssocEvaluationCallback::endActionEvaluation(OdDbAssocAction* pAction)
{
  if (!pAction)
    return;

  OdDbDatabase* pDb = pAction->database();
  if (!pDb)
    return;

  OdDbObjectId rootNetworkId = OdDbAssocNetwork::getInstanceFromDatabase(pDb, false);

  if (rootNetworkId.isNull() || pAction->objectId() != rootNetworkId)
    return;

  // Clear all postponed actions after execution (smart pointers handle cleanup)
  m_postponedActions.clear();
}

void OdDbDynBlockAssocEvaluationCallback::setActionEvaluationErrorStatus(OdDbAssocAction* /*pAction*/,
                                                                          OdResult /*errorStatus*/,
                                                                          const OdDbObjectId& /*objectId*/,
                                                                          OdDbObject* /*pObject*/,
                                                                          void* /*pErrorInfo*/)
{
}

bool OdDbDynBlockAssocEvaluationCallback::cancelActionEvaluation()
{
  return false;
}

OdDbEvalContext* OdDbDynBlockAssocEvaluationCallback::getAdditionalData() const
{
  return nullptr;
}

OdDbAssocTransformationType OdDbDynBlockAssocEvaluationCallback::getTransformationType() const
{
  return kNotSpecified;
}

// Module initialization function - should be called when DbConstraints module loads
void initializeDynBlockAssocCallback()
{
  if (!g_pDynBlockAssocCallback)
  {
    g_pDynBlockAssocCallback.reset(new OdDbDynBlockAssocEvaluationCallback());
  }
}

// Module cleanup function - should be called when DbConstraints module unloads
void uninitializeDynBlockAssocCallback()
{
  // unique_ptr will automatically delete the object
  g_pDynBlockAssocCallback.reset();
}