/////////////////////////////////////////////////////////////////////////////// 
// 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 "RxDynamicModule.h"

#include "daiValidationCommon.h"

#include "daiModelValidationTask.h"
#include "daiExtentValidationTask.h"
#include "daiInstanceValidationTask.h"
#include "daiReferenceValidationTask.h"

#include "IfcPlaneAngleUnitValidationTask.h"
#include "IfcCompositeCurveConsistencyValidationTask.h"
#include "IfcClosedShellValidationTask.h"
#include "IfcOpenShellValidationTask.h"
#include "IfcProfileDefValidationTask.h"
#include "IfcProfileDef.h"
#include "IfcShapeRepresentationTask.h"
#include "IfcPSDQTOValidationTask.h"
#include "IfcRepresentationContextValidationTask.h"
#include "IfcRepresentationContextRedundantValidationTask.h"
#include "IfcCurveSegmentParametrizationTask.h"
#include "IfcWhereRulesValidationHealer.h"
#include "daiWhereRulesEntitiesValidationTask.h"
#include "IfcFaceLoopsOrientationValidationTask.h"
#include "IfcReferenceValidationTaskSubHealer.h"
//#include "IfcFacetedBrepValidationTask.h"
//#include "IfcFacetedBrep.h"

using namespace OdIfc;


class IFC_VALIDATION_EXPORT OdIfcValidationModuleImpl
  : public OdDAI::ValidationModule
{
public:

  /** \details
  Initialization of the IFC validation module.
  */

  void initApp() override;
  /** \details
  Uninitialization of the IFC validation module.
  */
  void uninitApp() override;

  /** \details
  Retrieves the name of validation module group.
  \returns An ANSI string that contains the name of validation module group.
  */
  OdAnsiString groupingName() const override;
};

ODRX_DEFINE_DYNAMIC_MODULE(OdIfcValidationModuleImpl);

//#define NOT_IMPLEMENTED_TASKS

namespace
{
  IfcContextSubHealer* g_ifcReferenceHealer = nullptr;
}

void OdIfcValidationModuleImpl::initApp()
{
  PlaneAngleUnitValidationTask::rxInit(m_taskHolder);
  PlaneAngleUnitValidationHealer::rxInit();
  CompositeCurveConsistencyValidationTask::rxInit(m_taskHolder);
  ShapeRepresentationTask::rxInit(m_taskHolder);
  RepresentationContextValidationTask::rxInit(m_taskHolder);
  RepresentationContextValidationHealer::rxInit();
  RepresentationContextRedundantValidationTask::rxInit(m_taskHolder);
  RepresentationContextRedundantValidationHealer::rxInit();
  //IfcPSDQTOValidationTask::rxInit(m_taskHolder);
  CurveSegmentParametrizationValidationTask::rxInit(m_taskHolder);
  CurveSegmentParametrizationValidationHealer::rxInit();
  WhereRulesHealerEntityValidation::rxInit();
  FaceLoopsOrientationValidationTask::rxInit(m_taskHolder);
  FaceLoopsOrientationValidationHealer::rxInit();

#ifdef NOT_IMPLEMENTED_TASKS
  OdIfcProfileDefValidationTask::rxInit(m_taskHolder);
  ClosedShellValidationTask::rxInit(m_taskHolder);
  OpenShellValidationTask::rxInit(m_taskHolder);
  ShellValidationHealer::rxInit();
  //  OdIfcFacetedBrepValidationTask::rxInit();
#endif


  OdDAI::WhereRulesEntitiesValidationTask::desc()->addX(OdDAI::ValidationHealer::desc(), WhereRulesHealerEntityValidation::createObject());
  PlaneAngleUnitValidationTask::desc()->addX(OdDAI::ValidationHealer::desc(), PlaneAngleUnitValidationHealer::createObject());
  RepresentationContextValidationTask::desc()->addX(OdDAI::ValidationHealer::desc(), RepresentationContextValidationHealer::createObject());
  RepresentationContextRedundantValidationTask::desc()->addX(OdDAI::ValidationHealer::desc(), RepresentationContextRedundantValidationHealer::createObject());
  CurveSegmentParametrizationValidationTask::desc()->addX(OdDAI::ValidationHealer::desc(), CurveSegmentParametrizationValidationHealer::createObject());
  FaceLoopsOrientationValidationTask::desc()->addX(OdDAI::ValidationHealer::desc(), FaceLoopsOrientationValidationHealer::createObject());

  // OdIfcFacetedBrep::desc()->addX(OdDAI::ModelValidationTask::desc(), OdIfcFacetedBrepValidationTask::createObject());

  //Adding IfcContextSubHealer
  {
    const OdDAI::ValidationTasksHolder& pTaskHolder = oddaiGetValidationTasksHolder();
    OdRxClassPtr pTask = pTaskHolder.findValidationTask("ReferenceValidationTask");

    if (pTask)
    {
      OdRxObjectPtr pHealer = pTask->getX(OdDAI::ValidationHealer::desc());
      OdDAI::ReferenceValidationTaskHealerPtr pTaskCasted = OdDAI::ReferenceValidationTaskHealer::cast(pHealer);
      g_ifcReferenceHealer = new IfcContextSubHealer();
      pTaskCasted->addSubHealer(g_ifcReferenceHealer);
    }
  }
}

void OdIfcValidationModuleImpl::uninitApp()
{
  {
    const OdDAI::ValidationTasksHolder& pTaskHolder = oddaiGetValidationTasksHolder();
    OdRxClassPtr pTask = pTaskHolder.findValidationTask("ReferenceValidationTask");

    if (pTask)
    {
      OdRxObjectPtr pHealer = pTask->getX(OdDAI::ValidationHealer::desc());
      OdDAI::ReferenceValidationTaskHealerPtr pTaskCasted = OdDAI::ReferenceValidationTaskHealer::cast(pHealer);
      pTaskCasted->deleteSubhealer(g_ifcReferenceHealer);
      delete g_ifcReferenceHealer;
      g_ifcReferenceHealer = nullptr;
    }
  }
  // OdIfcFacetedBrep::desc()->delX(OdDAI::ValidationHealer::desc());
  FaceLoopsOrientationValidationTask::desc()->delX(OdDAI::ValidationHealer::desc());
  CurveSegmentParametrizationValidationTask::desc()->delX(OdDAI::ValidationHealer::desc());
  RepresentationContextRedundantValidationTask::desc()->delX(OdDAI::ValidationHealer::desc());
  RepresentationContextValidationTask::desc()->delX(OdDAI::ValidationHealer::desc());
  PlaneAngleUnitValidationTask::desc()->delX(OdDAI::ValidationHealer::desc());
  OdDAI::WhereRulesEntitiesValidationTask::desc()->delX(OdDAI::ValidationHealer::desc());

  FaceLoopsOrientationValidationHealer::rxUninit();
  FaceLoopsOrientationValidationTask::rxUninit(m_taskHolder);
  WhereRulesHealerEntityValidation::rxUninit();
  CurveSegmentParametrizationValidationHealer::rxUninit();
  CurveSegmentParametrizationValidationTask::rxUninit(m_taskHolder);
  //IfcPSDQTOValidationTask::rxUninit(m_taskHolder);
  RepresentationContextRedundantValidationHealer::rxUninit();
  RepresentationContextRedundantValidationTask::rxUninit(m_taskHolder);
  RepresentationContextValidationHealer::rxUninit();
  RepresentationContextValidationTask::rxUninit(m_taskHolder);
  ShapeRepresentationTask::rxUninit(m_taskHolder);
  PlaneAngleUnitValidationHealer::rxUninit();
  PlaneAngleUnitValidationTask::rxUninit(m_taskHolder);
  CompositeCurveConsistencyValidationTask::rxUninit(m_taskHolder);

#ifdef NOT_IMPLEMENTED_TASKS
  //  OdIfcFacetedBrepValidationTask::rxUninit(m_taskHolder);
  ShellValidationHealer::rxUninit();
  OpenShellValidationTask::rxUninit(m_taskHolder);
  ClosedShellValidationTask::rxUninit(m_taskHolder);
  OdIfcProfileDefValidationTask::rxUninit(m_taskHolder);
#endif
}

OdAnsiString OdIfcValidationModuleImpl::groupingName() const
{
  return "IFC";
}