//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : API_GdbModify.cpp       Data : 06.10.14        Versione : 1.5i5
// Contenuto : Funzioni di modifica geometrica per API.
//
//
//
// Modifiche : 06.10.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------


//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "API.h"
#include "API_Macro.h"
#include "AuxTools.h"
#include "GeoTools.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EInConst.h"
#include "/EgtDev/Include/EgkGeoPoint3d.h"
#include "/EgtDev/Include/EgkGeoVector3d.h"
#include "/EgtDev/Include/EgkSurfTriMesh.h"
#include "/EgtDev/Include/EgkExtText.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGnStringConverter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"

using namespace std ;


//-------------------------------------------------------------------------------
BOOL
__stdcall EgtChangeGroupFrame( int nId, double ptOrig[3],
                               double vtX[3], double vtY[3], double vtZ[3], int nRefType)
{
  // costruisco il riferimento
   Frame3d frFrame ;
   if ( ! frFrame.Set( ptOrig, vtX, vtY, vtZ))
      return FALSE ;
  // eseguo
   return ( EgtChangeGroupFrame( nId, frFrame, nRefType) ? TRUE : FALSE) ;
}

//-------------------------------------------------------------------------------
bool
EgtChangeGroupFrame( int nId, const Frame3d& frNewRef, int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
   bool bOk = true ;
  // recupero il riferimento del gruppo
   Frame3d* pFrame = pGeomDB->GetGroupFrame( nId) ;
   bOk = bOk && ( pFrame != nullptr) ;
  // porto il nuovo riferimento in locale
   Frame3d frNewL = frNewRef ;
   if ( nRefType != RTY_LOC) {
      Frame3d frLoc ;
      bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
      if ( nRefType == RTY_GLOB)
         frNewL.ToLoc( frLoc) ;
      else /* RTY_GRID */
         frNewL.LocToLoc( pGeomDB->GetGridFrame(), frLoc) ;
   }
  // aggiorno il gruppo
   if ( bOk)
      *pFrame = frNewL ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtChangeGroupFrame(" + ToString( nId) + ",{" +
                                             ToString( frNewRef.Orig()) + "},{" +
                                             ToString( frNewRef.VersX()) + "},{" +
                                             ToString( frNewRef.VersY()) + "},{" +
                                             ToString( frNewRef.VersZ()) + "}," +
                                             RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
BOOL
__stdcall EgtChangeVectorBase( int nId, const double ptB[3], int nRefType)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, FALSE)
   bool bOk = true ;
  // recupero il vettore
   IGeoVector3d* pGVect = GetGeoVector3d( pGeomDB->GetGeoObj( nId)) ;
   bOk = bOk && ( pGVect != nullptr) ;
  // recupero il riferimento locale
   Frame3d frLoc ;
   bOk = bOk && pGeomDB->GetGlobFrame( nId, frLoc) ;
  // porto il nuovo punto base in locale
   Point3d ptBL = GetPointLocal( pGeomDB, ptB, nRefType, frLoc) ;
  // imposto il nuovo punto di base
   bOk = bOk && pGVect->ChangeBase( ptBL) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtChangeVectorBase(" + ToString( nId) + ",{" +
                                             ToString( Point3d( ptB)) + "}," +
                                             RefTypeToString( nRefType) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return ( bOk ? TRUE : FALSE) ;
}

//----------------------------------------------------------------------------
BOOL
__stdcall EgtInvertSurface( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, FALSE)
   bool bOk = true ;
  // eseguo inversione singola
   if ( nId != GDB_ID_SEL) {
     // recupero la superficie e la inverto
      ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( nId)) ;
      if ( pSurf != nullptr  &&  ! pSurf->Invert())
         bOk = false ;
   }
  // eseguo inversione dei selezionati
   else {
      int nI = pGeomDB->GetFirstSelectedObj() ;
      while ( nI != GDB_ID_NULL  &&  bOk) {
        // recupero la superficie e la inverto
         ISurf* pSurf = GetSurf( pGeomDB->GetGeoObj( nI)) ;
         if ( pSurf != nullptr  &&  ! pSurf->Invert())
            bOk = false ;
        // passo alla successiva
         nI = pGeomDB->GetNextSelectedObj() ;
      }
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtInvertSurf(" + ( nId != GDB_ID_SEL ? ToString( nId) : "GDB_ID_SEL") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return ( bOk ? TRUE : FALSE) ;
}

//----------------------------------------------------------------------------
BOOL
__stdcall EgtSurfTmDoSewing( int nNumId, const int nIds[], BOOL bErase)
{
   INTVECTOR vIds ;
   vIds.reserve( nNumId) ;
   for ( int i = 0 ; i < nNumId ; ++i) {
      vIds.push_back( nIds[i]) ;
   }
   return ( EgtSurfTmDoSewing( vIds, ( bErase != FALSE)) ? TRUE : FALSE) ;
}

//----------------------------------------------------------------------------
bool
EgtSurfTmDoSewing( const INTVECTOR& vIds, bool bErase)
{
  // --- tutte le superfici vengono cucite alla prima ---
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // almeno un oggetto nell'elenco
   bool bOk = ( vIds.size() > 0) ;
  // recupero la prima superficie
   ISurfTriMesh* pStm = GetSurfTriMesh( pGeomDB->GetGeoObj( vIds[0])) ;
   bOk = bOk && ( pStm != nullptr) ;
  // ne recupero il riferimento
   Frame3d frStm ;
   bOk = bOk && pGeomDB->GetGlobFrame( vIds[0], frStm) ;
  // esecuzione
   for ( size_t i = 1 ; bOk && i < vIds.size() ; ++ i) {
     // recupero la superficie da cucire
      const ISurfTriMesh* pStmS = GetSurfTriMesh( pGeomDB->GetGeoObj( vIds[i])) ;
      bOk = bOk && ( pStmS != nullptr) ;
     // recupero il riferimento
      Frame3d frStmS ;
      bOk = bOk && pGeomDB->GetGlobFrame( vIds[i], frStmS) ;
     // lo esprimo rispetto a quello della prima superficie
      frStmS.ToLoc( frStm) ;
     // eseguo la cucitura
      bOk = bOk && pStm->DoSewing( *pStmS, frStm) ;
   }
  // se richiesto, cancello le superfici cucite alla prima
   if ( bOk  &&  bErase) {
      for ( size_t i = 1 ; i < vIds.size() ; ++ i)
         pGeomDB->Erase( vIds[i]) ;
   }
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sIds ;
      for ( size_t i = 0 ; i < vIds.size() ; ++ i) {
         if ( i > 0)
            sIds += "," ;
         sIds += vIds[i] ;
      }
      string sLua = "EgtSurfTmDoSewing({" + sIds + "}," +
                                            ( bErase ? "true" : "false") + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco il risultato
   return bOk ;
}

//-------------------------------------------------------------------------------
BOOL
__stdcall EgtModifyText( int nId, const wchar_t* wsNewText)
{
   return ( EgtModifyText( nId, wstrztoA( wsNewText)) ? TRUE : FALSE) ;
}

//-------------------------------------------------------------------------------
bool
EgtModifyText( int nId, const string& sNewText)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il testo
   IExtText* pTXT = GetExtText( pGeomDB->GetGeoObj( nId)) ; 
   if ( pTXT == nullptr)
      return false ;
  // eseguo l'operazione
   return pTXT->ModifyText( sNewText) ;
}

//-------------------------------------------------------------------------------
BOOL
__stdcall EgtChangeTextFont( int nId, const wchar_t* wsNewFont)
{
   return ( EgtChangeTextFont( nId, wstrztoA( wsNewFont)) ? TRUE : FALSE) ;
}

//-------------------------------------------------------------------------------
bool
EgtChangeTextFont( int nId, const string& sNewFont)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, false)
  // recupero il testo
   IExtText* pTXT = GetExtText( pGeomDB->GetGeoObj( nId)) ; 
   if ( pTXT == nullptr)
      return false ;
  // eseguo l'operazione
   return pTXT->ChangeFont( sNewFont) ;
}

//-------------------------------------------------------------------------------
BOOL
__stdcall EgtFlipText( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, FALSE)
  // recupero il testo
   IExtText* pTXT = GetExtText( pGeomDB->GetGeoObj( nId)) ; 
   if ( pTXT == nullptr)
      return FALSE ;
  // eseguo l'operazione
   return ( pTXT->Flip() ? TRUE : FALSE) ;
}

//-------------------------------------------------------------------------------
BOOL
__stdcall EgtMirrorText( int nId, BOOL bOnL)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, FALSE)
  // recupero il testo
   IExtText* pTXT = GetExtText( pGeomDB->GetGeoObj( nId)) ; 
   if ( pTXT == nullptr)
      return FALSE ;
  // eseguo l'operazione
   return ( pTXT->Mir( ( bOnL ? true : false)) ? TRUE : FALSE) ;
}

//-------------------------------------------------------------------------------
BOOL
__stdcall EgtExplodeText( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, FALSE)
   bool bOk = true ;
  // recupero il testo
   IExtText* pTXT = GetExtText( pGeomDB->GetGeoObj( nId)) ; 
   if ( pTXT == nullptr)
      bOk = false ;
  // recupero l'outline del testo
   ICURVEPLIST lstPCRV ;
   bOk = bOk && pTXT->GetOutline( lstPCRV) ;
  // inserisco le curve nella stessa posizione del testo
   ICURVEPLIST::iterator iIter ;
   for ( iIter = lstPCRV.begin() ; bOk && iIter != lstPCRV.end() ; ++ iIter) {
     // inserisco la curva nello stesso gruppo e nello stesso posto del GeomDB
      int nCrvId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, (*iIter)) ;
      if ( nCrvId == GDB_ID_NULL)
         bOk = false ;
     // copio gli attributi
      if ( ! pGeomDB->CopyAttributes( nId, nCrvId))
         bOk = false ;
   }
  // elimino il testo originale
   bOk = bOk && pGeomDB->Erase( nId) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtExplodeText(" + ToString( nId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return ( bOk ? TRUE : FALSE) ;
}

//-------------------------------------------------------------------------------
BOOL
__stdcall EgtSplitText( int nId)
{
   IGeomDB* pGeomDB = GetCurrGeomDB() ;
   VERIFY_GEOMDB( pGeomDB, FALSE)
   bool bOk = true ;
  // recupero il testo
   IExtText* pTXT = GetExtText( pGeomDB->GetGeoObj( nId)) ; 
   if ( pTXT == nullptr)
      bOk = false ;
  // recupero l'esplosione del testo in linee singole
   IEXTTEXTPVECTOR vTxt ;
   bOk = bOk && pTXT->SplitOnLineBreak( vTxt) ;
  // inserisco i nuovi testi nella stessa posizione del testo
   for ( int i = 0 ; bOk && i < int( vTxt.size()) ; ++ i) {
     // inserimento
      int nCrvId = pGeomDB->InsertGeoObj( GDB_ID_NULL, nId, GDB_BEFORE, vTxt[i]) ;
     // se errore 
      if ( nCrvId == GDB_ID_NULL) {
         delete vTxt[i] ;
         bOk = false ;
      }
     // altrimenti copio gli attributi
      else {
         if ( ! pGeomDB->CopyAttributes( nId, nCrvId))
            bOk = false ;
      }
   }
  // elimino il testo originale
   bOk = bOk && pGeomDB->Erase( nId) ;
  // se richiesto, salvo il comando Lua equivalente
   if ( IsCmdLog()) {
      string sLua = "EgtSplitText(" + ToString( nId) + ")" +
                    " -- Ok=" + ToString( bOk) ;
      LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
   }
  // restituisco risultato
   return ( bOk ? TRUE : FALSE) ;
}