/////////////////////////////////////////////////////////////////////////////// 
// 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 "daiModule.h"
#include "daiRepository.h"
#include "daiModel.h"
#include "daiHeaderSection.h"

#include "ExStepHostAppServices.h"
#include "ExStepTutorial_06.h"
#include "ExStepTutorialBase.h"
#include "Common/examples/daiSimpleProgramOptions.h"

#define USING_AP242

namespace {
  enum EnumType
  {
    kOperatorEnum,
    kOperandEnum
  };

  enum OperatorType
  {
    kUnionOperator = 1,
    kIntersectionOperator,
    kDifferenceOperator
  };

  enum OperandType
  {
    kBlockOperand = 1,               //--Common
    kRectangularPyramidOperand,      //--AP238 STEP - NC / AP242
    kRightAngularWedgeOperand,       //--Common
    kRightCircularConeOperand,       //--Common
    kRightCircularCylinderOperand,   //--Common
    kSphereOperand,                  //--Common
    kTorusOperand,                   //--Common
//    kFacetedPrimitiveOperand,        //--AP238 STEP - NC / AP242
    kTetrahedronOperand,             //--AP238 STEP - NC / AP242
    kConvexHexahedronOperand,        //--AP238 STEP - NC / AP242
//Don't support yet:
    kCyclideSegmentSolidOperand,     //--AP238 STEP - NC / AP242
    kEccentricConeOperand,           //--AP238 STEP - NC / AP242
    kEllipsoidOperand,               //--AP238 STEP - NC / AP242
//    BoundedPrimitive2d:            //--AP242
    kCircularAreaOperand,
    kEllipticAreaOperand,
    kPolygonalAreaOperand,
    kRectangularAreaOperand,
    kAreaWithOuterBoundaryOperand,
//Don't support yet:
    kPathAreaWithParametersOperand
  };

  int getValue(const OdAnsiString& fromCli, EnumType type)
  {
    int value = atoi(OdString(fromCli));
    if (value)
      return value;

    OdString arg = OdString(fromCli);

    if (arg[0] == '-')
      arg.deleteChars(0, 1);
    arg.makeLower();
    if (type == kOperatorEnum)
    {
      if (!arg.compare("union"))
        return kUnionOperator;
      if (!arg.compare("intersection"))
        return kIntersectionOperator;
      if (!arg.compare("difference"))
        return kDifferenceOperator;
    }
    else if (type == kOperandEnum)
    {
      if (!arg.compare("block"))
        return kBlockOperand;
      if (!arg.compare("cyclide_segment_solid"))
        return kCyclideSegmentSolidOperand;
      if (!arg.compare("eccentric_cone"))
        return kEccentricConeOperand;
      if (!arg.compare("ellipsoid"))
        return kEllipsoidOperand;
//      if (!arg.compare("faceted_primitive"))
//        return kFacetedPrimitiveOperand;
      if (!arg.compare("tetrahedron"))
        return kTetrahedronOperand;
      if (!arg.compare("convex_hexahedron"))
        return kConvexHexahedronOperand;
      if (!arg.compare("rectangular_pyramid"))
        return kRectangularPyramidOperand;
      if (!arg.compare("right_angular_wedge"))
        return kRightAngularWedgeOperand;
      if (!arg.compare("right_circular_cone"))
        return kRightCircularConeOperand;
      if (!arg.compare("right_circular_cylinder"))
        return kRightCircularCylinderOperand;
      if (!arg.compare("sphere"))
        return kSphereOperand;
      if (!arg.compare("torus"))
        return kTorusOperand;
      if (!arg.compare("area_with_outer_boundary"))
        return kAreaWithOuterBoundaryOperand;
      if (!arg.compare("circular_area"))
        return kCircularAreaOperand;
      if (!arg.compare("elliptic_area"))
        return kEllipticAreaOperand;
      if (!arg.compare("path_area_with_parameters"))
        return kPathAreaWithParametersOperand;
      if (!arg.compare("polygonal_area"))
        return kPolygonalAreaOperand;
      if (!arg.compare("rectangular_area"))
        return kRectangularAreaOperand;
    }
    return -1;
  }

  OdAnsiString getOperator(int type)
  {
    switch (type)
    {
    case kUnionOperator:
      return "UNION";
    case kIntersectionOperator:
      return "INTERSECTION";
    case kDifferenceOperator:
      return "DIFFERENCE";
    default:
      ODA_ASSERT_ONCE(!"Unknown operator");
      break;
    }
    return "";
  }

  OdDAIObjectId getOperand(OdDAI::Model* pModel, int type, double num)
  {
    switch (type)
    {
    case kBlockOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("block");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_3d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0., num));
      pAxisInst->putAttr("axis", createDirection(pModel, (OdAnsiString)"", 0., 0., 1.));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", 1., 0., 0.));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("x", 1.5);
      pInst->putAttr("y", 1.5);
      pInst->putAttr("z", 1.5);
      return pModel->appendEntityInstance(pInst);
    }
//    case kBoundedPrimitive2dOperand:
//      break;
    case kCyclideSegmentSolidOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("cyclide_segment_solid");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_3d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0., num));
      pAxisInst->putAttr("axis", createDirection(pModel, (OdAnsiString)"", 0., 0., 1.));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", 1., 0., 0.));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("radius1", 1.5);
      pInst->putAttr("radius2", 0.5);
      pInst->putAttr("cone_angle1", 0.);
      pInst->putAttr("cone_angle2", 0.);
      pInst->putAttr("turn_angle", OdaPI);
      return pModel->appendEntityInstance(pInst);
    }
    case kEccentricConeOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("eccentric_cone");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_3d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0., num));
      pAxisInst->putAttr("axis", createDirection(pModel, (OdAnsiString)"", 0., 0., 1.));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", 1., 0., 0.));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("semi_axis_1", 1);
      pInst->putAttr("semi_axis_2", 0.5);
      pInst->putAttr("height", 2.0);
      pInst->putAttr("x_offset", 0.2);
      pInst->putAttr("y_offset", 0.1);
      pInst->putAttr("ratio", 0.5);
      return pModel->appendEntityInstance(pInst);
    }
    case kEllipsoidOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("ellipsoid");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_3d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0., num));
      pAxisInst->putAttr("axis", createDirection(pModel, (OdAnsiString)"", 0., 0., 1.));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", cos(OdaPI4), sin(OdaPI4), 0.));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("semi_axis_1", 1.);
      pInst->putAttr("semi_axis_2", 2.);
      pInst->putAttr("semi_axis_3", 1.);

      return pModel->appendEntityInstance(pInst);
    }
    /*case kFacetedPrimitiveOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("faceted_primitive");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAIObjectIds points;
      points.append(createCartesianPoint(pModel, "", 2., 2., 2+num));
      points.append(createCartesianPoint(pModel, "", 2., 2., num));
      points.append(createCartesianPoint(pModel, "", 0., 2., num));
      points.append(createCartesianPoint(pModel, "", 0., 2., 2+num));
      pInst->putAttr("points", points);
      return pModel->appendEntityInstance(pInst);
    }*/
    case kTetrahedronOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("tetrahedron");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAIObjectIds points;
      points.append(createCartesianPoint(pModel, "", 2., 2., num));
      points.append(createCartesianPoint(pModel, "", 2., 0., num));
      points.append(createCartesianPoint(pModel, "", 0., 2., num));
      points.append(createCartesianPoint(pModel, "", 1., 1., 2 + num));
      pInst->putAttr("points", points);
      return pModel->appendEntityInstance(pInst);
    }
    case kConvexHexahedronOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("convex_hexahedron");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAIObjectIds points;
      points.append(createCartesianPoint(pModel, "", -1., -1., -1 + num));
      points.append(createCartesianPoint(pModel, "", -1., 1., -1 + num));
      points.append(createCartesianPoint(pModel, "", 1., 1., -1 + num));
      points.append(createCartesianPoint(pModel, "", 1., -1., -1 + num));

      points.append(createCartesianPoint(pModel, "", -1., -1., 1 + num));
      points.append(createCartesianPoint(pModel, "", -1., 1., 0.5 + num));
      points.append(createCartesianPoint(pModel, "", 1., 1., 1 + num));
      points.append(createCartesianPoint(pModel, "", 1., -1., 1.5 + num));
      pInst->putAttr("points", points);
      return pModel->appendEntityInstance(pInst);
    }
    case kRectangularPyramidOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("rectangular_pyramid");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_3d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0., num));
      pAxisInst->putAttr("axis", createDirection(pModel, (OdAnsiString)"", 0., 0., 1.));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", 1., 0., 0.));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("xlength", 1.5);
      pInst->putAttr("ylength", 1.5);
      pInst->putAttr("height", 2.);
      return pModel->appendEntityInstance(pInst);
    }
    case kRightAngularWedgeOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("right_angular_wedge");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_3d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0., num));
      pAxisInst->putAttr("axis", createDirection(pModel, (OdAnsiString)"", 0., 0., 1.));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", 1., 0., 0.));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("x", 1.5);
      pInst->putAttr("y", 1.5);
      pInst->putAttr("z", 2.);
      pInst->putAttr("ltx", 0.5);
      return pModel->appendEntityInstance(pInst);
    }
    case kRightCircularConeOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("right_circular_cone");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_3d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0., num));
      pAxisInst->putAttr("axis", createDirection(pModel, (OdAnsiString)"", 0., cos(OdaPI4), sin(OdaPI4)));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", 1., 0., 0.));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("height", 1.5);
      pInst->putAttr("radius", 0.5);
      pInst->putAttr("semi_angle", OdaPI4);
      return pModel->appendEntityInstance(pInst);
    }
    case kRightCircularCylinderOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("right_circular_cylinder");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_3d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0., num));
      pAxisInst->putAttr("axis", createDirection(pModel, (OdAnsiString)"", 0., 0., 1.));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", 1., 0., 0.));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("height", 1.5);
      pInst->putAttr("radius", 1.);

      return pModel->appendEntityInstance(pInst);
    }
    case kSphereOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("sphere");
      pInst->putAttr("name", (OdAnsiString)"");
      pInst->putAttr("radius", 1.);
      pInst->putAttr("centre", createCartesianPoint(pModel, "", 0.,0., num));
      return pModel->appendEntityInstance(pInst);
    }
    case kTorusOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("torus");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis1_placement");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0., num));
      pAxisInst->putAttr("axis", createDirection(pModel, (OdAnsiString)"", 0., 0., 1.));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("major_radius", 2.);
      pInst->putAttr("minor_radius", 1.);

      return pModel->appendEntityInstance(pInst);
    }
    case kAreaWithOuterBoundaryOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("area_with_outer_boundary");
      pInst->putAttr("name", (OdAnsiString)"");
      pInst->putAttr("agreement_flag", true);

      OdDAI::ApplicationInstancePtr pCompositeCurveInst = pModel->createEntityInstance("composite_curve");
      pCompositeCurveInst->putAttr("name", (OdAnsiString)"");
      pCompositeCurveInst->putAttr("self_intersect", OdDAI::Logical::False);

      OdDAI::ApplicationInstancePtr pTrimmedCurve1 = pModel->createEntityInstance("trimmed_curve");
      pTrimmedCurve1->putAttr("name", (OdAnsiString)"");
      pTrimmedCurve1->putAttr("sense_agreement", true);
      pTrimmedCurve1->putAttr("master_representation", (OdAnsiString)"PARAMETER");

      OdRxSpecifiedValueType vtStepParamValue(OdRxValueType::Desc<double>::value(), "parameter_value");
      OdArray<OdRxValue> trim1;
      OdRxValue val;
      val << -1.;
      trim1.append(OdRxValue(vtStepParamValue, val));
      pTrimmedCurve1->putAttr("trim_1", trim1);
      OdArray<OdRxValue> trim2;
      val << 1.;
      trim2.append(OdRxValue(vtStepParamValue, val));
      pTrimmedCurve1->putAttr("trim_2", trim2);

      OdDAI::ApplicationInstancePtr pLine1 = pModel->createEntityInstance("line");
      pLine1->putAttr("name", (OdAnsiString)"");
      pLine1->putAttr("pnt", createCartesianPoint(pModel, "", 0., 0.5 * num));

      OdDAI::ApplicationInstancePtr pVector = pModel->createEntityInstance("vector");
      pVector->putAttr("name", (OdAnsiString)"");
      pVector->putAttr("magnitude", 1.);
      pVector->putAttr("orientation", createDirection(pModel, "", 1., 0.));

      pLine1->putAttr("dir", pModel->appendEntityInstance(pVector));
      pTrimmedCurve1->putAttr("basis_curve", pModel->appendEntityInstance(pLine1));

      OdDAI::ApplicationInstancePtr pTrimmedCurve2 = pModel->createEntityInstance("trimmed_curve");
      pTrimmedCurve2->putAttr("name", (OdAnsiString)"");
      pTrimmedCurve2->putAttr("sense_agreement", true);
      pTrimmedCurve2->putAttr("master_representation", (OdAnsiString)"PARAMETER");

      trim1.clear();
      val << 0.;
      trim1.append(OdRxValue(vtStepParamValue, val));
      pTrimmedCurve2->putAttr("trim_1", trim1);
      trim2.clear();
      val << OdaPI;
      trim2.append(OdRxValue(vtStepParamValue, val));
      pTrimmedCurve2->putAttr("trim_2", trim2);

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_2d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", 0., 0.5*num));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", 1., 0.));

      OdDAI::ApplicationInstancePtr pCircle = pModel->createEntityInstance("circle");
      pCircle->putAttr("name", (OdAnsiString)"");
      pCircle->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pCircle->putAttr("radius", 1.);
      pTrimmedCurve2->putAttr("basis_curve", pModel->appendEntityInstance(pCircle));

      OdDAI::ApplicationInstancePtr pCompositeCurveSegment1 = pModel->createEntityInstance("composite_curve_segment");
      pCompositeCurveSegment1->putAttr("transition", (OdAnsiString)"CONTINUOUS");
      pCompositeCurveSegment1->putAttr("same_sense", true);
      pCompositeCurveSegment1->putAttr("parent_curve", pModel->appendEntityInstance(pTrimmedCurve1));

      OdDAI::ApplicationInstancePtr pCompositeCurveSegment2 = pModel->createEntityInstance("composite_curve_segment");
      pCompositeCurveSegment2->putAttr("transition", (OdAnsiString)"CONTINUOUS");
      pCompositeCurveSegment2->putAttr("same_sense", true);
      pCompositeCurveSegment2->putAttr("parent_curve", pModel->appendEntityInstance(pTrimmedCurve2));


      OdDAIObjectIds compositeCurves;
      compositeCurves.append(pModel->appendEntityInstance(pCompositeCurveSegment1));
      compositeCurves.append(pModel->appendEntityInstance(pCompositeCurveSegment2));

      pCompositeCurveInst->putAttr("segments", compositeCurves);
      pInst->putAttr("base_curve", pModel->appendEntityInstance(pCompositeCurveInst));
      return pModel->appendEntityInstance(pInst);
    }
    case kCircularAreaOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("circular_area");
      pInst->putAttr("name", (OdAnsiString)"");
      pInst->putAttr("radius", 1.);
      pInst->putAttr("centre", createCartesianPoint(pModel, "", num, 0.));
      return pModel->appendEntityInstance(pInst);
    }
    case kEllipticAreaOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("elliptic_area");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_2d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", num, 0.));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", cos(OdaPI4), sin(OdaPI4)));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("semi_axis_1", 1.);
      pInst->putAttr("semi_axis_2", 2.);

      return pModel->appendEntityInstance(pInst);
    }
    case kPathAreaWithParametersOperand:
    {

    }
    case kPolygonalAreaOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("polygonal_area");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAIObjectIds points;
      points.append(createCartesianPoint(pModel, "", 2. + num, 3. + num));
      points.append(createCartesianPoint(pModel, "", 2. + num, 0. + num));
      points.append(createCartesianPoint(pModel, "", 0. + num, 0. + num));
      pInst->putAttr("bounds", points);
      return pModel->appendEntityInstance(pInst);
    }
    case kRectangularAreaOperand:
    {
      OdDAI::ApplicationInstancePtr pInst = pModel->createEntityInstance("rectangular_area");
      pInst->putAttr("name", (OdAnsiString)"");

      OdDAI::ApplicationInstancePtr pAxisInst = pModel->createEntityInstance("axis2_placement_2d");
      pAxisInst->putAttr("name", (OdAnsiString)"");
      pAxisInst->putAttr("location", createCartesianPoint(pModel, (OdAnsiString)"", num, 0.5*num));
      pAxisInst->putAttr("ref_direction", createDirection(pModel, (OdAnsiString)"", cos(OdaPI4), sin(OdaPI4)));

      pInst->putAttr("position", pModel->appendEntityInstance(pAxisInst));
      pInst->putAttr("x", 1.5);
      pInst->putAttr("y", 2.);
      return pModel->appendEntityInstance(pInst);
    }
    default:
      ODA_ASSERT_ONCE(!"Unknown operand!");
      break;
    }
    return OdDAIObjectId();
  }
}

StepTutorial::ExecutionResult Tutorial_06(const ExStepServices&, const std::vector<OdString>& params, std::ostream& ouputStream)
{
  OdAnsiString stepFile;
  OdAnsiString operation;
  OdAnsiString primitive1;
  OdAnsiString primitive2;

  OdDAI::utils::argv_parser  tutorialArgsParser("Tutorial_06");
  tutorialArgsParser.add_param(std::make_shared<OdDAI::utils::key_value_option<OdAnsiString>>(stepFile, "filename", "STEP physical file name.", true, false));
  tutorialArgsParser.add_param(std::make_shared<OdDAI::utils::key_value_option<OdAnsiString>>(operation, "operation", "boolean_operation name or it's number in operations enum.", true, false));
  tutorialArgsParser.add_param(std::make_shared<OdDAI::utils::key_value_option<OdAnsiString>>(primitive1, "primitive1", "first csg_primitive name or it's number in operands enum.", true, false));
  tutorialArgsParser.add_param(std::make_shared<OdDAI::utils::key_value_option<OdAnsiString>>(primitive2, "primitive2", "second csg_primitive name or it's number in operands enum.", true, false));

  switch (tutorialArgsParser.parse(params, ouputStream))
  {
    case OdDAI::utils::ParseResult::showHelp:
    {
      return StepTutorial::ExecutionResult::eShowHelp;
    }
    break;
    case OdDAI::utils::ParseResult::failed:
    {
      odPrintConsoleString(L"Wrong input params!\n");
      return StepTutorial::ExecutionResult::eWrongParams;
    }
    break;
    default:
      break;
  }

  OdDAI::SessionPtr session = oddaiCreateSession();
  
  OdAnsiString workDir = StepTutorial::WorkDir::getPath(); // Your path to .exp file
#ifdef USING_AP242
  OdDAI::SchemaPtr workSchema = oddaiGetSchema(workDir + "Schemas/ap242ed2_mim_lf_v1.101.exp");
#else
  OdDAI::SchemaPtr workSchema = oddaiGetSchema(workDir + "Schemas/AP214E3_2010.exp");
#endif // USING_AP242

  if (!workSchema.isNull())
  {
    OdDAI::RepositoryPtr repo = session->createRepo("TUTORIAL_06_Repo");
    session->openRepo(repo);

    OdDAI::ModelPtr tutorialModel = repo->createModel("Tutorial_06", workSchema);

    OdString fileName;

    if (primitive2.isEmpty() || operation.isEmpty())
      fileName = workDir + "Tutorial_06.stp";
    else
      fileName = stepFile;

    {  //creating header section
      OdDAI::OdHeaderSectionPtr header = repo->getHeaderSection();

      //filling in the description
      OdDAI::ApplicationInstancePtr pDesc = header->getEntityByType(OdDAI::OdHeaderEntityType::kFileDescription);
      OdAnsiStringArray description;
#ifdef USING_AP242
      description.append("STEP AP242");
#else
      description.append("STEP AP214");
#endif // USING_AP242

      pDesc->putAttr("description", description);

      //filling in name info
      OdDAI::ApplicationInstancePtr pFileName = header->getEntityByType(OdDAI::OdHeaderEntityType::kFileName);
      pFileName->putAttr("name", fileName);

      OdTimeStamp timeStamp(OdTimeStamp::kInitLocalTime);
      OdString timeStampString;// ("2022-01-12T09:08:49");
      timeStamp.strftime(L"%Y-%m-%dT%H:%M:%S", timeStampString);
      pFileName->putAttr("time_stamp", timeStampString);

      OdAnsiStringArray author;
      author.append(" ");
      pFileName->putAttr("author", author);

      OdAnsiString originatingSystem(" ");
      pFileName->putAttr("originating_system", originatingSystem);

      OdAnsiString authorization(" ");
      pFileName->putAttr("authorization", authorization);
    }

    {  //creating model section
      if (!tutorialModel.isNull())
      {
        tutorialModel->promoteModelToReadWrite();

        OdDAI::Aggr* aggr = nullptr;

        OdDAI::ApplicationInstancePtr inst_1 = tutorialModel->createEntityInstance("mechanical_design_geometric_presentation_representation");
        tutorialModel->appendEntityInstance(inst_1);
        inst_1->putAttr("name", (OdAnsiString)"");

        OdDAI::ApplicationInstancePtr inst_2 = tutorialModel->createEntityInstance("product_definition_context");
        OdDAIObjectId id_inst_2 = tutorialModel->appendEntityInstance(inst_2);
        inst_2->putAttr("name", (OdAnsiString)"");
        inst_2->putAttr("life_cycle_stage", (OdAnsiString)"design");

        OdDAI::ApplicationInstancePtr inst_3 = tutorialModel->createEntityInstance("application_protocol_definition");
        tutorialModel->appendEntityInstance(inst_3);
        inst_3->putAttr("status", (OdAnsiString)"INTERNATIONAL STANDARD");
#ifdef USING_AP242
        inst_3->putAttr("application_interpreted_model_schema_name", (OdAnsiString)"AP242_MANAGED_MODEL_BASED_3D_ENGINEERING_MIM_LF");
        inst_3->putAttr("application_protocol_year", 2011);
#else
        inst_3->putAttr("application_interpreted_model_schema_name", (OdAnsiString)"automotive_design");
        inst_3->putAttr("application_protocol_year", 1994);
#endif // USING_AP242

        OdDAI::ApplicationInstancePtr inst_4 = tutorialModel->createEntityInstance("product_category_relationship");
        tutorialModel->appendEntityInstance(inst_4);
        inst_4->putAttr("name", (OdAnsiString)"NONE");
        inst_4->putAttr("description", (OdAnsiString)"NONE");

        OdDAI::ApplicationInstancePtr inst_5 = tutorialModel->createEntityInstance("shape_definition_representation");
        tutorialModel->appendEntityInstance(inst_5);

        OdDAI::EntityPtr geom_rep_context = workSchema->find("geometric_representation_context");
        OdDAI::EntityPtr global_unsert_assigned_context = workSchema->find("global_uncertainty_assigned_context");
        OdDAI::EntityPtr global_unit_assigned_context = workSchema->find("global_unit_assigned_context");
        OdDAI::EntityPtr representation_context = workSchema->find("representation_context");

        OdDAI::List<OdDAI::Entity*> ent_6;
        ent_6.createEmpty();
        ent_6.addByIndex(0, geom_rep_context);
        ent_6.addByIndex(1, global_unsert_assigned_context);
        ent_6.addByIndex(2, global_unit_assigned_context);
        ent_6.addByIndex(3, representation_context);

        OdDAI::EntityPtr complexEntity_Units = workSchema->getComplexEntity(ent_6);
        OdDAI::ApplicationInstancePtr inst_6 = tutorialModel->createEntityInstance(complexEntity_Units);
        OdDAIObjectId id_inst_6 = tutorialModel->appendEntityInstance(inst_6);
        inst_6->putAttr("coordinate_space_dimension", 3);
        inst_6->putAttr("context_identifier", (OdAnsiString)"NONE");
        inst_6->putAttr("context_type", (OdAnsiString)"WORKSPACE");

        inst_1->putAttr("context_of_items", id_inst_6);

        OdDAI::ApplicationInstancePtr inst_7 = tutorialModel->createEntityInstance("styled_item");
        OdDAIObjectId id_inst_7 = tutorialModel->appendEntityInstance(inst_7);
        inst_7->putAttr("name", (OdAnsiString)"");

        OdDAI::Set<OdDAI::Select>* items{};
        inst_1->getAttr("items") >> items;
        items->createEmpty();
        items->Add(OdRxValue(id_inst_7));

        OdDAI::ApplicationInstancePtr inst_8 = tutorialModel->createEntityInstance("application_context");
        OdDAIObjectId id_inst_8 = tutorialModel->appendEntityInstance(inst_8);
        inst_8->putAttr("application", (OdAnsiString)"");

        inst_2->putAttr("frame_of_reference", id_inst_8);
        inst_3->putAttr("application", id_inst_8);

        OdDAI::ApplicationInstancePtr inst_9 = tutorialModel->createEntityInstance("product_category");
        inst_9->putAttr("name", (OdAnsiString)"part");
        inst_9->putAttr("description", (OdAnsiString)"NONE");

        inst_4->putAttr("category", tutorialModel->appendEntityInstance(inst_9));

        OdDAI::ApplicationInstancePtr inst_10 = tutorialModel->createEntityInstance("product_related_product_category");
        inst_10->putAttr("name", (OdAnsiString)"detail");
        inst_10->putAttr("description", (OdAnsiString)" ");

        inst_4->putAttr("sub_category", tutorialModel->appendEntityInstance(inst_10));

        OdDAI::ApplicationInstancePtr inst_11 = tutorialModel->createEntityInstance("product_definition_shape");
        inst_11->putAttr("name", (OdAnsiString)"NONE");
        inst_11->putAttr("description", (OdAnsiString)"NONE");

        inst_5->putAttr("definition", tutorialModel->appendEntityInstance(inst_11));

        OdDAI::ApplicationInstancePtr inst_12 = tutorialModel->createEntityInstance("csg_shape_representation");
        inst_12->putAttr("name", (OdAnsiString)"");
        inst_12->putAttr("context_of_items", id_inst_6);

        inst_5->putAttr("used_representation", tutorialModel->appendEntityInstance(inst_12));

        OdDAI::ApplicationInstancePtr inst_13 = tutorialModel->createEntityInstance("uncertainty_measure_with_unit");
        inst_13->putAttr("name", (OdAnsiString)"");
        inst_13->putAttr("description", (OdAnsiString)"");

        OdDAI::Select* value_component;
        inst_13->getAttr("value_component") >> value_component;
        if (value_component->underlyingTypeName("length_measure"))
          value_component->setDouble(3.93700787401575E-008);

        OdDAI::Set <OdDAIObjectId>* set6;
        inst_6->getAttr("uncertainty") >> set6;
        set6->createEmpty();
        set6->Add(tutorialModel->appendEntityInstance(inst_13));

        OdDAI::EntityPtr ent_named_unit = workSchema->find("named_unit");
        OdDAI::EntityPtr ent_conversion_based_unit = workSchema->find("conversion_based_unit");
        OdDAI::EntityPtr ent_length_unit = workSchema->find("length_unit");
        OdDAI::EntityPtr ent_si_unit = workSchema->find("si_unit");
        OdDAI::EntityPtr ent_plane_angle_unit = workSchema->find("plane_angle_unit");
        OdDAI::EntityPtr ent_solid_angle_unit = workSchema->find("solid_angle_unit");

        OdDAI::List<OdDAI::Entity*> ent_14;
        ent_14.createEmpty();
        ent_14.addByIndex(0, ent_conversion_based_unit);
        ent_14.addByIndex(1, ent_length_unit);
        ent_14.addByIndex(2, ent_named_unit);

        OdDAI::EntityPtr complexEntity_14 = workSchema->getComplexEntity(ent_14);
        OdDAI::ApplicationInstancePtr inst_14 = tutorialModel->createEntityInstance(complexEntity_14);
        OdDAIObjectId id_inst_14 = tutorialModel->appendEntityInstance(inst_14);
        inst_14->putAttr("name", (OdAnsiString)"INCH");

        inst_13->putAttr("unit_component", id_inst_14);

        OdDAI::List<OdDAI::Entity*> ent_15;
        ent_15.createEmpty();
        ent_15.addByIndex(0, ent_named_unit);
        ent_15.addByIndex(1, ent_plane_angle_unit);
        ent_15.addByIndex(2, ent_si_unit);

        OdDAI::EntityPtr complexEntity_15 = workSchema->getComplexEntity(ent_15);
        OdDAI::ApplicationInstancePtr inst_15 = tutorialModel->createEntityInstance(complexEntity_15);
        OdDAIObjectId id_inst_15 = tutorialModel->appendEntityInstance(inst_15);
        inst_15->putAttr("name", (OdAnsiString)"RADIAN");

        OdDAI::List<OdDAI::Entity*> ent_16;
        ent_16.createEmpty();
        ent_16.addByIndex(0, ent_named_unit);
        ent_16.addByIndex(1, ent_solid_angle_unit);
        ent_16.addByIndex(2, ent_si_unit);

        OdDAI::ApplicationInstancePtr inst_16 = tutorialModel->createEntityInstance(workSchema->getComplexEntity(ent_16));
        OdDAIObjectId id_inst_16 = tutorialModel->appendEntityInstance(inst_16);
        inst_16->putAttr("name", (OdAnsiString)"STERADIAN");

        OdDAI::Set <OdDAI::Select>* set_6;
        inst_6->getAttr("units") >> set_6;
        set_6->createEmpty();
        set_6->Add(OdRxValue(id_inst_14));
        set_6->Add(OdRxValue(id_inst_15));
        set_6->Add(OdRxValue(id_inst_16));

        OdDAI::ApplicationInstancePtr inst_17 = tutorialModel->createEntityInstance("presentation_style_assignment");
        OdDAIObjectId id_inst_17 = tutorialModel->appendEntityInstance(inst_17);

        OdDAI::Set <OdDAIObjectId>* set7;
        inst_7->getAttr("styles") >> set7;
        set7->createEmpty();
        set7->Add(id_inst_17);

        OdDAI::ApplicationInstancePtr inst_18 = tutorialModel->createEntityInstance("surface_style_usage");
        OdDAIObjectId id_inst_18 = tutorialModel->appendEntityInstance(inst_18);
        inst_18->putAttr("side", (OdAnsiString)"BOTH");

        OdDAI::Set <OdDAI::Select>* set17;
        inst_17->getAttr("styles") >> set17;
        set17->createEmpty();
        set17->Add(OdRxValue(id_inst_18));

        OdDAI::ApplicationInstancePtr inst_19 = tutorialModel->createEntityInstance("surface_side_style");
        inst_19->putAttr("name", (OdAnsiString)"");
        inst_18->putAttr("style", tutorialModel->appendEntityInstance(inst_19));

        OdDAI::ApplicationInstancePtr inst_20 = tutorialModel->createEntityInstance("surface_style_fill_area");
        OdDAIObjectId id_inst_20 = tutorialModel->appendEntityInstance(inst_20);

        OdDAI::Set <OdDAI::Select>* set19;
        inst_19->getAttr("styles") >> set19;
        set19->createEmpty();
        set19->Add(OdRxValue(id_inst_20));

        OdDAI::ApplicationInstancePtr inst_21 = tutorialModel->createEntityInstance("fill_area_style");
        inst_21->putAttr("name", (OdAnsiString)"");
        inst_20->putAttr("fill_area", tutorialModel->appendEntityInstance(inst_21));

        OdDAI::ApplicationInstancePtr inst_22 = tutorialModel->createEntityInstance("fill_area_style_colour");
        OdDAIObjectId id_inst_22 = tutorialModel->appendEntityInstance(inst_22);
        inst_22->putAttr("name", (OdAnsiString)"");

        OdDAI::Set <OdDAI::Select>* set21;
        inst_21->getAttr("fill_styles") >> set21;
        set21->createEmpty();
        set21->Add(OdRxValue(id_inst_22));

        inst_22->putAttr("fill_colour", createColorRgb(tutorialModel, (OdAnsiString)"", 0., 0., 0.));

        OdDAI::ApplicationInstancePtr inst_23 = tutorialModel->createEntityInstance("csg_solid");
        OdDAIObjectId id_inst_23 = tutorialModel->appendEntityInstance(inst_23);
        inst_23->putAttr("name", (OdAnsiString)"");
        inst_7->putAttr("item", id_inst_23);

        OdDAI::ApplicationInstancePtr inst_24 = tutorialModel->createEntityInstance("product");
        OdDAIObjectId id_inst_24 = tutorialModel->appendEntityInstance(inst_24);
        inst_24->putAttr("id", 1);
        inst_24->putAttr("description", (OdAnsiString)"PART--DESC");
        inst_24->putAttr("name", (OdAnsiString)",");

        OdDAI::Set <OdDAIObjectId>* set10;
        inst_10->getAttr("products") >> set10;
        set10->createEmpty();
        set10->Add(id_inst_24);

        OdDAI::ApplicationInstancePtr inst_25 = tutorialModel->createEntityInstance("product_definition");
        OdDAIObjectId id_inst_25 = tutorialModel->appendEntityInstance(inst_25);
        inst_25->putAttr("id", (OdAnsiString)"");
        inst_25->putAttr("description", (OdAnsiString)"NONE");
        inst_25->putAttr("frame_of_reference", id_inst_2);

        inst_11->putAttr("definition", id_inst_25);

        OdDAI::ApplicationInstancePtr inst_26 = tutorialModel->createEntityInstance("product_definition_formation_with_specified_source");
        OdDAIObjectId id_inst_26 = tutorialModel->appendEntityInstance(inst_26);
        inst_26->putAttr("id", (OdAnsiString)"");
        inst_26->putAttr("description", (OdAnsiString)"NONE");
        inst_26->putAttr("make_or_buy", (OdAnsiString)"NOT_KNOWN");

        inst_25->putAttr("formation", id_inst_26);
        inst_26->putAttr("of_product", id_inst_24);

        OdDAI::ApplicationInstancePtr inst_27 = tutorialModel->createEntityInstance("product_context");
        OdDAIObjectId id_inst_27 = tutorialModel->appendEntityInstance(inst_27);
        inst_27->putAttr("name", (OdAnsiString)"");
        inst_27->putAttr("discipline_type", (OdAnsiString)"mechanical");
        inst_27->putAttr("frame_of_reference", id_inst_8);

        OdDAI::Set <OdDAIObjectId>* set24;
        inst_24->getAttr("frame_of_reference") >> set24;
        set24->createEmpty();
        set24->Add(id_inst_27);

        OdDAI::ApplicationInstancePtr inst_28 = tutorialModel->createEntityInstance("axis2_placement_3d");
        OdDAIObjectId id_inst_28 = tutorialModel->appendEntityInstance(inst_28);
        inst_28->putAttr("name", (OdAnsiString)"");
        inst_28->putAttr("location", createCartesianPoint(tutorialModel, (OdAnsiString)"", 0., 0., 0.));
        inst_28->putAttr("axis", createDirection(tutorialModel, (OdAnsiString)"", 0., 0., 1.));
        inst_28->putAttr("ref_direction", createDirection(tutorialModel, (OdAnsiString)"", 1., 0., 0.));

        OdDAI::Set <OdDAIObjectId>* set15;
        inst_12->getAttr("items") >> set15;
        set15->createEmpty();
        set15->Add(id_inst_23);
        set15->Add(id_inst_28);

        OdDAI::ApplicationInstancePtr inst_29 = tutorialModel->createEntityInstance("length_measure_with_unit");
        OdDAIObjectId id_inst_29 = tutorialModel->appendEntityInstance(inst_29);

        OdDAI::Select* value_component_29;
        inst_29->getAttr("value_component") >> value_component_29;
        if (value_component_29->underlyingTypeName("length_measure"))
          value_component_29->setDouble(25.4);

        OdDAI::List<OdDAI::Entity*> ent_30;
        ent_30.createEmpty();
        ent_30.addByIndex(0, ent_named_unit);
        ent_30.addByIndex(1, ent_length_unit);
        ent_30.addByIndex(2, ent_si_unit);

        OdDAI::EntityPtr complexEntity_30 = workSchema->getComplexEntity(ent_30);
        OdDAI::ApplicationInstancePtr inst_30 = tutorialModel->createEntityInstance(complexEntity_30);
        OdDAIObjectId id_inst_30 = tutorialModel->appendEntityInstance(inst_30);
        inst_30->putAttr("prefix", (OdAnsiString)"MILLI");
        inst_30->putAttr("name", (OdAnsiString)"METRE");

        inst_29->putAttr("unit_component", id_inst_30);

        inst_14->putAttr("conversion_factor", id_inst_29);

        OdDAIObjectId id_inst_31 = createDimmExponents(tutorialModel, 1., 0., 0., 0., 0., 0., 0.);

        inst_14->putAttr("dimensions", id_inst_31);

        OdDAIObjectId id_inst_32 = createDimmExponents(tutorialModel, 0., 0., 0., 0., 0., 0., 0.);

        if (!primitive2.isEmpty() && !operation.isEmpty())
        {
          OdDAI::ApplicationInstancePtr inst_33 = tutorialModel->createEntityInstance("boolean_result");
          OdDAIObjectId id_inst_34 = tutorialModel->appendEntityInstance(inst_33);
          inst_23->putAttr("tree_root_expression", id_inst_34);
          inst_33->putAttr("name", (OdAnsiString)"");
          inst_33->putAttr("operator", getOperator(getValue(operation, kOperatorEnum)));
          inst_33->putAttr("first_operand", getOperand(tutorialModel, getValue(primitive1, kOperandEnum), 0));
          inst_33->putAttr("second_operand", getOperand(tutorialModel, getValue(primitive2, kOperandEnum), 1));
        }
        else
        {
          inst_23->putAttr("tree_root_expression", getOperand(tutorialModel, getValue(operation, kOperandEnum), 0));
        }

        OdDAI::ApplicationInstancePtr inst_34 = tutorialModel->createEntityInstance("presentation_layer_assignment");
        OdDAIObjectId id_inst_34 = tutorialModel->appendEntityInstance(inst_34);
        inst_34->putAttr("name", (OdAnsiString)"0");
        inst_34->putAttr("description", (OdAnsiString)"0");
        OdDAI::Set <OdDAI::Select>* set34;
        inst_34->getAttr("assigned_items") >> set34;
        set34->createEmpty();
        set34->Add(OdRxValue(id_inst_23));
      }

      repo->writeFile(fileName);

      session->closeRepo(repo);
      odPrintConsoleString(L"\n");

      oddaiCloseCurrentSession();
      return StepTutorial::ExecutionResult::eSucceed;
    }
  }

  odPrintConsoleString(L"Incorrect schema\n");
  return StepTutorial::ExecutionResult::eFailed;
}