// Interface.cpp: definisce le funzioni esportate per l'applicazione DLL.
//

#include "stdafx.h"
#include "/EgtDev/Include/EInAPI.h"
#include "/EgtDev/Include/EInDllMain.h"
#include "/EgtDev/Include/EGkDllMain.h"
#include "/EgtDev/Include/ENkDllMain.h"
#include "/EgtDev/Include/EGnDllMain.h"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EGrDllMain.h"
#include "/EgtDev/Include/EGkGeomDB.h"
#include "/EgtDev/Include/EExImportStl.h"
#include "/EgtDev/Include/EExImportDxf.h"
#include "/EgtDev/Include/EExExportStl.h"
#include "/EgtDev/Include/EExExportDxf.h"
#include "/EgtDev/Include/EGrScene.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EGnStringConverter.h"
#include "/EgtDev/Include/EgtLogger.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include <fstream>

using namespace std ;
using namespace egtlogger ;


//-----------------------------------------------------------------------------
static Logger*    s_pLogGen = nullptr ;
static IGeomDB*   s_pGeomDB = nullptr ;
static HWND       s_hWnd = nullptr ;
static IEGrScene* s_pScene = nullptr ;
static Color      s_colDef = BLACK ;

//-----------------------------------------------------------------------------
int
__stdcall EgtSetLog( int nDebug, const wchar_t* sLogFile)
{
  // creo il logger generale
   s_pLogGen = new Logger( ( nDebug > 0 ? LL_DEBUG : LL_INFO), "EgtInterface") ;
   if ( s_pLogGen == nullptr)
      return 0 ;
  // assegno il file
   s_pLogGen->AddOutputStream( new ofstream( sLogFile), true) ;
  // lo passo alle DLL
   SetEGnLogger( s_pLogGen) ;
   SetENkLogger( s_pLogGen) ;
   SetEGkLogger( s_pLogGen) ;
   SetEExLogger( s_pLogGen) ;
   SetEGrLogger( s_pLogGen) ;

   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtSetFont( const wchar_t* sNfeFontDir, const wchar_t* sDefaultFont)
{
  // inizializzazioni gestore font Nfe
   InitFontManager( LPSTR( WtoA( sNfeFontDir)), LPSTR( WtoA( sDefaultFont))) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtInit( HWND hWnd, int nDriver, int b2Buff, int nColorBits, int nDepthBits)
{
  // inizio programma
   LOG_DATETIME( s_pLogGen, " Init")
  // versione dell'interfaccia
   LOG_INFO( s_pLogGen, GetEInVersion())
  // versione delle librerie
   LOG_INFO( s_pLogGen, GetEGnVersion())
   LOG_INFO( s_pLogGen, GetENkVersion())
   LOG_INFO( s_pLogGen, GetEGkVersion())
   LOG_INFO( s_pLogGen, GetEExVersion())
   LOG_INFO( s_pLogGen, GetEGrVersion())

  // inizializzazioni DB geometrico
   s_pGeomDB = CreateGeomDB() ;
   if ( s_pGeomDB == nullptr)
      return 0 ;
   s_pGeomDB->Init() ;
   s_pGeomDB->SetDefaultMaterial( s_colDef) ;

  // inizializzazione scena OpenGL
   s_pScene = CreateEGrScene() ;
   if ( s_pScene == nullptr)
      return 0 ;
   s_hWnd = hWnd ;
   HDC hdc = GetDC( hWnd) ; 
   if ( ! s_pScene->CreateContext( hdc, nDriver, ( b2Buff != 0), nColorBits, nDepthBits))
      return 0 ;
   s_pScene->SetBackground( WHITE, WHITE) ;
   s_pScene->SetShowMode( SM_SHADING) ;
   s_pScene->SetShowCurveDirection( false) ;
   s_pScene->SetCamera( CT_TOP) ;
   s_pScene->ZoomAll() ;
   s_pScene->SetWinRectAttribs( true, BLACK) ;
   s_pScene->SetMark( YELLOW) ;
   s_pScene->Init( s_pGeomDB) ;
  // log con info sulla scena
   string sSceneInfo = s_pScene->GetOpenGLInfo() + '\n' +
                       s_pScene->GetGLSLInfo() + '\n' +
                       s_pScene->GetPixelFormatInfo() ;
   LOG_INFO( s_pLogGen, sSceneInfo.c_str())

   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtExit( void)
{
  // fine programma
   LOG_DATETIME( s_pLogGen, " Exit")

  // scena
   if ( s_pScene != nullptr) {
      s_pScene->Destroy() ;
      delete s_pScene ;
      s_pScene = nullptr ;
   }
   s_hWnd = nullptr ;
  // geomDB
   if ( s_pGeomDB != nullptr) {
      delete s_pGeomDB ;
      s_pGeomDB = nullptr ;
   }
  // logger
   if ( s_pLogGen != nullptr) {
      delete s_pLogGen ;
      s_pLogGen = nullptr ;
   }

   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtSetDefaultMaterial( int nRed, int nGreen, int nBlue)
{
  // verifico GeomDB
   if ( s_pGeomDB == nullptr) {
      LOG_ERROR( s_pLogGen, "GeomDB invalid (EgtSetDefaultMaterial)")
      return 0 ;
   }
  // imposto il materiale di default
   s_colDef.Set( nRed, nGreen, nBlue) ;
   s_pGeomDB->SetDefaultMaterial( s_colDef) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtSetBackground( int nTopRed, int nTopGreen, int nTopBlue,
                            int nBottomRed, int nBottomGreen, int nBottomBlue)
{
  // verifico GeomDB
   if ( s_pGeomDB == nullptr) {
      LOG_ERROR( s_pLogGen, "GeomDB invalid (EgtSetDefaultMaterial)")
      return 0 ;
   }
  // imposto lo sfondo
   s_pScene->SetBackground( Color( nTopRed, nTopGreen, nTopBlue), Color( nBottomRed, nBottomGreen, nBottomBlue)) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtNewFile( void)
{
  // verifico GeomDB
   if ( s_pGeomDB == nullptr) {
      LOG_ERROR( s_pLogGen, "GeomDB invalid (EgtNewFile)")
      return 0 ;
   }
  // reinizializzazione (con pulizia) del DB geometrico
   s_pGeomDB->Init() ;
   s_pGeomDB->SetDefaultMaterial( s_colDef) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtOpenFile( const wchar_t* sFilePath)
{
  // reinizializzazione (con pulizia) del DB geometrico
   if ( ! EgtNewFile())
      return 0 ;
  // carico il file
   if ( s_pGeomDB->Load( LPSTR( WtoA( sFilePath))))
      return 1 ;
   else
      return 0 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtTestImportExt( const wchar_t* sFilePath)
{
  // divido in nome e direttorio
   string sFileDir, sFileName ;
   SplitLast( LPSTR( WtoA( sFilePath)), "\\", sFileDir, sFileName) ;

  // recupero l'estensione
   string sFileTitle, sFileExt ;
   SplitLast( sFileName, ".", sFileTitle, sFileExt) ;
   ToUpper( sFileExt) ;

   if ( sFileExt == "DXF")
      return 1 ;
   else if ( sFileExt == "STL")
      return 2 ;
   else {
     // emetto info
      string sInfo = "File type (" + sFileExt + ") not recognized" ;
      LOG_INFO( s_pLogGen, sInfo.c_str())
      return 0 ;
   }
}

//-----------------------------------------------------------------------------
int
__stdcall EgtImportDxf( const wchar_t* sFilePath)
{
  // verifico GeomDB
   if ( s_pGeomDB == nullptr) {
      LOG_ERROR( s_pLogGen, "GeomDB invalid (ImportFile)")
      return 0 ;
   }
  // importo il file DXF
   // aggiungo un gruppo pezzo
   int nPartId = s_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
   // preparo l'importatore
   PtrOwner<IImportDxf> pImpDxf( CreateImportDxf()) ;
   if ( IsNull( pImpDxf)) {
      LOG_ERROR( s_pLogGen, "Error : CreateImportDxf")
      return 0 ;
   }
   // eseguo l'importazione
   if ( pImpDxf->Import( LPSTR( WtoA( sFilePath)), s_pGeomDB, nPartId))
      return 1 ;
   else
      return 0 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtImportStl( const wchar_t* sFilePath)
{
  // verifico GeomDB
   if ( s_pGeomDB == nullptr) {
      LOG_ERROR( s_pLogGen, "GeomDB invalid (EgtImportStl)")
      return 0 ;
   }
  // importo il file STL
   // aggiungo un gruppo pezzo e un gruppo layer
   int nPartId = s_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
   int nLayerId = s_pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
   // preparo l'importatore
   PtrOwner<IImportStl> pImpStl( CreateImportStl()) ;
   if ( IsNull( pImpStl)) {
      LOG_ERROR( s_pLogGen, "Error : CreateImportStl")
      return 0 ;
   }
   // eseguo l'importazione
   if ( pImpStl->Import( LPSTR( WtoA( sFilePath)), s_pGeomDB, nLayerId))
      return 1 ;
   else
      return 0 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtDraw( void)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtDraw)")
      return 0 ;
   }
  // eseguo disegno
   s_pScene->Draw() ;
  // valido la finestra disegnata
   ValidateRgn( s_hWnd, NULL) ;

   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtResize( int nW, int nH)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtResize)")
      return 0 ;
   }

   s_pScene->Resize( nW, nH) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtSetShowMode( int nShowMode)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtSetShowMode)")
      return 0 ;
   }

   if ( nShowMode >= SM_WIREFRAME  &&  nShowMode <= SM_SHADING) {
      s_pScene->SetShowMode( nShowMode) ;
      return 1 ;
   }
   else
      return 0 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtSetShowCurveDirection( int nShow)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtZoom)")
      return 0 ;
   }

   s_pScene->SetShowCurveDirection( nShow != 0) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtZoom( int nZoom)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtZoom)")
      return 0 ;
   }

   const double COEFF_IN = 0.9 ;
   const double COEFF_OUT = 1 / COEFF_IN ;

   switch ( nZoom) {
   case 1 :
      s_pScene->ZoomAll() ;
      return 1 ;
      break ;
   case 2 :
      s_pScene->ZoomChange( COEFF_IN) ;
      return 1 ;
      break ;
   case 3 :
      s_pScene->ZoomChange( COEFF_OUT) ;
      return 1 ;
      break ;
   }

   return 0 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtZoomOnPoint( int nWinX, int nWinY, double dCoeff)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtZoomOnPoint)")
      return 0 ;
   }
  
   s_pScene->ZoomOnPoint( Point3d( nWinX, nWinY), dCoeff) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtSetWinRect( int nPrevX, int nPrevY, int nCurrX, int nCurrY)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtSetWinRect)")
      return 0 ;
   }
  // eseguo panoramica
   s_pScene->SetWinRect( Point3d( nPrevX, nPrevY), Point3d( nCurrX, nCurrY)) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtResetWinRect( void)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtResetWinRect)")
      return 0 ;
   }
  // eseguo panoramica
   s_pScene->ResetWinRect() ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtZoomWin( int nPrevX, int nPrevY, int nCurrX, int nCurrY)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtZoomWin)")
      return 0 ;
   }
  // eseguo panoramica
   s_pScene->ZoomWin( Point3d( nPrevX, nPrevY), Point3d( nCurrX, nCurrY)) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtSetView( int nView)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtSetView)")
      return 0 ;
   }

   if ( nView >= CT_TOP  &&  nView <= CT_ISO_NW) {
      s_pScene->SetCamera( nView) ;
      return 1 ;
   }
   else
      return 0 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtPanCamera( int nPrevX, int nPrevY, int nCurrX, int nCurrY)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtPanCamera)")
      return 0 ;
   }
  // eseguo panoramica
   s_pScene->PanCamera( Point3d( nPrevX, nPrevY), Point3d( nCurrX, nCurrY)) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtRotateCamera( int nPrevX, int nPrevY, int nCurrX, int nCurrY)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtRotateCamera)")
      return 0 ;
   }
  // eseguo panoramica
   s_pScene->RotateCamera( Point3d( nPrevX, nPrevY), Point3d( nCurrX, nCurrY)) ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtGetCameraDir( int* pnDir)
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtGetCameraDir)")
      return 0 ;
   }
  // recupero direzione di vista
   if ( pnDir != nullptr)
      *pnDir = s_pScene->GetCameraDir() ;
   return 1 ;
}

//-----------------------------------------------------------------------------
int
__stdcall EgtUnProject( int nWinX, int nWinY, double ptP[3])
{
  // verifico Scena
   if ( s_pScene == nullptr) {
      LOG_ERROR( s_pLogGen, "Scene invalid (EgtGetCameraDir)")
      return 0 ;
   }
  // eseguo l'inverso della proiezione (considero Z punto su centro)
   Point3d ptView( nWinX, nWinY, s_pScene->GetProjectedCenter().z) ;
   Point3d ptWorld ;
   if ( ! s_pScene->UnProject( ptView, ptWorld))
      return 0 ;
   ptP[0] = ptWorld.x ;
   ptP[1] = ptWorld.y ;
   ptP[2] = ptWorld.z ;
   return 1 ;
}