-- ProcessStepJointNotch.lua by Egaltech s.r.l. 2019/10/23
-- Gestione calcolo tacca a gradino per Travi

-- Tabella per definizione modulo
local ProcessStepJointNotch = {}

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

EgtOutLog( ' ProcessStepJointNotch started', 1)

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

---------------------------------------------------------------------
-- Riconoscimento della feature
function ProcessStepJointNotch.Identify( Proc)
   return ( ( Proc.Grp == 3 or Proc.Grp == 4)  and  Proc.Prc == 80)
end

---------------------------------------------------------------------
-- Classificazione della feature
function ProcessStepJointNotch.Classify( Proc)
   -- numero delle facce
   local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
   -- gestisco solo 2 o 4 facce
   if nFacetCnt ~= 2 and nFacetCnt ~= 4 then
      return false, false
   end
   -- verifico le normali delle facce
   local bDown = false
   for i = 1, nFacetCnt do
      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i-1, GDB_ID.ROOT)
      -- se faccia limite
      if AreSameOrOppositeVectorApprox( vtN, Y_AX()) or AreSameOrOppositeVectorApprox( vtN, Z_AX()) then
         -- attualmente non gestita
         return false, false
      -- altrimenti faccia principale
      elseif vtN:getZ() < -0.1 then
         bDown = true
      end
   end
   return true, bDown
end

---------------------------------------------------------------------
-- Lavorazione di due facce
local function MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- 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 on process ' .. tostring( Proc.Id) .. ' 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
   local bAdj, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, 0, 1, GDB_ID.ROOT)
   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
   -- recupero la lavorazione
   local sCutting = ML.FindCutting( 'HeadSide')
   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
   -- verifico se necessari tagli supplementari
   local vCuts = DC.GetDice( EgtGetParent( Proc.Id), b3Solid, ptC[nBigInd], vtN[nBigInd], false, ptC[nSmaInd], vtN[nSmaInd])
   --DC.PrintOrderCut( vCuts)
   if #vCuts > 0 then
      -- recupero gruppo per geometria addizionale
      local nAddGrpId = BL.GetAddGroup( nPartId)
      if not nAddGrpId then
         local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' missing AddGroup'
         EgtOutLog( sErr)
         return false, sErr
      end
      -- sistemo posizione nel DB e nome
      for i = 1, #vCuts do
         for j = 1, #vCuts[i] do
            EgtRelocateGlob( vCuts[i][j], nAddGrpId)
            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 k, l = nBigInd, nSmaInd
         if ( i % 2) == 1 then
            k, l = l, k
         end
         local nOrthoOpposite 
         if bOnY then
            local bFront = ( ptC[k]:getY() < ptPs:getY())
            nOrthoOpposite = EgtIf( bFront, MCH_MILL_FU.ORTHO_BACK, MCH_MILL_FU.ORTHO_FRONT)
         else
            local bOver = true
            nOrthoOpposite = EgtIf( bOver, MCH_MILL_FU.ORTHO_DOWN, MCH_MILL_FU.ORTHO_TOP)
         end
         -- 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, 'HeadSide')
      if not bOk then
         return bOk, sErr
      end
   end
   return true
end

---------------------------------------------------------------------
-- Lavorazione di due facce
local function MakeFourFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- Prime due facce
   local bOk, sErr = MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
   if not bOk then return bOk, sErr end
   -- Seconde due facce
   -- recupero gruppo per geometria addizionale
   local nAddGrpId = BL.GetAddGroup( nPartId)
   if not nAddGrpId then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' missing AddGroup'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- copio la superficie e scambio le facce
   local AddId = EgtCopyGlob( Proc.Id, nAddGrpId)
   if AddId then
      EgtSurfTmSwapFacets( AddId, 0, 2)
      EgtSurfTmSwapFacets( AddId, 1, 3)
      EgtSetName( AddId, 'AddCut_' .. tostring( Proc.Id))
      -- applico lavorazione
      local NewProc = { Id = AddId, Grp = Proc.Grp, Prc = Proc.Prc, Box = Proc.Box, Fct = Proc.Fct, Flg = Proc.Flg}
      local bOk, sErr = MakeTwoFaces( NewProc, nPhase, nRawId, nPartId, dOvmHead)
      if not bOk then return bOk, sErr end
   end
   return true
end

---------------------------------------------------------------------
-- lavorazione smussi
local function MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- verifico che lo smusso sia richiesto
   local dDepth = EgtGetInfo( Proc.Id, 'Q01', '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') or 0
   if AuxId then AuxId = AuxId + Proc.Id end
   if not AuxId  or  ( EgtGetType( AuxId) & GDB_FY.GEO_CURVE) == 0 then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' 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
   if abs( vtExtr:getZ()) > 0.1 then
      local sWarn = 'Warning on process ' .. tostring( Proc.Id) .. ' skipped not horizontale 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 on process ' .. tostring( Proc.Id) .. ' skipped chamfer (feature smaller than beam)'
      EgtOutLog( sWarn)
      return true
   end
   local dExtra = 2
   -- recupero la lavorazione
   local sMilling = ML.FindMilling( 'Mark')
   if not sMilling then
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' 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 ProcessStepJointNotch.Make( Proc, nPhase, nRawId, nPartId, dOvmHead)
   -- se due facce
   if Proc.Fct == 2 then
      local bOk, sErr = MakeTwoFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
      if not bOk then return bOk, sErr end
   -- se quattro facce
   elseif Proc.Fct == 4 then
      local bOk, sErr = MakeFourFaces( Proc, nPhase, nRawId, nPartId, dOvmHead)
      if not bOk then return bOk, sErr end
   -- altrimenti errore
   else
      local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' face number not allowed'
      EgtOutLog( sErr)
      return false, sErr
   end
   -- esecuzione eventuale smusso
   return MakeChamfer( Proc, nPhase, nRawId, nPartId, dOvmHead)
end

---------------------------------------------------------------------
return ProcessStepJointNotch