//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : Machining.cpp       Data : 10.06.15          Versione : 1.6f2
// Contenuto : Implementazione gestione base lavorazioni.
//
//
//
// Modifiche : 10.06.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "DllMain.h"
#include "MachMgr.h"
#include "Machining.h"
#include "/EgtDev/Include/EGkGeoPoint3d.h"
#include "/EgtDev/Include/EGkCurve.h"

using namespace std ;

//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
Machining::Machining( void)
{
}

//----------------------------------------------------------------------------
const string&
Machining::GetToolName( void) const
{
   return GetToolData().m_sName ;
}

//----------------------------------------------------------------------------
const string&
Machining::GetHeadName( void) const
{
   return GetToolData().m_sHead ;
}

//----------------------------------------------------------------------------
int
Machining::GetExitNbr( void) const
{
   return GetToolData().m_nExit ;
}

//----------------------------------------------------------------------------
const string&
Machining::GetToolTcPos( void) const
{
   return GetToolData().m_sTcPos ;
}

//----------------------------------------------------------------------------
bool
Machining:: NeedPrevHome( void) const
{
   return false ;
}

//----------------------------------------------------------------------------
bool
Machining::GetStartPoint( Point3d& ptStart) const
{
  // verifico validità gestore DB geometrico
   if ( m_pGeomDB == nullptr)
      return false ;
  // recupero gruppo per geometria di lavorazione (Cutter Location)
   int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
   if ( nClId == GDB_ID_NULL)
      return false ;
  // recupero la prima entità del primo sottogruppo
   int nEntId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetFirstGroupInGroup( nClId)) ;
   if ( nEntId == GDB_ID_NULL)
      return false ;
  // recupero il punto iniziale di questa entità
   const IGeoObj* pGeoObj = m_pGeomDB->GetGeoObj( nEntId) ;
   if ( pGeoObj->GetType() == GEO_PNT3D) {
      ptStart = GetGeoPoint3d( pGeoObj)->GetPoint() ;
      return true ;
   }
   else if ( ( pGeoObj->GetType() & GEO_CURVE) != 0)
      return GetCurve( pGeoObj)->GetStartPoint( ptStart) ;
   else
      return false ;
}

//----------------------------------------------------------------------------
bool
Machining::GetEndPoint( Point3d& ptEnd) const
{
  // verifico validità gestore DB geometrico
   if ( m_pGeomDB == nullptr)
      return false ;
  // recupero gruppo per geometria di lavorazione (Cutter Location)
   int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
   if ( nClId == GDB_ID_NULL)
      return false ;
  // recupero l'ultima entità dell'ultimo sottogruppo
   int nEntId = m_pGeomDB->GetLastInGroup( m_pGeomDB->GetLastGroupInGroup( nClId)) ;
   if ( nEntId == GDB_ID_NULL)
      return false ;
  // recupero il punto finale di questa entità
   const IGeoObj* pGeoObj = m_pGeomDB->GetGeoObj( nEntId) ;
   if ( pGeoObj->GetType() == GEO_PNT3D) {
      ptEnd = GetGeoPoint3d( pGeoObj)->GetPoint() ;
      return true ;
   }
   else if ( ( pGeoObj->GetType() & GEO_CURVE) != 0)
      return GetCurve( pGeoObj)->GetEndPoint( ptEnd) ;
   else
      return false ;
}

//----------------------------------------------------------------------------
bool
Machining::PrepareToolPreview( void) const
{
  // verifico validità gestori DB geometrico e CAM
   if ( m_pGeomDB == nullptr  ||  m_pMchMgr == nullptr)
      return false ;
  // creo o svuoto gruppo per anteprima utensile
   int nStId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
   // se non c'è, lo aggiungo
   if ( nStId == GDB_ID_NULL) {
      nStId = m_pGeomDB->AddGroup( GDB_ID_NULL, GetOwner(), Frame3d()) ;
      if ( nStId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nStId, MCH_ST) ;
      m_pGeomDB->SetLevel( nStId, GDB_LV_TEMP) ;
   }
   // altrimenti lo svuoto
   else
      m_pGeomDB->EmptyGroup( nStId) ;
  // se necessario, imposto l'utensile corrente
   string sCurrTool ; m_pMchMgr->GetCalcTool( sCurrTool) ;
   const_cast<Machining*>( this)->UpdateToolData() ;
   if ( ! EqualNoCase( sCurrTool, GetToolName())) {
      if ( ! m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()))
         return false ;
   }
  // copio la testa della lavorazione nel gruppo
   int nHeadId = m_pMchMgr->GetHeadId( GetHeadName()) ;
   int nId = m_pGeomDB->CopyGlob( nHeadId, GDB_ID_NULL, nStId) ;
   m_pGeomDB->SetMode( nId, GDB_MD_STD) ;
   m_pGeomDB->SetStatus( nId, GDB_ST_OFF) ;
   return ( nId != GDB_ID_NULL) ;
}

//----------------------------------------------------------------------------
bool
Machining::RemoveToolPreview( void) const
{
  // verifico validità gestore DB geometrico
   if ( m_pGeomDB == nullptr)
      return false ;
  // recupero gruppo per anteprima utensile
   int nStId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST) ;
  // lo svuoto
   m_pGeomDB->EmptyGroup( nStId) ;
   return true ;
}

//----------------------------------------------------------------------------
int
GetToolPreviewNext( IGeomDB* pGeomDB, int nEntId, int nParentId)
{
  // recupero la successiva
   int nNewId = (( nEntId != GDB_ID_NULL) ? pGeomDB->GetNext( nEntId) : pGeomDB->GetFirstInGroup( nParentId)) ;
   int nNewParentId = nParentId ;
  // ciclo nei gruppi successivi
   do {
     // ciclo nel gruppo
      while ( nNewId != GDB_ID_NULL) {
         string sName ; pGeomDB->GetName( nNewId, sName) ;
         if ( sName != MCH_CL_CLIMB  &&  sName != MCH_CL_RISE)
            break ;
         nNewId = pGeomDB->GetNext( nNewId) ;
      }
     // se trovata, esco
      if ( nNewId != GDB_ID_NULL)
         return nNewId ;
     // recupero la prima entità del successivo gruppo
      nNewParentId = pGeomDB->GetNextGroup( nNewParentId) ;
      nNewId = pGeomDB->GetFirstInGroup( nNewParentId) ;
   } while ( nNewId != GDB_ID_NULL) ;
   return GDB_ID_NULL ;
}

//----------------------------------------------------------------------------
int
GetToolPreviewPrev( IGeomDB* pGeomDB, int nEntId, int nParentId)
{
  // recupero la precedente
   int nNewId = (( nEntId != GDB_ID_NULL) ? pGeomDB->GetPrev( nEntId) : pGeomDB->GetLastInGroup( nParentId)) ;
   int nNewParentId = nParentId ;
  // ciclo nei gruppi precedenti
   do {
     // ciclo nel gruppo
      while ( nNewId != GDB_ID_NULL) {
         string sName ; pGeomDB->GetName( nNewId, sName) ;
         if ( sName != MCH_CL_CLIMB  &&  sName != MCH_CL_RISE)
            break ;
         nNewId = pGeomDB->GetPrev( nNewId) ;
      }
     // se trovata, esco
      if ( nNewId != GDB_ID_NULL)
         return nNewId ;
     // recupero l'ultima entità del precedente gruppo
      nNewParentId = pGeomDB->GetPrevGroup( nNewParentId) ;
      nNewId = pGeomDB->GetLastInGroup( nNewParentId) ;
   } while ( nNewId != GDB_ID_NULL) ;
   return GDB_ID_NULL ;
}

//----------------------------------------------------------------------------
int
Machining::ToolPreview( int nEntId, int nFlag) const
{
  // verifico validità gestori DB geometrico e CAM
   if ( m_pGeomDB == nullptr  ||  m_pMchMgr == nullptr)
      return GDB_ID_NULL ;
  // recupero la testa nel gruppo per anteprima utensile
   int nId = m_pGeomDB->GetFirstGroupInGroup( m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_ST)) ;
   if ( nId == GDB_ID_NULL)
      return GDB_ID_NULL ;
   m_pGeomDB->SetStatus( nId, GDB_ST_OFF) ;
  // recupero gruppo per geometria di lavorazione (Cutter Location)
   int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
   if ( nClId == GDB_ID_NULL)
      return GDB_ID_NULL ;
   int nParentId ;
  // se entità nulla
   if ( nEntId == GDB_ID_NULL  ||  ! m_pGeomDB->ExistsObj( nEntId)) {
     // recupero il gruppo di appartenenza
      nParentId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
     // se richiesta successiva
      if ( nFlag == MCH_TPM_AFTER)
         nEntId = GetToolPreviewNext( m_pGeomDB, nEntId, nParentId) ;
     // se richiesta precedente
      else if ( nFlag == MCH_TPM_BEFORE)
         nEntId = GetToolPreviewPrev( m_pGeomDB, nEntId, nParentId) ;
     // altrimenti richiesta corrente
      else
         nEntId = GDB_ID_NULL ;
   }
  // altrimenti
   else {
     // verifico che l'entità stia in un sottogruppo di CL
      nParentId =  m_pGeomDB->GetParentId( nEntId) ;
      if ( m_pGeomDB->GetParentId( nParentId) == nClId) {
        // se richiesta successiva
         if ( nFlag == MCH_TPM_AFTER)
            nEntId = GetToolPreviewNext( m_pGeomDB, nEntId, nParentId) ;
        // se richiesta precedente
         else if ( nFlag == MCH_TPM_BEFORE)
            nEntId = GetToolPreviewPrev( m_pGeomDB, nEntId, nParentId) ;
      }
      else
         nEntId = GDB_ID_NULL ;
   }
  // se esiste il gruppo genitore, visualizzo testa preview
   if ( nParentId != GDB_ID_NULL)
      m_pGeomDB->SetStatus( nId, GDB_ST_ON) ;
  // recupero i dati di questa entità
   const CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
   if ( pCamData == nullptr)
      return GDB_ID_NULL ;
   Point3d ptEnd = pCamData->GetEndPoint() ;
   AdjustEndPointForAxesCalc( pCamData, ptEnd) ;
   Vector3d vtTool = pCamData->GetToolDir() ;
   Vector3d vtBAux = pCamData->GetBackAuxDir() ;
  // dati correnti testa/uscita
   int nExitId = m_pGeomDB->GetFirstNameInGroup( nId, MCH_EXIT + ToString( GetExitNbr())) ;
   Frame3d frExit ;
   m_pGeomDB->GetGroupGlobFrame( nExitId, frExit) ;
   Point3d ptOrig = frExit.Orig() ;
   Vector3d vtDir = frExit.VersZ() ;
   Vector3d vtAux ;
   int nAvId = m_pGeomDB->GetFirstNameInGroup( nId, MCH_AUX_VECT) ;
   ExeStartVector( nAvId, GDB_ID_ROOT, vtAux) ;
  // rototraslo opportunamente
   Frame3d frHead ;
   m_pGeomDB->GetGroupGlobFrame( nId, frHead) ;
   Frame3d frRef ;
   if ( vtAux.IsSmall())
      frRef.Set( ptOrig, vtDir) ;
   else
      frRef.Set( ptOrig, vtDir, vtAux) ;
   Frame3d frShow ;
   if ( vtBAux.IsSmall())
      frShow.Set( ptEnd + vtTool * GetToolData().m_dLen, vtTool) ;
   else
      frShow.Set( ptEnd + vtTool * GetToolData().m_dLen, vtTool, vtBAux) ;
   frHead.ToLoc( frRef) ;
   frHead.ToGlob( frShow) ;
   *(m_pGeomDB->GetGroupFrame( nId)) = frHead ;

   return nEntId ;
}

//----------------------------------------------------------------------------
bool
Machining::PostApply( string& sErr)
{
  // recupero la macchina corrente
   Machine* pMch = m_pMchMgr->GetCurrMachine() ;
   if ( pMch == nullptr)
      return false ;
  // costanti
   static const string EMC_VAR = "EMC" ;              // tabella variabili locali per calcolo
   static const string EVAR_PHASE = ".PHASE" ;        // IN  (int)    indice fase
   static const string EVAR_MCHID = ".MCHID" ;        // IN  (int)    identificativo della lavorazione
   static const string EVAR_ERROR = ".ERR" ;          // OUT (int)    codice di errore ( 0 = ok, > 0 errore, < 0 warning)
   static const string EVAR_MSG = ".MSG" ;            // OUT (string) stringa di errore ( opzionale)
   static const string ON_POST_APPLY = "OnPostApplyMachining" ;

  // eseguo l'azione
   if ( pMch->LuaExistsFunction( ON_POST_APPLY)) {
      bool bOk = true ;
      int nErr = 99 ;
     // imposto valori parametri
      bOk = bOk && pMch->LuaCreateGlobTable( EMC_VAR) ;
      bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_PHASE, m_nPhase) ;
      bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_MCHID, m_nOwnerId) ;
     // eseguo
      bOk = bOk && pMch->LuaCallFunction( ON_POST_APPLY, false) ;
     // recupero valori parametri obbligatori
      bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
     // recupero valori parametri opzionali
      string sMsg ;
      bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MSG, sMsg) ;
     // reset
      bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
     // segnalo errori
      if ( ! bOk  ||  nErr > 0) {
         bOk = false ;
         sErr = sMsg ;
         if ( IsEmptyOrSpaces( sErr))
            sErr = "  Error in " + ON_POST_APPLY + " (" + ToString( nErr) + ")" ;
      }
     // recupero eventuale warning
      else if ( nErr < 0) {
         string sOut = sMsg ;
         if ( IsEmptyOrSpaces( sOut))
            sOut = "  Warning in " + ON_POST_APPLY + " (" + ToString( abs( nErr)) + ")" ;
         m_pMchMgr->SetWarning( abs( nErr), sOut) ;
      }
      return bOk ;
   }
   else
      return true ;
}