//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : EGnLuaAux.h       Data : 21.03.15        Versione : 1.6c6
// Contenuto : Funzioni per gestione parametri generali con LUA.
//
//
//
// Modifiche : 21.03.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "/EgtDev/Include/EgtNumCollection.h"
#include "/EgtDev/Extern/Lua/Include/lua.hpp"

//----------------------------------------------------------------------------
#define LuaCheckParam(L,I,P)            { if ( ! LuaGetParam(L,I,P)) \
                                          return luaL_error( L, " Invalid Parameter # " #I) ;}
#define LuaCheckTabFieldParam(L,I,F,P)  { if ( ! LuaGetTabFieldParam(L,I,F,P)) \
                                          return luaL_error( L, " Invalid Parameter # " #I " (field %s)", F) ;}

//----------------------------------------------------------------------------
inline bool
LuaGetParam( lua_State* L, int nInd, bool& bPar)
{
   if ( ! lua_isboolean( L, nInd))
      return false ;
   bPar = ( lua_toboolean( L, nInd) != 0) ;
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaGetParam( lua_State* L, int nInd, int& nPar)
{
   if ( ! lua_isnumber( L, nInd))
      return false ;
   double dVal = lua_tonumber( L, nInd) ;
   nPar = int( dVal + (( dVal > 0) ? 0.5 : - 0.5)) ;
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaGetParam( lua_State* L, int nInd, double& dPar)
{
   if ( ! lua_isnumber( L, nInd))
      return false ;
   dPar = lua_tonumber( L, nInd) ;
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaGetParam( lua_State* L, int nInd, std::string& sPar)
{
   if ( ! lua_isstring( L, nInd))
      return false ;
   sPar = lua_tostring( L, nInd) ;
   return true ;
}

//----------------------------------------------------------------------------
template <size_t size>
bool
LuaGetParam( lua_State* L, int nInd, double (&dVal)[size])
{
   if ( ! lua_istable( L, nInd))
      return false ;
   for ( int i = 1 ; i <= size ; ++ i) {
      lua_rawgeti( L, nInd, i) ;
      if ( ! lua_isnumber( L, -1))
         return false ;
      dVal[i-1] = lua_tonumber( L, -1) ;
      lua_pop( L, 1) ;
   }
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaGetParam( lua_State* L, int nInd, INTVECTOR& vPar)
{
   vPar.clear() ;
   if ( lua_isnumber( L, nInd)) {
      int nVal = int( lua_tointeger( L, nInd)) ;
      vPar.push_back( nVal) ;
      return true ;
   }
   else if ( lua_istable( L, nInd)) {
     // lunghezza della tavola
      lua_len( L, nInd) ;
      if ( ! lua_isnumber( L, -1))
         return false ;
      int nLen = int( lua_tointeger( L, -1)) ;
      lua_pop( L, 1) ;
      vPar.reserve( nLen) ;
      for ( int i = 1 ; i <= nLen ; ++ i) {
         lua_rawgeti( L, nInd, i) ;
         if ( ! lua_isnumber( L, -1))
            return false ;
         int nVal = int( lua_tointeger( L, -1)) ;
         vPar.push_back( nVal) ;
         lua_pop( L, 1) ;
      }
      return true ;
   }
   else
      return false ;
}

//----------------------------------------------------------------------------
inline bool
LuaGetParam( lua_State* L, int nInd, DBLVECTOR& vPar)
{
   vPar.clear() ;
   if ( lua_isnumber( L, nInd)) {
      double dVal = lua_tonumber( L, nInd) ;
      vPar.push_back( dVal) ;
      return true ;
   }
   else if ( lua_istable( L, nInd)) {
     // lunghezza della tavola
      lua_len( L, nInd) ;
      if ( ! lua_isnumber( L, -1))
         return false ;
      int nLen = int( lua_tointeger( L, -1)) ;
      lua_pop( L, 1) ;
      vPar.reserve( nLen) ;
      for ( int i = 1 ; i <= nLen ; ++ i) {
         lua_rawgeti( L, nInd, i) ;
         if ( ! lua_isnumber( L, -1))
            return false ;
         double dVal = lua_tonumber( L, -1) ;
         vPar.push_back( dVal) ;
         lua_pop( L, 1) ;
      }
      return true ;
   }
   else
      return false ;
}

//----------------------------------------------------------------------------
template <class T>
bool
LuaGetTabFieldParam( lua_State* L, int nInd, const char* szField, T& Val)
{
   lua_getfield( L, nInd, szField) ;
   if ( ! LuaGetParam( L, -1, Val))
      return false ;
   lua_pop( L, 1) ;
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaClearStack( lua_State* L)
{
   int n = lua_gettop( L) ;
   if ( n > 0)
      lua_pop( L, n) ;
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaSetReturn( lua_State* L)
{
   try {
      lua_pushnil( L) ;
   }
   catch ( ...) {
      return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaSetReturn( lua_State* L, bool bPar)
{
   try {
      lua_pushboolean( L, ( bPar ? 1 : 0)) ;
   }
   catch ( ...) {
      return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaSetReturn( lua_State* L, int nPar)
{
   try {
      lua_pushinteger( L, nPar) ;
   }
   catch ( ...) {
      return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaSetReturn( lua_State* L, double dPar)
{
   try {
      lua_pushnumber( L, dPar) ;
   }
   catch ( ...) {
      return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaSetReturn( lua_State* L, const std::string& sPar)
{
   try {
      lua_pushstring( L, sPar.c_str()) ;
   }
   catch ( ...) {
      return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
inline bool
LuaSetReturn( lua_State* L, const INTVECTOR& vPar)
{
   try {
      int nSize = int( vPar.size()) ;
      lua_createtable( L, nSize, 0) ;
      for ( int i = 1 ; i <= nSize ; ++ i) {
         lua_pushnumber( L, vPar[i-1]) ;
         lua_rawseti( L, -2, i) ;
      }
   }
   catch( ...) {
      return false ;
   }
   return true ;
}