///////////////////////////////////////////////////////////////////////////////
// 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 <sstream>
#include "ExIgesTutorial_05.h"
#include "RxValue.h"
#include "Ge/GeExtents3d.h"

#include "IgesEntities.h"
#include "IgesSelectTypes.h"
#include <IgesSchemaSelectTypes.h>

#include "blockAutoImpl.h"
#include "right_angular_wedgeAutoImpl.h"
#include "right_circular_cylinderAutoImpl.h"
#include "right_circular_cone_frustumAutoImpl.h"
#include "sphereAutoImpl.h"
#include "torusAutoImpl.h"
#include "solid_of_revolutionAutoImpl.h"
#include "solid_of_linear_extrusionAutoImpl.h"
#include "ellipsoidAutoImpl.h"

#include "ExPrintConsole.h" 

using namespace OdDAI;

namespace
{
  void setGeometricData(Iges::constructive_solid_geometryPtr pCsg, OdAnsiString label, int level, int subscript, Iges::blank_status blank, Iges::color_number color)
  {
    pCsg->setlabel(label);
    pCsg->level().setint_val(level);
    pCsg->setsubscript(subscript);
    pCsg->setblank(blank);
    pCsg->color().setcolor_number(color);
  }

  OdDAIObjectId createBlock(OdDAI::Model* pModel)
  {
    Iges::blockPtr pBlock = Iges::block::createObject(pModel);
    setGeometricData(pBlock, "Block", 1, 0, Iges::kblank_status_visible, Iges::kcolor_number_blue);
    pBlock->setx1(0.); pBlock->sety1(0.); pBlock->setz1(0.);
    pBlock->setlx(10.); pBlock->setly(10.); pBlock->setlz(10.);
    pBlock->seti1(1.0); pBlock->setj1(0.0); pBlock->setk1(0.0);
    pBlock->seti2(0.0); pBlock->setj2(0.0); pBlock->setk2(1.0);
    pBlock->setsubordinate(Iges::ksubordinate_switch_independent);
    return pBlock->id();
  }

  OdDAIObjectId createRightCircularCylinder(OdDAI::Model* pModel)
  {
    Iges::right_circular_cylinderPtr pCylinder = Iges::right_circular_cylinder::createObject(pModel);
    setGeometricData(pCylinder, "Cylinder", 1, 0, Iges::kblank_status_visible, Iges::kcolor_number_green);
    pCylinder->setx1(0.); pCylinder->sety1(0.); pCylinder->setz1(0.);
    pCylinder->seth(10.); pCylinder->setr(5.);
    pCylinder->seti1(0.); pCylinder->setj1(0.); pCylinder->setk1(1.);
    pCylinder->setsubordinate(Iges::ksubordinate_switch_independent);
    return pCylinder->id();
  }

  OdDAIObjectId createSphere(OdDAI::Model* pModel)
  {
    Iges::spherePtr pSphere = Iges::sphere::createObject(pModel);
    setGeometricData(pSphere, "Sphere", 1, 0, Iges::kblank_status_visible, Iges::kcolor_number_red);
    pSphere->setr(5.);
    pSphere->setx1(0.); pSphere->sety1(0.); pSphere->setz1(0.);
    pSphere->setsubordinate(Iges::ksubordinate_switch_independent);
    return pSphere->id();
  }

  OdDAIObjectId createTorus(OdDAI::Model* pModel)
  {
    Iges::torusPtr pTorus = Iges::torus::createObject(pModel);
    setGeometricData(pTorus, "Torus", 1, 0, Iges::kblank_status_visible, Iges::kcolor_number_cyan);
    pTorus->setr1(10.);
    pTorus->setr2(2.);
    pTorus->setx1(0.); pTorus->sety1(0.); pTorus->setz1(0.);
    pTorus->seti1(0.); pTorus->setj1(0.); pTorus->setk1(1.);
    pTorus->setsubordinate(Iges::ksubordinate_switch_independent);
    return pTorus->id();
  }

  OdDAIObjectId createEllipse(OdDAI::Model* pModel)
  {
    Iges::conic_arcPtr pEllipArc = Iges::conic_arc::createObject(pModel);
    OdGePoint3d center(0., 0., 0.);
    OdGeVector3d majorAxis(1., 0., 0.);
    OdGeVector3d minorAxis(0., 1., 0.);
    pEllipArc->setFrom(OdGeEllipArc3d(center, majorAxis, minorAxis, 7, 5));
    pEllipArc->setsubordinate(Iges::ksubordinate_switch_physicallyDependent);
    pEllipArc->setused(Iges::kuse_flag_geometry);
    pEllipArc->line_font().setline_pattern(Iges::kline_pattern_none);
    pEllipArc->setline_weight(0);
    return pEllipArc->id();
  }

  OdDAIObjectId createSolidOfLinearExtrusion(OdDAI::Model* pModel)
  {
    OdDAIObjectId profileId = createEllipse(pModel); //Profile must be closed
    Iges::solid_of_linear_extrusionPtr pSolid = Iges::solid_of_linear_extrusion::createObject(pModel);
    setGeometricData(pSolid, "Linear Extrusion", 1, 0, Iges::kblank_status_visible, Iges::kcolor_number_magenta);
    pSolid->setptr(profileId);
    pSolid->setl(10.);
    pSolid->seti1(0.); pSolid->setj1(0.); pSolid->setk1(1.);
    pSolid->setsubordinate(Iges::ksubordinate_switch_independent);
    return pSolid->id();
  }

  OdDAIObjectId createCircularArc(OdDAI::Model* pModel)
  {
    Iges::circular_arcPtr pCircularArc = Iges::circular_arc::createObject(pModel);
    OdGePoint3d center(0., 0., 0.);
    OdGePoint3d start(5., 0., 0.);
    OdGePoint3d end(-5., 0., 0.);
    pCircularArc->setFrom(OdGeCircArc3d(center, start, end));
    pCircularArc->setsubordinate(Iges::ksubordinate_switch_physicallyDependent);
    pCircularArc->setused(Iges::kuse_flag_geometry);
    pCircularArc->line_font().setline_pattern(Iges::kline_pattern_none);
    pCircularArc->setline_weight(0);
    return pCircularArc->id();
  }

  OdDAIObjectId createSolidOfRevolution(OdDAI::Model* pModel)
  {
    OdDAIObjectId arcId = createCircularArc(pModel);
    Iges::solid_of_revolutionPtr pSolid = Iges::solid_of_revolution::createObject(pModel);
    setGeometricData(pSolid, "Solid of Revolution", 1, 0, Iges::kblank_status_visible, Iges::kcolor_number_yellow);
    pSolid->setform(1);
    pSolid->setptr(arcId);
    pSolid->setf(Oda2PI);
    pSolid->setx1(0.); pSolid->sety1(0.); pSolid->setz1(0.);
    pSolid->seti1(1.); pSolid->setj1(0.); pSolid->setk1(0.);
    pSolid->setsubordinate(Iges::ksubordinate_switch_independent);
    return pSolid->id();
  }

  OdDAIObjectId createRightAngularWedge(OdDAI::Model* pModel)
  {
    Iges::right_angular_wedgePtr pWedge = Iges::right_angular_wedge::createObject(pModel);
    setGeometricData(pWedge, "Wedge", 1, 0, Iges::kblank_status_visible, Iges::kcolor_number_red);
    pWedge->setx1(0.); pWedge->sety1(0.); pWedge->setz1(0.);
    pWedge->setlx(10.); pWedge->setly(10.); pWedge->setlz(10.);
    pWedge->setltx(5.);
    pWedge->seti1(1.); pWedge->setj1(0.); pWedge->setk1(0.);
    pWedge->seti2(0.); pWedge->setj2(0.); pWedge->setk2(1.);
    pWedge->setsubordinate(Iges::ksubordinate_switch_independent);
    return pWedge->id();
  }

  OdDAIObjectId createRightCircularConeFrustum(OdDAI::Model* pModel)
  {
    Iges::right_circular_cone_frustumPtr pConeFrustum = Iges::right_circular_cone_frustum::createObject(pModel);
    setGeometricData(pConeFrustum, "Cone Frustum", 1, 0, Iges::kblank_status_visible, Iges::kcolor_number_cyan);
    pConeFrustum->setx1(0.); pConeFrustum->sety1(0.); pConeFrustum->setz1(0.);
    pConeFrustum->seth(10.);
    pConeFrustum->setr1(5.);
    pConeFrustum->setr2(2.);
    pConeFrustum->seti1(0.); pConeFrustum->setj1(0.); pConeFrustum->setk1(1.);
    pConeFrustum->setsubordinate(Iges::ksubordinate_switch_independent);
    return pConeFrustum->id();
  }

  OdDAIObjectId createEllipsoid(OdDAI::Model* pModel)
  {
    Iges::ellipsoidPtr pEllipsoid = Iges::ellipsoid::createObject(pModel);
    setGeometricData(pEllipsoid, "Ellipsoid", 1, 0, Iges::kblank_status_visible, Iges::kcolor_number_magenta);
    pEllipsoid->setlx(5.); pEllipsoid->setly(3.); pEllipsoid->setlz(2.);
    pEllipsoid->setx1(0.); pEllipsoid->sety1(0.); pEllipsoid->setz1(0.);
    pEllipsoid->seti1(1.); pEllipsoid->setj1(0.); pEllipsoid->setk1(0.);
    pEllipsoid->seti2(0.); pEllipsoid->setj2(1.); pEllipsoid->setk2(0.);
    pEllipsoid->setsubordinate(Iges::ksubordinate_switch_independent);
    return pEllipsoid->id();
  }

  void writeIgesFile(IgesFilePtr igesFile, const OdString& fileName)
  {
    OdDAI::Model* pModel = igesFile->getModel();

    Iges::iges_filePtr pFile = Iges::iges_file::createObject(pModel);
    OdDAI::ListOfOdAnsiString& fileStartSection = pFile->start_section();
    fileStartSection.createEmpty();
    fileStartSection.addByIndex(0, "Open Design Alliance IGES SDK Tutorial_05");

    Iges::globalPtr pGlobal = Iges::global::createObject(pModel);
    pGlobal->setparameter_delimiter(",");
    pGlobal->setrecord_delimiter(";");
    pGlobal->setnumber_of_binary_bits(32);
    pGlobal->setsingle_precision_magnitude(38);
    pGlobal->setsingle_precision_significance(6);
    pGlobal->setdouble_precision_magnitude(308);
    pGlobal->setdouble_precision_significance(15);
    pGlobal->setmodel_space_scale(1.);
    pGlobal->setunit_flag(Iges::kunitFlag_inches);
    pGlobal->setunits("IN");
    pGlobal->setmax_num_line_weight_gradations(1000);
    pGlobal->setwidth_max_line_weight(5.);
    pGlobal->setdate_time_file_generation("20250715.140000");
    pGlobal->setmax_coordinate_value(0.);
    pGlobal->setauthor("Tutorial_05");
    pGlobal->setorganization("Open Design Alliance");
    pGlobal->setversion(11);
    pGlobal->setdrafting_standard_code(Iges::kdraftingStandardCode_none);
    pGlobal->setdate_time_created_modified("20250715.140000");
    pGlobal->setmilspec("NULL");

    pFile->setglobal_section(pGlobal->id());

    igesFile->writeFile(fileName);
  }

}

Tutorial_05::Tutorial_05(const OdString& applicationName)
  : BaseIgesTutorial(applicationName)
  , m_primitiveType(L"Block")
{
  m_tutorialArgsParser
    .add_param(
      std::make_shared<OdDAI::utils::hardplace_value_option<OdString>>(m_outputFileName, "outputFileName", "output file name for generated .iges file"));

  m_tutorialArgsParser
    .add_param(
      std::make_shared<OdDAI::utils::hardplace_value_option<OdString>>(m_primitiveType, "primitive", "Type of the CSG primitive (e.g., Block, Cylinder, Sphere, etc.)."));

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

const std::map<OdString, std::function<OdDAIObjectId(OdDAI::Model*)>> Tutorial_05::csgObjectFactories = {
  {L"Block", createBlock},
  {L"Cylinder", createRightCircularCylinder},
  {L"Sphere", createSphere},
  {L"Torus", createTorus},
  {L"Extrusion", createSolidOfLinearExtrusion},
  {L"Revolution", createSolidOfRevolution},
  {L"Wedge", createRightAngularWedge},
  {L"ConeFrustum", createRightCircularConeFrustum},
  {L"Ellipsoid", createEllipsoid}
};

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

  if (m_outputFileName.isEmpty())
  {
    odPrintConsoleString(OD_T("Error: Output file not specified.\n"));
    return 1;
  }

  if (m_primitiveType.isEmpty())
  {
    odPrintConsoleString(OD_T("Error: Missing primitive type.\nPlease specify -primitive <type>.\n"));
    return 1;
  }

  auto it = csgObjectFactories.find(m_primitiveType);
  if (it == csgObjectFactories.end())
  {
    odPrintConsoleString(OD_T("Error: Unknown primitive type: %ls\n"), m_primitiveType.c_str());
    odPrintConsoleString(OD_T("Available types: Block, Cylinder, Sphere, Torus, Extrusion, Revolution, Wedge, ConeFrustum, Ellipsoid\n"));
    return 1;
  }

  IgesFilePtr igesFile = svcs.createDatabase();
  OdDAI::ModelPtr model = igesFile->getModel(sdaiRW);

  // Create views_visible instance
  Iges::views_visiblePtr viewsVisible = Iges::views_visible::createObject(model);
  viewsVisible->setlabel("");
  viewsVisible->setsubscript(0);
  OdDAI::ListOfOdDAIObjectId& dev = viewsVisible->dev();
  dev.createEmpty();
  OdDAI::ListOfOdDAIObjectId& de = viewsVisible->de();
  de.createEmpty();

  OdDAIObjectId idPrimitive = it->second(model);
  de.putByIndex(0, idPrimitive);

  writeIgesFile(igesFile, m_outputFileName);
  odPrintConsoleString(OD_T("Generated: %ls\n"), m_outputFileName.c_str());

  odPrintConsoleString(OD_T("\nSuccessfully generated one IGES file with a CSG primitive.\n"));

  return eOk;
}