/*==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 "../FeatureLib/pfPython/pyEnum.h"
#include "../FeatureLib/pfPython/pyNetServerSessionInfo.h"
#include "../FeatureLib/pfPython/pyAgeLinkStruct.h"

#include "../plNetCommon/plCreatePlayerFlags.h"
#include <python.h>

// glue functions
PYTHON_CLASS_DEFINITION(ptNetClientComm, pyNetClientComm);

PYTHON_DEFAULT_NEW_DEFINITION(ptNetClientComm, pyNetClientComm)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptNetClientComm)

PYTHON_INIT_DEFINITION(ptNetClientComm, args, keywords)
{
    PYTHON_RETURN_INIT_OK;
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, initObj, args)
{
    char threaded = 1;
    int logLevel = 0;
    if (!PyArg_ParseTuple(args, "bi", &threaded, &logLevel))
    {
        PyErr_SetString(PyExc_TypeError, "initObj expects a boolean and an int");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->Init(threaded != 0, logLevel));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, fini, args)
{
    float flushMsgsSecs = 0;
    if (!PyArg_ParseTuple(args, "f", &flushMsgsSecs))
    {
        PyErr_SetString(PyExc_TypeError, "fini expects a float");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->Fini(flushMsgsSecs));
}

PYTHON_METHOD_DEFINITION_NOARGS(ptNetClientComm, update)
{
    return PyInt_FromLong(self->fThis->Update());
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, setActiveServer, args)
{
    PyObject* arg1;
    int port = 0;
    if (!PyArg_ParseTuple(args, "O|i", &arg1, &port))
    {
        PyErr_SetString(PyExc_TypeError, "setActiveServer expects a string and an int, or a ptNetServerSessionInfo");
        PYTHON_RETURN_ERROR;
    }
    if (pyNetServerSessionInfo::Check(arg1))
    {
        pyNetServerSessionInfo* info = pyNetServerSessionInfo::ConvertFrom(arg1);
        return PyInt_FromLong(self->fThis->SetActiveServer(info));
    }
    else if (PyString_Check(arg1))
    {
        char* addr = PyString_AsString(arg1);
        return PyInt_FromLong(self->fThis->SetActiveServer2(addr, port));
    }
    PyErr_SetString(PyExc_TypeError, "setActiveServer expects a string and an int, or a ptNetServerSessionInfo");
    PYTHON_RETURN_ERROR;
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, setAuthInfo, args)
{
    char* account;
    char* password;
    if (!PyArg_ParseTuple(args, "ss", &account, &password))
    {
        PyErr_SetString(PyExc_TypeError, "setAuthInfo expects two strings");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->SetAuthInfo(account, password));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, authenticate, args)
{
    double maxAuthSecs;
    PyObject* cb = NULL;
    unsigned long context = 0;
    if (!PyArg_ParseTuple(args, "d|Ol", &maxAuthSecs, &cb, &context))
    {
        PyErr_SetString(PyExc_TypeError, "authenticate expects a double, an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->NetAuthenticate(maxAuthSecs, cb, context));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, getPlayerList, args)
{
    PyObject* cb = NULL;
    unsigned long context = 0;
    if (!PyArg_ParseTuple(args, "|Ol", &cb, &context))
    {
        PyErr_SetString(PyExc_TypeError, "getPlayerList expects an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->NetGetPlayerList(cb, context));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, setActivePlayer, args)
{
    unsigned long playerID;
    char* playerName;
    PyObject* cb = NULL;
    unsigned long context = 0;
    if (!PyArg_ParseTuple(args, "ls|Ol", &playerID, &playerName, &cb, &context))
    {
        PyErr_SetString(PyExc_TypeError, "setActivePlayer expects a double, a string, an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->NetSetActivePlayer(playerID, playerName, cb, context));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, createPlayer, args)
{
    char* playerName;
    char* avatarShape;
    unsigned long createFlags;
    PyObject* cb = NULL;
    unsigned long context = 0;
    if (!PyArg_ParseTuple(args, "ssl|Ol", &playerName, &avatarShape, &createFlags, &cb, &context))
    {
        PyErr_SetString(PyExc_TypeError, "createPlayer expects two strings, a double, an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->NetCreatePlayer(playerName, avatarShape, createFlags, cb, context));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, findAge, args)
{
    PyObject* linkObj = NULL;
    PyObject* cb = NULL;
    unsigned long context = 0;
    if (!PyArg_ParseTuple(args, "O|Ol", &linkObj, &cb, &context))
    {
        PyErr_SetString(PyExc_TypeError, "findAge expects a ptAgeLinkStruct, an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    if (!pyAgeLinkStruct::Check(linkObj))
    {
        PyErr_SetString(PyExc_TypeError, "findAge expects a ptAgeLinkStruct, an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    pyAgeLinkStruct* link = pyAgeLinkStruct::ConvertFrom(linkObj);
    return PyInt_FromLong(self->fThis->NetFindAge(link, cb, context));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, joinAge, args)
{
    PyObject* cb = NULL;
    unsigned long context = 0;
    if (!PyArg_ParseTuple(args, "|Ol", &cb, &context))
    {
        PyErr_SetString(PyExc_TypeError, "joinAge expects an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->NetJoinAge(cb, context));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, leave, args)
{
    unsigned char reason;
    PyObject* cb = NULL;
    unsigned long context = 0;
    if (!PyArg_ParseTuple(args, "b|Ol", &reason, &cb, &context))
    {
        PyErr_SetString(PyExc_TypeError, "leave expects an unsigned 8-bit int, an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->NetLeave(reason, cb, context));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, ping, args)
{
    int serverType;
    int timeoutSecs = 0;
    PyObject* cb = NULL;
    unsigned long context = 0;
    if (!PyArg_ParseTuple(args, "i|iOl", &serverType, &timeoutSecs, &cb, &context))
    {
        PyErr_SetString(PyExc_TypeError, "ping expects an int, and optional int, an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->NetPing(serverType, timeoutSecs, cb, context));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, setTimeout, args)
{
    float timeoutSecs;
    PyObject* cb = NULL;
    unsigned long context = 0;
    if (!PyArg_ParseTuple(args, "f|Ol", &timeoutSecs, &cb, &context))
    {
        PyErr_SetString(PyExc_TypeError, "setTimeout expects a float, an optional object and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->NetSetTimeout(timeoutSecs, cb, context));
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, setLog, args)
{
    char* name;
    unsigned long flags = 0;
    if (!PyArg_ParseTuple(args, "s|l", &name, &flags))
    {
        PyErr_SetString(PyExc_TypeError, "setLog expects a string and an optional unsigned long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetLogByName(name, flags);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptNetClientComm, getLog)
{
    return self->fThis->GetLog();
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, setLogLevel, args)
{
    int level;
    if (!PyArg_ParseTuple(args, "i", &level))
    {
        PyErr_SetString(PyExc_TypeError, "setLogLevel expects an integer");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetLogLevel(level);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptNetClientComm, setServerSilenceTime, args)
{
    float secs;
    if (!PyArg_ParseTuple(args, "f", &secs))
    {
        PyErr_SetString(PyExc_TypeError, "setServerSilenceTime expects a float");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetServerSilenceTime(secs);
    PYTHON_RETURN_NONE;
}

PYTHON_START_METHODS_TABLE(ptNetClientComm)
    PYTHON_METHOD(ptNetClientComm, initObj, "Params: threaded=1,logLevel=0\nInitialize this object"),
    PYTHON_METHOD(ptNetClientComm, fini, "Params: flushMsgsSecs=0\nFinalize this object"),
    PYTHON_METHOD_NOARGS(ptNetClientComm, update, "Update this object"),
    PYTHON_METHOD(ptNetClientComm, setActiveServer, "Params: addr,port\nAlso accepts a ptNetServerSessionInfo instead of address and port"),
    PYTHON_METHOD(ptNetClientComm, setAuthInfo, "Params: accountName,password\nSets the authentication info"),
    PYTHON_METHOD(ptNetClientComm, authenticate, "Params: maxAuthSecs,callback=None,cbContext=0\nAuthenticate with the server"),
    PYTHON_METHOD(ptNetClientComm, getPlayerList, "Params: callback=None,cbContext=0\nGets a list of players and uses the callback"),
    PYTHON_METHOD(ptNetClientComm, setActivePlayer, "Params: playerID,playerName,callback=None,cbContext=0\nSets the current active player"),
    PYTHON_METHOD(ptNetClientComm, createPlayer, "Params: playerName,avatarShape,createFlags,callback=None,cbContext=0\nCreates a new player"),
    PYTHON_METHOD(ptNetClientComm, findAge, "Params: ageLink,callback=None,cbContext=0\nFinds an age based on a ptAgeLinkStruct"),
    PYTHON_METHOD(ptNetClientComm, joinAge, "Params: callback=None,cbContext=0\nUNKNOWN"),
    PYTHON_METHOD(ptNetClientComm, leave, "Params: reason,callback=None,cbContext=0\nLeaves the lobby"),
    PYTHON_METHOD(ptNetClientComm, ping, "Params: serverType,timeoutSecs=0,callback=None,cbContext=0\nPings a server"),
    PYTHON_METHOD(ptNetClientComm, setTimeout, "Params: timeoutSecs,callback=None,cbContext=0\nSets the timeout duration"),
    PYTHON_METHOD(ptNetClientComm, setLog, "Params: name,flags=0\nUNKNOWN"),
    PYTHON_METHOD_NOARGS(ptNetClientComm, getLog, "UNKNOWN"),
    PYTHON_METHOD(ptNetClientComm, setLogLevel, "Params: level\nSets the logging level"),
    PYTHON_METHOD(ptNetClientComm, setServerSilenceTime, "Params: secs\nUNKNOWN"),
PYTHON_END_METHODS_TABLE;

// Type structure definition
PLASMA_DEFAULT_TYPE(ptNetClientComm, "UNKNOWN");

// required functions for PyObject interoperability
PYTHON_CLASS_NEW_IMPL(ptNetClientComm, pyNetClientComm)

PYTHON_CLASS_CHECK_IMPL(ptNetClientComm, pyNetClientComm)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptNetClientComm, pyNetClientComm)

///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyNetClientComm::AddPlasmaClasses(PyObject *m)
{
    PYTHON_CLASS_IMPORT_START(m);
    PYTHON_CLASS_IMPORT(m, ptNetClientComm);
    PYTHON_CLASS_IMPORT_END(m);

    PYTHON_ENUM_START(PtCreatePlayerFlags);
    PYTHON_ENUM_ELEMENT(PtCreatePlayerFlags, kDefaultFlags, plCreatePlayerFlags::kDefaultFlags);
    PYTHON_ENUM_ELEMENT(PtCreatePlayerFlags, kNoNeighborhood, plCreatePlayerFlags::kNoNeighborhood);
    PYTHON_ENUM_ELEMENT(PtCreatePlayerFlags, kNoCityLink, plCreatePlayerFlags::kNoCityLink);
    PYTHON_ENUM_END(m, PtCreatePlayerFlags);
}