//----------------------------------------------------------------------------
//  EgalTech 2025-2025
//----------------------------------------------------------------------------
// File : LUA_Trimming.cpp       Data : 23.10.25      Versione : 2.7j3
// Contenuto : Funzioni per le lavorazioni di Trimming.
//
// Modifiche : 23.10.25 RE Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "LUA.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGkLuaAux.h"
#include "/EgtDev/Include/EGnStringUtils.h"

using namespace std ;

// ------------------------------------------------------------------------------
static int
LuaTrimmingAutoSearch( lua_State* L)
{
  // 9 parametri : nParentId, nSurfLayerId, dShapeLinTol, dShapeAngTol, dLinTol, dEdgeLinTol, dAngTol, dAngFaceTol, vsShapes
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   int nSurfLayerId ;
   LuaCheckParam( L, 2, nSurfLayerId)
   double dShapeLinTol ;
   LuaCheckParam( L, 3, dShapeLinTol)
   double dShapeAngTol ;
   LuaCheckParam( L, 4, dShapeAngTol)
   double dLinTol ;
   LuaCheckParam( L, 5, dLinTol)
   double dEdgeLinTol ;
   LuaCheckParam( L, 6, dEdgeLinTol)
   double dAngTol ;
   LuaCheckParam( L, 7, dAngTol)
   double dAngFaceTol ;
   LuaCheckParam( L, 8, dAngFaceTol)
   STRVECTOR vsShapes ;
   LuaCheckParam( L, 9, vsShapes)
   LuaClearStack( L) ;
  // Recupero le lavorazioni di Trimming associate
   INTVECTOR vOtherFaces ;
   bool bOk = ExeTrimmingAutoSearch( nParentId, nSurfLayerId, dShapeLinTol, dShapeAngTol, dLinTol,
                                     dEdgeLinTol, dAngTol, dAngFaceTol, vsShapes) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

// ------------------------------------------------------------------------------
static int
LuaTrimmingGetSurfTmFaceAdj( lua_State* L)
{
  // 6 parametri : nSurfId, vTria, vPts, dAngTol, dSize, dSizeTol 
   int nSurfId ;
   LuaCheckParam( L, 1, nSurfId)
   INTVECTOR vTria ;
   LuaCheckParam( L, 2, vTria)
   PNTVECTOR vPts ;
   LuaCheckParam( L, 3, vPts)
   double dAngTol ;
   LuaCheckParam( L, 4, dAngTol)
   double dSize ;
   LuaCheckParam( L, 5, dSize)
   double dSizeTol ;
   LuaCheckParam( L, 6, dSizeTol)
   LuaClearStack( L) ;
  // Recupero le facce adiacenti in tolleranza angolare
   INTVECTOR vOtherFaces ;
   bool bOk = ExeTrimmingGetSurfTmFaceAdj( nSurfId, vTria, vPts, dAngTol, dSize, dSizeTol, vOtherFaces) ;
   LuaSetParam( L, bOk) ;
   if ( bOk)
      LuaSetParam( L, vOtherFaces) ;
   else
      LuaSetParam( L) ;
   return 2 ;
}

// ------------------------------------------------------------------------------
static int
LuaTrimmingGetSurfTmFromStmFaces( lua_State* L)
{
  // 3 Parametri : nParentId, nSurfId, vFaces
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   int nSurfId ;
   LuaCheckParam( L, 2, nSurfId)
   INTVECTOR vFaces ;
   LuaCheckParam( L, 3, vFaces)
   LuaClearStack( L) ;
  // Eseguo
   int nNewSurfId = ExeTrimmingGetSurfTmFromStmFaces( nParentId, nSurfId, vFaces) ;
   LuaSetParam( L, nNewSurfId) ;
   return 1 ;
}

// ------------------------------------------------------------------------------
static int
LuaTrimmingGetAdjSurfs( lua_State* L)
{
  // 5 parametri : nRefSfrId, vAllSurfId, dLinTol, dAngTol, dAngFaceTol
   INTVECTOR vRefSurfId ;
   LuaCheckParam( L, 1, vRefSurfId)
   INTVECTOR vOtherSurfId ;
   LuaCheckParam( L, 2, vOtherSurfId)
   double dLinTol ;
   LuaCheckParam( L, 3, dLinTol)
   double dAngTol ;
   LuaCheckParam( L, 4, dAngTol)
   double dAngFaceTol ;
   LuaCheckParam( L, 5, dAngFaceTol)
   LuaClearStack( L) ;
  // Calcolo le facce adiacenti per tolleranza
   INTVECTOR vOtherSurf ;
   bool bOk = ExeTrimmingGetAdjSurfs( vRefSurfId, vOtherSurfId, dLinTol, dAngTol, dAngFaceTol, vOtherSurf) ;
  // Restituisco il risultato
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, vOtherSurf) ;
   return 2 ;
}

// -------------------------------------------------------------------------------
static int
LuaTrimmingGetBorders( lua_State* L)
{
  // 4 parametri : nParentId, vIds, dLinTol, dAngTol
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   SELVECTOR vIds ;
   LuaCheckParam( L, 2, vIds)
   double dLinTol ;
   LuaCheckParam( L, 3, dLinTol)
   double dAngTol ;
   LuaCheckParam( L, 4, dAngTol)
   LuaClearStack( L) ;
  // Creo le curve di Edge grezze
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
   bool bOk = ExeTrimmingGetBorders( nParentId, vIds, dLinTol, dAngTol, nFirstId, nCount) ;
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, nFirstId) ;
   LuaSetParam( L, nCount) ;
   return 3 ;
}

// -------------------------------------------------------------------------------
static int
LuaTrimmingGetBordersByNormals( lua_State* L)
{
  // 5 o 6 parametri : nParentId, vIds, dLinTol, dAngTol, dThickness [, ptNear]
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   SELVECTOR vIds ;
   LuaCheckParam( L, 2, vIds)
   double dLinTol ;
   LuaCheckParam( L, 3, dLinTol)
   double dAngTol ;
   LuaCheckParam( L, 4, dAngTol)
   double dThickness ;
   LuaCheckParam( L, 5, dThickness)
   Point3d ptNear = P_INVALID ;
   LuaGetParam( L, 6, ptNear) ;
   LuaClearStack( L) ;
  // Creo le curve di Edge grezze
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
   bool bOk = ExeTrimmingGetBordersByNormals( nParentId, vIds, dLinTol, dAngTol, dThickness, ptNear, nFirstId, nCount) ;
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, nFirstId) ;
   LuaSetParam( L, nCount) ;
   return 3 ;
}

// -------------------------------------------------------------------------------
static int
LuaTrimmingGetFinalBorders( lua_State* L)
{
  // 4 o 5 o 6 o 7 parametri : nParentId, vCrvBezierId, dLinTol, dAngTol [,vBreakingPts] [,dThick [,dThickTol]]
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   INTVECTOR vCrvBezierId ;
   LuaCheckParam( L, 2, vCrvBezierId)
   double dLinTol ;
   LuaCheckParam( L, 3, dLinTol)
   double dAngTol ;
   LuaCheckParam( L, 4, dAngTol)
   PNTVECTOR vBreakingPts ;
   int nInd = 5 ;
   if ( LuaGetParam( L, nInd, vBreakingPts))
      ++ nInd ;
   double dThick = 0., dThickTol = EPS_SMALL ;
   if ( LuaGetParam( L, nInd, dThick)) {
      if ( ! LuaGetParam( L, nInd + 1, dThickTol)) {
         LuaClearStack( L) ;
         LuaSetParam( L, false) ;
         return 1 ;
      }
   }
   LuaClearStack( L) ;
  // Creo le curve Edges
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
   bool bOk = ExeTrimmingGetFinalBorders( nParentId, vCrvBezierId, dLinTol, dAngTol, vBreakingPts, dThick, dThickTol,
                                          nFirstId, nCount) ;
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, nFirstId) ;
   LuaSetParam( L, nCount) ;
   return 3 ;
}

//-------------------------------------------------------------------------------
static int
LuaTrimmingGetRuledBezier( lua_State* L)
{
  // 5 o 6 parametri : nParentId, vIds, nEdge1Id, nEdge2Id, dLinTol [,vnLineId]
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   INTVECTOR vIds ;
   LuaCheckParam( L, 2, vIds) ; // serve per orientare la superficie rigata ( Ids delle superfici)
   int nEdge1Id ;
   LuaCheckParam( L, 3, nEdge1Id)
   int nEdge2Id ;
   LuaCheckParam( L, 4, nEdge2Id)
   double dLinTol ;
   LuaCheckParam( L, 5, dLinTol)
   INTVECTOR vnLineId ;
   LuaGetParam( L, 6, vnLineId) ;
   LuaClearStack( L) ;
  // Calcolo la superficie di Bezier rigata
   int nId = ExeTrimmingGetRuledBezier( nParentId, vIds, nEdge1Id, nEdge2Id, dLinTol, vnLineId) ;
   LuaSetParam( L, nId) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTrimmingGetSurfBzSyncPoints( lua_State* L)
{
  // 4 parametri : nParentId, nEdge1Id, nEdge2Id, dLinTol
   int nParentId ;
   LuaCheckParam( L, 1, nParentId)
   int nEdge1Id ;
   LuaCheckParam( L, 2, nEdge1Id)
   int nEdge2Id ;
   LuaCheckParam( L, 3, nEdge2Id)
   double dLinTol ;
   LuaCheckParam( L, 4, dLinTol)
   LuaClearStack( L) ;
  // Inserisco i tratti lineari associati ai punti di sincronizzazione
   int nFirstId = GDB_ID_NULL ;
   int nCount = 0 ;
   bool bOk = ExeTrimmingGetSurfBzSyncPoints( nParentId, nEdge1Id, nEdge2Id, dLinTol, nFirstId, nCount) ;
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, nFirstId) ;
   LuaSetParam( L, nCount) ;
   return 3 ;
}

// ------------------------------------------------------------------------------
static int
LuaTrimmingSkimSyncPoints( lua_State* L)
{
  // 5 o 6 parametri : nEdge1Id, nEdge2Id, vnLineId, dLinTol, dAngTol [,nMaxInvLine]
   int nEdge1Id ;
   LuaCheckParam( L, 1, nEdge1Id)
   int nEdge2Id ;
   LuaCheckParam( L, 2, nEdge2Id)
   INTVECTOR vnLineId ;
   LuaCheckParam( L, 3, vnLineId)
   double dLinTol ;
   LuaCheckParam( L, 4, dLinTol)
   double dAngTol ;
   LuaCheckParam( L, 5, dAngTol)
   int nMaxInvLine = 4 ;
   LuaGetParam( L, 6, nMaxInvLine) ;
   LuaClearStack( L) ;
  // Nascondo/Visualizzo i tratti lineari di sincronizzazione
   bool bOk = ExeTrimmingSkimSyncPoints( nEdge1Id, nEdge2Id, vnLineId, dLinTol, dAngTol, nMaxInvLine) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallTrimming( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
  // ---
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingAutoSearch", LuaTrimmingAutoSearch) ;
  // --- 
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetSurfTmFaceAdj", LuaTrimmingGetSurfTmFaceAdj) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetSurfTmFromStmFaces", LuaTrimmingGetSurfTmFromStmFaces) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetAdjSurfs", LuaTrimmingGetAdjSurfs) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetBorders", LuaTrimmingGetBorders) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetBordersByNormals", LuaTrimmingGetBordersByNormals) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetFinalBorders", LuaTrimmingGetFinalBorders) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetRuledBezier", LuaTrimmingGetRuledBezier) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingGetSurfBzSyncPoints", LuaTrimmingGetSurfBzSyncPoints) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimmingSkimSyncPoints", LuaTrimmingSkimSyncPoints) ;
   return bOk ;
}