//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : LUA_GdbModifyCurve.cpp       Data : 28.12.14        Versione : 1.5l2
// Contenuto : Funzioni di modifica delle curve per LUA.
//
//
//
// Modifiche : 03.10.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

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

using namespace std ;

//----------------------------------------------------------------------------
static int
LuaInvertCurve( lua_State* L)
{
  // 1 parametro : Id/s
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   LuaClearStack( L) ;
  // eseguo inversione curve
   bool bOk = ExeInvertCurve( vId) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOffsetCurve( lua_State* L)
{
  // 2 o 3 parametri : Id, dDist [, nType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dDist ;
   LuaCheckParam( L, 2, dDist)
   int nType = ICurve::OFF_FILLET ;
   LuaGetParam( L, 3, nType) ;
   LuaClearStack( L) ;
  // offset della curva
   bool bOk = ExeOffsetCurve( nId, dDist, nType) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaChangeClosedCurveStartPoint( lua_State* L)
{
  // 2 o 3 parametri : Id, NewStart [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptStart ;
   LuaCheckParam( L, 2, ptStart)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // modifico il punto iniziale
   bool bOk = ExeChangeClosedCurveStartPoint( nId, ptStart, nRefType) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveStartPoint( lua_State* L)
{
  // 2 o 3 parametri : Id, NewStart [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptStart ;
   LuaCheckParam( L, 2, ptStart)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // modifico il punto iniziale
   bool bOk = ExeModifyCurveStartPoint( nId, ptStart, nRefType) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveEndPoint( lua_State* L)
{
  // 2 o 3 parametri : Id, NewEnd [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptEnd ;
   LuaCheckParam( L, 2, ptEnd)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // modifico il punto finale
   bool bOk = ExeModifyCurveEndPoint( nId, ptEnd, nRefType) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveExtrusion( lua_State* L)
{
  // 2 o 3 parametri : Id/s, vtExtr [, nRefType]
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   Vector3d vtExtr ;
   LuaCheckParam( L, 2, vtExtr)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // modifico il vettore estrusione
   bool bOk = ExeModifyCurveExtrusion( vId, vtExtr, nRefType) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaModifyCurveThickness( lua_State* L)
{
  // 2 parametri : Id/s, Thick
   INTVECTOR vId ;
   LuaCheckParam( L, 1, vId)
   double dThick ;
   LuaCheckParam( L, 2, dThick)
   LuaClearStack( L) ;
  // modifico lo spessore di estrusione
   bool bOk = ExeModifyCurveThickness( vId, dThick) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveStartAtLen( lua_State* L)
{
  // 2 parametri : Id, dLen
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLen ;
   LuaCheckParam( L, 2, dLen)
   LuaClearStack( L) ;
  // taglio la curva all'inizio
   bool bOk = ExeTrimCurveStartAtLen( nId, dLen) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveEndAtLen( lua_State* L)
{
  // 2 parametri : Id, dLen
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLen ;
   LuaCheckParam( L, 2, dLen)
   LuaClearStack( L) ;
  // taglio la curva alla fine
   bool bOk = ExeTrimCurveEndAtLen( nId, dLen) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveStartAtParam( lua_State* L)
{
  // 2 parametri : Id, dPar
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dPar ;
   LuaCheckParam( L, 2, dPar)
   LuaClearStack( L) ;
  // taglio la curva all' inizio
   bool bOk = ExeTrimCurveStartAtParam( nId, dPar) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveEndAtParam( lua_State* L)
{
  // 2 parametri : Id, dPar
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dPar ;
   LuaCheckParam( L, 2, dPar)
   LuaClearStack( L) ;
  // taglio la curva alla fine
   bool bOk = ExeTrimCurveEndAtParam( nId, dPar) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimCurveStartEndAtParam( lua_State* L)
{
  // 3 parametri : Id, dParS, dParE
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dParS ;
   LuaCheckParam( L, 2, dParS)
   double dParE ;
   LuaCheckParam( L, 3, dParE)
   LuaClearStack( L) ;
  // taglio la curva alla fine
   bool bOk = ExeTrimCurveStartEndAtParam( nId, dParS, dParE) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaTrimExtendCurveByLen( lua_State* L)
{
  // 3 o 4 parametri : Id, dLen, ptNear [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLen ;
   LuaCheckParam( L, 2, dLen)
   Point3d ptNear ;
   LuaCheckParam( L, 3, ptNear)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 4, nRefType) ;
   LuaClearStack( L) ;
  // taglio o allungo la curva nell'estremo pił vicino al punto
   bool bOk = ExeTrimExtendCurveByLen( nId, dLen, ptNear, nRefType) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaSplitCurve( lua_State* L)
{
  // 2 parametri : Id, nParts
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nParts ;
   LuaCheckParam( L, 2, nParts)
   LuaClearStack( L) ;
  // divido la curva nel punto
   int nFirstId = ExeSplitCurve( nId, nParts) ;
   if ( nFirstId != GDB_ID_NULL)
      LuaSetReturn( L, nFirstId) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//----------------------------------------------------------------------------
static int
LuaSplitCurveAtPoint( lua_State* L)
{
  // 2 o 3 parametri : Id, ptOn [, nRefType]
   int nId ;
   LuaCheckParam( L, 1, nId)
   Point3d ptOn ;
   LuaCheckParam( L, 2, ptOn)
   int nRefType = RTY_DEFAULT ;
   LuaGetParam( L, 3, nRefType) ;
   LuaClearStack( L) ;
  // divido la curva nel punto
   int nNewId = ExeSplitCurveAtPoint( nId, ptOn, nRefType) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetReturn( L, nNewId) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaModifyCurveArcRadius( lua_State* L)
{
  // 2 parametri : Id, dNewRad
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dNewRad ;
   LuaCheckParam( L, 2, dNewRad)
   LuaClearStack( L) ;
  // modifica del raggio
   bool bOk = ExeModifyCurveArcRadius( nId, dNewRad) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaExplodeCurveCompo( lua_State* L)
{
  // 1 parametro : Id
   int nId ;
   LuaCheckParam( L, 1, nId)
   LuaClearStack( L) ;
  // esplosione della curva composita
   int nCount ;
   int nFirstId = ExeExplodeCurveCompo( nId, &nCount) ;
   if ( nFirstId != GDB_ID_NULL)
      LuaSetReturn( L, nFirstId) ;
   else
      LuaSetReturn( L) ;
   LuaSetReturn( L, nCount) ;
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaApproxCurveArc( lua_State* L)
{
  // 1 o 2 parametri : Id [, dLinTol]
   int nId ;
   LuaCheckParam( L, 1, nId)
   double dLinTol = 0.01 ;
   LuaGetParam( L, 2, dLinTol) ;
   LuaClearStack( L) ;
  // approssimazione dell'arco con rette
   int nNewId = ExeApproxCurveArc( nId, dLinTol) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetReturn( L, nNewId) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaApproxCurveBezier( lua_State* L)
{
  // 2 o 3 parametri : Id, nArcsVsLines [, dLinTol]
   int nId ;
   LuaCheckParam( L, 1, nId)
   int nTemp ;
   LuaCheckParam( L, 2, nTemp)
   bool bArcsVsLines = ( nTemp != 0) ;
   double dLinTol = 0.01 ;
   LuaGetParam( L, 3, dLinTol) ;
   LuaClearStack( L) ;
  // approssimazione della curva di Bezier con archi o rette
   int nNewId = ExeApproxCurveBezier( nId, bArcsVsLines, dLinTol) ;
   if ( nNewId != GDB_ID_NULL)
      LuaSetReturn( L, nNewId) ;
   else
      LuaSetReturn( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGdbModifyCurve( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtInvertCurve", LuaInvertCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOffsetCurve", LuaOffsetCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtChangeClosedCurveStartPoint", LuaChangeClosedCurveStartPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveStartPoint", LuaModifyCurveStartPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveEndPoint", LuaModifyCurveEndPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveExtrusion", LuaModifyCurveExtrusion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveThickness", LuaModifyCurveThickness) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveStartAtLen", LuaTrimCurveStartAtLen) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveEndAtLen", LuaTrimCurveEndAtLen) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveStartAtParam", LuaTrimCurveStartAtParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveEndAtParam", LuaTrimCurveEndAtParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimCurveStartEndAtParam", LuaTrimCurveStartEndAtParam) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTrimExtendCurveByLen", LuaTrimExtendCurveByLen) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitCurve", LuaSplitCurve) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitCurveAtPoint", LuaSplitCurveAtPoint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtModifyCurveArcRadius", LuaModifyCurveArcRadius) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExplodeCurveCompo", LuaExplodeCurveCompo) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtApproxCurveArc", LuaApproxCurveArc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtApproxCurveBezier", LuaApproxCurveBezier) ;
   return bOk ;
}