/////////////////////////////////////////////////////////////////////////////// 
// 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 <iostream>
#include "ProjectSetup.h"
#include "ExIfcTutorial_IfcTunnel.h"

using namespace OdIfc;

OdDAIObjectId appendCartesianPoint(OdIfcModel *model, const OdArray<double> &dblArr);
OdDAIObjectId appendDirection(OdIfcModel *model, const OdArray<double> &dblArr);
OdDAIObjectId appendSpatialChild(OdIfcModel *model, const OdDAIObjectId &idRelating, OdIfc::OdIfcInstance *related, const OdDAIObjectId &idOwnerHistory);
OdDAIObjectId appendContained(OdIfcModel *model, const OdDAIObjectId &idRelating, OdIfc::OdIfcInstance *related, const OdDAIObjectId &idOwnerHistory);


Tutorial_IfcTunnel_Deployment::Tutorial_IfcTunnel_Deployment(const OdString& applicationName)
  : BaseIfcTutorial(applicationName)
{
  m_tutorialArgsParser.
    add_param(
      std::make_shared<OdDAI::utils::hardplace_value_option<OdString>>(m_fileName, "filename", "output .ifc file"));

  m_tutorialArgsParser.
    add_param(
      std::make_shared<OdDAI::utils::key_value_option<OdAnsiString>>(m_georef, "georef", "Georef scenario for sprint 1.2, one of A, B or C", true));

  m_tutorialArgsParser
    .add_param(
      std::make_shared<OdDAI::utils::flag_value_option>(m_noWait, "-NoWait", "disable \"press any key\" on finish."));
}


int Tutorial_IfcTunnel_Deployment::run(const MyServices &svcs, const std::vector<OdString>& argv, std::ostream& resultStream)
{
  auto parseResult = BaseIfcTutorial::run(svcs, argv, resultStream);
  if (parseResult != 0)
  {
    return parseResult;
  }

  OdIfcFilePtr ifcFile = svcs.createDatabase(kScmIfc4x4);
  OdIfcModelPtr model = ifcFile->getModel(sdaiRW);

  OdDAI::ApplicationInstancePtr person = model->createEntityInstance("ifcperson");
  person->putAttr("identification", (const char*)"Vov-A6 Lab Tech");
  person->putAttr("givenname", (const char*)"Vovchik");
  OdDAIObjectId idPerson = model->appendEntityInstance(person); // person added to model and has id after this line
  OdDAI::ApplicationInstancePtr organization = model->createEntityInstance("ifcorganization");
  organization->putAttr("name", (const char *)"Open Design Alliance");
  OdDAIObjectId idOrganization = model->appendEntityInstance(organization);

  auto personAndOrganization = model->createEntityInstance("ifcpersonandorganization");
  personAndOrganization->putAttr("theperson", idPerson);
  personAndOrganization->putAttr("theorganization", idOrganization);
  auto idPersonAndOrganization = model->appendEntityInstance(personAndOrganization);

  auto organizationForApplication = model->createEntityInstance("ifcorganization");
  organizationForApplication->putAttr("name", OdAnsiString("Company 1"));
  organizationForApplication->putAttr("description", OdAnsiString("File produced in ODA IFC SDK ExIfcTutorials example"));
  auto idOrganizationForApplication = model->appendEntityInstance(organizationForApplication);

  auto application = model->createEntityInstance("ifcapplication");
  application->putAttr("applicationdeveloper", idOrganizationForApplication);
  application->putAttr("version", OdAnsiString("0.1 pre alpha"));
  application->putAttr("applicationfullname", OdAnsiString("ExIfcTutorials module for ODA IFC SDK"));
  application->putAttr("applicationidentifier", OdAnsiString("ExIfcTutorials"));
  auto idApplication = model->appendEntityInstance(application);

  auto ownerHistory = model->createEntityInstance("ifcownerhistory");
  ownerHistory->putAttr("owninguser", idPersonAndOrganization);
  ownerHistory->putAttr("owningapplication", idApplication);
  ownerHistory->putAttr("changeaction", OdAnsiString("ADDED"));
  OdTimeStamp timeStamp(OdTimeStamp::kInitUniversalTime);
  ownerHistory->putAttr("lastmodifieddate", static_cast<int>(timeStamp.packedValue()));
  ownerHistory->putAttr("creationdate", 0);
  auto idOwnerHistory = model->appendEntityInstance(ownerHistory);


  OdArray<OdRxValue> units;
  units.append(appendIfcSiUnit(model, "LENGTHUNIT", nullptr, "METRE"));
  units.append(appendIfcSiUnit(model, "AREAUNIT", nullptr, "SQUARE_METRE"));
  units.append(appendIfcSiUnit(model, "VOLUMEUNIT", nullptr, "CUBIC_METRE"));

#ifdef _USE_RADIAN
  units.append(appendIfcSiUnit(model, "PLANEANGLEUNIT", nullptr, "RADIAN"));
#else
  OdDAIObjectId idPlaneAngleUnit = appendIfcSiUnit(model, "PLANEANGLEUNIT", nullptr, "RADIAN");
  OdDAI::ApplicationInstancePtr measureWithUnit = model->createEntityInstance("ifcmeasurewithunit");
  OdDAI::AttributeDataBlock adb;
  adb.typePath.add("ifcplaneanglemeasure");
  adb.value.setValue(0.017453292519943295);
  measureWithUnit->putAttr("valuecomponent", &adb);
  measureWithUnit->putAttr("unitcomponent", idPlaneAngleUnit);
  OdDAIObjectId idMeasureWithUnit = model->appendEntityInstance(measureWithUnit);

  OdDAI::ApplicationInstancePtr dimensionalExponents = model->createEntityInstance("ifcdimensionalexponents");
  dimensionalExponents->putAttrs(
    "lengthexponent", 0,
    "massexponent", 0,
    "timeexponent", 0,
    "electriccurrentexponent", 0,
    "thermodynamictemperatureexponent", 0,
    "amountofsubstanceexponent", 0,
    "luminousintensityexponent", 0);
  OdDAIObjectId idDimensionalExponents = model->appendEntityInstance(dimensionalExponents);

  OdDAI::ApplicationInstancePtr conversionBasedUnit = model->createEntityInstance("ifcconversionbasedunit");
  conversionBasedUnit->putAttr("dimensions", idDimensionalExponents);
  conversionBasedUnit->putAttr("unittype", (const char*)"PLANEANGLEUNIT");
  conversionBasedUnit->putAttr("name", (const char*)"degree");
  conversionBasedUnit->putAttr("conversionfactor", idMeasureWithUnit);
  units.append(model->appendEntityInstance(conversionBasedUnit));
#endif

  units.append(appendIfcSiUnit(model, "MASSUNIT", "KILO", "GRAM"));
  units.append(appendIfcSiUnit(model, "TIMEUNIT", nullptr, "SECOND"));

  auto unitAssignment = model->createEntityInstance("ifcunitassignment");
  unitAssignment->putAttrCaseInsensitive("Units", units);
  auto idUnitAssignment = model->appendEntityInstance(unitAssignment);


  auto project = model->createEntityInstance("ifcproject");
  project->putAttr("globalid", OdDAI::CompressedGUID::generate());
  project->putAttr("ownerhistory", idOwnerHistory);
  project->putAttr("name", (const char*)"Ifc Tunnel Deployment");
  project->putAttr("unitsincontext", idUnitAssignment);
  auto idProject = model->appendEntityInstance(project);

  OdArray<double> dblArr;
  dblArr.append(0.);
  dblArr.append(0.);
  auto idCartesianPoint2d = appendCartesianPoint(model, dblArr);
  dblArr.append(0.);
  auto idCartesianPoint3d = appendCartesianPoint(model, dblArr);

  dblArr[2] = 1.;
  auto idDirectionZ = appendDirection(model, dblArr);

  //
  // Representation Contexts
  //
  OdDAIObjectIds idsCtx;

  // Plan context
  auto axis2placement2d = model->createEntityInstance("ifcaxis2placement2d");
  axis2placement2d->putAttr("location", idCartesianPoint2d);
  auto idAxis2Placement2d = model->appendEntityInstance(axis2placement2d);

  auto ctxPlan = model->createEntityInstance("ifcgeometricrepresentationcontext");
  ctxPlan->putAttr("contextidentifier", OdAnsiString("2D"));
  ctxPlan->putAttr("contexttype", OdAnsiString("Plan"));
  ctxPlan->putAttr("coordinatespacedimension", 2);
  ctxPlan->putAttr("worldcoordinatesystem", idAxis2Placement2d);
  idsCtx.append(model->appendEntityInstance(ctxPlan));

  // Model context
  auto axis2placement3d = model->createEntityInstance("ifcaxis2placement3d");
  axis2placement3d->putAttr("location", idCartesianPoint3d);
  auto idAxis2Placement3d = model->appendEntityInstance(axis2placement3d);

  auto ctxModel = model->createEntityInstance("ifcgeometricrepresentationcontext");
  ctxModel->putAttr("contextidentifier", OdAnsiString("3D"));
  ctxModel->putAttr("contexttype", OdAnsiString("Model"));
  ctxModel->putAttr("coordinatespacedimension", 3);
  ctxModel->putAttr("worldcoordinatesystem", idAxis2Placement3d);
  idsCtx.append(model->appendEntityInstance(ctxModel));

  project->putAttr("representationcontexts", idsCtx);

  //
  // IfcClassification
  //
  auto classification = model->createEntityInstance("ifcclassification");
  classification->putAttr("source", (const char*)"Classification Source");
  classification->putAttr("name", (const char*)"Classification");
  auto idClassification = model->appendEntityInstance(classification);

  auto relAssociatesClassification = model->createEntityInstance("ifcrelassociatesclassification");
  relAssociatesClassification->putAttr("globalid", OdDAI::CompressedGUID::generate());
  OdDAI::Aggr *aggrRelatedObjects{};
  relAssociatesClassification->getAttr("relatedobjects") >> aggrRelatedObjects;
  OdDAI::SetOfOdDAIObjectId *relatedObjects = static_cast<OdDAI::SetOfOdDAIObjectId*>(aggrRelatedObjects);
  relatedObjects->createEmpty();
  relatedObjects->Add(OdRxValue(idProject));
  relAssociatesClassification->putAttr("relatingclassification", idClassification);
  auto idRelAssociatesClassification = model->appendEntityInstance(relAssociatesClassification);

  //
  // IfcRelDeclares
  //
  OdDAI::ApplicationInstancePtr projectDeclares;
  OdDAI::SetOfOdDAIObjectId *projectRelatedDefinitions{};
  {
    //
    // IfcGroup
    //
    OdDAI::ApplicationInstancePtr group = model->createEntityInstance("ifcgroup");
    group->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
    group->putAttr("ownerhistory", idOwnerHistory);
    group->putAttr("name", (const char*)"Just a group");
    OdDAIObjectId idGroup = model->appendEntityInstance(group);

    //
    // IfcActor
    //
    OdDAI::ApplicationInstancePtr actorRole = model->createEntityInstance("ifcactorrole");
    actorRole->putAttr("role", (const char*)"USERDEFINED");
    actorRole->putAttr("userdefinedrole", (const char*)"Ifc Tunnel Deployer");
    OdDAIObjectId idActorRole = model->appendEntityInstance(actorRole);

    OdDAI::ApplicationInstancePtr person = model->createEntityInstance("ifcperson");
    person->putAttr("givenname", (const char*)"Name of person");
    OdDAI::Aggr *aggrRoles{};
    person->getAttr("roles") >> aggrRoles;
    OdDAI::ListOfOdDAIObjectId *roles = static_cast<OdDAI::ListOfOdDAIObjectId *>(aggrRoles);
    roles->createEmpty();
    roles->addByIndex(0, idActorRole);
    OdDAIObjectId idPerson = model->appendEntityInstance(person);

    OdDAI::ApplicationInstancePtr actor = model->createEntityInstance("ifcactor");
    actor->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
    actor->putAttr("ownerhistory", idOwnerHistory);
    actor->putAttr("name", (const char*)"An Ifc Tunnel Actor");
    actor->putAttr("theactor", idPerson);
    OdDAIObjectId idActor = model->appendEntityInstance(actor);

    projectDeclares = model->createEntityInstance("ifcreldeclares");
    projectDeclares->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
    projectDeclares->putAttr("ownerhistory", idOwnerHistory);
    projectDeclares->putAttr("name", (const char*)"Declarations for IfcProject");
    projectDeclares->putAttr("relatingcontext", idProject);
    OdDAI::Aggr *aggrRelatedDefinitions{};
    projectDeclares->getAttr("relateddefinitions") >> aggrRelatedDefinitions;
    projectRelatedDefinitions = static_cast<OdDAI::SetOfOdDAIObjectId*>(aggrRelatedDefinitions);
    projectRelatedDefinitions->createEmpty();
    projectRelatedDefinitions->Add(OdRxValue(idGroup));
    projectRelatedDefinitions->Add(OdRxValue(idActor));
    OdDAIObjectId idRelDeclares = model->appendEntityInstance(projectDeclares);
  }

  //
  // Spatial structure
  //
  OdIfcInstancePtr site = model->createEntityInstance("ifcsite");
  site->putAttr("name", (const char*)"Site");
  auto idSite = appendSpatialChild(model, idProject, site, idOwnerHistory);

  OdIfcInstancePtr tunnel = model->createEntityInstance("ifctunnel");
  tunnel->putAttr("name", (const char*)"Tunnel");
  tunnel->putAttr("predefinedtype", (const char*)"ACCESSTUNNEL");
  auto idTunnel = appendSpatialChild(model, idSite, tunnel, idOwnerHistory);

    const OdAnsiString wktGeoref_Geodetic =
      "GEODCRS[\"WGS 84\","
      "  DATUM[\"World Geodetic System 1984\","
      "  ELLIPSOID[\"WGS 84\", 6378137, 298.257223563, LENGTHUNIT[\"metre\", 1]]],"
      "  CS[ellipsoidal, 2],"
      "  AXIS[\"Latitude(lat)\", north, ORDER[1]],"
      "  AXIS[\"Longitude(lon)\", east, ORDER[2]],"
      "  ANGLEUNIT[\"degree\", 0.0174532925199433]]\"";

    const OdAnsiString wktGeoref_Projected =
      "PROJCS[\"Pulkovo 1942 / Caspian Sea Mercator\","
      "  GEOGCS[\"Pulkovo 1942\","
      "    DATUM[\"Pulkovo_1942\","
      "      SPHEROID[\"Krassowsky 1940\", 6378245, 298.3],"
      "      TOWGS84[25, -141, -78.5, 0, -0.35, -0.736, 0]],"
      "    PRIMEM[\"Greenwich\", 0,"
      "      AUTHORITY[\"EPSG\", \"8901\"]],"
      "    UNIT[\"degree\", 0.0174532925199433,"
      "      AUTHORITY[\"EPSG\", \"9122\"]],"
      "    AUTHORITY[\"EPSG\", \"4284\"]],"
      "  PROJECTION[\"Mercator_2SP\"],"
      "  PARAMETER[\"standard_parallel_1\", 42],"
      "  PARAMETER[\"central_meridian\", 51],"
      "  PARAMETER[\"false_easting\", 0],"
      "  PARAMETER[\"false_northing\", 0],"
      "  UNIT[\"metre\", 1,"
      "    AUTHORITY[\"EPSG\", \"9001\"]],"
      "  AUTHORITY[\"EPSG\", \"3388\"]]";

  //
  // Georef_A
  //
  if (m_georef.isEmpty() || m_georef == "A")
  {
    OdDAI::ApplicationInstancePtr projectedCRS = model->createEntityInstance("ifcprojectedcrs");
    projectedCRS->putAttr("name", (const char*)"EPSG:2589");
    projectedCRS->putAttr("geodeticdatum", (const char*)"Pulkovo 1942 / 3-degree Gauss-Kruger CM 42E");
    auto idProjectedCRS = model->appendEntityInstance(projectedCRS);

    OdDAI::ApplicationInstancePtr mapConversion = model->createEntityInstance("ifcmapconversion");
    mapConversion->putAttr("sourcecrs", OdDAIObjectId(ctxModel->id()));
    mapConversion->putAttr("targetcrs", idProjectedCRS);
    mapConversion->putAttr("eastings", 10000.);
    mapConversion->putAttr("northings", 15000.);
    mapConversion->putAttr("orthogonalheight", 0.);
    mapConversion->putAttr("xaxisabscissa", 1.);
    mapConversion->putAttr("xaxisordinate", 0.);
    mapConversion->putAttr("scale", 1.);
    auto idMapConversion = model->appendEntityInstance(mapConversion);

    OdDAI::ApplicationInstancePtr wellKnownText = model->createEntityInstance("ifcwellknowntext");
    wellKnownText->putAttr("wellknowntext", wktGeoref_Projected);
    wellKnownText->putAttr("coordinatereferencesystem", idProjectedCRS);
    auto idWellKnownText = model->appendEntityInstance(wellKnownText);
  }

  //
  // Georef_B
  //
  else if (m_georef == "B")
  {
    OdDAI::ApplicationInstancePtr geographicCRS = model->createEntityInstance("ifcgeographiccrs");
    geographicCRS->putAttr("name", (const char*)"EPSG:4326");
    geographicCRS->putAttr("geodeticdatum", (const char*)"World Geodetic System (WGS84)");
    auto idGeographicCRS = model->appendEntityInstance(geographicCRS);

    OdDAI::ApplicationInstancePtr rigidOperation = model->createEntityInstance("ifcrigidoperation");
    rigidOperation->putAttr("sourcecrs", OdDAIObjectId(ctxModel->id()));
    rigidOperation->putAttr("targetcrs", idGeographicCRS);

    OdDAI::AttributeDataBlock adbFirstCoordinate;
    adbFirstCoordinate.typePath.add("IfcPlaneAngleMeasure");
    adbFirstCoordinate.value.setValue(0.);
    rigidOperation->putAttr("firstcoordinate", &adbFirstCoordinate);

    OdDAI::AttributeDataBlock adbSecondCoordinate;
    adbSecondCoordinate.typePath.add("IfcPlaneAngleMeasure");
    adbSecondCoordinate.value.setValue(90.);
    rigidOperation->putAttr("secondcoordinate", &adbSecondCoordinate);

    rigidOperation->putAttr("height", 0.);
    auto idRigidOperation = model->appendEntityInstance(rigidOperation);

    OdDAI::ApplicationInstancePtr wellKnownText = model->createEntityInstance("ifcwellknowntext");
    wellKnownText->putAttr("wellknowntext", wktGeoref_Geodetic);
    wellKnownText->putAttr("coordinatereferencesystem", idGeographicCRS);
    auto idWellKnownText = model->appendEntityInstance(wellKnownText);
  }

  //
  // Georef_C
  //
  else
  {
    OdDAI::ApplicationInstancePtr projectedCRS = model->createEntityInstance("ifcprojectedcrs");
    projectedCRS->putAttr("name", (const char*)"EPSG:2589");
    projectedCRS->putAttr("geodeticdatum", (const char*)"Pulkovo 1942 / 3-degree Gauss-Kruger CM 42E");
    auto idProjectedCRS = model->appendEntityInstance(projectedCRS);

    OdDAI::ApplicationInstancePtr rigidOperation = model->createEntityInstance("ifcrigidoperation");
    rigidOperation->putAttr("sourcecrs", OdDAIObjectId(ctxModel->id()));
    rigidOperation->putAttr("targetcrs", idProjectedCRS);

    OdDAI::AttributeDataBlock adbFirstCoordinate;
    adbFirstCoordinate.typePath.add("IfcLengthMeasure");
    adbFirstCoordinate.value.setValue(100.);
    rigidOperation->putAttr("firstcoordinate", &adbFirstCoordinate);

    OdDAI::AttributeDataBlock adbSecondCoordinate;
    adbSecondCoordinate.typePath.add("IfcLengthMeasure");
    adbSecondCoordinate.value.setValue(500.);
    rigidOperation->putAttr("secondcoordinate", &adbSecondCoordinate);

    rigidOperation->putAttr("height", 0.);
    auto idRigidOperation = model->appendEntityInstance(rigidOperation);

    OdDAI::ApplicationInstancePtr wellKnownText = model->createEntityInstance("ifcwellknowntext");
    wellKnownText->putAttr("wellknowntext", wktGeoref_Projected);
    wellKnownText->putAttr("coordinatereferencesystem", idProjectedCRS);
    auto idWellKnownText = model->appendEntityInstance(wellKnownText);
  }

  //
  // Sprint 1.3
  //
  if (0)
  {
    //
    // IfcDocumentInformation
    //
    OdDAI::ApplicationInstancePtr documentInformation = model->createEntityInstance("ifcdocumentinformation");
    documentInformation->putAttr("identification", (const char*)"Document identification");
    documentInformation->putAttr("name", (const char*)"Just Document Name");
    documentInformation->putAttr("location", (const char*)"URI://document.location");
    documentInformation->putAttr("electronicformat", (const char*)"application/pdf");
    OdDAI::Set<OdDAI::Select> *editors{};
    documentInformation->getAttr("editors") >> editors;
    editors->createEmpty();
    editors->Add(OdRxValue(OdDAIObjectId(person->id())));
    auto idDocumentInformation = model->appendEntityInstance(documentInformation);

    {
      OdDAI::ApplicationInstancePtr relAssociatesDocument = model->createEntityInstance("ifcrelassociatesdocument");
      relAssociatesDocument->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
      relAssociatesDocument->putAttr("ownerhistory", idOwnerHistory);

      OdDAI::Set<OdDAI::Select> *relatedObjects{};
      relAssociatesDocument->getAttr("relatedobjects") >> relatedObjects;
      relatedObjects->createEmpty();
      relatedObjects->Add(OdRxValue(OdDAIObjectId(project->id())));

      relAssociatesDocument->putAttr("relatingdocument", idDocumentInformation);
      auto idRelAssociatesDocument = model->appendEntityInstance(relAssociatesDocument);
    }

    //
    // IfcDatasetInformation
    //
    OdDAI::ApplicationInstancePtr datasetInformation = model->createEntityInstance("ifcdatasetinformation");
    datasetInformation->putAttr("identification", (const char*)"Dataset identification");
    datasetInformation->putAttr("name", (const char*)"Just Dataset Name");
    datasetInformation->putAttr("location", (const char*)"URI://dataset.location");
    datasetInformation->putAttr("electronicformat", (const char*)"text/xml");
    datasetInformation->putAttr("schemareference", (const char*)"http://geosciml.org/geosciml/2.0/xsd/geosciml.xsd");
    auto idDatasetInformation = model->appendEntityInstance(datasetInformation);

    {
      OdDAI::ApplicationInstancePtr relAssociatesDataset = model->createEntityInstance("ifcrelassociatesdataset");
      relAssociatesDataset->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
      relAssociatesDataset->putAttr("ownerhistory", idOwnerHistory);

      OdDAI::Set<OdDAI::Select> *relatedObjects{};
      relAssociatesDataset->getAttr("relatedobjects") >> relatedObjects;
      relatedObjects->createEmpty();
      relatedObjects->Add(OdRxValue(OdDAIObjectId(project->id())));

      relAssociatesDataset->putAttr("relatingdataset", idDatasetInformation);
      auto idRelAssociatesDataset = model->appendEntityInstance(relAssociatesDataset);
    }

    //
    // IfcLibraryInformation
    //
    OdDAI::ApplicationInstancePtr libraryInformation = model->createEntityInstance("ifclibraryinformation");
    libraryInformation->putAttr("location", (const char*)"URI://library.location");
    libraryInformation->putAttr("version", (const char*)"1.33");
    libraryInformation->putAttr("versiondate", (const char*)"30.03.2023");
    libraryInformation->putAttr("publisher", idPerson);
    auto idLibraryInformation = model->appendEntityInstance(libraryInformation);

    {
      OdDAI::ApplicationInstancePtr relAssociatesLibrary = model->createEntityInstance("ifcrelassociateslibrary");
      relAssociatesLibrary->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
      relAssociatesLibrary->putAttr("ownerhistory", idOwnerHistory);

      OdDAI::Set<OdDAI::Select> *relatedObjects{};
      relAssociatesLibrary->getAttr("relatedobjects") >> relatedObjects;
      relatedObjects->createEmpty();
      relatedObjects->Add(OdRxValue(OdDAIObjectId(project->id())));

      relAssociatesLibrary->putAttr("relatinglibrary", idLibraryInformation);
      auto idRelAssociatesLibrary = model->appendEntityInstance(relAssociatesLibrary);
    }

    OdDAI::ApplicationInstancePtr archElementType = model->createEntityInstance("ifcarchelementtype");
    archElementType->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
    archElementType->putAttr("ownerhistory", idOwnerHistory);
    //libraryInformation->putAttr("location", (const char*)"URI://library.location");
    //libraryInformation->putAttr("version", (const char*)"1.33");
    //libraryInformation->putAttr("versiondate", (const char*)"30.03.2023");
    //libraryInformation->putAttr("publisher", idPerson);
    auto idArchElementType = model->appendEntityInstance(archElementType);
    projectRelatedDefinitions->Add(OdRxValue(idArchElementType));

    //
    // IfcPropertySetTemplate
    //
    OdDAI::ApplicationInstancePtr propertySetTemplate = model->createEntityInstance("ifcpropertysettemplate");
    propertySetTemplate->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
    propertySetTemplate->putAttr("ownerhistory", idOwnerHistory);
    propertySetTemplate->putAttr("name", (const char*)"Pset_GeoObsBoreholeConstruction");
    propertySetTemplate->putAttr("templatetype", (const char*)"PSET_TYPEDRIVENOVERRIDE");
    propertySetTemplate->putAttr("applicableentity", (const char*)"IfcBorehole");
    OdDAI::SetOfOdDAIObjectId *hasPropertyTemplates{};
    propertySetTemplate->getAttr("haspropertytemplates") >> hasPropertyTemplates;
    hasPropertyTemplates->createEmpty();
    auto idPropertySetTemplate = model->appendEntityInstance(propertySetTemplate);
    projectRelatedDefinitions->Add(OdRxValue(idPropertySetTemplate));

    OdDAI::ApplicationInstancePtr simplePropertyTemplate = model->createEntityInstance("ifcsimplepropertytemplate");
    simplePropertyTemplate->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
    simplePropertyTemplate->putAttr("ownerhistory", idOwnerHistory);
    simplePropertyTemplate->putAttr("name", (const char*)"DrillingDiameter");
    simplePropertyTemplate->putAttr("templatetype", (const char*)"P_SINGLEVALUE");
    simplePropertyTemplate->putAttr("primarymeasuretype", (const char*)"IfcPositiveLengthMeasure");
    auto idSimplePropertyTemplate = model->appendEntityInstance(simplePropertyTemplate);
    hasPropertyTemplates->Add(idSimplePropertyTemplate);
  }

  //
  // Style
  //
  /*
  auto colourRGB = model->createEntityInstance("ifccolourrgb");
  colourRGB->putAttr("name", OdAnsiString("Blue"));
  colourRGB->putAttr("red", 0.);
  colourRGB->putAttr("green", 0.);
  colourRGB->putAttr("blue", 1.);
  auto idColourRGB = model->appendEntityInstance(colourRGB);

  auto surfaceStyleRendering = model->createEntityInstance("ifcsurfacestylerendering");
  surfaceStyleRendering->putAttr("surfacecolour", idColourRGB);
  surfaceStyleRendering->putAttr("reflectancemethod", OdAnsiString("NOTDEFINED"));
  auto idSurfaceStyleRendering = model->appendEntityInstance(surfaceStyleRendering);

  OdArray<OdRxValue> styles; // Aggregation of Selects
  styles.push_back(idSurfaceStyleRendering);
  auto surfaceStyle = model->createEntityInstance("ifcsurfacestyle");
  surfaceStyle->putAttr("name", OdAnsiString("Style for columns"));
  surfaceStyle->putAttr("side", OdAnsiString("POSITIVE"));
  surfaceStyle->putAttr("styles", styles);
  auto idSurfaceStyle = model->appendEntityInstance(surfaceStyle);
  */





  //
  // Spatial containment
  //
  /*
  OdIfcInstancePtr column = model->createEntityInstance("ifccolumn");
  column->putAttr("name", OdAnsiString("Column"));
  auto idColumn = appendContained(model, idTunnel, column, idOwnerHistory);

  // Geometrical representation
  auto circleProfileDef = model->createEntityInstance("ifccircleprofiledef");
  circleProfileDef->putAttr("profiletype", OdAnsiString("AREA")); // ENUM
  circleProfileDef->putAttr("profilename", OdAnsiString("Circular profile for columns"));
  circleProfileDef->putAttr("radius", 400.);
  auto idCircleProfileDef = model->appendEntityInstance(circleProfileDef);

  auto extrudedAreasolid = model->createEntityInstance("ifcextrudedareasolid");
  extrudedAreasolid->putAttr("sweptarea", idCircleProfileDef);
  extrudedAreasolid->putAttr("extrudeddirection", idDirectionZ);
  extrudedAreasolid->putAttr("depth", 4000.);

  OdDAIObjectIds items;
  items.append(model->appendEntityInstance(extrudedAreasolid));

  // Style assignment to Extruded Area Solid
  OdArray<OdRxValue> stylesForIlem;
  stylesForIlem.append(idSurfaceStyle);
  auto styledItem = model->createEntityInstance("ifcstyleditem");
  styledItem->putAttr("item", items[0]);
  styledItem->putAttr("styles", stylesForIlem); // Aggregation of Selects
  auto idStyledItem = model->appendEntityInstance(styledItem);

  auto shapeRepresentation = model->createEntityInstance("ifcshaperepresentation");
  shapeRepresentation->putAttr("contextofitems", OdDAIObjectId(ctxModel->id()));
  shapeRepresentation->putAttr("representationidentifier", OdAnsiString("Body"));
  shapeRepresentation->putAttr("representationtype", (const char *)"SweptSolid");
  shapeRepresentation->putAttr("items", items);

  OdDAIObjectIds idsRepresentation;
  idsRepresentation.append(model->appendEntityInstance(shapeRepresentation));

  auto productDefinitionShape = model->createEntityInstance("ifcproductdefinitionshape");
  productDefinitionShape->putAttr("representations", idsRepresentation);
  auto idProductDefinitionShape = model->appendEntityInstance(productDefinitionShape);

  column->putAttr("representation", idProductDefinitionShape);
  */




  //
  // Additional: How to get with new IFC4.4 entities
  //

  //
  // IfcLogicalVoxelData
  //
  OdDAI::ApplicationInstancePtr logicalVoxelData = model->createEntityInstance("ifclogicalvoxeldata");
  logicalVoxelData->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
  logicalVoxelData->putAttr("ownerhistory", idOwnerHistory);
  logicalVoxelData->putAttr("name", (const char*)"Name of IfcLabelVoxelData");

  logicalVoxelData->putAttr("valuetype", (const char*)"Value Type for IfcLogicalVoxelData");

  OdDAI::Aggr *aggr_logicals{};
  logicalVoxelData->getAttr("valuedata") >> aggr_logicals;
  OdDAI::List<OdDAI::Logical>* valuedata_logicals = static_cast<OdDAI::List<OdDAI::Logical>*>(aggr_logicals);
  valuedata_logicals->createEmpty();
  valuedata_logicals->insertByIndex(0, OdDAI::Logical::Unknown);
  valuedata_logicals->insertByIndex(1, OdDAI::Logical::False);
  valuedata_logicals->insertByIndex(2, OdDAI::Logical::True);
  OdDAIObjectId idLogicalVoxelData = model->appendEntityInstance(logicalVoxelData);

  //aggr_logicals = nullptr;
  //logicalVoxelData->getAttr("values") >> aggr_logicals; // Derived
  //OdDAI::Array<OdDAI::Logical> *values_logicals = static_cast<OdDAI::Array<OdDAI::Logical>*>(aggr_logicals);


  //
  // IfcVoxelGrid
  //
  OdDAI::ApplicationInstancePtr voxelGrid = model->createEntityInstance("ifcvoxelgrid");
  voxelGrid->putAttr("voxelsizex", 1.);
  voxelGrid->putAttr("voxelsizey", 1.);
  voxelGrid->putAttr("voxelsizez", 1.);
  const int numberOfVoxels{ 5 };
  voxelGrid->putAttr("numberofvoxelsx", numberOfVoxels);
  voxelGrid->putAttr("numberofvoxelsy", numberOfVoxels);
  voxelGrid->putAttr("numberofvoxelsz", numberOfVoxels);

  OdDAI::Aggr *aggrVoxels{};
  voxelGrid->getAttr("voxels") >> aggrVoxels;
  OdDAI::ArrayOfBoolean *voxels = static_cast<OdDAI::ArrayOfBoolean*>(aggrVoxels);
  voxels->createEmpty();
  for (int i = 0; i < numberOfVoxels*numberOfVoxels*numberOfVoxels; ++i)
  {
    voxels->putByIndex(i, i % 2 ? OdDAI::Boolean::True : OdDAI::Boolean::False);
  }
  OdDAIObjectId idVoxelGrid = model->appendEntityInstance(voxelGrid);


  //
  // IfcLabelVoxelData
  //
  OdDAI::ApplicationInstancePtr labelVoxelData = model->createEntityInstance("ifclabelvoxeldata");
  labelVoxelData->putAttr("globalid", ::odrxSystemServices()->createOdGUID().toString(OdGUID::StringFormat::Base64String));
  labelVoxelData->putAttr("ownerhistory", idOwnerHistory);
  labelVoxelData->putAttr("name", (const char*)"Name of IfcLabelVoxelData");

  labelVoxelData->putAttr("valuetype", (const char*)"Value Type for IfcLabelVoxelData");

  OdDAI::Aggr *aggr_labels{};
  labelVoxelData->getAttr("valuedata") >> aggr_labels;
  OdDAI::List<OdAnsiString> *values_labels = static_cast<OdDAI::List<OdAnsiString>*>(aggr_labels);
  values_labels->createEmpty();
  values_labels->insertByIndex(0, (const char*)"Value1");
  values_labels->insertByIndex(1, (const char*)"Value2");
  OdDAIObjectId idLabelVoxelData = model->appendEntityInstance(labelVoxelData);

  return (int)ifcFile->writeFile(m_fileName);
}