//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : Import3MF.h           Data : 29.01.21          Versione : 2.3b1 
// Contenuto : Dichiarazione della classe Import3MF.
//
//
//
// Modifiche : 21.01.21 SP Creazione modulo.
//
//
//----------------------------------------------------------------------------


//--------------------------- Include ----------------------------------------

#include "stdafx.h"
#include "Import3MF.h"
#include "DllMain.h"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EGkSurfTriMesh.h"

using namespace std ;
using namespace Lib3MF ;

//----------------------------------------------------------------------------
IImport3MF*
CreateImport3MF( void)
{
  // verifico la chiave e le opzioni
   if ( ! VerifyKey( KEYOPT_EEX_INPBASE))
      return nullptr ;
  // creo l'oggetto
   return static_cast<IImport3MF*> ( new( nothrow) Import3MF) ;
}

//----------------------------------------------------------------------------
bool
Import3MF::Import( const string& sFile, IGeomDB* pGDB, int nIdGroup, int nFlag)
{ 
   LOG_INFO( GetEExLogger(), ( "Import3MF : " + sFile).c_str()) ;

  // verifico il DB geometrico
   if ( pGDB == nullptr) {
      LOG_ERROR( GetEExLogger(), "   Import3MF : Error on GeomDB") ;
      return false ;
   }
   m_pGDB = pGDB ;

  // verifico l'Id di gruppo
   if ( ! m_pGDB->ExistsObj( nIdGroup)) {
      LOG_ERROR( GetEExLogger(), "   Import3MF : Error on IdGroup") ;
      return false ;
   }
   m_nIdGroup = nIdGroup ;

  // imposto le opzioni di importazione
   m_nFlag = nFlag ;

   try {
      if ( ! DoImport( sFile))
         return false ;
   }
   catch ( ELib3MFException &exception) {
      LOG_ERROR( GetEExLogger(), exception.what()) ;
      return false ;
   }
 
   return true ;   
}

//----------------------------------------------------------------------------
bool
Import3MF::DoImport( const string& sFile)
{
  // libreria 3MF
   m_wrapper = CWrapper::loadLibrary() ;
   if ( m_wrapper == nullptr) {
      LOG_ERROR( GetEExLogger(), "   Import3MF : Error on lib3mf Wrapper") ;
      return false ;  
   }

  // creazione del 3MF model 
   m_model = m_wrapper->CreateModel() ;
   if ( m_model == nullptr) {
      LOG_ERROR( GetEExLogger(), "   Import3MF : Error on lib3mf Model") ;
      return false ;  
   }

  // lettura file 
   PReader reader = m_model->QueryReader( "3mf") ;
   reader->ReadFromFile( sFile) ;
   for ( Lib3MF_uint32 nWarning = 0 ; nWarning < reader->GetWarningCount() ; nWarning ++) {
      Lib3MF_uint32 nErrorCode ;
      string sWarningMsg = reader->GetWarning( nWarning, nErrorCode) ;
      string sErrorMsg = "   Reading 3MF file encountered warning # " + to_string( nErrorCode) + " : " + sWarningMsg ;
      LOG_ERROR( GetEExLogger(), sErrorMsg.c_str()) ;
   }

   switch ( m_model->GetUnit()) {
      case eModelUnit::MicroMeter :
         m_dScaleFactor = 0.001 ;
         break ;
      case eModelUnit::MilliMeter :
         m_dScaleFactor = 1.0 ;
         break ;
      case eModelUnit::CentiMeter :
         m_dScaleFactor = 10.0 ;
         break ;
      case eModelUnit::Inch :
         m_dScaleFactor = 25.4 ;
         break ;
      case eModelUnit::Foot :
         m_dScaleFactor = 304.8 ;
         break ;
      case eModelUnit::Meter :
         m_dScaleFactor = 1000.0 ;
         break ;
      default:
         m_dScaleFactor = 1.0 ;
   }   

  // analisi metadata
   PMetaDataGroup metaDataGrp = m_model->GetMetaDataGroup() ;
   Lib3MF_uint32 nMetaDataCount = metaDataGrp->GetMetaDataCount() ;
   for ( Lib3MF_uint32 i = 0 ; i < nMetaDataCount ; i ++) {
      PMetaData metaData = metaDataGrp->GetMetaData( i) ;
      string sName = metaData->GetName() ;
      string sValue = metaData->GetValue() ;      
      if ( ! sName.empty()  &&  ! sValue.empty()) 
         m_pGDB->SetInfo( m_nIdGroup, sName, sValue) ;   
   }

  // scorro gli items nel build node
   PBuildItemIterator pBuildItemsIter = m_model->GetBuildItems() ;
   while ( pBuildItemsIter->MoveNext()) {
      PBuildItem pItem = pBuildItemsIter->GetCurrent() ;
     // ignoro i suoi attributes e i suoi metadata
     // recupero la sua trasformazione
      sTransform sTransf = pItem->GetObjectTransform() ;
     // lettura oggetto associato 
      if ( ! ReadObject( pItem->GetObjectResource(), sTransf, m_nIdGroup))
         return false ;
   }

  return true ;
}

//-------------------------------------------------------------------------------------------------
bool
Import3MF::ReadObject( const PObject pObj, const sTransform& Transform, int nParentId)
{ 
   if ( pObj == nullptr)
      return false ;

  // attributes
   INFOVECTOR vInfo ;
   string sName = pObj->GetName() ;   
   string sProp = pObj->GetPartNumber() ;
   if ( ! sProp.empty())
      vInfo.emplace_back( "PartNumber", sProp) ;   
   bool bUUID = false ;
   sProp = pObj->GetUUID( bUUID) ;
   if ( bUUID)
      vInfo.emplace_back( "UUID", sProp) ;  

   switch ( pObj->GetType()) {
      case eObjectType::Model :
         vInfo.emplace_back( "Type", "Model") ;
         break ;
      case eObjectType::Support :
         vInfo.emplace_back( "Type", "Support") ;
         break ; 
      case eObjectType::SolidSupport :
         vInfo.emplace_back( "Type", "SolidSupport") ;
         break ;
      default :
         break ;
   }

  // metadata
   PMetaDataGroup pMetaDataGrp = pObj->GetMetaDataGroup() ;
   for ( Lib3MF_uint32 i = 0 ; i < pMetaDataGrp->GetMetaDataCount() ; i ++) {
      PMetaData metaData = pMetaDataGrp->GetMetaData( i) ;
      string sMetaDataName = metaData->GetName() ;
      string sMetaDataValue = metaData->GetValue() ;
      if ( ! sMetaDataName.empty()  &&  ! sMetaDataValue.empty())
         vInfo.emplace_back( sMetaDataName, sMetaDataValue) ;
   }

   if ( pObj->IsMeshObject())
      return ReadMesh( pObj->GetResourceID(), sName, vInfo, Transform, nParentId) ;
   else if ( pObj->IsComponentsObject())
      return ReadComponent( pObj->GetResourceID(), sName, vInfo, Transform, nParentId) ;

   return false ;
}

//----------------------------------------------------------------------------------------------------------------
bool 
Import3MF::ReadMesh( Lib3MF_uint32 nId, const string& sName, const INFOVECTOR& vInfo, const sTransform& Transform, int nParentId)
{
  // Recupero puntatore alla mesh 3MF
   PMeshObject pMesh = m_model->GetMeshObjectByID( nId) ;
   if ( pMesh == nullptr)
      return false ;

  // Creo e inizializzo trimesh
   PtrOwner<ISurfTriMesh> pStm( CreateSurfTriMesh()) ;
   if ( IsNull( pStm)  ||  ! pStm->Init( pMesh->GetVertexCount(), pMesh->GetTriangleCount())) {
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : ISurfTriMesh Create error") ;
      return false ;
   }
   pStm->SetLinearTolerance( 10 * EPS_SMALL) ;

  // Ciclo sui vertici della mesh 3MF
   for ( Lib3MF_uint32 i = 0 ; i < pMesh->GetVertexCount() ; i ++) {
     // recupero le coordinate del vertice
      sPosition pVertex = pMesh->GetVertex( i) ;
     // applico la trasformazione
      double x = 0.0, y = 0.0, z = 0.0 ;
      for ( int k = 0 ; k < 3 ; k ++) {
         x += pVertex.m_Coordinates[k] * Transform.m_Fields[k][0] ;
         y += pVertex.m_Coordinates[k] * Transform.m_Fields[k][1] ;
         z += pVertex.m_Coordinates[k] * Transform.m_Fields[k][2] ;      
      }
      x += Transform.m_Fields[3][0] ;
      y += Transform.m_Fields[3][1] ;
      z += Transform.m_Fields[3][2] ;
     // inserisco il vertice nella trimesh
      if ( pStm->AddVertex( Point3d( x, y, z) * m_dScaleFactor) == SVT_NULL) {
         LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : ISurfTriMesh AddVertex error") ;
         return false ;       
      }
   }

  // Ciclo sui triangoli della mesh 3MF
   for ( Lib3MF_uint32 i = 0 ; i < pMesh->GetTriangleCount() ; i ++) {
     // recupero gli indici dei vertici del triangolo
      sTriangle tTrg = pMesh->GetTriangle( i) ;
      int nIdV[3] = { int( tTrg.m_Indices[0]), int( tTrg.m_Indices[1]), int( tTrg.m_Indices[2])} ;
     // se i vertici sono tutti diversi tra loro, inserisco il triangolo
      if ( nIdV[0] != nIdV[1]  &&  nIdV[0] != nIdV[2]  &&  nIdV[1] != nIdV[2]) {
         if ( pStm->AddTriangle( nIdV) == SVT_NULL) {
            LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : ISurfTriMesh AddTriangle error") ;
            return false ; 
         }
      }
   }

  // Aggiustamenti finali
   if ( ! pStm->DoCompacting()) {
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : ISurfTriMesh DoCompacting error") ;
      return false ;
   }
  
  // Inserimento nel DB geometrico
   int nGeoId = m_pGDB->AddGeoObj( GDB_ID_NULL, nParentId, Release( pStm)) ; 
   if ( nGeoId == GDB_ID_NULL) {
      LOG_ERROR( GetEExLogger(), "  Error reading 3MF mesh : error adding GeoObject") ;
      return false ;
   }
  
  // colore
   Lib3MF_uint32 pid, pindex ;
   if ( pMesh->GetObjectLevelProperty( pid, pindex)) {
      Color cCol ;
      if ( FindColor( pid, pindex, cCol))
         m_pGDB->SetMaterial( nGeoId, cCol) ;  
   }
  
  // attributes
   if ( ! sName.empty())
      m_pGDB->SetName( nGeoId, sName) ;
   for ( int i = 0 ; i < int( vInfo.size()) ; i++)
      m_pGDB->SetInfo( nGeoId, vInfo[i].first, vInfo[i].second) ;    

   return true ;
}

//-----------------------------------------------------------------------------------
bool 
Import3MF::ReadComponent( Lib3MF_uint32 nId, const string& sName, const INFOVECTOR& vInfo, const sTransform& Transform, int nParentId)
{
  // se va conservata la gerarchia ogni componente corrisponde ad un layer, altrimenti gli elementi della componente vengono
  // inseriti direttamente in m_nIdGroup e i suoi attributes vengono ignorati

   PComponentsObject pComponents = m_model->GetComponentsObjectByID( nId) ;
   if ( pComponents == nullptr)
      return false ;

   int nLayerId = nParentId ;
  // se importo gerarchia creo il layer corrispondente alla componente
   if ( ( m_nFlag & EI3FLAG_KEEP_GROUPS) != 0) {     
      nLayerId = m_pGDB->AddGroup( GDB_ID_NULL, nParentId, GLOB_FRM) ;
     // assegno nome e info
      if ( ! sName.empty())
         m_pGDB->SetName( nLayerId, sName) ;
      for ( int i = 0 ; i < int( vInfo.size()) ; i++)
         m_pGDB->SetInfo( nLayerId, vInfo[i].first, vInfo[i].second) ;
   }   

  // scorro tutti i suoi oggetti
   for ( Lib3MF_uint32 nC = 0 ; nC < pComponents->GetComponentCount() ; nC++) {
      
      PComponent pComponent = pComponents->GetComponent( nC) ;

     // combino le trasformazioni   
      sTransform TransfComp = pComponent->GetTransform() ;     
      sTransform TransfRes ;
     // inizializzo TransfRes a zero
      for ( Lib3MF_uint32 i = 0 ; i < 4 ; i++)
         fill( TransfRes.m_Fields[i], TransfRes.m_Fields[i] + 3, ( Lib3MF_single) 0.0) ;   

      for ( Lib3MF_uint32 i = 0 ; i < 4 ; i ++)
         for ( Lib3MF_uint32 j = 0 ; j < 3 ; j++)
            for ( Lib3MF_uint32 k = 0 ; k < 3 ; k ++)
               TransfRes.m_Fields[i][j] += TransfComp.m_Fields[i][k] * Transform.m_Fields[k][j] ;   // prodotto fra matrici
      
      for ( Lib3MF_uint32 j = 0 ; j < 3 ; j ++)
         TransfRes.m_Fields[3][j] += Transform.m_Fields[3][j] ; 

      if ( ! ReadObject( pComponent->GetObjectResource(), TransfRes, nLayerId))
         return false ;
   }
   return true ;
}

//------------------------------------------------------------------------------------
bool 
Import3MF::FindColor( Lib3MF_uint32 pid, Lib3MF_uint32 pindex, Color& cCol) const
{
   sColor sCol ; 

   switch ( m_model->GetPropertyTypeByID( pid)) {
   case ePropertyType::BaseMaterial :
      {
         PBaseMaterialGroup pBaseMatGrp = m_model->GetBaseMaterialGroupByID( pid) ;
         sCol = pBaseMatGrp->GetDisplayColor( pindex) ;
         break ;
      }
   case ePropertyType::Colors :
      {
         PColorGroup pColorGrp = m_model->GetColorGroupByID( pid) ;
         sCol = pColorGrp->GetColor( pindex) ;  
         break ;
      }
   case ePropertyType::Multi :
      {
         PMultiPropertyGroup pMultiPropGrp = m_model->GetMultiPropertyGroupByID( pid) ;
        // multiproperty corrispondente a pindex 
         UINTVECTOR pindices ;  
         pMultiPropGrp->GetMultiProperty( pindex, pindices) ;
        // analizzo i layers alla ricerca di una proprietà che definisca un colore 
         Lib3MF_uint32 nLayers = pMultiPropGrp->GetLayerCount() ;
         for ( Lib3MF_uint32 i = 0 ; i < nLayers ; i ++) {
            sMultiPropertyLayer layer = pMultiPropGrp->GetLayer( i) ;
            Lib3MF_uint32 pidLayer = layer.m_ResourceID ; 
           // appena trovo una propietà che definisce un colore mi fermo
            if ( m_model->GetPropertyTypeByID( pidLayer) == ePropertyType::BaseMaterial || 
                  m_model->GetPropertyTypeByID( pidLayer) == ePropertyType::Colors)
               return FindColor( pidLayer, pindices[i], cCol) ;
         }
         return false ;
      }
   case ePropertyType::Composite :
      {
         PCompositeMaterials pCompoMat = m_model->GetCompositeMaterialsByID( pid) ;
        // BaseMaterialGroup corrispondente 
         PBaseMaterialGroup pBaseMatGrp = pCompoMat->GetBaseMaterialGroup() ;
         vector<sCompositeConstituent> vComposite ;
         pCompoMat->GetComposite( pindex, vComposite) ;

        // check sui valori in vComposite
         double dMixSum = 0.0 ;
         for( int i = 0 ; i < int( vComposite.size()) ; i ++) 
            dMixSum += vComposite[i].m_MixingRatio ;
        // se fossero tutti zero, considero proporzioni uguali per ogni colore 
         if ( abs( dMixSum) < EPS_SMALL) {
            dMixSum = vComposite.size() ;
            for ( int i = 0 ; i < int( vComposite.size()) ; i++)
               vComposite[i].m_MixingRatio = 1 ;        
         }             

         double dRed = 0.0, dGreen = 0.0, dBlue = 0.0, dAlpha = 0.0 ;      // colore finale
         Lib3MF_uint8 nRedTmp, nGreenTmp, nBlueTmp, nAlphaTmp ;            // colore del BaseMaterial 
        // per ogni elemento di composite aggiungo il suo colore con l'opportuno coefficiente 
         for ( int i = 0 ; i < int( vComposite.size()) ; i++) {
            sCol = pBaseMatGrp->GetDisplayColor( vComposite[i].m_PropertyID) ;            
            m_wrapper->ColorToRGBA( sCol, nRedTmp, nGreenTmp, nBlueTmp, nAlphaTmp) ;
            double dMixingRatio = vComposite[i].m_MixingRatio / dMixSum ;
            dRed += nRedTmp * dMixingRatio ;
            dGreen += nGreenTmp * dMixingRatio ;
            dBlue += nBlueTmp * dMixingRatio ;
            dAlpha += nAlphaTmp * dMixingRatio ;
         }
         dAlpha = dAlpha * 100.0 / 255.0 ;
         cCol.Set( int( dRed + 0.5), int( dGreen + 0.5), int( dBlue + 0.5), int( dAlpha + 0.5)) ;
         return true ;
      }
   default :
      return false ;
   }

  // converto il colore 
   Lib3MF_uint8 nRed, nGreen, nBlue, nAlpha ;
   m_wrapper->ColorToRGBA( sCol, nRed, nGreen, nBlue, nAlpha) ;
   nAlpha = Lib3MF_uint8( nAlpha * 100.0 / 255.0 + 0.5) ; 
   cCol.Set( nRed, nGreen, nBlue, nAlpha) ; 

   return true ;
}