-- ProcessRidgeLap.lua by Egaltech s.r.l. 2023/08/10
-- Gestione calcolo mezzolegno di testa per Travi

-- Tabella per definizione modulo
local ProcessRidgeLap = {}

-- Include
require( 'EgtBase')
local BL = require( 'BeamLib')
local Fbs = require( 'FacesBySaw')
local Cut = require( 'ProcessCut')
local DC = require( 'DiceCut')
local LapJoint = require( 'ProcessLapJoint')

EgtOutLog( ' ProcessRidgeLap started', 1)

-- Dati
local BD = require( 'BeamData')
local ML = require( 'MachiningLib')

---------------------------------------------------------------------
-- Riconoscimento della feature
function ProcessRidgeLap.Identify( Proc)
   return (( Proc.Grp == 1 or Proc.Grp == 2)  and  Proc.Prc == 30)
end

---------------------------------------------------------------------
-- Classificazione della feature
function ProcessRidgeLap.Classify( Proc, b3Raw)
   -- se PF con testa da sotto oppure TURN, ammessa qualunque orientazione
   if ( BD.C_SIMM and BD.DOWN_HEAD) or BD.TURN then
      return true, false
   end
   -- Se più corta del limite si può fare anche da sotto
   if Proc.Box:getDimX() <= BD.GetMaxLenRidgeLapFromBottom( b3Raw:getDimZ()) then
      return true, false
   end
   -- verifico le normali delle facce
   local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
   for i = 1, nFacetCnt do
      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i-1, GDB_ID.ROOT)
      if vtN:getZ() < - 0.707 then
         return true, true
      end
   end
   return true, false
end

---------------------------------------------------------------------
-- Applicazione della lavorazione
function ProcessRidgeLap.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
   local nForceUseBladeOnNotContinueFace = EgtGetInfo( Proc.Id, 'Q04', 'i') or 0
   local bUseMill = ( EgtGetInfo( Proc.Id, 'Q05', 'i') or 0) == 1
   -- recupero l'ingombro del grezzo di appartenenza
   local b3Raw = EgtGetRawPartBBox( nRawId)
   -- ingombro del pezzo
   local Ls = EgtGetFirstNameInGroup( nPartId, 'Box')
   local b3Solid = EgtGetBBoxGlob( Ls or GDB_ID.NULL, GDB_BB.STANDARD)
   if not b3Solid then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' part box not found'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- verifico che ci siano almeno due facce (altrimenti non è da lavorare)
   local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
   if nFacetCnt < 2 then
      return true
   end
   -- dati delle facce
   local ptC = {}
   local vtN = {}
   for i = 1, nFacetCnt do
      ptC[i], vtN[i] = EgtSurfTmFacetCenter( Proc.Id, i-1, GDB_ID.ROOT)
   end
   -- ordino le facce (1=esterna, 2=interna, 3=intermedia)
   local vFaceOrd = { 0, 0, 0}
   for i = 1, nFacetCnt do
      if abs( vtN[i]:getX()) < 0.1 then
         vFaceOrd[3] = i
         break
      end
   end
   if vFaceOrd[3] == 0 then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' missing intermediate face'
      EgtOutLog( sErr)
      return false, sErr
   end
   for i = 1, nFacetCnt do
      if i ~= vFaceOrd[3] then
         local bTouch, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, i-1, vFaceOrd[3] - 1, GDB_ID.ROOT)
         if bTouch and dAng > 0 then
            vFaceOrd[1] = i
         elseif bTouch and dAng < 0 then
            vFaceOrd[2] = i
         end
      end
   end
   -- determino se di testa o di coda
   local bHead = ( vtN[vFaceOrd[2]]:getX() > 0)
   -- determino se da lavorare con testa da sotto
   local bDownHead = ( BD.DOWN_HEAD and vtN[vFaceOrd[3]]:getZ() < -0.1)
   -- recupero la lavorazione
   local sCutting = ML.FindCutting( 'HeadSide', not bDownHead, bDownHead)
   if not sCutting then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' cutting not found in library'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- recupero i dati dell'utensile
   local dSawDiam = 400
   local dMaxDepth = 0
   if EgtMdbSetCurrMachining( sCutting) then
      local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
      if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
         dSawDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dSawDiam
         dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
      end
   end
   local dMaxVertDepth = dMaxDepth - ( BD.DECR_VERT_CUT or 0)
   local dVzLimDwnUp = EgtIf( bDownHead, -2, nil)
   -- taglio sulla faccia esterna
   if vFaceOrd[1] ~= 0 then
      -- recupero gruppo per geometria addizionale
      local nAddGrpId = BL.GetAddGroup( nPartId)
      if not nAddGrpId then
         local sErr = 'Error : missing AddGroup'
         EgtOutLog( sErr)
         return false, sErr
      end
      -- creo piano di taglio sulla faccia esterna e lo lavoro
      local AddId = EgtSurfTmPlaneInBBox( nAddGrpId, ptC[vFaceOrd[1]], vtN[vFaceOrd[1]], b3Solid, GDB_RT.GLOB)
      if AddId then
         EgtSetName( AddId, 'AddCut_' .. tostring( Proc.Id))
         EgtSetInfo( AddId, 'TASKID', Proc.TaskId)
         -- applico taglio di lama
         local b3Cut = EgtGetBBoxGlob( AddId or GDB_ID.NULL, GDB_BB.STANDARD)
         local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = b3Cut, Fct = 1, Flg = Proc.Flg,
                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId, PartId = Proc.PartId}
         CutProc.AffectedFaces = BL.GetProcessAffectedFaces( CutProc)
         if BL.IsCutNeeded( CutProc, b3Raw, dOvmHead) then
            local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead, false)
            if not bOk then return bOk, sErr end
         elseif bUseMill then
            Proc.bForceMill = true
            return LapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
         elseif nForceUseBladeOnNotContinueFace > 0 then
            EgtSurfTmRemoveFacet( Proc.Id, vFaceOrd[1] - 1)
            Proc.Fct = Proc.Fct - 1
            Proc.Face = BL.GetFacetsInfo( Proc, b3Raw)
            return LapJoint.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
         end
      end
   end
   -- recupero gruppo per geometria addizionale
   local nAddGrpId = BL.GetAddGroup( nPartId)
   if not nAddGrpId then
      local sErr = 'Error : missing AddGroup'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- se esistono faccia interna ed intermedia, verifico se richiedono taglio a cubetti
   local vCuts = {}
   if vFaceOrd[2] ~= 0 and vFaceOrd[3] ~= 0 then
      vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[vFaceOrd[3]], vtN[vFaceOrd[3]], false, ptC[vFaceOrd[2]], vtN[vFaceOrd[2]])
   end
   if #vCuts > 0 then
      -- sistemo posizione nel DB e nome
      for i = 1, #vCuts do
         for j = 1, #vCuts[i] do
            EgtSetName( vCuts[i][j], 'AddCut_' .. tostring( Proc.Id))
            EgtSetInfo( vCuts[i][j], 'TASKID', Proc.TaskId)
         end
      end
      -- calcolo riferimenti per facce inclinate
      local vtRef = Vector3d( vtN[vFaceOrd[3]])
      local vtRef2 = Vector3d( vtN[vFaceOrd[2]])
      -- eseguo
      for i = 1, #vCuts do
         local vtOrtho
         if i % 2 == 1 then
            vtOrtho = vtRef
         else
            vtOrtho = vtRef2
         end
         -- lavoro la faccia
         for j = 1, #vCuts[i] do
            local bOk, sErr = Fbs.MakeOne( vCuts[i][j], 0, sCutting, dSawDiam, vtOrtho, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
            if not bOk then
               return bOk, sErr
            end
         end
      end
   else
      -- taglio sulla faccia interna
      if vFaceOrd[2] ~= 0 then
         -- inserisco la lavorazione
         local nOrthoOpposite = BL.GetNearestOrthoOpposite( vtN[vFaceOrd[3]])
         local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[2] - 1, sCutting, dSawDiam, nOrthoOpposite, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
         if not bOk then return bOk, sErr end
      end
      -- taglio sulla faccia intermedia
      if vFaceOrd[3] ~= 0 then
         -- inserisco la lavorazione
         local nOrthoOpposite = BL.GetNearestOrthoOpposite( EgtIf( bHead, X_AX(), -X_AX()))
         local bOk, sErr = Fbs.MakeOne( Proc.Id, vFaceOrd[3] - 1, sCutting, dSawDiam, nOrthoOpposite, dVzLimDwnUp, 0, BD.CUT_SIC, 0, 0, 0, nil, b3Raw)
         if not bOk then return bOk, sErr end
      end
   end
   -- aggiornamento ingombro di testa o coda
   if Proc.Head then
      local dHCI = 0
      if vtN[vFaceOrd[3]]:getZ() > 0.1 then
         local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
         if b3Fac1 then dHCI = b3Raw:getMax():getX() - dOvmHead - b3Fac1:getMin():getX() end
      else
         -- se feature inclinata, si va oltre ingombro del box. Si considera metà dell'ingombro della faccia inclinata 
         if vtN[vFaceOrd[2]] and vtN[vFaceOrd[2]]:getZ() > 0 then
            dHCI = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX() - ( vtN[vFaceOrd[2]]:getZ() * b3Raw:getDimZ())
         else
            dHCI = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX()
         end
      end
      BL.UpdateHCING( nRawId, dHCI)
   elseif Proc.Tail then
      local dTCI = 0
      if vtN[vFaceOrd[3]]:getZ() > 0.1 then
         local b3Fac1 = EgtSurfTmGetFacetBBoxGlob( Proc.Id, vFaceOrd[1] - 1, GDB_BB.STANDARD)
         if b3Fac1 then dTCI = b3Fac1:getMax():getX() - b3Solid:getMin():getX() end
      else
         -- se feature inclinata, si va oltre ingombro del box. Si considera metà dell'ingombro della faccia inclinata 
         if vtN[vFaceOrd[2]] and vtN[vFaceOrd[2]]:getZ() > 0 then
            dTCI = Proc.Box:getMax():getX() - b3Solid:getMin():getX() - ( vtN[vFaceOrd[2]]:getZ() * b3Raw:getDimZ())
         else
            dTCI = Proc.Box:getMax():getX() - b3Solid:getMin():getX()
         end
      end
      BL.UpdateTCING( nRawId, dTCI)
   end
   return true
end   

---------------------------------------------------------------------
return ProcessRidgeLap