-- ProcessLongDoubleCut.lua by Egaltech s.r.l. 2020/01/28
-- Gestione calcolo doppio taglio longitudinale per Travi

-- Tabella per definizione modulo
local ProcessLong2Cut = {}

-- Include
require( 'EgtBase')
local BL = require( 'BeamLib')

EgtOutLog( ' ProcessLongDoubleCut started', 1)

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

---------------------------------------------------------------------
-- Riconoscimento della feature
function ProcessLong2Cut.Identify( Proc)
   return ( Proc.Grp == 0  and  Proc.Prc == 12)
end

---------------------------------------------------------------------
-- Classificazione della feature
function ProcessLong2Cut.Classify( Proc)
   return true, false
end

---------------------------------------------------------------------
-- Classificazione della feature, calcolo il numero di facce longitudinali e limite.
-- Ritorna due valori :
--  il primo indica il numero di facce longitudinali
--  il secondo indica quante e quali facce limite sono presenti con questa codifica
--    0: nessuna faccia limite; 1: faccia limite a destra (X+); 2: faccia limite a sinistra (X-); 3: due facce limite.
function ProcessLong2Cut.IdentifyFaces( Proc)
   -- verifico le normali delle facce
   local nFaceLong = 0
   local nFaceLimit = 0
   local nFacetCnt = EgtSurfTmFacetCount( Proc.Id)
   for i = 1, nFacetCnt do
      local vtN = EgtSurfTmFacetNormVersor( Proc.Id, i-1, GDB_ID.ROOT)
      -- se è una faccia limite a sinistra
      if vtN:getX() > GEO.EPS_SMALL then
         nFaceLimit = nFaceLimit + 2
      -- se è una faccia limite a destra
      elseif vtN:getX() < -GEO.EPS_SMALL then
         nFaceLimit = nFaceLimit + 1
      -- altrimenti è una faccia longitudinale
      else
         nFaceLong = nFaceLong + 1
      end
   end
   return nFaceLong, nFaceLimit
end

---------------------------------------------------------------------
-- Applicazione della lavorazione
function ProcessLong2Cut.Make( Proc, nPhase, nRawId, nPartId)
   -- dati delle facce
   local nFc = {0,1}
   local ptC = {}
   local vtN = {}
   -- ciclo sulle facce per identificare le facce longitudinali
   local nLongFct = 0
   for j = 1, Proc.Fct do
      local ptCen, vtNrm = EgtSurfTmFacetCenter( Proc.Id, (j-1), GDB_ID.ROOT)
      if abs( vtNrm:getX()) < GEO.EPS_SMALL then
         nLongFct = nLongFct + 1
         ptC[nLongFct] = Point3d( ptCen)
         vtN[nLongFct] = Vector3d( vtNrm)
      end
   end
   local dLen = EgtGetBBoxGlob( Proc.Id, GDB_BB.STANDARD):getDimX()
   -- verifico posizione (+1=sopra, -1=sotto, 0=sui lati)
   local nSide = 0
   if vtN[1]:getZ() > -10 * GEO.EPS_SMALL and vtN[2]:getZ() > -10 * GEO.EPS_SMALL then
      nSide = 1
   elseif vtN[1]:getZ() < -10 * GEO.EPS_SMALL and vtN[2]:getZ() < -10 * GEO.EPS_SMALL then
      nSide = -1
   end
   -- angolo diedro per stabilire se taglio convesso
   local bInt, ptP1, ptP2, dAng = EgtSurfTmFacetsContact( Proc.Id, nFc[1], nFc[2], GDB_ID.ROOT)
   local bConvex
   local bOrtho
   local ptM
   if bInt then
      bConvex = ( dAng >= 0)
      bOrtho = ( abs( dAng + 90) < 1)
      ptM = ( ptP1 + ptP2) / 2
   else
      bConvex = true
      bOrtho = false
      ptM = ( ptC[1] + ptC[2]) / 2
   end
   local ptRef = ( ptC[1] + ptC[2]) / 2
   -- analisi del taglio
   local vOrd = {}
   local vFaceUse = {}
   if nSide == 1 then
      vOrd = EgtIf( ptC[1]:getY() < ptRef:getY(), { 1, 2}, { 2, 1})
      vFaceUse = { BL.GetNearestOrthoOpposite( ptC[1] - ptM), BL.GetNearestOrthoOpposite( ptC[2] - ptM)}
   elseif nSide == -1 then
      vOrd = EgtIf( ptC[1]:getY() < ptM:getY(), { 1, 2}, { 2, 1})
      vFaceUse = { BL.GetNearestParalOpposite( ptC[1] - ptM), BL.GetNearestParalOpposite( ptC[2] - ptM)}
   else
      local bFront = ( vtN[1]:getY() < 0)
      if bFront then
         vOrd = EgtIf( ptC[1]:getZ() < ptM:getZ(), { 1, 2}, { 2, 1})
         vFaceUse = { BL.GetNearestOrthoOpposite( ptC[1] - ptM), BL.GetNearestOrthoOpposite( ptC[2] - ptM)}
      else
         vOrd = EgtIf( ptC[1]:getZ() < ptM:getZ(), { 2, 1}, { 1, 2})
         vFaceUse = { BL.GetNearestOrthoOpposite( ptC[1] - ptM), BL.GetNearestOrthoOpposite( ptC[2] - ptM)}
      end
   end
   local vWidth = {}
   _, _, vWidth[1] = BL.GetFaceHvRefDim( Proc.Id, nFc[1])
   _, _, vWidth[2] = BL.GetFaceHvRefDim( Proc.Id, nFc[2])

   local sWarn
   -- Se ho 2 face longitudinali e non limitato da altre facce e da sopra e richiesto con doppio taglio di lama
   if nLongFct == 2 and Proc.Fct == 2 and nSide == 1 and EgtGetInfo( Proc.Id, 'Q01', 'i') == 1 then
      -- recupero la lavorazione
      local sCutting = ML.FindCutting( 'HeadSide')
      if not sCutting then
         local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' sawing not found in library'
         EgtOutLog( sErr)
         return false, sErr
      end
      -- recupero i dati dell'utensile
      local dToolDiam = 0
      local dMaxDepth = 0
      local dToolThick = 0
      if EgtMdbSetCurrMachining( sCutting) then
         local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
            dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
            dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
            dToolThick = EgtTdbGetCurrToolParam(MCH_TP.THICK) or dToolThick
         end
      end

      -- determino numero di parti
      local dStartAccDist = BD.LONGCUT_ENDLEN
      local dEndAccDist = BD.LONGCUT_ENDLEN
      local nC = ceil( ( dLen - dStartAccDist - dEndAccDist) / BD.LONGCUT_MAXLEN)
      local dC = 0
      if nC > 0 then
         dC = dLen / ( nC + 2)
         dStartAccDist = dC
         dEndAccDist = dC
         nC = nC + 2
      else
         if dLen > min( dStartAccDist, dEndAccDist) then
            nC = 2
            dStartAccDist = dLen/2
            dEndAccDist = dStartAccDist
         else
            nC = 1
            dStartAccDist = 0
            dEndAccDist = 0
         end
      end

      local nM = 0
      -- se convesso lavoro ogni faccia in due metà lasciando attaccata la parte centrale
      if bConvex then
         -- si percorrono i lati alto e basso della faccia
         for i = 1, nC do
            -- Posizione braccio portatesta
            local nSCC = EgtIf( ( i == 1 or i == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
            -- ciclo sulle due facce
            for j = 1, #vOrd do
               -- determino se lavorazione da davanti o da dietro
               local bFront = ( vtN[vOrd[j]]:getY() < 0)
               -- determino l'utilizzo della faccia
               local nFaceUse  = EgtIf( abs( vtN[vOrd[j]]:getY()) > 0.01, MCH_MILL_FU.ORTHO_TOP, EgtIf( bFront, MCH_MILL_FU.ORTHO_BACK, MCH_MILL_FU.ORTHO_FRONT))
               local nFaceUse2 = EgtIf( abs( vtN[vOrd[j]]:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK))
               -- ciclo sulle passate
               local dOffset = ( vWidth[vOrd[j]] + BD.DIM_STRIP_SMALL) / 2 ;
               local dLioTang = 0
               local dLioPerp = ( vWidth[vOrd[j]] - BD.DIM_STRIP_SMALL) / 2 + BD.CUT_SIC ;
               for k = 1, 2 do
                  -- inserisco le parti di lavorazione
                  nM = nM + 1
                  local sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM) .. '_' .. tostring(j)
                  local nMchFId = EgtAddMachining( sNameF, sCutting)
                  if not nMchFId then
                     local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCutting
                     EgtOutLog( sErr)
                     return false, sErr
                  end
                  -- aggiungo geometria
                  EgtSetMachiningGeometry( {{ Proc.Id, vOrd[j]-1}})
                  -- limito opportunamente la lavorazione
                  local dSal = EgtIf( i == nC, 0, - dEndAccDist - ( nC - i - 1) * dC)
                  local dEal = EgtIf( i == 1, 0, - dStartAccDist - ( i - 2) * dC)
                  if ( not bFront and k == 1) or ( bFront and k == 2) then
                     dSal, dEal = dEal, dSal
                  end
                  EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
                  EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
                  -- imposto offset radiale
                  EgtSetMachiningParam( MCH_MP.OFFSR, dOffset)
                  -- imposto attacco/uscita
                  EgtSetMachiningParam( MCH_MP.LITANG, dLioTang)
                  EgtSetMachiningParam( MCH_MP.LIPERP, dLioPerp)
                  EgtSetMachiningParam( MCH_MP.LOTANG, dLioTang)
                  EgtSetMachiningParam( MCH_MP.LOPERP, dLioPerp)
                  -- imposto posizione braccio porta testa per non ingombrare agli estremi
                  EgtSetMachiningParam( MCH_MP.SCC, nSCC)
                  -- imposto uso della faccia
                  EgtSetMachiningParam( MCH_MP.FACEUSE, EgtIf( k == 1, nFaceUse, nFaceUse2))
                  -- eseguo
                  if not EgtApplyMachining( true, false) then
                     local _, sErr = EgtGetLastMachMgrError()
                     EgtSetOperationMode( nMchFId, false)
                     return false, sErr
                  end
               end
            end
         end
      -- altrimenti concavo
      else
         -- si percorrono i lati alto e basso della faccia
         for i = 1, nC do
            -- Posizione braccio portatesta
            local nSCC = EgtIf( ( i == 1 or i == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
            -- ciclo sulle due facce
            for j = 1, #vOrd do
               -- determino se lavorazione da davanti o da dietro
               local bFront = ( vtN[vOrd[j]]:getY() < 0)
               -- determino l'utilizzo della faccia
               local nFaceUse  = EgtIf( abs( vtN[vOrd[j]]:getY()) > 0.01, MCH_MILL_FU.ORTHO_TOP, EgtIf( bFront, MCH_MILL_FU.ORTHO_BACK, MCH_MILL_FU.ORTHO_FRONT))
               local nFaceUse2 = EgtIf( abs( vtN[vOrd[j]]:getY()) > 0.01, MCH_MILL_FU.ORTHO_DOWN, EgtIf( bFront, MCH_MILL_FU.ORTHO_FRONT, MCH_MILL_FU.ORTHO_BACK))
               -- ciclo sulle passate
               local dOffset
               local dLioPerp
               if j == 1 then -- il primo taglio lo faccio completo
                  dOffset = 0
                  dLioPerp = vWidth[vOrd[j]] + BD.CUT_SIC
               else -- il secondo ridotto della distanza minima e della componente spessore della lama
                  dOffset = BD.DIM_STRIP_SMALL + ((dToolThick* vtN[vOrd[1]]) - (dToolThick* vtN[vOrd[1]]) * vtN[vOrd[2]] * vtN[vOrd[2]]):len()
                  dLioPerp = vWidth[vOrd[j]] - dOffset + BD.CUT_SIC
               end
               local dLioTang = 0
               
               local sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring(j)
               local nMchFId = EgtAddMachining( sNameF, sCutting)
               if not nMchFId then
                  local sErr = 'Error adding machining ' .. sNameF .. '-' .. sCutting
                  EgtOutLog( sErr)
                  return false, sErr
               end
               -- aggiungo geometria
               EgtSetMachiningGeometry( {{ Proc.Id, vOrd[j]-1}})
               -- limito opportunamente la lavorazione
               local dSal = EgtIf( i == nC, 0, - dEndAccDist - ( nC - i - 1) * dC)
               local dEal = EgtIf( i == 1, 0, - dStartAccDist - ( i - 2) * dC)
               if ( bFront) then
                  dSal, dEal = dEal, dSal
               end
               EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
               EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
               -- imposto offset radiale
               EgtSetMachiningParam( MCH_MP.OFFSR, dOffset)
               -- imposto attacco/uscita
               EgtSetMachiningParam( MCH_MP.LITANG, dLioTang)
               EgtSetMachiningParam( MCH_MP.LIPERP, dLioPerp)
               EgtSetMachiningParam( MCH_MP.LOTANG, dLioTang)
               EgtSetMachiningParam( MCH_MP.LOPERP, dLioPerp)
               -- imposto posizione braccio porta testa per non ingombrare agli estremi
               EgtSetMachiningParam( MCH_MP.SCC, nSCC)
               -- imposto uso della faccia
               EgtSetMachiningParam( MCH_MP.FACEUSE, nFaceUse2)
               -- eseguo
               if not EgtApplyMachining( true, false) then
                  local _, sErr = EgtGetLastMachMgrError()
                  EgtSetOperationMode( nMchFId, false)
                  return false, sErr
               end
            end
         end
      end

   -- Se non è sotto : lavorazione Long2Cut
   elseif nSide ~= - 1 then
      -- recupero la lavorazione
      local sMilling = ML.FindMilling( 'Long2Cut')
      if not sMilling then
         local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library'
         EgtOutLog( sErr)
         return false, sErr
      end
      -- recupero i dati dell'utensile
      local dToolDiam = 0
      local dMaxDepth = 0
      if EgtMdbSetCurrMachining( sMilling) then
         local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
            dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
            dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
         end
      end
      -- determino il numero di parti in cui dividere la lavorazione
      local dEndLen = BD.LONGCUT_ENDLEN
      if dLen < 2 * dEndLen + BD.LONGCUT_MAXLEN then
         dEndLen = dLen / 3
      end
      local nC = ceil( ( dLen - 2 * dEndLen) / BD.LONGCUT_MAXLEN)
      local dC = 0
      if nC > 0 then dC = ( dLen - 2 * dEndLen) / nC end
      nC = nC + 2
      -- ciclo sulle parti
      local nM = 0
      for j = 1, nC do
         -- se facce ortogonali (concave), lavoro solo quella con versore maggiormente verso l'alto
         local nIni, nFin = 1, 2
         if bOrtho then
            if vtN[vOrd[1]]:getZ() >= vtN[vOrd[2]]:getZ() then
               nFin = 1
            else
               nIni = 2
            end
         end
         -- su entrambe le facce
         for i = nIni, nFin do
            -- Limitazioni della lavorazione
            local nPos = EgtIf( i == 1, j, nC - j + 1)
            local dSal = EgtIf( nPos == 1, 0, - dEndLen - ( nPos - 2) * dC)
            local dEal = EgtIf( nPos == nC, 0, - dEndLen - ( nC - nPos - 1) * dC)
            -- Posizione braccio portatesta
            local nSCC = EgtIf( ( j == 1 or j == nC - 1), MCH_SCC.ADIR_XP, MCH_SCC.ADIR_XM)
            -- ciclo sulle passate
            local nO = 1
            local dStep = 0
            local dAgg = EgtIf( bConvex, 2 * BD.CUT_EXTRA, BD.CUT_EXTRA)
            if vWidth[vOrd[i]] > 0.8 * dToolDiam then 
               nO = ceil( vWidth[vOrd[i]] / ( 0.6 * dToolDiam))
               if nO > 1 then
                  dStep = vWidth[vOrd[i]] / nO
               end
            end
            for k = 1, nO do
               -- inserisco le parti di lavorazione
               nM = nM + 1
               local sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM)
               local nMchFId = EgtAddMachining( sNameF, sMilling)
               if not nMchFId then
                  local sErr = 'Error adding machining ' .. sNameF .. '-' .. sMilling
                  EgtOutLog( sErr)
                  return false, sErr
               end
               -- aggiungo geometria
               EgtSetMachiningGeometry( {{ Proc.Id, nFc[vOrd[i]]}})
               -- limito opportunamente la lavorazione
               EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
               EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
               -- imposto posizione braccio porta testa per non ingombrare agli estremi
               EgtSetMachiningParam( MCH_MP.SCC, nSCC)
               -- imposto uso faccia
               EgtSetMachiningParam( MCH_MP.FACEUSE, vFaceUse[vOrd[i]])
               -- imposto lato di lavoro e inversione
               EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
               EgtSetMachiningParam( MCH_MP.INVERT, false)
               -- imposto offset radiale (nullo se concavo)
               if k < nO then
                  EgtSetMachiningParam( MCH_MP.OFFSR, ( nO - k) * dStep)
               else
                  EgtSetMachiningParam( MCH_MP.OFFSR, EgtIf( bConvex, - BD.CUT_EXTRA, 0))
               end
               -- eseguo
               if not EgtApplyMachining( true, false) then
                  local _, sErr = EgtGetLastMachMgrError()
                  EgtSetOperationMode( nMchFId, false)
                  return false, sErr
               end
            end
         end
      end

   -- altrimenti è sotto : lavorazione Long2CutDown
   else
      -- recupero la lavorazione
      local sMilling = ML.FindMilling( 'Long2CutDown')
      if not sMilling then
         local sErr = 'Error on process ' .. tostring( Proc.Id) .. ' milling not found in library'
         EgtOutLog( sErr)
         return false, sErr
      end
      -- recupero i dati dell'utensile
      local dToolDiam = 0
      local dMaxDepth = 0
      if EgtMdbSetCurrMachining( sMilling) then
         local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
         if EgtTdbSetCurrTool( EgtTdbGetToolFromUUID( sTuuid) or '') then
            dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM) or dToolDiam
            dMaxDepth = EgtTdbGetCurrToolMaxDepth() or dMaxDepth
         end
      end
      -- aggiuntivo sull'affondamento
      local dAgg = EgtIf( bConvex, BD.CUT_EXTRA, 0)
      -- determino il numero di parti in cui dividere la lavorazione
      local dEndLen = BD.LONGCUT_ENDLEN
      if dLen < 2 * dEndLen + BD.LONGCUT_MAXLEN then
         dEndLen = dLen / 3
      end
      local nC = ceil( ( dLen - 2 * dEndLen) / BD.LONGCUT_MAXLEN)
      local dC = 0
      if nC > 0 then dC = ( dLen - 2 * dEndLen) / nC end
      nC = nC + 2
      -- ciclo sulle parti
      local nM = 0
      for j = 1, nC do
         -- su entrambe le facce
         for i = 1, 2 do
            -- Limitazioni della lavorazione
            local nPos = EgtIf( i == 1, j, nC - j + 1)
            local dSal = EgtIf( nPos == 1, 0, - dEndLen - ( nPos - 2) * dC)
            local dEal = EgtIf( nPos == nC, 0, - dEndLen - ( nC - nPos - 1) * dC)
            -- Posizione braccio portatesta
            local nSCC = MCH_SCC.ADIR_XP
            -- inserisco le parti di lavorazione
            nM = nM + 1
            local sNameF = 'L2C_' .. ( EgtGetName( Proc.Id) or tostring( Proc.Id)) .. '_' .. tostring( nM)
            local nMchFId = EgtAddMachining( sNameF, sMilling)
            if not nMchFId then
               local sErr = 'Error adding machining ' .. sNameF .. '-' .. sMilling
               EgtOutLog( sErr)
               return false, sErr
            end
            -- aggiungo geometria
            EgtSetMachiningGeometry( {{ Proc.Id, nFc[vOrd[i]]}})
            -- limito opportunamente la lavorazione
            EgtSetMachiningParam( MCH_MP.STARTADDLEN, dSal)
            EgtSetMachiningParam( MCH_MP.ENDADDLEN, dEal)
            -- imposto posizione braccio porta testa per non ingombrare agli estremi
            EgtSetMachiningParam( MCH_MP.SCC, nSCC)
            -- imposto uso faccia
            EgtSetMachiningParam( MCH_MP.FACEUSE, vFaceUse[vOrd[i]])
            -- imposto lato di lavoro e inversione
            EgtSetMachiningParam( MCH_MP.WORKSIDE, MCH_MILL_WS.LEFT)
            EgtSetMachiningParam( MCH_MP.INVERT, true)
            if vWidth[vOrd[i]] + dAgg > dMaxDepth - BD.COLL_SIC then
               sWarn = 'Warning in LongDoubleCut : depth (' .. EgtNumToString( vWidth[vOrd[i]] + dAgg, 1) .. ') bigger than max tool depth (' .. EgtNumToString( dMaxDepth - BD.COLL_SIC, 1) .. ')'
            end
            local dDepth = min( dMaxDepth - BD.COLL_SIC, vWidth[vOrd[i]] + dAgg)
            EgtSetMachiningParam( MCH_MP.DEPTH, dDepth)
            -- eseguo
            if not EgtApplyMachining( true, false) then
               local _, sErr = EgtGetLastMachMgrError()
               EgtSetOperationMode( nMchFId, false)
               return false, sErr
            end
         end
      end
   end

   return true, sWarn
end   

---------------------------------------------------------------------
return ProcessLong2Cut