//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : API_GdbPartLayers.cpp       Data : 29.01.15        Versione : 1.6a7
// Contenuto : Funzioni di gestione pezzi e layer relativi.
//
//
//
// Modifiche : 29.01.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "API.h"
#include "API_Macro.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EgkCurve.h"
#include "/EgtDev/Include/EgkChainCurves.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"

using namespace std ;

//-------------------------------------------------------------------------------
static bool
EgtIsUserObj( IGeomDB* pGeomDB, int nId)
{
   int nLev ;
   return ( pGeomDB->GetCalcLevel( nId, nLev)  &&  nLev == GDB_LV_USER) ;
}

//-------------------------------------------------------------------------------
static bool
EgtIsVisibleObj( IGeomDB* pGeomDB, int nId)
{
   int nStat ;
   return ( pGeomDB->GetCalcStatus( nId, nStat)  &&  nStat != GDB_ST_OFF) ;
}

//-------------------------------------------------------------------------------
static int
EgtVerifyOrNext( IGeomDB* pGeomDB, int nId, bool bOnlyVisible)
{
   while ( nId != GDB_ID_NULL) {
      if ( EgtIsUserObj( pGeomDB, nId)  &&
           ( ! bOnlyVisible  ||  EgtIsVisibleObj( pGeomDB, nId)))
         return nId ;
      nId = pGeomDB->GetNextGroup( nId) ;
   }
   return GDB_ID_NULL ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtGetCurrPart( void)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, GDB_ID_NULL)
  // recupero il pezzo corrente
   return pGseCtx->m_nCurrPart ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtGetCurrLayer( void)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, GDB_ID_NULL)
  // recupero il pezzo corrente
   return pGseCtx->m_nCurrLayer ;
}

//-------------------------------------------------------------------------------
BOOL
__stdcall EgtSetCurrPartLayer( int nPartId, int nLayerId)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, FALSE)
   IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
   bool bOk = true ;
  // verifico validità e visibilità pezzo
   if ( pGeomDB->GetParentId( nPartId) == GDB_ID_ROOT  &&  EgtIsVisibleObj( pGeomDB, nPartId)) {
      if ( nPartId != pGseCtx->m_nCurrPart)
         pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
      pGseCtx->m_nCurrPart = nPartId ;
   }
   else {
      if ( nPartId == pGseCtx->m_nCurrPart || nPartId == GDB_ID_NULL) {
         pGseCtx->m_nCurrPart = GDB_ID_NULL ;
         pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
      }
     bOk = false ;
   }
  // verifico validità e visibilità layer
   if ( pGeomDB->GetParentId( nLayerId) == nPartId  &&  EgtIsVisibleObj( pGeomDB, nLayerId)) {
      pGseCtx->m_nCurrLayer = nLayerId ;
   }
   else {
      if ( nLayerId == pGseCtx->m_nCurrLayer  ||  nLayerId == GDB_ID_NULL)
         pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
     bOk = false ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSetCurrPartLayer(" + ToString( nPartId) + "," +
                                             ToString( nLayerId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
   return ( bOk ? TRUE : FALSE) ;
}

//-------------------------------------------------------------------------------
BOOL
__stdcall EgtResetCurrPartLayer( void)
{
   GseContext* pGseCtx = GetCurrGseContext() ;
   VERIFY_CTX_GEOMDB( pGseCtx, FALSE)
   IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
  // reset
   pGseCtx->m_nCurrPart = GDB_ID_NULL ;
   pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
  // cerco il primo pezzo con un layer visibile
   int nPartId = EgtGetFirstPart( true) ;
   while ( nPartId != GDB_ID_NULL) {
     // cerco il primo layer visibile del pezzo
      int nLayerId = EgtGetFirstLayer( nPartId, true) ;
      if ( nLayerId != GDB_ID_NULL) {
        // assegno il pezzo corrente
         pGseCtx->m_nCurrPart = nPartId  ;
        // assegno il layer corrente
         pGseCtx->m_nCurrLayer = nLayerId ;
        // esco dal ciclo di ricerca
         break ;
      }
      nPartId = EgtGetNextPart( nPartId, true) ;
   }
  // se non ho trovato layer visibile mi accontento del primo pezzo visibile
   if ( pGseCtx->m_nCurrPart == GDB_ID_NULL)
      pGseCtx->m_nCurrPart = EgtGetFirstPart( true) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtResetCurrPartLayer()"
                    " -- Ids=" + ToString( pGseCtx->m_nCurrPart) + "," + ToString( pGseCtx->m_nCurrLayer) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
   return TRUE ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtGetPartNbr( bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // conto i pezzi, considerando richiesta di visibilità
   int nCount = 0 ;
   int nPartId = EgtGetFirstPart( bOnlyVisible) ;
   while ( nPartId != GDB_ID_NULL) {
      ++ nCount ;
      nPartId = EgtGetNextPart( nPartId, bOnlyVisible) ;
   }
   return nCount ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtGetFirstPart( bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il primo gruppo sotto la radice
   int nPartId = pGeomDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
  // verifico oppure passo al primo successivo valido
   return EgtVerifyOrNext( pGeomDB, nPartId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtGetNextPart( int nId, bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il successivo gruppo
   int nPartId = pGeomDB->GetNextGroup( nId) ;
  // verifico oppure passo al primo successivo valido
   return EgtVerifyOrNext( pGeomDB, nPartId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtGetFirstLayer( int nPartId, bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // verifico il pezzo (livello utente e se richiesto visibile)
   if ( ! EgtIsUserObj( pGeomDB, nPartId)  ||
        ( bOnlyVisible  &&  ! EgtIsVisibleObj( pGeomDB, nPartId)))
      return GDB_ID_NULL ;
  // recupero il primo layer nel pezzo
   int nLayerId = pGeomDB->GetFirstGroupInGroup( nPartId) ;
  // verifico oppure passo al primo successivo valido
   return EgtVerifyOrNext( pGeomDB, nLayerId, bOnlyVisible) ;
}

//-------------------------------------------------------------------------------
int
__stdcall EgtGetNextLayer( int nId, bool bOnlyVisible)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
  // recupero il successivo gruppo
   int nLayerId = pGeomDB->GetNextGroup( nId) ;
  // verifico sia visibile oppure passo al primo successivo visibile
   return EgtVerifyOrNext( pGeomDB, nLayerId, bOnlyVisible) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSelectPartObjs( int nPartId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // verifico sia veramente un pezzo (gruppo sotto la radice)
   if ( pGeomDB->GetGdbType( nPartId) == GDB_TY_GROUP  &&
        pGeomDB->GetParentId( nPartId) == GDB_ID_ROOT) {
     // ciclo sugli oggetti del pezzo
      int nId = pGeomDB->GetFirstInGroup( nPartId) ;
      while ( nId != GDB_ID_NULL) {
        // se è gruppo seleziono i suoi componenti
         if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP)
            pGeomDB->SelectGroupObjs( nId) ;
        // altrimenti lo seleziono direttamente
         else
            pGeomDB->SelectObj( nId) ;
        // passo al successivo
         nId = pGeomDB->GetNext( nId) ;
      }
   }
   else
      bOk = false ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSelectPartObjs(" + ToString( nPartId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return ( bOk ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtDeselectPartObjs( int nPartId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // verifico sia veramente un pezzo (gruppo sotto la radice)
   if ( pGeomDB->GetGdbType( nPartId) == GDB_TY_GROUP  &&
        pGeomDB->GetParentId( nPartId) == GDB_ID_ROOT) {
     // ciclo sugli oggetti del pezzo
      int nId = pGeomDB->GetFirstInGroup( nPartId) ;
      while ( nId != GDB_ID_NULL) {
        // se è gruppo deseleziono i suoi componenti
         if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP)
            pGeomDB->DeselectGroupObjs( nId) ;
        // altrimenti lo deseleziono direttamente
         else
            pGeomDB->DeselectObj( nId) ;
        // passo al successivo
         nId = pGeomDB->GetNext( nId) ;
      }
   }
   else
      bOk = false ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtDeselectPartObjs(" + ToString( nPartId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return ( bOk ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSelectLayerObjs( int nLayerId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // verifico sia veramente un layer (gruppo senza sottogruppi)
   if ( pGeomDB->GetGdbType( nLayerId) == GDB_TY_GROUP  &&
        pGeomDB->GetFirstGroupInGroup( nLayerId) == GDB_ID_NULL) {
     // ciclo sugli oggetti del layer
      int nId = pGeomDB->GetFirstInGroup( nLayerId) ;
      while ( nId != GDB_ID_NULL) {
        // seleziono
         pGeomDB->SelectObj( nId) ;
        // passo al successivo
         nId = pGeomDB->GetNext( nId) ;
      }
   }
   else
      bOk = false ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSelectLayerObjs(" + ToString( nLayerId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return ( bOk ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtDeselectLayerObjs( int nLayerId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // verifico sia veramente un layer (gruppo senza sottogruppi)
   if ( pGeomDB->GetGdbType( nLayerId) == GDB_TY_GROUP  &&
        pGeomDB->GetFirstGroupInGroup( nLayerId) == GDB_ID_NULL) {
     // ciclo sugli oggetti del layer
      int nId = pGeomDB->GetFirstInGroup( nLayerId) ;
      while ( nId != GDB_ID_NULL) {
        // deseleziono
         pGeomDB->DeselectObj( nId) ;
        // passo al successivo
         nId = pGeomDB->GetNext( nId) ;
      }
   }
   else
      bOk = false ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtDeselectLayerObjs(" + ToString( nLayerId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return ( bOk ? TRUE : FALSE) ;
}

//-----------------------------------------------------------------------------
BOOL
__stdcall EgtSelectPathObjs( int nId, BOOL bHaltOnFork)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
   bool bOk = true ;
  // verifico appartenga ad un layer
   int nIdLayer = pGeomDB->GetParentId( nId) ;
   int nIdPart = pGeomDB->GetParentId( nIdLayer) ;
   int nIdRoot = pGeomDB->GetParentId( nIdPart) ;
   bOk = bOk && ( nIdLayer != GDB_ID_NULL && nIdPart != GDB_ID_NULL && nIdRoot == GDB_ID_ROOT) ;
  // seleziono percorso a partire da entità indicata usando tutte le curve del pezzo
   const int CHAIN_SIZE = 1000 ;
   const double CHAIN_TOLER = 10 * EPS_SMALL ;
   Point3d ptNear ;
   ChainCurves chainC ;
   bOk = bOk && chainC.Init( true, CHAIN_TOLER, CHAIN_SIZE) ;
   // ciclo sui layer del pezzo
   for ( int nLayId = pGeomDB->GetFirstGroupInGroup( nIdPart) ;
         nLayId != GDB_ID_NULL ;
         nLayId = pGeomDB->GetNextGroup( nLayId)) {
      // ciclo sulle entità del layer
      for ( int nEntId = pGeomDB->GetFirstInGroup( nLayId) ;
            nEntId != GDB_ID_NULL ;
            nEntId = pGeomDB->GetNext( nEntId)) {
        // non deve essere nascosta
         int nEntStat ;
         pGeomDB->GetCalcStatus( nEntId, nEntStat) ;
         if ( nEntStat == GDB_ST_OFF)
            continue ;
        // recupero la curva e il suo riferimento
         ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nEntId)) ;
         if ( pCrv == nullptr)
            continue ;
         Frame3d frCrv ;
         if ( ! pGeomDB->GetGlobFrame( nEntId, frCrv))
            continue ;
        // recupero i dati della curva necessari al concatenamento e li assegno
         Point3d ptStart, ptEnd ;
         Vector3d vtStart, vtEnd ;
         if ( ! pCrv->GetStartPoint( ptStart)  ||  ! pCrv->GetStartDir( vtStart)  ||
              ! pCrv->GetEndPoint( ptEnd)  ||  ! pCrv->GetEndDir( vtEnd))
            return GDB_ID_NULL ;
         ptStart.ToGlob( frCrv) ;
         vtStart.ToGlob( frCrv) ;
         ptEnd.ToGlob( frCrv) ;
         vtEnd.ToGlob( frCrv) ;
         if ( nEntId == nId)
            ptNear = ptStart + vtStart ;
         if ( ! chainC.AddCurve( nEntId, ptStart, vtStart, ptEnd, vtEnd))
            continue ;
      }
   }
  // recupero il primo percorso concatenato
   int nFirstId = GDB_ID_NULL ;
   INTVECTOR vId2s ;
   bOk = bOk && chainC.GetChainFromNear( ptNear, ( bHaltOnFork != FALSE), vId2s) ;
   for ( size_t i = 0 ; i < vId2s.size() ; ++i) {
      pGeomDB->SetStatus( abs( vId2s[i]), GDB_ST_SEL) ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSelectPathObjs(" + ToString( nId) + "," +
                                           ( bHaltOnFork ? "true" : "false") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return ( bOk ? TRUE : FALSE) ;
}