//----------------------------------------------------------------------------
//  EgalTech 2015-2016
//----------------------------------------------------------------------------
// File : EXE_NstMachining.cpp       Data : 08.02.16       Versione : 1.6n1
// Contenuto : Funzioni Nesting di lavorazione per EXE.
//
//
//
// Modifiche : 08.02.16 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "EXE_Const.h"
#include "EXE_Macro.h"
#include "EXE_Nst.h"
#include "/EgtDev/Include/EXeExecutor.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGkSimpleCDSurfFrMove.h"
#include "/EgtDev/Include/EMkOperationConst.h"
#include "/EgtDev/Include/EMkMachiningConst.h"
#include "/EgtDev/Include/EMkMachiningGeoConst.h"

using namespace std ;

//----------------------------------------------------------------------------
bool
ExeVerifyMachining( int nMchId, int& nResult)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)

  // Flag per calcolo box
   const int BBF_MCH_MY_FLAG = BBF_STANDARD ;
   const int BBF_PART_MY_FLAG = BBF_ONLY_VISIBLE | BBF_IGNORE_TEXT | BBF_IGNORE_DIM ;

  // Recupero il box e le regioni della lavorazione
   BBox3d b3Mch ;
   INTVECTOR vMchRReg, vMchLiReg, vMchLoReg ;
  // recupero gruppo preview lavorazioni nella lavorazione
   int nPVGrp = pGeomDB->GetFirstNameInGroup( nMchId, MCH_PV) ;
   if ( nPVGrp == GDB_ID_NULL)
      return false ;
  // se vuoto, cerco il rimando al preview nel pezzo
   if ( pGeomDB->GetGroupObjs( nPVGrp) == 0  &&
        ! pGeomDB->GetInfo( nPVGrp, MCH_PV_KEY_RELOCATE, nPVGrp))
      return false ;
  // ciclo sui percorsi utensile (CL)
   int nClId = pGeomDB->GetFirstGroupInGroup( nPVGrp) ;
   while ( nClId != GDB_ID_NULL) {
     // tagli ridotti
      int nCrId = pGeomDB->GetFirstNameInGroup( nClId, MCH_PV_RRCUT) ;
      while ( nCrId != GDB_ID_NULL) {
         BBox3d b3Reg ;
         if ( ! pGeomDB->GetGlobalBBox( nCrId, b3Reg, BBF_MCH_MY_FLAG))
            return false ;
         b3Mch.Add( b3Reg) ;
         vMchRReg.emplace_back( nCrId) ;
         nCrId = pGeomDB->GetNextName( nCrId, MCH_PV_RRCUT) ;
      }
     // ingressi
      int nLiId = pGeomDB->GetFirstNameInGroup( nClId, MCH_PV_RLICUT) ;
      while ( nLiId != GDB_ID_NULL) {
         BBox3d b3Reg ;
         if ( ! pGeomDB->GetGlobalBBox( nLiId, b3Reg, BBF_MCH_MY_FLAG))
            return false ;
         b3Mch.Add( b3Reg) ;
         vMchLiReg.emplace_back( nLiId) ;
         nLiId = pGeomDB->GetNextName( nLiId, MCH_PV_RLICUT) ;
      }
     // uscite
      int nLoId = pGeomDB->GetFirstNameInGroup( nClId, MCH_PV_RLOCUT) ;
      while ( nLoId != GDB_ID_NULL) {
         BBox3d b3Reg ;
         if ( ! pGeomDB->GetGlobalBBox( nLoId, b3Reg, BBF_MCH_MY_FLAG))
            return false ;
         b3Mch.Add( b3Reg) ;
         vMchLoReg.emplace_back( nLoId) ;
         nLoId = pGeomDB->GetNextName( nLoId, MCH_PV_RLOCUT) ;
      }
     // passo al successivo percorso utensile
      nClId = pGeomDB->GetNextGroup( nClId) ;
   }

  // Recupero il pezzo cui è associata la lavorazione
   int nMchPartId = GDB_ID_NULL ;
   SELVECTOR vIds ;
   if ( ExeSetCurrMachining( nMchId)  &&  ExeGetMachiningGeometry( vIds)  &&  ! vIds.empty())
      nMchPartId = pGeomDB->GetParentId( pGeomDB->GetParentId( vIds[0].nId)) ;

  // Recupero la fase di appartenenza della lavorazione
   int nPhase = ExeGetOperationPhase( nMchId) ;

  // Determino le regioni di tutti gli altri pezzi compresi nella regione della lavorazione
   INTVECTOR vOthReg ;
   int nRawId = ExeGetFirstRawPart() ;
   while ( nRawId != GDB_ID_NULL) {
     // se il grezzo appartiene alla fase di lavorazione
      if ( ExeVerifyRawPartPhase( nRawId, nPhase)) {
        // ciclo sui pezzi presenti nel grezzo
         int nId = ExeGetFirstPartInRawPart( nRawId) ;
         while ( nId != GDB_ID_NULL) {
            if ( nId != nMchPartId) {
               BBox3d b3Part ;
               if ( pGeomDB->GetGlobalBBox( nId, b3Part, BBF_PART_MY_FLAG) &&
                    b3Mch.OverlapsXY( b3Part)) {
                 // recupero regione del pezzo
                  int nRegId = GetFlatPartRegion( pGeomDB, nId) ;
                  if ( nRegId != GDB_ID_NULL)
                     vOthReg.emplace_back( nRegId) ;
                  else
                     return false ;
               }
            }
            nId = ExeGetNextPartInRawPart( nId) ;
         }
      }
      nRawId = ExeGetNextRawPart( nRawId) ;
   }

  // Eseguo verifiche
   nResult = FMI_NONE ;
  // confronto la regione di attacco della lavorazione con le regioni degli altri pezzi
   for ( int nMchRegId : vMchLiReg) {
      for ( int nOthRegId : vOthReg) {
         if ( ExeSurfFrChunkSimpleClassify( nMchRegId, 0, nOthRegId, 0) != REGC_OUT)
            nResult |= FMI_LI ;
      }
   }
  // confronto la regione ridotta della lavorazione con le regioni degli altri pezzi
   for ( int nMchRegId : vMchRReg) {
      for ( int nOthRegId : vOthReg) {
         if ( ExeSurfFrChunkSimpleClassify( nMchRegId, 0, nOthRegId, 0) != REGC_OUT)
            nResult |= FMI_RM ;
      }
   }
  // confronto la regione di uscita della lavorazione con le regioni degli altri pezzi
   for ( int nMchRegId : vMchLoReg) {
      for ( int nOthRegId : vOthReg) {
         if ( ExeSurfFrChunkSimpleClassify( nMchRegId, 0, nOthRegId, 0) != REGC_OUT)
            nResult |= FMI_LO ;
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
int
ExeVerifyCutAsSplitting( int nMchId)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_MACHMGR( pGseCtx, false)

  // verifico che la lavorazione indicata sia veramente un taglio con lama
   if ( pGseCtx->m_pMachMgr->GetOperationType( nMchId) != OPER_SAWING)
      return false ;

  // recupero la lavorazione corrente
   int nCurrMch = pGseCtx->m_pMachMgr->GetCurrMachining() ;
  // imposto la nuova lavorazione corrente
   pGseCtx->m_pMachMgr->SetCurrMachining( nMchId) ;
  // risultato
   int nResult = CAR_INTERF ;
  // recupero attacco e uscita correnti della lavorazione
   int nLiType ;
   pGseCtx->m_pMachMgr->GetMachiningParam( MPA_LEADINTYPE, nLiType) ;
   int nLoType ;
   pGseCtx->m_pMachMgr->GetMachiningParam( MPA_LEADOUTTYPE, nLoType) ;
  // verifico se posso portare attacco al bordo grezzo
   bool bLiToModif = ( nLiType != SAW_LI_EXT_CENT  &&  nLiType != SAW_LI_EXT_OUT) ;
   if ( bLiToModif) {
     // cambio attacco
      pGseCtx->m_pMachMgr->SetMachiningParam( MPA_LEADINTYPE, SAW_LI_EXT_CENT) ;
     // aggiorno preview
      pGseCtx->m_pMachMgr->MachiningPreview( true) ;
     // verifico interferenza
      int nRes ;
      if ( ExeVerifyMachining( nMchId, nRes)  &&  nRes == FMI_NONE)
         nResult += CAR_LI_OK ;
     // ripristino attacco originale
      pGseCtx->m_pMachMgr->SetMachiningParam( MPA_LEADINTYPE, nLiType) ;
   }
  // verifico se posso portare uscita al bordo grezzo
   bool bLoToModif = ( nLoType != SAW_LO_EXT) ;
   if ( bLoToModif) {
      pGseCtx->m_pMachMgr->SetMachiningParam( MPA_LEADOUTTYPE, SAW_LO_EXT) ;
     // aggiorno preview
      pGseCtx->m_pMachMgr->MachiningPreview( true) ;
     // verifico interferenza
      int nRes ;
      if ( ExeVerifyMachining( nMchId, nRes)  &&  nRes == FMI_NONE)
         nResult += CAR_LO_OK ;
     // ripristino uscita originale
      pGseCtx->m_pMachMgr->SetMachiningParam( MPA_LEADOUTTYPE, nLoType) ;
   }
  // aggiorno preview con attacco/uscita originali
   pGseCtx->m_pMachMgr->MachiningPreview( true) ;
  // se già al bordo grezzo, faccio verifica
   if ( ! bLiToModif  &&  ! bLoToModif) {
     // aggiorno preview
      pGseCtx->m_pMachMgr->MachiningPreview( true) ;
     // verifico interferenza
      int nRes ;
      if ( ExeVerifyMachining( nMchId, nRes)  &&  nRes == FMI_NONE)
         nResult = CAR_LI_LO_OK ;
   }
  // ripristino lavorazione corrente
   pGseCtx->m_pMachMgr->SetCurrMachining( nCurrMch) ;

  // restituisco il risultato
   return nResult ;
}