//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : LUA_General.cpp       Data : 27.09.14        Versione : 1.5i5
// Contenuto : Funzioni generali per LUA.
//
//
//
// Modifiche : 27.09.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "EXE.h"
#include "LUA.h"
#include "/EgtDev/Include/ExeExecutor.h"
#include "/EgtDev/Include/EGkLuaAux.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EGnFileUtils.h"
#include "/EgtDev/Include/EGnFileCompare.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#include "/EgtDev/Include/EgtStringConverter.h"

using namespace std ;

//----------------------------------------------------------------------------
static PerformanceCounter s_Counter ;

//-------------------------------------------------------------------------------
static int
MyPrint( lua_State* L)
{
   string sOut ;
   int n = lua_gettop( L) ;  /* number of arguments */
   lua_getglobal( L, "tostring") ;
   for ( int i = 1 ; i <= n ; ++ i) {
      const char* s ;
      lua_pushvalue( L, -1) ;  /* function to be called */
      lua_pushvalue( L, i) ;   /* value to print */
      lua_call( L, 1, 1) ;
      s = lua_tostring( L, -1) ;  /* get result */
      if ( s == nullptr)
         return luaL_error( L,
                            LUA_QL("tostring") " must return a string to " LUA_QL("print")) ;
      if ( i > 1)
         sOut += "\t" ;
      sOut += s ;
      lua_pop( L, 1) ;  /* pop result */
   }
   if ( ! sOut.empty())
      LOG_INFO( GetLogger(), sOut.c_str())

   return 0 ; 
}

//-------------------------------------------------------------------------------
static int
SetContext( lua_State* L)
{
  // un solo parametro intero
   int nGseCtx ;
   LuaCheckParam( L, 1, nGseCtx)
   LuaClearStack( L) ;
  // imposto il contesto
   bool bOk = SetCurrGseContext( nGseCtx) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
GetContext( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // restituisco l'indice del contesto
   LuaSetReturn( L, GetIndCurrGseContext()) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaPause( lua_State* L)
{
  // 1 parametro : numero di millisecondi
   int nTime ;
   LuaCheckParam( L, 1, nTime)
   LuaClearStack( L) ;
  // controllo la durata della pausa e la eseguo
   const int MIN_TIME = 0 ;
   const int MAX_TIME = 10000 ;
   if ( nTime < MIN_TIME)
      nTime = MIN_TIME ;
   else if ( nTime > MAX_TIME)
      nTime = MAX_TIME ;
   Sleep( nTime) ;
  // restituisco il risultato
   LuaSetReturn( L, true) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaStartCounter( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // avvio il contatore
   s_Counter.Start() ;
   return 0 ;
}

//-------------------------------------------------------------------------------
static int
LuaStopCounter( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // fermo il contatore
   double dTime = s_Counter.Stop() ;
  // restituisco il risultato
   LuaSetReturn( L, dTime) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaNumToString( lua_State* L)
{
  // 2 parametri : dVal, nDec
   double dVal ;
   LuaCheckParam( L, 1, dVal)
   int nDec ;
   LuaCheckParam( L, 2, nDec)
   LuaClearStack( L) ;
  // costruisco la stringa
   string sVal = ToString( dVal, nDec) ;
  // ritorno il risultato
   LuaSetReturn( L, sVal) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaExecTsc( lua_State* L)
{
  // 1 parametro : file
   string sFile ;
   LuaCheckParam( L, 1, sFile)
   LuaClearStack( L) ;
  // eseguo lo script TSC
   bool bOk = ExeTscExecFile( sFile) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOutLog( lua_State* L)
{
  // 1 parametro : stringa da emettere
   string sOut ;
   LuaCheckParam( L, 1, sOut)
   LuaClearStack( L) ;
  // accodo il messaggio nel file di log
   LOG_INFO( GetLogger(), sOut.c_str())
  // non c'è risultato
   return 0 ;
}

//-------------------------------------------------------------------------------
static int
LuaOutBox( lua_State* L)
{
  // 3 o 4 parametri : stringa, titolo, icona [bModal]
   string sOut ;
   LuaCheckParam( L, 1, sOut)
   string sTitle ;
   LuaCheckParam( L, 2, sTitle)
   string sIcon ;
   LuaCheckParam( L, 3, sIcon)
   int nIcon = MB_ICONINFORMATION ;
   ToUpper( sIcon) ;
   if ( sIcon == "ERROR")
      nIcon = MB_ICONERROR ;
   else if ( sIcon == "WARNING")
      nIcon = MB_ICONWARNING ;
   bool bModal = true ;
   LuaGetParam( L, 4, bModal) ;
   LuaClearStack( L) ;
  // emetto la finestra di dialogo
   int nRes = MessageBox( nullptr, stringtoW( sOut), stringtoW( sTitle),
                          MB_OKCANCEL | nIcon | ( bModal ? MB_TASKMODAL : MB_SYSTEMMODAL)) ;
  // risultato (Ok->true, Cancel->false)
   LuaSetReturn( L, ( nRes == IDOK)) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaEraseFile( lua_State* L)
{
  // 1 parametro : file
   string sFile ;
   LuaCheckParam( L, 1, sFile)
   LuaClearStack( L) ;
  // svuoto il direttorio
   bool bOk = EraseFile( sFile) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaEmptyDirectory( lua_State* L)
{
  // 1 parametro : dir
   string sDir ;
   LuaCheckParam( L, 1, sDir)
   LuaClearStack( L) ;
  // svuoto il direttorio
   bool bOk = EmptyDirectory( sDir) ;
  // restituisco il risultato
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTextFileCompare( lua_State* L)
{
  // 4 parametri : file1, file2, inizio commento, file diff
   string sFile1 ;
   LuaCheckParam( L, 1, sFile1)
   string sFile2 ;
   LuaCheckParam( L, 2, sFile2)
   string sRemStart ;
   LuaCheckParam( L, 3, sRemStart)
   string sFileDiff ;
   LuaCheckParam( L, 4, sFileDiff)
   LuaClearStack( L) ;
  // eseguo il confronto
   bool bOk = TextFileCompare( sFile1, sFile2, sRemStart, sFileDiff) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaBinaryFileCompare( lua_State* L)
{
  // 3 parametri : file1, file2, file diff
   string sFile1 ;
   LuaCheckParam( L, 1, sFile1)
   string sFile2 ;
   LuaCheckParam( L, 2, sFile2)
   string sFileDiff ;
   LuaCheckParam( L, 3, sFileDiff)
   LuaClearStack( L) ;
  // eseguo il confronto
   bool bOk = BinaryFileCompare( sFile1, sFile2, sFileDiff) ;
   LuaSetReturn( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetVersion( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // costruisco la stringa con le versioni
   string sVer ;
   if ( ! ExeGetVersionInfo( sVer, "\n"))
      sVer = "VersionInfo error" ;
  // restituisco il risultato
   LuaSetReturn( L, sVer) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaIs64bit( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // restituisco il risultato
#if defined( _WIN64)
   bool bRes = true ;
#elif defined( _WIN32)
   bool bRes = false ;
#endif    
   LuaSetReturn( L, bRes) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGeneral( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "print", MyPrint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetContext", SetContext) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetContext", GetContext) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPause", LuaPause) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtStartCounter", LuaStartCounter) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtStopCounter", LuaStopCounter) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtNumToString", LuaNumToString) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExecTsc", LuaExecTsc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOutLog", LuaOutLog) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOutBox", LuaOutBox) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEraseFile", LuaEraseFile) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEmptyDirectory", LuaEmptyDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTextFileCompare", LuaTextFileCompare) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBinaryFileCompare", LuaBinaryFileCompare) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetVersion", LuaGetVersion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtIs64bit", LuaIs64bit) ;
   return bOk ;
}