-- MachiningLib.lua by Egaltech s.r.l. 2022/05/07
-- Libreria ricerca lavorazioni per Travi
-- 2022/05/07 ES Profonde modifiche per scelta ottimale lavorazioni in macchine con più teste.
-- 2022/07/27 Aggiunta la gestione del tipo di foratura "AngleDrill" per fori molto inclinati

-- Tabella per definizione modulo
local MachiningLib = {}

-- Include
require( 'EgtBase')

EgtOutLog( ' MachiningLib started', 1)

-- Dati
local BD = require( 'BeamData')
local Cuttings = require( 'CutData')
local Millings = require( 'MillingData')
local Pocketings = require( 'PocketingData')
local Sawings = require( 'SawingData')
local Drillings = require( 'DrillData')

-- tipo di teste macchina
local ONE_HEAD = 1                      -- una testa (Fast, One, Turn1T)
local TWO_EQUAL_HEADS = 2               -- due teste uguali (PF, Turn)
local TWO_UP_DOWN_HEADS = 3             -- due teste una sopra l'altra sotto (PF1250)
local MachineHeadType = 0

-- testa correntementa attiva, e utensili correnti per ogni testa
local nActiveHead = 0
local H1_TOOL = ''
local H2_TOOL = ''

-- testa e utensile della lavorazione restituita ma non ancora confermata
local nNextMachHead = 0
local H1_NEXT_TOOL = ''
local H2_NEXT_TOOL = ''

-- teste con utensili fissi
local vFixedHeads = {}

---------------------------------------------------------------------
-- funzione che imposta il tipo di macchina corrente
local function SetCurrMachineHeadType()
   -- se già inizializzato, esco
   if MachineHeadType and MachineHeadType >= 1 and MachineHeadType <= 3 then return end
   -- altrimenti, lo imposto
   if BD.DOWN_HEAD then
      MachineHeadType = TWO_UP_DOWN_HEADS
   elseif BD.TWO_EQUAL_HEADS then
      MachineHeadType = TWO_EQUAL_HEADS
   else
      MachineHeadType = ONE_HEAD
   end
   -- imposto eventuali teste con utensili fissi
   if BD.C_SIMM then
      vFixedHeads = { [31] = true}
   elseif BD.TURN then
      vFixedHeads = { [12] = true, [22] = true}
   else   -- FAST
      vFixedHeads = { [2] = true}
   end
end

---------------------------------------------------------------------
-- funzione che conferma e rende attivi testa e utensile ipotizzati
local function ConfirmNextMachining()
   -- se non definita testa successiva, esco
   if not nNextMachHead or nNextMachHead < 1 or nNextMachHead > 2 then return end
   -- altrimenti, la confermo come attiva
   nActiveHead = nNextMachHead
   if nNextMachHead == 1 then
      H1_TOOL = H1_NEXT_TOOL
   elseif nNextMachHead == 2 then
      H2_TOOL = H2_NEXT_TOOL
   end
   -- reset prossima testa
   nNextMachHead = 0
   H1_NEXT_TOOL = ''
   H2_NEXT_TOOL = ''
end

---------------------------------------------------------------------
-- funzione che traccia testa e utensile ipotizzati
local function SetNextMachining( sToolName, nHead, bFixed)
   if nHead < 1 or nHead > 2 then return end
   if bFixed then
      nNextMachHead = 0
      H1_NEXT_TOOL = ''
      H2_NEXT_TOOL = ''
   end
   nNextMachHead = nHead
   if nHead == 1 then
      H1_NEXT_TOOL = sToolName
   elseif nHead == 2 then
      H2_NEXT_TOOL = sToolName
   end
end
   
---------------------------------------------------------------------
local function SetCurrMachiningAndTool( sMachName)
   if not EgtMdbSetCurrMachining( sMachName) then return false end
   local sTuuid = EgtMdbGetCurrMachiningParam( MCH_MP.TUUID)
   local sTool = EgtTdbGetToolFromUUID( sTuuid)
   if not sTool then return false end
   if not EgtTdbSetCurrTool( sTool) then return false end
   local bActive = EgtTdbGetCurrToolParam( MCH_TP.ACTIVE)
   local sHead = EgtTdbGetCurrToolParam( MCH_TP.HEAD)
   local nHead = tonumber( sHead:sub( 2, #sHead))
   local bH2 = ( nHead >= 21 and nHead <= 29)
   local bFixed = ( vFixedHeads[nHead])
   return bActive, sTool, bH2, bFixed
end

---------------------------------------------------------------------
function VerifyDrill( dDiam, dDepth, bH2)
   local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
   local dTMaxMat = EgtTdbGetCurrToolParam( MCH_TP.MAXMAT)
   local dMaxToolLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
   local dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
   local dDiamTh = EgtTdbGetCurrToolThDiam()
   local dLenTh = 72
   if EgtTdbGetCurrToolThLength then dLenTh = EgtTdbGetCurrToolThLength() end
   local dFreeLen = EgtTdbGetCurrToolParam( MCH_TP.LEN) - dLenTh - EgtMdbGetGeneralParam( MCH_GP.MAXDEPTHSAFE)
   if dTDiam < dDiam + 10 * GEO.EPS_SMALL and
      dTDiam > dDiam - BD.DRILL_TOL - 10 * GEO.EPS_SMALL and
      ( not dDepth or dTMaxMat > dDepth - GEO.EPS_SMALL) then
      return true, { TMaxMat = dTMaxMat, MaxToolLength = dMaxToolLength, ToolDiam = dToolDiam, DiamTh = dDiamTh, FreeLen = dFreeLen, H2 = bH2}
   end
end

---------------------------------------------------------------------
function VerifyDrillPocket( dDiam, dDepth, bH2)
   local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
   local dTMaxDepth = EgtTdbGetCurrToolMaxDepth()
   local dMaxToolLength = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
   local dToolDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
   local dDiamTh = EgtTdbGetCurrToolThDiam()
   local dFreeLen = dTMaxDepth
   if dTDiam < dDiam - 10 * GEO.EPS_SMALL and
      ( not dDepth or dTMaxDepth > dDepth - GEO.EPS_SMALL) then
      return true, { TMaxDepth = dTMaxDepth, MaxToolLength = dMaxToolLength, ToolDiam = dToolDiam, DiamTh = dDiamTh, FreeLen = dFreeLen, H2 = bH2}
   end
end

---------------------------------------------------------------------
function VerifyMill( dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bH2)
   local sTuuid = EgtGetMachiningParam( MCH_MP.TUUID)
   local dTMaxDepth = EgtTdbGetCurrToolMaxDepth()
   local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
   local dTTotLen = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
   if ( not dDepth or dTMaxDepth > dDepth - GEO.EPS_SMALL) and
      ( not sTuuidMstr or sTuuidMstr == sTuuid) and
      ( not dMaxDiam or dTDiam < dMaxDiam + GEO.EPS_SMALL) and
      ( not dMaxTotLen or dTTotLen < dMaxTotLen + GEO.EPS_SMALL) then
      return true, { TMaxDepth = dTMaxDepth, TDiam = dTDiam, H2 = bH2}
   end
end

---------------------------------------------------------------------
function VerifyPocket( dMaxDiam, dDepth, dMaxTotLen, bH2)
   local dTDiam = EgtTdbGetCurrToolParam( MCH_TP.DIAM)
   local dTMaxDepth = EgtTdbGetCurrToolMaxDepth()
   local dTTotLen = EgtTdbGetCurrToolParam( MCH_TP.TOTLEN)
   if ( not dMaxDiam or dTDiam < dMaxDiam + GEO.EPS_SMALL) and
      ( not dDepth or dTMaxDepth > dDepth - GEO.EPS_SMALL) and
      ( not dMaxTotLen or dTTotLen < dMaxTotLen + GEO.EPS_SMALL) then
      return true, { TDiam = dTDiam, TMaxDepth = dTMaxDepth, H2 = bH2}
   end
end

---------------------------------------------------------------------
function VerifyTool( MachiningType, sType, Params, bH2)
   if MachiningType == MCH_MY.DRILLING then
      if EgtStartsWith( sType, 'Drill') or EgtStartsWith( sType, 'AngleDrill') then
         return VerifyDrill( Params.Diam, Params.Depth, bH2)
      elseif EgtStartsWith( sType, 'Pocket') then
         return VerifyDrillPocket( Params.Diam, Params.Depth, bH2)
      end
   elseif MachiningType == MCH_MY.SAWING then
      return true, { H2 = bH2}
   elseif MachiningType == MCH_MY.MILLING then
      return VerifyMill( Params.Depth, Params.TuuidMstr, Params.MaxDiam, Params.MaxTotLen, bH2)
   elseif MachiningType == MCH_MY.POCKETING then
      return VerifyPocket( Params.MaxDiam, Params.Depth, Params.MaxTotLen, bH2)
   elseif MachiningType == MCH_MY.MORTISING then
      return true, { H2 = bH2}
   else
      return false
   end
end

---------------------------------------------------------------------
function GetMachinings( MachiningType)
   if MachiningType == MCH_MY.DRILLING then
      return Drillings
   elseif MachiningType == MCH_MY.SAWING then
      return Cuttings
   elseif MachiningType == MCH_MY.MILLING then
      return Millings
   elseif MachiningType == MCH_MY.POCKETING then
      return Pocketings
   elseif MachiningType == MCH_MY.MORTISING then
       return Sawings
   end
end

---------------------------------------------------------------------
function ReturnParams( MachiningType, MachiningName, sType, ToolParams)
   if MachiningType == MCH_MY.DRILLING then
      local _, sOrigType = EgtEndsWith( sType, '_H2')
      return MachiningName, sType, EgtIf( sOrigType == 'Drill' or sOrigType == 'AngleDrill' , ToolParams.TMaxMat, ToolParams.TMaxDepth), ToolParams.MaxToolLength, ToolParams.ToolDiam, ToolParams.DiamTh, ToolParams.FreeLen
   elseif MachiningType == MCH_MY.SAWING then
      return MachiningName, ToolParams.H2
   elseif MachiningType == MCH_MY.MILLING then
      return MachiningName, ToolParams.TMaxDepth, ToolParams.TDiam, ToolParams.H2
   elseif MachiningType == MCH_MY.POCKETING then
      return MachiningName, ToolParams.TDiam, ToolParams.TMaxDepth, ToolParams.H2
   elseif MachiningType == MCH_MY.MORTISING then
      return MachiningName
   end
end

---------------------------------------------------------------------
local function FindMachining( MachiningType, sType, Params, bTopHead, bDownHead)
   if bTopHead == nil and bDownHead == nil then
      bTopHead = true
      bDownHead = false
   elseif bTopHead == nil then
      bTopHead = not bDownHead
   elseif bDownHead == nil then
      bDownHead = not bTopHead
   end
   SetCurrMachineHeadType()
   -- verifico se testa attiva va bene
   local sH1Mach = ''
   local sH1Tool = ''
   local sH1Param
   local sH2Mach = ''
   local sH2Tool = ''
   local sH2Param
   -- ricerca sulle forature, dal diametro maggiore al minore
   local Machinings = GetMachinings( MachiningType)
   local ForStart = 1
   local ForEnd = #Machinings
   local ForStep = 1
   if MachiningType == MCH_MY.DRILLING then
      ForStart = #Machinings
      ForEnd = 1
      ForStep = -1
   end
   if ( BEAM and BEAM.BW) or MachineHeadType == ONE_HEAD or MachineHeadType == TWO_EQUAL_HEADS or ( MachineHeadType == TWO_UP_DOWN_HEADS and not bDownHead) then
      _, sType = EgtEndsWith( sType, '_H2')
   elseif ( not BEAM or not BEAM.BW) and MachineHeadType == TWO_UP_DOWN_HEADS and bDownHead then
      if not EgtEndsWith( sType, '_H2') then
         sType = sType .. '_H2'
      end
   end
   local MachineHeadUse = MachineHeadType
   if not BEAM or not BEAM.BW then
      MachineHeadUse = ONE_HEAD
   end
   if BEAM and BEAM.BW and MachineHeadUse == TWO_UP_DOWN_HEADS and bTopHead and bDownHead then
      -- se posso usare entrambe le teste, la gestisco come una macchina a due teste da sopra
      MachineHeadUse = TWO_EQUAL_HEADS
   end
   for i = ForStart, ForEnd, ForStep do
      local Machining = Machinings[i]
      local sMachiningType = Machining.Type
      if BEAM and BEAM.BW then
         _, sMachiningType = EgtEndsWith( Machining.Type, '_H2')
      end
      -- recupero dati utensile
      local bToolActive, sToolName, bH2, bFixed = SetCurrMachiningAndTool( Machining.Name)
      if Machining.On and sMachiningType == sType and bToolActive then
         local bOk, ToolParams = VerifyTool( MachiningType, sType, Params, bH2)
         if bOk then
            if MachineHeadUse == ONE_HEAD then
               SetNextMachining( sToolName, 1, bFixed)
               return ReturnParams(MachiningType, Machining.Name, Machining.Type, ToolParams)
            elseif MachineHeadUse == TWO_EQUAL_HEADS then
               -- se nessuna testa attiva, prendo la prima lavorazione disponibile
               if nActiveHead == 0 then
                  SetNextMachining( sToolName, EgtIf( bH2, 2, 1), bFixed)
                  return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
               -- verifico se posso usare lo stesso utensile della testa attiva
               elseif ( nActiveHead == 1 and not bH2 and sToolName == H1_TOOL) or ( nActiveHead == 2 and bH2 and sToolName == H2_TOOL) then
                  SetNextMachining( sToolName, nActiveHead, bFixed)
                  return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
               else
                  -- segno le lavorazioni disponibili per entrambe le teste
                  if bH2 then
                     if not sH2Mach or sH2Mach == '' then
                        sH2Mach = Machining.Name
                        sH2Tool = sToolName
                        sH2Param = ToolParams
                     end
                  else
                     if not sH1Mach or sH1Mach == '' then
                        sH1Mach = Machining.Name
                        sH1Tool = sToolName
                        sH1Param = ToolParams
                     end
                  end
               end
            elseif MachineHeadUse == TWO_UP_DOWN_HEADS then
               if bTopHead and not bH2 then
                  SetNextMachining( sToolName, 1, bFixed)
                  return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
               elseif bDownHead and bH2 then
                  SetNextMachining( sToolName, 2, bFixed)
                  return ReturnParams( MachiningType, Machining.Name, Machining.Type, ToolParams)
               end
            end
         end
      end
   end
   if MachineHeadUse == TWO_EQUAL_HEADS then
      -- verifico se cambiare testa o cambiare utensile su quella corrente
      if nActiveHead == 1 then
         if sH2Mach ~= "" then
            SetNextMachining( sH2Tool, 2, bFixed)
            return ReturnParams( MachiningType, sH2Mach, sType, sH2Param)
            --return sH2Mach, sH2Param.Type, sH2Param.TMaxMat, sH2Param.MaxToolLength, sH2Param.ToolDiam, sH2Param.DiamTh, sH2Param.FreeLen
         elseif sH1Mach ~= "" then
            SetNextMachining( sH1Tool, 1, bFixed)
            return ReturnParams( MachiningType, sH1Mach, sType, sH1Param)
            --return sH1Mach, sH1Param.Type, sH1Param.TMaxMat, sH1Param.MaxToolLength, sH1Param.ToolDiam, sH1Param.DiamTh, sH1Param.FreeLen
         end
      elseif nActiveHead == 2 then
         if sH1Mach ~= "" then
            SetNextMachining( sH1Tool, 1, bFixed)
            return ReturnParams( MachiningType, sH1Mach, sType, sH1Param)
            --return sH1Mach, sH1Param.Type, sH1Param.TMaxMat, sH1Param.MaxToolLength, sH1Param.ToolDiam, sH1Param.DiamTh, sH1Param.FreeLen
         elseif sH2Mach ~= "" then
            SetNextMachining( sH2Tool, 2, bFixed)
            return ReturnParams( MachiningType, sH2Mach, sType, sH2Param)
            --return sH2Mach, sH2Param.Type, sH2Param.TMaxMat, sH2Param.MaxToolLength, sH2Param.ToolDiam, sH2Param.DiamTh, sH2Param.FreeLen
         end
      end
   end
   local bH2, sOrigType = EgtEndsWith( sType, '_H2')
   if ( not BEAM or not BEAM.BW) and MachineHeadType == TWO_UP_DOWN_HEADS and bH2 and bTopHead then
      return FindMachining( MachiningType, sOrigType, Params, true, false)
   end
end

---------------------------------------------------------------------
function MachiningLib.FindCutting( sType, bTopHead, bDownHead)
   return FindMachining( MCH_MY.SAWING, sType, nil, bTopHead, bDownHead)
end

---------------------------------------------------------------------
function MachiningLib.FindDrilling( dDiam, dDepth, bTopHead, bDownHead)
   local MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, 'Drill', { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead)
   if not MachiningName or MachiningName == '' then
      MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, 'Pocket', { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead)
   end
   if MachiningName and MachiningName ~= '' then
      return MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5
   end
end

---------------------------------------------------------------------
function MachiningLib.FindAngleDrilling( dDiam, dDepth, bTopHead, bDownHead)
   local MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5 = FindMachining( MCH_MY.DRILLING, 'AngleDrill', { Diam = dDiam, Depth = dDepth}, bTopHead, bDownHead)
   if MachiningName and MachiningName ~= '' then
      return MachiningName, MachiningType, Param1, Param2, Param3, Param4, Param5
   end
end

---------------------------------------------------------------------
function MachiningLib.FindMilling( sType, dDepth, sTuuidMstr, dMaxDiam, dMaxTotLen, bTopHead, bDownHead)
   return FindMachining( MCH_MY.MILLING, sType, { Depth = dDepth, TuuidMstr = sTuuidMstr, MaxDiam = dMaxDiam, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead)
end

---------------------------------------------------------------------
function MachiningLib.FindPocketing( sType, dMaxDiam, dDepth, dMaxTotLen, bTopHead, bDownHead)
   return FindMachining( MCH_MY.POCKETING, sType, { MaxDiam = dMaxDiam, Depth = dDepth, MaxTotLen = dMaxTotLen}, bTopHead, bDownHead)
end

---------------------------------------------------------------------
function MachiningLib.FindSawing( sType)
   return FindMachining( MCH_MY.MORTISING, sType)
end

-------------------------------------------------------------------------------------------------------------
function MachiningLib.ApplyMachining( bRecalc, bApplyPost)
   local bResult = EgtApplyMachining( bRecalc, bApplyPost)
   if bResult then ConfirmNextMachining() end
   return bResult
end

-------------------------------------------------------------------------------------------------------------
return MachiningLib