-- WProcessMortise.lua by Egaltech s.r.l. 2021/07/30
-- Gestione calcolo mortase per Pareti
-- 2023/01/05 Permesse le mortase laterali in presenza di offset Z, tra grezzo e tavola, di almeno 100 mm
-- 2023/05/25 Funzioni EgtAddMachining sostituite da WM.AddMachining in modo da trascrivere le priorità da btl alle lavorazioni.

-- Tabella per definizione modulo
local WPM = {}

-- Include
require( 'EgtBase')
local WL = require( 'WallLib')

EgtOutLog( ' WProcessMortise started', 1)

-- Dati
local WD = require( 'WallData')
local WM = require( 'WMachiningLib')

---------------------------------------------------------------------
-- Riconoscimento della feature
function WPM.Identify( Proc)
   return ( (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 50) or
            (( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 53))
end

---------------------------------------------------------------------
-- Classificazione della feature: decide se la feature è in una posizione che per lavorala
-- deve essere ribaltata o no
function WPM.Classify( Proc, b3Raw)
   -- recupero e verifico il percorso supplementare
   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
   if AuxId then AuxId = AuxId + Proc.Id end
   -- recupero versore estrusione della curva supplementare e non più della superficie
   -- perché quest'ultima potrebbe non avere il fondo e dare quindi un risultato non corretto
   local vtExtr = EgtCurveExtrusion( AuxId or GDB_ID.NULL, GDB_ID.ROOT)
   -- recupero i dati della faccia di fondo
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
   -- verifico sia una superficie
   if not vtExtr then
      return false
   end
   if not vtN then
      return false
   end
   -- Confronto le direzioni Z dei 2 versori : se diverse la faccia 0 non è il fondo => mortasa passante
   if abs( vtExtr:getZ() - vtN:getZ()) > 10 * GEO.EPS_SMALL then
      return true
   -- altrimenti è chiusa
   else
      -- verifico se la mortasa è lavorabile da sopra o dal lato se con offset Z
      local dMinZRaw = b3Raw:getMin():getZ()
      local b3Tab = EgtGetTableArea()
      local dMaxZTable = b3Tab:getMax():getZ()
      local dDeltaZ = dMinZRaw - dMaxZTable
      local MIN_Z_OFFSET = 99.9
      return EgtIf( dDeltaZ < MIN_Z_OFFSET - GEO.EPS_SMALL, vtN:getZ() > WD.NZ_MINA, vtN:getZ() > -0.1)
   end
end

----------------------------------------------------------------------
-- Classificazione del flip della feature per nesting
-- return nFlip0, nFlip1
function WPM.FlipClassify( Proc)
   -- recupero e verifico il percorso supplementare
   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
   if AuxId then AuxId = AuxId + Proc.Id end
   -- recupero versore estrusione della curva supplementare e non più della superficie
   -- perché quest'ultima potrebbe non avere il fondo e dare quindi un risultato non corretto
   local vtExtr = EgtCurveExtrusion( AuxId or GDB_ID.NULL, GDB_ID.ROOT)
   -- recupero i dati della faccia di fondo
   local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
   -- verifico sia una superficie
   if not vtExtr then
      return false 
   end
   if not vtN then
      return false
   end
   -- Confronto le direzioni Z dei 2 versori : se diverse la faccia 0 non è il fondo => mortasa passante
   if abs( vtExtr:getZ() - vtN:getZ()) > 10 * GEO.EPS_SMALL then
      return 100, 100
   -- altrimenti è chiusa
   else
      -- verifico se la mortasa è lavorabile da sopra
      nFlip0 = EgtIf( vtN:getZ() > WD.NZ_MINA, 100, 0)
      nFlip1 = EgtIf( - vtN:getZ() > WD.NZ_MINA, 100, 0)
   end
   
   return nFlip0, nFlip1
  
end

---------------------------------------------------------------------
-- Applicazione della lavorazione
function WPM.Make( Proc, nRawId, b3Raw)
   -- recupero e verifico l'entità curva
   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
   if AuxId then AuxId = AuxId + Proc.Id end
   if not AuxId  or  ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then
      local sErr = 'Error : missing profile geometry'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- recupero versore estrusione della curva supplementare
   local vtExtr = EgtCurveExtrusion( AuxId, GDB_ID.ROOT)
   -- recupero i dati della faccia di fondo
   local frMor, dL, dW = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0, GDB_ID.ROOT)
   local ptC = ORIG()
   local vtN = V_NULL()
   if frMor then
      ptC = frMor:getOrigin()
      vtN = frMor:getVersZ()
   end
   -- verifico se è presente il fondo (sempre faccia 0)
   local bClosedBtm = AreSameVectorApprox( vtExtr, vtN)
   -- Se curva di contorno aperta
   local dLenOpenSide = 0
   if not EgtCurveIsClosed( AuxId) then
      -- se c'è il fondo
      if bClosedBtm then 
         local NewId, nCount = EgtExtractSurfTmFacetLoops( Proc.Id, 0, EgtGetParent( Proc.Id))
         if NewId then
            -- elimino eventuali loop interni (non dovrebbero comunque esserci)
            for i = 1, nCount - 1 do
               EgtErase( NewId + i)
            end
            -- sostituisco il loop esterno alla curva originale
            EgtModifyCurveExtrusion( NewId, vtExtr, GDB_ID.ROOT)
            EgtRelocate( NewId, AuxId, GDB_IN.AFTER)
            EgtErase( AuxId)
            EgtChangeId( NewId, AuxId)
            -- sistemo i lati aperti
            local vFacAdj = EgtSurfTmFacetAdjacencies( Proc.Id, 0)[1]
            if vFacAdj then
               local sOpen = ''
               for i = 1, #vFacAdj do
                  if vFacAdj[i] < 0 then
                     sOpen = sOpen .. EgtIf( #sOpen > 0, ',', '') .. tostring( i - 1)
                     local dLen = dist( EgtUP( AuxId, i-1), EgtUP( AuxId, i))
                     dLenOpenSide = max( dLen, dLenOpenSide)
                  end
               end
               if #sOpen > 0 then
                  EgtSetInfo( AuxId, 'OPEN', sOpen)
               end
            end
         end
      -- altrimenti aperta
      else
         dLenOpenSide = dist( EgtSP( AuxId), EgtEP( AuxId))
         local _, nCrvCnt = EgtCurveDomain( AuxId)
         EgtCloseCurveCompo( AuxId) 
         EgtSetInfo( AuxId, 'OPEN', nCrvCnt)
      end
   end
   -- Se mortasa passante
   if not bClosedBtm then
      -- creo superficie chiusa
      local nFlat = EgtSurfTmByFlatContour( EgtGetParent( AuxId), AuxId, 0.05)
      if nFlat then
         -- la superficie deve sempre essere rivolta verso l'alto
         local vtNN = EgtSurfTmFacetNormVersor( nFlat, 0, GDB_ID.ROOT)
         frMor, dL, dW = EgtSurfTmFacetMinAreaRectangle( nFlat, 0, GDB_ID.ROOT)
         ptC = frMor:getOrigin()
         vtN = frMor:getVersZ()
         -- verifico se copiare la geometria lungo l'asse Z
         local b3Aux = EgtGetBBoxRef( AuxId, GDB_BB.STANDARD, frMor) 
         local bxMax = b3Aux:getMax()
         local b3Mor = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, frMor) 
         local bxMin = b3Mor:getMin()
         local dMove = bxMin:getZ() - bxMax:getZ()
         if vtNN:getZ() < 0.1 then dMove = -dMove end
         -- se il percorso ausiliario è esterno al grezzo, lo riavvicino
         if abs( dMove) > GEO.EPS_SMALL then
            AuxId = EgtCopyGlob( AuxId, WL.GetAddGroup( Proc.PartId))
            EgtMove( AuxId, Vector3d( 0, 0, dMove), GDB_RT.GLOB)
            EgtMove( nFlat, Vector3d( 0, 0, dMove), GDB_RT.GLOB)
            frMor, dL, dW = EgtSurfTmFacetMinAreaRectangle( nFlat, 0, GDB_ID.ROOT)
            ptC = frMor:getOrigin()
            vtN = frMor:getVersZ()
         end
         -- cancello le prove del misfatto (superficie piana)
         EgtErase( nFlat)
      end
   end
   -- scrivo info nel log
   EgtOutLog( 'ptC=' .. tostring( ptC) ..' vtN=' .. tostring( vtN), 3)
   -- Se mortasa chiusa
   local bForceOneSide
   local bRevertSide
   if bClosedBtm then
      -- verifico se la mortasa è lavorabile da sopra o dal lato se con offset Z
      local dMinZRaw = b3Raw:getMin():getZ()
      local b3Tab = EgtGetTableArea()
      local dMaxZTable = b3Tab:getMax():getZ()
      local dDeltaZ = dMinZRaw - dMaxZTable
      local MIN_Z_OFFSET = 100
      if vtExtr:getZ() < WD.NZ_MINA then
         if dDeltaZ < MIN_Z_OFFSET - GEO.EPS_SMALL or vtExtr:getZ() <= -0.1 then
            local sErr = 'Error : Mortise from bottom impossible'
            EgtOutLog( sErr)
            return false, sErr
         end
      end
    -- altrimenti passante
   else
      -- determino se la mortasa da lavorare sul lato opposto sia di angolo inferiore a quello consentito
      if abs( vtN:getZ()) > 0.1 then
         bForceOneSide = true
      end
      -- determino se è meglio lavorare la mortasa nel lato opposto
      if vtN:getZ() < -GEO.EPS_SMALL then
         bRevertSide = true
      end
   end

   -- determino altezza della mortasa
   local b3Mor = EgtGetBBoxRef( Proc.Id, GDB_BB.STANDARD, frMor) 
   local dMorH = b3Mor:getDimZ()
   -- elevazione del punto centro
   local _, dCenElev = WL.GetPointDirDepth( Proc.PartId, ptC, vtN)
   dMorH = max( dMorH, dCenElev or 0)
   -- determino larghezza della mortasa
   if dL < dW then dL, dW = dW, dL end
   dW = max( dW, min( 2 * dW, dLenOpenSide))
   -- recupero la lavorazione
   local sPocketing
   if Proc.Prc ~= 53 then
      sPocketing = WM.FindPocketing( 'Mortise', dW)
   end
   if not sPocketing then
      sPocketing = WM.FindPocketing( 'Pocket', dW)
   end
   if not sPocketing then
      local sErr = 'Error : Mortise or Pocket not found in library'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- recupero i dati dell'utensile
   local dMillDiam = 20
   local dMaxDepth = 0
   local bCW = true
   if EgtMdbSetCurrMachining( sPocketing) then
      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
         dMillDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dMillDiam
         dMaxDepth = ( EgtTdbGetCurrToolMaxDepth() or dMaxDepth)
         local dSpeed = EgtMdbGetCurrMachiningParam( MCH_MP.SPEED) or 0
         bCW = ( dSpeed >= 0)
      end
   end
   -- inserisco la lavorazione di svuotatura
   local sName = 'Mort_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
   local nMchFId = WM.AddMachining( Proc, sName, sPocketing)
   if not nMchFId then
      local sErr = 'Error adding machining ' .. sName .. '-' .. sPocketing
      EgtOutLog( sErr)
      return false, sErr
   end
   -- verifico se invertire versore estrusione geometria
   if bRevertSide then
      EgtModifyCurveExtrusion( AuxId, -vtExtr, GDB_ID.ROOT)
   end
   -- aggiungo geometria
   EgtSetMachiningGeometry( {{ AuxId, -1}})
   -- sistemo la direzione di lavoro
   EgtSetMachiningParam( MCH_MP.INVERT, EgtIf( bCW, true, false))
   -- imposto posizione braccio porta testa
   if vtN:getY() < GEO.EPS_SMALL then
      if bRevertSide then
         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP)
      else
         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM)
      end
   else
      if bRevertSide then
         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YM)
      else
         EgtSetMachiningParam( MCH_MP.SCC, MCH_SCC.ADIR_YP)
      end
   end
   local sWarn
   local nDepthMin
   -- se elevazione superiore a massimo affondamento della fresa, riduco opportunamente
   if dMorH > dMaxDepth + 10 * GEO.EPS_SMALL then
      sWarn = 'Warning in mortise : elevation (' .. EgtNumToString( dMorH,1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth,1) .. ')'
      -- se non ho invertito la direzione di estrusione
      if not bRevertSide then
         nDepthMin = dMaxDepth - EgtIf( not bClosedBtm and not bForceOneSide, dMorH * 2, dMorH)
      else
         nDepthMin = dMaxDepth
      end
      EgtSetMachiningParam( MCH_MP.DEPTH, nDepthMin)
      dMorH = dMaxDepth
      EgtOutLog( sWarn .. ' (process ' .. tostring( Proc.Id) .. ')')
   else
      if not bClosedBtm and not bForceOneSide then -- se mortasa passante setto metà profondità
         nDepthMin = -dMorH
         EgtSetMachiningParam( MCH_MP.DEPTH, nDepthMin)
      elseif bRevertSide then
         EgtSetMachiningParam( MCH_MP.DEPTH, dMorH)
      end
   end
   -- imposto elevazione
   EgtSetMachiningParam( MCH_MP.USERNOTES, 'MaxElev=' .. EgtNumToString( dMorH, 1) .. ';')
   -- eseguo
   if not EgtApplyMachining( true, false) then
      local _, sErr = EgtGetLastMachMgrError()
      EgtSetOperationMode( nMchFId, false)
      return false, sErr
   end

   return true, sWarn
end

---------------------------------------------------------------------
return WPM