-- Strategia: STR0011
-- Descrizione 
-- foratura
-- Feature: foro

-- carico librerie
local BeamLib = require( 'BeamLib')
local BeamData = require( 'BeamDataNew')
local MachiningLib = require( 'MachiningLib')
local FeatureLib = require( 'FeatureLib')
-- strategie di base

-- Tabella per definizione modulo
local STR0011 = {}
local Strategy = {}

-- TODO Da fare completamente gestione foratura doppia con 2 teste

-------------------------------------------------------------------------------------------------------------
local function GetDrillingStrategy( Proc, Part)
   local ToolSearchParameters = {}
   local Machining = {}

   -- si cerca utensile 1
   local Drilling = MachiningLib.InitMachiningParameters( MCH_MY.DRILLING)
   ToolSearchParameters = {}
   ToolSearchParameters.dElevation = Proc.FeatureInfo.dDrillLen + BeamData.MILL_OVERLAP
   ToolSearchParameters.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
   ToolSearchParameters.dToolDiameter = Proc.FeatureInfo.dDrillDiam
   ToolSearchParameters.dDiameterTolerance = Strategy.Parameters.dDiameterTolerance
   ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sDrillBitList, 'Drilling')
   ToolSearchParameters.ptCheckOutStroke = { Proc.FeatureInfo.ptDrillCenter + ( EgtMdbGetGeneralParam( MCH_GP.SAFEZ) * ToolSearchParameters.vtToolDirection)}

   Drilling.ToolInfo = {}
   Drilling.ToolInfo = MachiningLib.FindDrill( Proc, ToolSearchParameters)
   -- se trovato utensile si settano i parametri comuni
   if Drilling.ToolInfo.nToolIndex then
      Drilling.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
      Drilling.nToolIndex = Drilling.ToolInfo.nToolIndex
      Drilling.vtToolDirection = Proc.FeatureInfo.vtDrillExtrusion
      Drilling.dStep = TOOLS[Drilling.nToolIndex].dStep
   end

   -- TODO se utensile 2 che si torverà è il gemello da usare nelle lavorazioni in doppio, allora gestire di conseguenza l'applicazione delle lavorazioni in doppio
   -- si cerca utensile 2
   local Drilling2 = MachiningLib.InitMachiningParameters( MCH_MY.DRILLING)
   Drilling2.ToolInfo = {}
   if Proc.FeatureInfo.bIsDrillOpen then
      ToolSearchParameters = {}
      ToolSearchParameters.dElevation = Proc.FeatureInfo.dDrillLen + BeamData.MILL_OVERLAP
      ToolSearchParameters.vtToolDirection = -Proc.FeatureInfo.vtDrillExtrusion
      ToolSearchParameters.dDiameterTolerance = Strategy.Parameters.dDiameterTolerance
      ToolSearchParameters.AvailableToolList = MachiningLib.GetAvailableToolList( Proc, Strategy.Parameters.sDrillBitList, 'Drilling')
      ToolSearchParameters.ptCheckOutStroke = { Proc.FeatureInfo.ptDrillCenter + ( ( Proc.FeatureInfo.dDrillLen + EgtMdbGetGeneralParam( MCH_GP.SAFEZ)) * ToolSearchParameters.vtToolDirection)}

      Drilling2.ToolInfo = MachiningLib.FindDrill( Proc, ToolSearchParameters)
      -- se trovato utensile si settano i parametri comuni
      if Drilling2.ToolInfo.nToolIndex then
         Drilling2.Geometry = {{ Proc.FeatureInfo.idAddAuxGeom, -1}}
         Drilling2.nToolIndex = Drilling2.ToolInfo.nToolIndex
         Drilling2.bInvert = true
         Drilling2.vtToolDirection = -Proc.FeatureInfo.vtDrillExtrusion
         Drilling2.dStep = TOOLS[Drilling2.nToolIndex].dStep
      end
   end

   -- se possono lavorare entrambi e si deve fare lavorazione doppia e si riesce a completare
   if Drilling.ToolInfo.nToolIndex and Drilling2.ToolInfo.nToolIndex and
      ( Strategy.Parameters.sDrillingMode == 'FORCE_TWO'  or Strategy.Parameters.sDrillingMode == 'AUTO') and
      Drilling.ToolInfo.dResidualDepth + Drilling2.ToolInfo.dResidualDepth < Proc.FeatureInfo.dDrillLen then

      local dExtraDrill = ( Proc.FeatureInfo.dDrillLen - BeamData.MILL_OVERLAP - ( Drilling.ToolInfo.dResidualDepth + Drilling2.ToolInfo.dResidualDepth)) / 2
      Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth - dExtraDrill
      table.insert( Machining, Drilling)

      Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth - dExtraDrill
      table.insert( Machining, Drilling2)

      -- voto
      Strategy.Result.sStatus = 'Completed'
      Strategy.Result.dCompletionIndex = 5
      Strategy.Result.sInfo = ''
      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')

   -- se utensile 1 esegue completamente
   elseif Drilling.ToolInfo.nToolIndex and Drilling.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL and
            ( Strategy.Parameters.sDrillingMode == 'PREFER_ONE' or ( not Drilling2.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode == 'AUTO') or not Proc.FeatureInfo.bIsDrillOpen) then
      Drilling.sDepth = Proc.FeatureInfo.dDrillLen
      table.insert( Machining, Drilling)
      -- voto
      Strategy.Result.sStatus = 'Completed'
      Strategy.Result.dCompletionIndex = 5
      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
      Strategy.Result.sInfo = ''
      -- annullo altra lavorazione
      Drilling2.ToolInfo.nToolIndex = nil
   -- se utensile 2 esegue completamente
   elseif Drilling2.ToolInfo.nToolIndex and Drilling2.ToolInfo.dResidualDepth < 10 * GEO.EPS_SMALL and
            ( Strategy.Parameters.sDrillingMode == 'PREFER_ONE' or ( not Drilling.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode == 'AUTO')) then
      Drilling2.sDepth = Proc.FeatureInfo.dDrillLen
      table.insert( Machining, Drilling2)
      -- voto
      Strategy.Result.sStatus = 'Completed'
      Strategy.Result.dCompletionIndex = 5
      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( EgtIf( Proc.FeatureInfo.bIsDrillOpen, 'ROUGH', 'FINE'))
      Strategy.Result.sInfo = ''
      -- annullo altra lavorazione
      Drilling.ToolInfo.nToolIndex = nil
   -- se possono lavorare entrambi
   elseif Drilling.ToolInfo.nToolIndex and Drilling2.ToolInfo.nToolIndex then
      Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth
      table.insert( Machining, Drilling)

      Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth
      table.insert( Machining, Drilling2)
      if Drilling.ToolInfo.dResidualDepth + Drilling2.ToolInfo.dResidualDepth < Proc.FeatureInfo.dDrillLen then
         Strategy.Result.sStatus = 'Not-Completed'
         local dMachinedLen = Machining[1].sDepth + Machining[2].sDepth
         local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
         Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
         Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
      else
         Strategy.Result.sStatus = 'Completed'
         Strategy.Result.dCompletionIndex = 5
         Strategy.Result.sInfo = ''
      end
      -- voto
      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
   -- se utensile 1 non completo
   elseif Drilling.ToolInfo.nToolIndex and ( Strategy.Parameters.sDrillingMode ~= 'FORCE_TWO' or Proc.FeatureInfo.bIsDrillOpen) then
      Drilling.sDepth = Proc.FeatureInfo.dDrillLen - Drilling.ToolInfo.dResidualDepth
      table.insert( Machining, Drilling)
      -- voto
      Strategy.Result.sStatus = 'Not-Completed'
      local dMachinedLen = Machining[1].sDepth
      local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
      Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
      Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
      -- annullo altra lavorazione
      Drilling2.ToolInfo.nToolIndex = nil
      -- se utensile 2 non completo
   elseif Drilling2.ToolInfo.nToolIndex and Strategy.Parameters.sDrillingMode ~= 'FORCE_TWO' then
      Drilling2.sDepth = Proc.FeatureInfo.dDrillLen - Drilling2.ToolInfo.dResidualDepth
      table.insert( Machining, Drilling2)
      -- voto
      Strategy.Result.sStatus = 'Not-Completed'
      local dMachinedLen = Machining[1].sDepth
      local dMachinedPrercentage = 100 * ( dMachinedLen / Proc.FeatureInfo.dDrillLen)
      Strategy.Result.dCompletionIndex = FeatureLib.GetFeatureCompletionIndex( dMachinedPrercentage)
      Strategy.Result.sInfo = 'Drill not complete, left ' .. tostring( 100 - ceil( dMachinedPrercentage)) .. '%'
      Strategy.Result.dQuality = FeatureLib.GetStrategyQuality( 'FINE')
      -- annullo altra lavorazione
      Drilling.ToolInfo.nToolIndex = nil
   else
      local sMessage
      -- se non sono state trovate punte
      if not Drilling.ToolInfo.nToolIndex and not Drilling2.ToolInfo.nToolIndex then
         sMessage = 'Drillbit not found'
      -- se son state trovate delle punte, ma non è stato possibile forare da entrambe le parti
      elseif Strategy.Parameters.sDrillingMode == 'FORCE_TWO' then
         sMessage = "Not possible to force machining from both sides. Please change drilling mode to AUTO"
      end
      Strategy.Result = FeatureLib.GetStrategyResultNotApplicable( sMessage)
   end

   -- calcolo tempo di lavorazione
   Strategy.Result.dTimeToMachine = 0
   if Drilling.ToolInfo.nToolIndex then
      Strategy.Result.dTimeToMachine = MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Drilling, Part)
   end
   if Drilling2.ToolInfo.nToolIndex then
      Strategy.Result.dTimeToMachine = Strategy.Result.dTimeToMachine + MachiningLib.GetTimeToMachineAllStepsWithLeadInOut( Drilling2, Part)
   end

   return Machining, Strategy.Result
end

-------------------------------------------------------------------------------------------------------------
function STR0011.Make( bAddMachining, Proc, Part, CustomParameters)
   -- carico parametri da default e li aggiorno con quelli passati dal chiamante (potrebbero non essere congruenti)
   local StrategyLib = {}
   StrategyLib.Config = STRATEGIES_CONFIG[CustomParameters.sStrategyId]
   Strategy.sName = StrategyLib.Config.sStrategyId
   Strategy.Parameters = BeamLib.LoadCustomParametersInStrategy( Proc, Part, CustomParameters, StrategyLib.Config)
   Strategy.Machinings = {}
   Strategy.Result = {}

   local bAreAllMachiningsAdded

   Strategy.Machinings, Strategy.Result = GetDrillingStrategy( Proc, Part)

   if bAddMachining and Strategy.Result.sStatus ~= 'Not-Applicable' then
      -- aggiunge lavorazione
      for j = 1, #Strategy.Machinings do
         Strategy.Machinings[j].nType = MCH_MY.DRILLING
         Strategy.Machinings[j].Steps.dStep = TOOLS[Strategy.Machinings[j].ToolInfo.nToolIndex].dStep
         bAreAllMachiningsAdded = MachiningLib.AddMachinings( Proc, Strategy.Machinings[j])
      end
   end

   return bAreAllMachiningsAdded, Strategy.Result
end

-------------------------------------------------------------------------------------------------------------

 return STR0011