/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "pyNetClientComm.h"
#include "../pfPython/pyAgeLinkStruct.h"
#include "../pfPython/pyNetServerSessionInfo.h"
#include "../pfPython/pyStatusLog.h"
#include "../plNetCommon/plCreatePlayerFlags.h"
#include "../pnNetCommon/plGenericVar.h"
#include "hsStlUtils.h"
#include "hsTimer.h"

#include <python.h>

////////////////////////////////////////////////////////////////////

class pyNetClientCommCallback : public plNetClientComm::Callback
{
public:
    PyObject * fPyObject;
    pyNetClientCommCallback( PyObject * pyObject )
        : fPyObject( pyObject )
    {
        Py_XINCREF( fPyObject );
    }
    ~pyNetClientCommCallback()
    {
        Py_XDECREF( fPyObject );
    }
    void OperationStarted( UInt32 context )
    {
        if ( fPyObject )
        {
            // Call the callback.
            PyObject* func = PyObject_GetAttrString( fPyObject, "operationStarted" );
            if ( func )
            {
                if ( PyCallable_Check(func)>0 )
                {
                    PyObject* retVal = PyObject_CallMethod(fPyObject, "operationStarted", "l", context);
                    Py_XDECREF(retVal);
                }
            }
        }
    }
    void OperationComplete( UInt32 context, int resultCode )
    {
        if ( fPyObject )
        {
            // Pass args.
            PyObject* pyArgs = PyObject_GetAttrString( fPyObject, "fCbArgs" );
            if ( pyArgs )
            {
                PyObject* pyDict = PyDict_New();
                std::map<UInt16,plCreatable*>   args;
                fCbArgs.GetItems( args );
                for ( std::map<UInt16,plCreatable*>::iterator ii=args.begin(); ii!=args.end(); ++ii )
                {
                    UInt16 key = ii->first;
                    PyObject* keyObj = PyInt_FromLong(key);
                    char* strTemp = NULL;
                    plCreatable* arg = ii->second;
                    plCreatableGenericValue * genValue = plCreatableGenericValue::ConvertNoRef( arg );
                    if ( genValue )
                    {
                        PyObject* valueObj;
                        plGenericType & value = genValue->Value();
                        switch ( value.GetType() )
                        {
                        case plGenericType::kInt:
                            valueObj = PyLong_FromLong((Int32)value);
                            PyDict_SetItem(pyDict, keyObj, valueObj);
                            Py_DECREF(valueObj);
                            break;
                        case plGenericType::kUInt:
                            valueObj = PyLong_FromUnsignedLong((UInt32)value);
                            PyDict_SetItem(pyDict, keyObj, valueObj);
                            Py_DECREF(valueObj);
                            break;
                        case plGenericType::kFloat:
                            valueObj = PyFloat_FromDouble((float)value);
                            PyDict_SetItem(pyDict, keyObj, valueObj);
                            Py_DECREF(valueObj);
                            break;
                        case plGenericType::kDouble:
                            valueObj = PyFloat_FromDouble((double)value);
                            PyDict_SetItem(pyDict, keyObj, valueObj);
                            Py_DECREF(valueObj);
                            break;
                        case plGenericType::kBool:
                            if ((bool)value)
                                valueObj = PyInt_FromLong(1);
                            else
                                valueObj = PyInt_FromLong(0);
                            PyDict_SetItem(pyDict, keyObj, valueObj);
                            Py_DECREF(valueObj);
                            break;
                        case plGenericType::kChar:
                            strTemp = new char[2];
                            strTemp[0] = (char)value;
                            strTemp[1] = 0;
                            valueObj = PyString_FromString(strTemp);
                            PyDict_SetItem(pyDict, keyObj, valueObj);
                            Py_DECREF(valueObj);
                            delete [] strTemp;
                            break;
                        case plGenericType::kString:
                            valueObj = PyString_FromString((const char*)value);
                            PyDict_SetItem(pyDict, keyObj, valueObj);
                            Py_DECREF(valueObj);
                            break;
                        case plGenericType::kAny:
                            break;
                        case plGenericType::kNone:
                            break;
                        }
                    }
                    plNetServerSessionInfo * serverInfo = plNetServerSessionInfo::ConvertNoRef( arg );
                    if ( serverInfo )
                    {
                        PyObject* valueObj = pyNetServerSessionInfo::New(*serverInfo);
                        PyDict_SetItem(pyDict, keyObj, valueObj);
                        Py_DECREF(valueObj);
                    }
                    Py_DECREF(keyObj);
                }
                PyObject_SetAttrString( fPyObject, "fCbArgs", pyDict );
                Py_DECREF(pyDict);
            }

            // Call the callback.
            PyObject* func = PyObject_GetAttrString( fPyObject, "operationComplete" );
            if ( func )
            {
                if ( PyCallable_Check(func)>0 )
                {
                    PyObject* retVal = PyObject_CallMethod(fPyObject, "operationComplete", "li", context, resultCode);
                    Py_XDECREF(retVal);
                }
            }
        }
        delete this;
    }
};

////////////////////////////////////////////////////////////////////

// Error handler - throws exception in python script
class pyNetClientCommErrorHandler : public plNetClientComm::ErrorHandler
{
public:
    void HandleError( Error err, int result )
    {
        std::string msg;
        xtl::format( msg, "pyNetClientComm: Error: %s", plNetClientComm::ErrorHandler::ErrorStr( err ) );
        PyErr_SetString(PyExc_KeyError, msg.c_str());
    }
} ThePyNetClientCommErrorHandler;

////////////////////////////////////////////////////////////////////

// pyNetClientComm ----------------------------------------------
pyNetClientComm::pyNetClientComm()
{
    fNetClient.SetErrorHandler( &ThePyNetClientCommErrorHandler );
}

// ~pyNetClientComm ----------------------------------------------
pyNetClientComm::~pyNetClientComm()
{
}

// NetAuthenticate ----------------------------------------------
int pyNetClientComm::NetAuthenticate( double maxAuthSecs, PyObject* cbClass/*=nil*/, UInt32 cbContext/*=0 */)
{
    return fNetClient.NetAuthenticate( maxAuthSecs, new pyNetClientCommCallback( cbClass ), cbContext );
}

// NetLeave ----------------------------------------------
int pyNetClientComm::NetLeave( UInt8 reason, PyObject* cbClass/*=nil*/, UInt32 cbContext/*=0 */)
{
    return fNetClient.NetLeave( reason, new pyNetClientCommCallback( cbClass ), cbContext );
}

// NetPing ----------------------------------------------
int pyNetClientComm::NetPing( int serverType, int timeoutSecs/*=0*/, PyObject* cbClass/*=nil*/, UInt32 cbContext/*=0 */)
{
    return fNetClient.NetPing( serverType, timeoutSecs, new pyNetClientCommCallback( cbClass ), cbContext );
}

// NetFindAge ----------------------------------------------
int pyNetClientComm::NetFindAge( const pyAgeLinkStruct* linkInfo, PyObject* cbClass/*=nil*/, UInt32 cbContext/*=0 */)
{
    return fNetClient.NetFindAge( linkInfo->GetAgeLink(), new pyNetClientCommCallback( cbClass ), cbContext );
}

// NetGetPlayerList ----------------------------------------------
int pyNetClientComm::NetGetPlayerList( PyObject* cbClass/*=nil*/, UInt32 cbContext/*=0 */)
{
    return fNetClient.NetGetPlayerList( new pyNetClientCommCallback( cbClass ), cbContext );
}

// NetSetActivePlayer ----------------------------------------------
int pyNetClientComm::NetSetActivePlayer( UInt32 playerID, const char* playerName, PyObject* cbClass/*=nil*/, UInt32 cbContext/*=0 */)
{
    return fNetClient.NetSetActivePlayer( playerID, playerName, 0 /*ccrLevel*/, new pyNetClientCommCallback( cbClass ), cbContext );
}

// NetCreatePlayer ----------------------------------------------
int pyNetClientComm::NetCreatePlayer( const char* playerName, const char* avatarShape, UInt32 createFlags, PyObject* cbClass/*=nil*/, UInt32 cbContext/*=0 */)
{
    return fNetClient.NetCreatePlayer( playerName, avatarShape, createFlags, nil, nil, nil, new pyNetClientCommCallback( cbClass ), cbContext );
}

// NetJoinAge ----------------------------------------------
int pyNetClientComm::NetJoinAge( PyObject* cbClass/*=nil*/, UInt32 cbContext/*=0 */)
{
    return fNetClient.NetJoinAge( true /*tryP2P*/, true /*allowTimeout*/, new pyNetClientCommCallback( cbClass ), cbContext );
}

// NetSetTimeout ----------------------------------------------
int pyNetClientComm::NetSetTimeout( float timeoutSecs, PyObject* cbClass/*=nil*/, UInt32 cbContext/*=0 */)
{
    return fNetClient.NetSetTimeout( timeoutSecs, new pyNetClientCommCallback( cbClass ), cbContext );
}

// SetLogLevel ----------------------------------------------
void pyNetClientComm::SetLogLevel( int logLevel )
{
    fNetClient.SetLogLevel( logLevel );
}

// Startup ----------------------------------------------
int pyNetClientComm::Init( bool threaded/*=true */, int logLevel/*=0 */)
{
    return fNetClient.Init( threaded, logLevel );
}

// Shutdown ----------------------------------------------
int pyNetClientComm::Fini( float flushMsgsSecs/*=0.f */)
{
    return fNetClient.Fini( flushMsgsSecs );
}

// Update ----------------------------------------------
int pyNetClientComm::Update()
{
    return fNetClient.Update( hsTimer::GetSeconds() );
}

// SetActiveServer ----------------------------------------------
int pyNetClientComm::SetActiveServer( pyNetServerSessionInfo* nfo )
{
    return fNetClient.SetActiveServer( &nfo->ServerInfo() );
}

// SetActiveServer2 ----------------------------------------------
int pyNetClientComm::SetActiveServer2( const char * addr, int port )
{
    plNetServerSessionInfo nfo;
    nfo.SetServerAddr( addr );
    nfo.SetServerPort( port );
    return fNetClient.SetActiveServer( &nfo );
}


// SetAuthInfo ----------------------------------------------
int pyNetClientComm::SetAuthInfo( const char* acctName, const char* password )
{
    return fNetClient.SetAuthInfo( acctName, password );
}

// SetLogByName ----------------------------------------------
void pyNetClientComm::SetLogByName( const char * name, UInt32 flags )
{
    plStatusLog * log = plStatusLogMgr::GetInstance().CreateStatusLog( 80, name,
        flags | plStatusLog::kTimestamp | plStatusLog::kDeleteForMe );
    fNetClient.SetLog( log );
}

// GetLog ----------------------------------------------
PyObject* pyNetClientComm::GetLog() const
{
    return pyStatusLog::New( fNetClient.GetLog() );
}

// SetServerSilenceTime ----------------------------------------------
void pyNetClientComm::SetServerSilenceTime( float secs )
{
    fNetClient.SetServerSilenceTime( secs );
}

////////////////////////////////////////////////////////////////////
// End.