-- ProcessDoubleCut.lua by Egaltech s.r.l. 2021/12/25
-- Gestione calcolo doppi tagli di lama per Travi

-- Tabella per definizione modulo
local ProcessDoubleCut = {}

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

EgtOutLog( ' ProcessDoubleCut started', 1)

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

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

---------------------------------------------------------------------
-- Classificazione della feature
function ProcessDoubleCut.Classify( Proc, b3Raw)
   --se una faccia, uso la classificazione dei tagli singoli
   if Proc.Fct == 1 then return Cut.Classify( Proc, b3Raw) end
   -- verifico se convesso
   local bAdj, _, _, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
   local bConvex = ( not bAdj or ( dAng > 0))
   if bConvex then return true, false end
   -- verifico le normali delle facce per tagli da sotto
   local dNzLimDwnUp = BL.GetNzLimDownUp( b3Raw)
   for i = 1, 2 do
      local ptC, vtN = EgtSurfTmFacetCenter( Proc.Id, i-1, GDB_ID.ROOT)
      local bDownCut = ( vtN:getZ() <= dNzLimDwnUp)
      if bDownCut then
         -- dimensione della faccia perpendicolare alla linea di intersezione tra le facce
         local vtN2 = EgtSurfTmFacetNormVersor( Proc.Id, 2-i, GDB_ID.ROOT)
         local vtX = vtN2 ^ vtN
         local frRef = Frame3d( ptC, ptC + 100 * vtX, ptC + 100 * vtN2)
         local b3Ref = EgtSurfTmGetFacetBBoxRef( Proc.Id, i-1, GDB_BB.STANDARD, frRef)
         if b3Ref:getDimY() > BD.MAX_DIM_DICE then
            return true, true
         end
      end
   end
   return true, false
end

---------------------------------------------------------------------
-- lavorazione smussi
local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- verifico che lo smusso sia richiesto
   local dDepth = EgtGetInfo( Proc.Id, 'Q06', 'd') or 0
   if dDepth < 0.1 then return true end
   -- ingombro del grezzo
   local b3Raw = EgtGetRawPartBBox( nRawId)
   -- recupero e verifico l'entità curva associata
   local AuxId = EgtGetInfo( Proc.Id, 'AUXID', 'i')
   if AuxId then AuxId = AuxId + Proc.Id end
   if not AuxId then return true end
   if ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then
      local sErr = 'Error : missing profile geometry'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- recupero i dati della curva e del profilo
   local dWidth = abs( EgtCurveThickness( AuxId))
   local vtExtr = EgtCurveExtrusion( AuxId, GDB_RT.GLOB)
   -- eseguo lo smusso solo se direzione orizzontale (non propago la segnalazione a TS3)
   if abs( vtExtr:getZ()) > 0.1 then
      local sWarn = 'Warning : skipped not horizontal chamfer'
      EgtOutLog( sWarn)
      return true
   end
   -- eseguo lo smusso solo se feature larga come la trave
   if dWidth < b3Raw:getDimY() - 1 then
      local sWarn = 'Warning : skipped chamfer (feature smaller than beam)'
      EgtOutLog( sWarn)
      return true, sWarn
   end
   local dExtra = 2
   -- recupero la lavorazione
   local sMilling = ML.FindMilling( 'Mark')
   if not sMilling then
      local sErr = 'Error : milling not found in library'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- Inserisco la lavorazione del lato standard
   local sName1 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
   local nMch1Id = EgtAddMachining( sName1, sMilling)
   if not nMch1Id then
      local sErr = 'Error adding machining ' .. sName1 .. '-' .. sMilling
      EgtOutLog( sErr)
      return false, sErr
   end
   -- aggiungo geometria
   EgtSetMachiningGeometry( {{ AuxId, -1}})
   -- assegno affondamento e offset radiale
   EgtSetMachiningParam( MCH_MP.DEPTH, dDepth + dExtra)
   EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
   -- assegno lato di lavoro
   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.RIGHT)
   -- eseguo
   if not EgtApplyMachining( true, false) then
      local _, sErr = EgtGetLastMachMgrError()
      EgtSetOperationMode( nMchId, false)
      return false, sErr
   end
   -- Inserisco la lavorazione del lato opposto
   local sName2 = 'SJN_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id))
   local nMch2Id = EgtAddMachining( sName2, sMilling)
   if not nMch2Id then
      local sErr = 'Error adding machining ' .. sName2 .. '-' .. sMilling
      EgtOutLog( sErr)
      return false, sErr
   end
   -- aggiungo geometria
   EgtSetMachiningGeometry( {{ AuxId, -1}})
   -- inverto direzione utensile
   EgtSetMachiningParam( MCH_MP.TOOLINVERT, true)
   -- assegno affondamento e offset radiale
   EgtSetMachiningParam( MCH_MP.DEPTH, dDepth + dExtra)
   EgtSetMachiningParam( MCH_MP.OFFSR, dExtra)
   -- assegno lato di lavoro
   EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
   -- eseguo
   if not EgtApplyMachining( true, false) then
      local _, sErr = EgtGetLastMachMgrError()
      EgtSetOperationMode( nMchId, false)
      return false, sErr
   end
   return true
end

---------------------------------------------------------------------
-- Applicazione della lavorazione
function ProcessDoubleCut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- se singola faccia, passo a quella lavorazione
   if Proc.Fct == 1 then return Cut.Make( Proc, nPhase, nRawId, nPartId, dOvmHead) end
   -- ingombro del grezzo
   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 : part box not found'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- dati delle facce
   local ptC = {}
   local vtN = {}
   ptC[1], vtN[1] = EgtSurfTmFacetCenter( Proc.Id, 0, GDB_ID.ROOT)
   ptC[2], vtN[2] = EgtSurfTmFacetCenter( Proc.Id, 1, GDB_ID.ROOT)
   -- normale media per capire se taglio di testa o di coda
   local vtNm = ( vtN[1] + vtN[2]) ;   vtNm:normalize()
   local bHead = ( vtNm:getX() > 0)
   -- angolo diedro per stabilire se taglio convesso
   local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
   local bConvex = true
   local bOnY = true
   local ptPs = ( ptC[1] + ptC[2]) / 2
   if bAdj then
      local vtDir = ptP1 - ptP2 ;   vtDir:normalize()
      bOnY = abs( vtDir:getZ()) > 0.5 and ( abs( vtDir:getZ()) + abs( vtDir:getX()) > abs( vtDir:getY()))
      ptPs = ( ptP1 + ptP2) / 2
      bConvex = ( dAng > 0)
   end
   -- determino quale faccia è più grande
   local _, dB1, dH1 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 0)
   local _, dB2, dH2 = EgtSurfTmFacetMinAreaRectangle( Proc.Id, 1)
   local nBigInd = EgtIf( dB1 * dH1 >= dB2 * dH2, 1, 2)
   local nSmaInd = 3 - nBigInd
   -- inserimento smussi
   local bOkc, sErrC = MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
   if not bOkc then return bOkc, sErrC end
   -- recupero la lavorazione
   local sCutting = ML.FindCutting( EgtIf( bHead, 'HeadSide', 'TailSide'))
   if not sCutting then
      local sErr = 'Error : 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
   -- 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 convesso, lo tratto come due tagli singoli
   if bConvex then
      -- lavoro per prima la faccia più diretta in alto
      local vOrd = { 1, 2}
      if vtN[2]:getZ() > vtN[1]:getZ() then
         vOrd = { 2, 1}
      end
      -- creo piano di taglio coincidente con la prima faccia e lo lavoro
      local AddId = EgtSurfTmPlaneInBBox( nAddGrpId, ptC[vOrd[1]], vtN[vOrd[1]], b3Solid, GDB_RT.GLOB)
      if AddId then
         EgtSetName( AddId, 'AddCut_' .. tostring( Proc.Id))
         EgtSetInfo( AddId, 'TASKID', Proc.TaskId)
         local b3Add = EgtGetBBoxGlob( AddId, GDB_BB.STANDARD)
         -- applico lavorazione
         local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = 10, Box = b3Add, Fct = 1, Flg = Proc.Flg,
                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
         if not bOk then return bOk, sErr end
      end
      -- creo piano di taglio coincidente con la seconda faccia e lo lavoro
      AddId = EgtSurfTmPlaneInBBox( nAddGrpId, ptC[vOrd[2]], vtN[vOrd[2]], b3Solid, GDB_RT.GLOB)
      if AddId then
         EgtSetName( AddId, 'AddCut_' .. tostring( Proc.Id))
         EgtSetInfo( AddId, 'TASKID', Proc.TaskId)
         local b3Add = EgtGetBBoxGlob( AddId, GDB_BB.STANDARD)
         -- applico lavorazione
         local CutProc = { Id = AddId, Grp = Proc.Grp, Prc = 10, Box = b3Add, Fct = 1, Flg = Proc.Flg,
                           Head = Proc.Head, Tail = Proc.Tail, CutId = Proc.CutId, TaskId = Proc.TaskId}
         local bOk, sErr = Cut.Make( CutProc, nPhase, nRawId, nPartId, dOvmHead)
         if not bOk then return bOk, sErr end
      end
   -- altrimenti concavo
   else
      -- verifico se necessari tagli supplementari
      local vCuts = DC.GetDice( nAddGrpId, b3Solid, ptC[nBigInd], vtN[nBigInd], false, ptC[nSmaInd], vtN[nSmaInd])
      --DC.PrintOrderCut( vCuts)
      if #vCuts > 0 then
         -- aggiorno nome e info
         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
         -- eseguo
         for i = 1, #vCuts do
            -- determino il modo di tagliare
            local vtOrthOpp = vtN[nBigInd]
            local vtNorm = vtN[nSmaInd]
            if ( i % 2) ~= 1 then vtOrthOpp, vtNorm = vtNorm, vtOrthOpp end
            if not bOnY then vtOrthOpp[2] = 0 end
            local nOrthoOpposite = BL.GetNearestOrthoOpposite( vtOrthOpp, vtNorm)
            -- lavoro la faccia
            for j = 1, #vCuts[i] do
               local bOk, sErr = BL.MakeOneFaceBySaw( vCuts[i][j], 0, sCutting, dSawDiam, nOrthoOpposite, nil, 0, BD.CUT_SIC, 0, 0, nil, b3Raw)
               if not bOk then
                  return bOk, sErr
               end
            end
         end
      -- altrimenti, tagli diretti delle facce
      else
         local bOk, sErr = Fbs.MakeTwo( Proc, nPhase, nRawId, nPartId, dOvmHead, EgtIf( bHead, 'HeadSide', 'TailSide'))
         if not bOk then
            return bOk, sErr
         end
      end
   end
   -- eventuale segnalazione ingombro di testa o coda (se non convesso, altrimenti già fatto nei tagli singoli)
   if not bConvex then
      if Proc.Head then
         local dOffs = b3Raw:getMax():getX() - dOvmHead - Proc.Box:getMin():getX()
         if vtNm:getZ() > 0.5 then
            dOffs = 0.4 * dOffs
         elseif abs( vtNm:getZ()) > 0.35 then
            dOffs = 0.75 * dOffs
         end
         BL.UpdateHCING( nRawId, dOffs)
      elseif Proc.Tail then
         local dOffs = Proc.Box:getMax():getX() - b3Solid:getMin():getX()
         if vtNm:getZ() > 0.5 then
            dOffs = 0.4 * dOffs
         elseif abs( vtNm:getZ()) > 0.35 then
            dOffs = 0.75 * dOffs
         end
         BL.UpdateTCING( nRawId, dOffs)
      end
   end
   return true
end

---------------------------------------------------------------------
return ProcessDoubleCut