-- RunPrepareExport.lua by Egaltech s.r.l. 2023/10/19
-- Creo le geometrie da esportare con 3dm

-- Tabella per definizione modulo
local RunPrepareExport = {}

-- Intestazioni
require( 'EgtBase')

EgtOutLog( ' RunPreprareExport started', 1)

-- Dati
local AMD = require( 'AddManData')

------------------------------------------------------------------
local function CalcCurves( nSliceId, nDestGrp, dStrandBase)
  
   -- scorro tutti i gruppi di curve
   local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
   for j = 1, #vCrvs do
      -- cerco il gruppo del toolpath
      local nTPath = EgtGetFirstNameInGroup( vCrvs[j], TOOLPATH_GRP)
      if nTPath then
         local nId = EgtGetFirstInGroup( nTPath)
         while nId do
            -- se non è wipe creo la fat curve da estrudere per creare il solido
            local nType = EgtGetInfo( nId, KEY_TYPE, 'i')
            if nType ~= TYPE.WIPE then
               local dStrand = EgtGetInfo( nId, KEY_CRV_STRAND, 'd') or dStrandBase
               
               -- calcolo fat region a partire da una copia della curva ( in questo modo nel DB geometrico non restano
               -- salvati i diagrammi di Voronoi che non servono per conti futuri)
               local nCopy = EgtCopyGlob( nId, nDestGrp)
               local nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand + 0.01, false)
               -- se fallisce ritento con valore leggermente diverso
               if not nSurf or nSurf == GDB_ID.NULL then
                  nSurf = EgtSurfFrFatCurve( nDestGrp, nCopy, 0.5 * dStrand - 0.05, false)
               end
               EgtErase( nCopy)

               if nSurf then
                  local nChunks = EgtSurfFrChunkCount( nSurf)
                  for k = 0, nChunks - 1 do
                     -- estraggo i loop associati
                     local nCrv, nCnt = EgtExtractSurfFrChunkLoops( nSurf, k, nDestGrp)

                     -- eventuali aggiustamenti per creare un percorso unico
                     if nCnt > 1 then
                        for nLoopId = nCrv + 1, nCrv + nCnt - 1 do
                           
                           -- recupero la prima curva del loop interno che non sia di raccordo
                           local vTempProps = EgtCurveCompoGetTempProp( nLoopId)
                           local dU
                           for i = 1, #vTempProps do
                              if vTempProps[i] > 0 then
                                 dU = i - 1
                                 break
                              end
                           end
                           -- taglio il loop interno
                           EgtChangeClosedCurveStart( nLoopId, dU + 0.5)
                           EgtTrimCurveStartAtLen( nLoopId, 5 * GEO.EPS_SMALL)
                           -- taglio il loop esterno in corrispondenza del loop interno
                           local _, _, dPar = EgtPointCurveDist( EgtSP( nLoopId), nCrv)
                           EgtChangeClosedCurveStart( nCrv, dPar)
                           EgtTrimCurveStartAtLen( nCrv, 5 * GEO.EPS_SMALL)
                           -- unisco le curve
                           EgtAddCurveCompoLine( nCrv, EgtSP( nLoopId))
                           EgtAddCurveCompoCurve( nCrv, nLoopId)
                           EgtCloseCurveCompo( nCrv)
                        end
                     end
                     
                     if nType == TYPE.OUTER_SHELL or nType == TYPE.EXTRA_OUTER_SHELL then 
                        EgtSetColor( nCrv, EgtStdColor( 'TEAL'))
                     elseif nType == TYPE.INNER_SHELL or nType == TYPE.EXTRA_SHELL then
                        EgtSetColor( nCrv, EgtStdColor( 'ORANGE'))
                     elseif nType == TYPE.LINK then
                        EgtSetColor( nCrv, EgtStdColor( 'GRAY'))
                     elseif nType == TYPE.INFILL then
                        EgtSetColor( nCrv, EgtStdColor( 'YELLOW'))
                     elseif nType == TYPE.COASTING then
                        EgtSetColor( nCrv, EgtStdColor( 'BLUE'))
                     elseif nType == TYPE.RIB then
                        EgtSetColor( nCrv, EgtStdColor( 'OLIVE'))
                     elseif nType == TYPE.AUX_SOLID then
                        EgtSetColor( nCrv, EgtStdColor( 'AQUA'))
                     end
                  end
                  EgtErase( nSurf)
               end
            end
            
            nId = EgtGetNext( nId)
         end
      end

      -- copio le frecce direzione dal gruppo dei solidi
      local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
      if nSolidGrp then
         local nId = EgtGetFirstNameInGroup( nSolidGrp, DIR_ARROW)
         while nId do
            local nCopy = EgtCopyGlob( nId, nDestGrp)
            EgtSetMode( nCopy, GDB_MD.STD)
            EgtSetStatus( nCopy, GDB_ST.ON)
            nId = EgtGetNextName( nId, DIR_ARROW)
         end
      end
   end
end

------------------------------------------------------------------
local function GetSolids( nSliceId, nDestGrp)
   
   -- scorro tutti i gruppi di curve
   local vCrvs = EgtGetNameInGroup( nSliceId, CONTOUR_GRP .. '*')
   for j = 1, #vCrvs do
      -- recupero il solido dal gruppo
      local nSolidGrp = EgtGetFirstNameInGroup( vCrvs[j], SOLID_GRP)
      if nSolidGrp then
         -- copio solo la prima freccia direzionale
         local nArrow = EgtGetFirstNameInGroup( nSolidGrp, DIR_ARROW) or GDB_ID.NULL
         EgtCopyGlob( nArrow, nDestGrp)
         local vSolids = EgtGetAllInGroup( nSolidGrp)
         for i = 1, #vSolids do
            if EgtGetName( vSolids[i]) ~= DIR_ARROW then
               EgtCopyGlob( vSolids[i], nDestGrp)
            end
         end
      end
   end
end

------------------------------------------------------------------
function RunPrepareExport.Exec()

   local nPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, PART .. '*')
   if not nPartId then 
      EgtOutBox( 'Error : no part', 'Export')
      return GDB_ID.NULL
   end
   
   -- creo o recupero il gruppo per l'esportazione
   local nGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, LAY_EXPORT)
   if not nGrp then
      -- se non esiste creo il gruppo
      nGrp = EgtGroup( GDB_ID.ROOT)
      EgtSetName( nGrp, LAY_EXPORT)
      EgtSetStatus( nGrp, GDB_ST.OFF)
      EgtSetLevel( nGrp, GDB_LV.TEMP)
   else
      -- se il gruppo esiste già non devo fare nulla
      return nGrp
   end
   
   -- creo il punto di origine del riferimento
   local ptRef = EgtGetInfo( nPartId, KEY_ORIG_REF, 'p')
   if not ptRef then
      local nFrameId = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( nPartId, LAY_FRAME), FRAME_PART)
      ptRef = EgtSP( nFrameId or GDB_ID.NULL, GDB_ID.ROOT)
   end
   local nPnt = EgtPoint( nGrp, ptRef, GDB_RT.GLOB)
   EgtSetName( nPnt, KEY_ORIG_REF)
   EgtSetStatus( nPnt, GDB_ST.OFF)
   
   -- recupero alcune info utili e le assegno al punto per poterle leggere da ThreeJS
   local dH = EgtGetInfo( nPartId, KEY_SLICE_STEP, 'd')
   EgtSetInfo( nPnt, KEY_SLICE_STEP, dH)
   local vtSlicing = EgtGetInfo( nPartId, KEY_SLICE_DIR, 'v') or EgtGetInfo( nPartId, "SlicingDir", 'v')
   EgtSetInfo( nPnt, "SlicingDir", vtSlicing)
   local bSpiralVase = EgtGetInfo( nPartId, KEY_SPIRAL_VASE, 'b') or false
   EgtSetInfo( nPnt, KEY_SPIRAL_VASE, bSpiralVase)
   local nSlicingType = EgtGetInfo( nPartId, KEY_SLICING_TYPE, 'i')
   
   -- recupero lo strand dai parametri generale nel caso non fosse definito sulle singole curve
   local dStrandBase = EgtGetInfo( nPartId, KEY_STRAND, 'd') or 0
   
   -- recupero gli slices
   local vSlices = EgtGetNameInGroup( nPartId, SLICE_LAYER .. '*') or {}
   if #vSlices == 0 then
      EgtOutBox( 'Error : no slices', 'Export')
      return GDB_ID.NULL
   end
   
   -- verifico che nel primo slice siano presenti sia i toolpath sia i solidi
   local nCrvGrp = EgtGetFirstNameInGroup( vSlices[1], CONTOUR_GRP .. '*')
   if not nCrvGrp then
      EgtOutBox( 'Error : no toolpaths', 'Export')
      return GDB_ID.NULL
   end
   local nTPath = EgtGetFirstNameInGroup( nCrvGrp, TOOLPATH_GRP)
   if not nTPath then
      EgtOutBox( 'Error : no toolpaths', 'Export')
      return GDB_ID.NULL
   end
   local nSolid = EgtGetFirstNameInGroup( nCrvGrp, SOLID_GRP)
   if not nSolid then
       EgtOutBox( 'Error : no solids', 'Export')
      return GDB_ID.NULL
   end

   for i = 1, #vSlices do
      -- creo il gruppo corrispondente
      local nDestGrp = EgtGroup( nGrp)
      EgtSetName( nDestGrp, EgtGetName( vSlices[i]))
      EgtSetStatus( nDestGrp, GDB_ST.OFF)
      
      -- se multiplanare o spiral vase esporto direttamente i solidi altrimenti esporto le curve che verranno estruse nel visualizzatore
      if nSlicingType == SLICING_TYPE.MULTIPLANAR or nSlicingType == SLICING_TYPE.MULTIPLANAR_DEG45 or nSlicingType == SLICING_TYPE.MULTIPLANAR_HOR or bSpiralVase then
         GetSolids( vSlices[i], nDestGrp)
      else
         CalcCurves( vSlices[i], nDestGrp, dStrandBase)
      end
   end

   return nGrp
end

---------------------------------------------------------------------
return RunPrepareExport