/////////////////////////////////////////////////////////////////////////////// 
// 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.
///////////////////////////////////////////////////////////////////////////////
/************************************************************************/
/* This console application validate instance attributes                */
/*                                                                      */
/* Calling sequence:                                                    */
/*                                                                      */
/* ExIfcModelValidator <target filename>                                */
/*                                                                      */
/************************************************************************/
#include "ExIfcModelValidator.h"
#include "RxDynamicModule.h"

ODGI_EXPORT void odgiInitialize();
ODGI_EXPORT void odgiUninitialize();

#include "IfcExamplesCommon.h"

#include "ExIfcHostAppServices.h"

#include "RxDynamicModule.h"
#include "DynamicLinker.h"

#include "ExConsoleValidationNotifier.h"
#include "ExTextValidationNotifier.h"
#include "ExHtmlValidationNotifier.h"

#include "daiStringWidthValidationTask.h"
#include "daiAggrSizeValidationTask.h"
#include "daiRequiredExplicitAttrsAssignedValidationTask.h"
#include "daiInverseAttrsValidationTask.h"
#include "daiWhereRulesAttrsValidationTask.h"
#include "daiWhereRulesEntitiesValidationTask.h"
#include "daiGlobalRulesValidationTask.h"
#include "daiUnsupportedSymbolsValidationTask.h"

#include "daiValidator.h"

#include "IfcPlaneAngleUnitValidationTask.h"

#include "daiSimpleProgramOptions.h"
#include "daiFileCompare.h"

using namespace OdDAI;
using namespace OdIfc;

//
// Define module map for statically linked modules:
//
#if !defined(_TOOLKIT_IN_DLL_) 
ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(OdSDAIModule);                                 \
ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(OdIfcCoreModule);                              \
ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(OdRxThreadPoolService);                        \
ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(OdIfc2x3Module);                               \
ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(OdIfc4Module);                                 \
ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(OdIfc4x3Module);                               \
ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT_XMLIO                                          \
ODRX_DECLARE_STATIC_MODULE_ENTRY_POINT(OdIfcValidationModuleImpl);                    \
ODRX_BEGIN_STATIC_MODULE_MAP()                                                        \
  ODRX_DEFINE_STATIC_APPMODULE(OdSDAIModuleName, OdSDAIModule)                        \
  ODRX_DEFINE_STATIC_APPMODULE(OdIfcCoreModuleName, OdIfcCoreModule)                  \
  ODRX_DEFINE_STATIC_APPMODULE(OdThreadPoolModuleName, OdRxThreadPoolService)         \
  ODRX_DEFINE_STATIC_APPMODULE(OdIfc2x3ModuleName, OdIfc2x3Module)                    \
  ODRX_DEFINE_STATIC_APPMODULE(OdIfc4ModuleName, OdIfc4Module)                        \
  ODRX_DEFINE_STATIC_APPMODULE(OdIfc4x3ModuleName, OdIfc4x3Module)                    \
  ODRX_DEFINE_STATIC_APPMODULE_XMLIO                                                  \
  ODRX_DEFINE_STATIC_APPMODULE(OdIfcValidationModuleName, OdIfcValidationModuleImpl)  \
ODRX_END_STATIC_MODULE_MAP()
#endif


void initApp()
{
  odrxDynamicLinker()->loadModule(OdIfcValidationModuleName);

  ConsoleValidationNotifier::rxInit();
  TextValidationNotifier::rxInit();
  HtmlValidationNotifier::rxInit();
}

void uninitApp()
{
  odrxDynamicLinker()->unloadModule(OdIfcValidationModuleName);

  ConsoleValidationNotifier::rxUninit();
  TextValidationNotifier::rxUninit();
  HtmlValidationNotifier::rxUninit();
}



#if defined(OD_USE_WMAIN)
int wmain(int argc, wchar_t* argv[])
#else
int main(int argc, char* argv[])
#endif
{
  OdString szTargetFileName;
  OdString benchmarkFileName;
  OdString createBenchmarkFileName;

  bool  disableText = false;
  bool  disableHtml = false;
  bool  disableConsole = false;
  bool  disableProgress = false;
  bool  enableTimer = false;

  using namespace OdDAI::utils;
  argv_parser  commandLineParser(OD_T("ExIfcModelValidator"));
  commandLineParser.add_param(std::make_shared<hardplace_value_option<OdString>>(szTargetFileName, "File name", "target filename"));
  commandLineParser.add_param(std::make_shared<flag_value_option>(disableText, "-textDisable", "disable text output."));
  commandLineParser.add_param(std::make_shared<flag_value_option>(disableHtml, "-htmlDisable", "disable html output."));
  commandLineParser.add_param(std::make_shared<flag_value_option>(disableConsole, "-consoleDisable", "disable validation console output."));
  commandLineParser.add_param(std::make_shared<flag_value_option>(disableProgress, "-progressDisable", "disable progress output."));
  commandLineParser.add_param(std::make_shared<flag_value_option>(enableTimer, "-timerEnable", "enable timer."));
  commandLineParser.add_param(std::make_shared<key_value_option<OdString>>(benchmarkFileName, "-benchmark", "path to file benchmark, to compare. Does not used if empty."));
  commandLineParser.add_param(std::make_shared<key_value_option<OdString>>(createBenchmarkFileName, "-createBenchmark", "creates benchmark and save it to the target path. Does not used if empty. "));

  std::vector<OdString> argumentList(argv + 1, argv + argc);
  std::stringstream executionStream;

  if (commandLineParser.parse(argumentList, executionStream) != ParseResult::succeed)
  {
    odPrintConsoleString(OD_T("\nExIfcModelValidator sample program. Copyright (c) 2025, Open Design Alliance\n"));
    odPrintConsoleString(OdString(executionStream.str().c_str()));
    odPrintConsoleString(OD_T("\nPress ENTER to continue...\n"));
    return 1;
  }

  // create a service
  OdStaticRxObject<MyServices>  svcs;

#if !defined(_TOOLKIT_IN_DLL_) 
  ODRX_INIT_STATIC_MODULE_MAP();
#endif

  /**********************************************************************/
  /* Initialize Runtime Extension environment                           */
  /**********************************************************************/
  odrxInitialize(&svcs);

  /**********************************************************************/
  /* Initialize IfcCore                                                 */
  /**********************************************************************/
  odIfcInitialize(false /* No CDA */, false /* No geometry calculation needed */);
  initApp();
  
  int result = 0;

  try 
  {

    OdIfcFilePtr pIfcFile = svcs.readFile(szTargetFileName);
    if (pIfcFile.isNull())
    {
      throw;
    }

    OdDAI::ModelPtr pModel = pIfcFile->getModel(sdaiRW);
    InstanceValidationContextPtr instanceValidationContext(new InstanceValidationContext(pModel));
    ValidatorPtr validator = Validator::createObject(instanceValidationContext,pIfcFile->getAppServices(), enableTimer);

    StringWidthValidationTaskPtr stringTask = StringWidthValidationTask::createObject();
    AggrSizeValidationTaskPtr aggrTask = AggrSizeValidationTask::createObject();
    RequiredExplicitAttrsAssignedValidationTaskPtr reqTask = RequiredExplicitAttrsAssignedValidationTask::createObject();
    InverseAttrsValidationTaskPtr inverseTask = InverseAttrsValidationTask::createObject();
    WhereRulesAttrsValidationTaskPtr wrAttrsTask = WhereRulesAttrsValidationTask::createObject();
    WhereRulesEntitiesValidationTaskPtr wrEntitiesTask = WhereRulesEntitiesValidationTask::createObject();

    GlobalRulesValidationTaskPtr globalRulesTask = GlobalRulesValidationTask::createObject();

    PlaneAngleUnitValidationTaskPtr angleTask = PlaneAngleUnitValidationTask::createObject();
    PlaneAngleUnitValidationHealerPtr angleHealer = PlaneAngleUnitValidationHealer::createObject();

    UnsupportedSymbolsValidationTaskPtr unsupportedSymbolsTask = UnsupportedSymbolsValidationTask::createObject();

    NotifierExtraInfo extraInfo;
    extraInfo.fileName = OdAnsiString(pIfcFile->getFileName());
    extraInfo.schemaName = pModel->underlyingSchemaName();
    extraInfo.validationTime = OdDAI::Consts::OdULongUnset;

    OdString benchmarkFileNameCurrent;
    if (!benchmarkFileName.isEmpty())
    {
      TextValidationNotifierPtr textValidationNotifier = TextValidationNotifier::createObject();
      textValidationNotifier->setDateFieldMode(false);
      textValidationNotifier->setVersionFieldMode(false);
      benchmarkFileNameCurrent = benchmarkFileName + OD_T(".cur.bnc");
      textValidationNotifier->setFileName(OdAnsiString(benchmarkFileNameCurrent));
      validator->addNotifier(textValidationNotifier);
    }

    if (!createBenchmarkFileName.isEmpty())
    {
      TextValidationNotifierPtr textValidationNotifier = TextValidationNotifier::createObject();
      textValidationNotifier->setDateFieldMode(false);
      textValidationNotifier->setVersionFieldMode(false);
      textValidationNotifier->setFileName(OdAnsiString(createBenchmarkFileName));
      validator->addNotifier(textValidationNotifier);
    }

    if (disableConsole == false)
    {
      ConsoleValidationNotifierPtr consoleValidationNotifier = ConsoleValidationNotifier::createObject();
      consoleValidationNotifier->setModelInfo(&extraInfo);
      validator->addNotifier(consoleValidationNotifier);
    }

    if (disableText == false)
    {
      TextValidationNotifierPtr textValidationNotifier = TextValidationNotifier::createObject();
      textValidationNotifier->setModelInfo(&extraInfo);
      OdAnsiString textFileName = OdAnsiString(szTargetFileName.left(szTargetFileName.getLength() - 4) + OD_T("_ValidationLog.txt"));
      textValidationNotifier->setFileName(textFileName);
      validator->addNotifier(textValidationNotifier);
    }

    if (disableHtml == false)
    {
      HtmlValidationNotifierPtr htmlValidationNotifier = HtmlValidationNotifier::createObject();
      htmlValidationNotifier->setModelInfo(&extraInfo);
      OdAnsiString htmlFileName = OdAnsiString(szTargetFileName.left(szTargetFileName.getLength() - 4) + OD_T("_ValidationLog.html"));
      htmlValidationNotifier->setFileName(htmlFileName);
      validator->addNotifier(htmlValidationNotifier);
    }

    PlaneAngleUnitValidationTask::desc()->addX(ValidationHealer::desc(), angleHealer);

    validator->addInstanceTask(stringTask);
    validator->addInstanceTask(aggrTask);
    validator->addInstanceTask(reqTask);
    validator->addInstanceTask(inverseTask);
    validator->addInstanceTask(wrAttrsTask);
    validator->addInstanceTask(wrEntitiesTask);
    validator->addInstanceTask(unsupportedSymbolsTask);

    validator->addModelTask(globalRulesTask);
    validator->addModelTask(angleTask);

    if (!disableProgress)
    {
      validator->setProgressMeter(svcs.newProgressMeter());
    }

//    validator->setPrintingResult(Validator::kAll);
//    validator->setPrintingResult(Validator::kNotOk);
//    validator->setValidationType(Validator::kModelValidation);

    validator->run();

    if (!benchmarkFileNameCurrent.isEmpty())
    {
      odPrintConsoleString(OD_T("\nBenchmark test - "));
      std::stringstream errorStream;
      auto isTheSame = OdDAI::utils::compareFiles(benchmarkFileNameCurrent, benchmarkFileName, errorStream);

      remove(static_cast<OdAnsiString>(benchmarkFileNameCurrent).c_str());

      if (isTheSame)
      {
        odPrintConsoleString(OD_T("ok\n"));
        result = 0;
      }
      else
      {
        odPrintConsoleString(OD_T("failed\n"));
        odPrintConsoleString(OdString(errorStream.str().c_str()).c_str());
        result = 1;
      }
    }
  }
  catch (...)
  {
    result = 1;
  }

  uninitApp();

  /**********************************************************************/
  /* Uninitialize IfcCore                                               */
  /**********************************************************************/
  odIfcUninitialize();

  /**********************************************************************/
  /* Uninitialize Runtime Extension environment                         */
  /**********************************************************************/
  ::odrxUninitialize();

  return result;
}