/*==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 "HeadSpin.h"
#include "plPythonMgr.h"

#include "../MaxComponent/plAutoUIBlock.h"
//#include "Python.h"
#include "plMaxCFGFile.h"
#include "../plFile/hsFiles.h"

#include "plgDispatch.h"
#include "../pfPython/cyPythonInterface.h"
#include "hsUtils.h"

plPythonMgr::plPythonMgr()
{
}

plPythonMgr& plPythonMgr::Instance()
{
    static plPythonMgr theInstance;
    return theInstance;
}

// Python wants char, not const char, LAME!
static char* kGetBlockID = "glue_getBlockID";
static char* kGetClassName = "glue_getClassName";
static char* kGetNumParams = "glue_getNumParams";
static char* kGetParam = "glue_getParam";
static char* kGetVersion = "glue_getVersion";
static char* kIsMultiModifier = "glue_isMultiModifier";
static char* kGetVisInfo = "glue_getVisInfo";

bool ICallVoidFunc(PyObject *dict, char *funcName, PyObject*& val)
{
    PyObject *func = PyDict_GetItemString(dict, (char*)funcName);
    if (func )
    {
        if (PyCallable_Check(func))
        {
            val = PyObject_CallFunction(func, NULL);
            if (val)
            {
                // there might have been some message printed, so get it out to the log file
                PythonInterface::getOutputAndReset();
                return true;
            }

            // There was an error when calling the function
            // get the error message
            PyErr_Print();
            PyErr_Clear();
            PythonInterface::getOutputAndReset();
        }
    }

    return false;
}

bool ICallIntFunc(PyObject *dict, char *funcName, int& val)
{
    PyObject *obj;
    if (ICallVoidFunc(dict, funcName, obj))
    {
        if (PyInt_Check(obj))
        {
            val = PyInt_AsLong(obj);
            Py_DECREF(obj);
            return true;
        }
    }
    return false;
}

bool ICallStrFunc(PyObject *dict, char *funcName, char*& val)
{
    PyObject *obj;
    if (ICallVoidFunc(dict, funcName, obj))
    {
        if (PyString_Check(obj))
        {
            val = hsStrcpy(PyString_AsString(obj));
            Py_DECREF(obj);
            return true;
        }
    }

    return false;
}


#include "../MaxComponent/plPythonFileComponent.h"
#include "hsUtils.h"

enum ParamTypes
{
                            // These numbers used in the python/plasma/glue.py code
    kTypeUndefined,         //  0
    kTypeBool,              //  1
    kTypeInt,               //  2
    kTypeFloat,             //  3
    kTypeString,            //  4
    kTypeSceneObj,          //  5
    kTypeSceneObjList,      //  6
    kTypeActivatorList,     //  7
    kTypeActivator,         //  8
    kTypeResponder,         //  9
    kTypeResponderList,     // 10
    kTypeDynamicText,       // 11
    kTypeGUIDialog,         // 12
    kTypeExcludeRegion,     // 13 (x-rude-oh legion-oh)
    kTypeAnimation,         // 14 (animation component)
    kTypeAvatarBehavior,    // 15 (avatar behaviors, such as one-shots or multistage behaviors)
    kTypeMaterial,          // 16 (material type)
    kTypeGUIPopUpMenu,      // 17 (GUI pop up menu)
    kTypeGUISkin,           // 18 (Guess)
    kTypeWaterComponent,    // 19
    kTypeDropDownList,      // 20
    kTypeSwimCurrentInterface,  // 21
    kTypeClusterComponent,  // 22
    kTypeMaterialAnimation, // 23
    kTypeGrassComponent, // 24
};

bool IGetTupleInt(PyObject *tuple, int pos, int& val)
{
    PyObject *param = PyTuple_GetItem(tuple, pos);
    if (param && PyInt_Check(param))
    {
        val = PyInt_AsLong(param);
        return true;
    }

    return false;
}

bool IGetTupleFloat(PyObject *tuple, int pos, float& val)
{
    PyObject *param = PyTuple_GetItem(tuple, pos);
    if (param && PyFloat_Check(param))
    {
        val = (float)PyFloat_AsDouble(param);
        return true;
    }

    return false;
}

bool IGetTupleString(PyObject *tuple, int pos, char*& val)
{
    PyObject *param = PyTuple_GetItem(tuple, pos);
    if (param && PyString_Check(param))
    {
        val = PyString_AsString(param);
        return true;
    }

    return false;
}

void IExtractVisInfo(PyObject* tuple, int* id, std::vector<std::string>* vec)
{
    PyObject* vid = PyTuple_GetItem(tuple, 0);
    PyObject* vstates = PyTuple_GetItem(tuple, 1);

    if (vid && PyInt_Check(vid))
    {
        *id = PyInt_AsLong(vid);
    }

    if (vstates && PyList_Check(vstates))
    {
        PyObject* element;
        int lsize = PyList_Size(vstates);

        for (int i = 0; i < lsize; i++)
        {
            element = PyList_GetItem(vstates, i);
            if (element && PyString_Check(element))
            {
                std::string str = PyString_AsString(element);
                vec->push_back(str);
            }
        }
    }
}

bool plPythonMgr::IQueryPythonFile(char *fileName)
{
    PyObject *module = PyImport_ImportModule(fileName);
    if (module)
    {
        // attach the glue python code to the end
        if ( !PythonInterface::RunString("execfile('.\\python\\plasma\\glue.py')", module) )
        {
            // display any output (NOTE: this would be disabled in production)
            // get the messages
            PythonInterface::getOutputAndReset();
            return false;           // if we can't create the instance then there is nothing to do here
        }
        // Get the dictionary for this module
        PyObject *dict = PyModule_GetDict(module);
        // set the name of the file for the glue.py code to find
        PyObject* pfilename = PyString_FromString(fileName);
        PyDict_SetItemString(dict, "glue_name", pfilename);

        // Get the block ID
        int blockID = 0;
        if (!ICallIntFunc(dict, kGetBlockID, blockID))
        {
            Py_DECREF(module);
            return false;
        }

        // Get the class name
        char *className = nil;
        if (!ICallStrFunc(dict, kGetClassName, className))
        {
            Py_DECREF(module);
            return false;
        }

        // Get the number of parameters
        int numParams = 0;
        if (!ICallIntFunc(dict, kGetNumParams, numParams))
        {
            Py_DECREF(module);
            return false;
        }

        // determine if this is a multimodifier
        int isMulti = 0;
        ICallIntFunc(dict, kIsMultiModifier, isMulti);

        // Get the version 
        //======================
        //  Get version must be the last call that needs a pythonfile class instance
        //  ... because it delete the instance afterwards
        //  NOTE: get attribute params doesn't need the pythonfile class instance
        int version = 0;
        if (!ICallIntFunc(dict, kGetVersion, version))
        {
            Py_DECREF(module);
            return false;
        }

        PyObject *getParamFunc = PyDict_GetItemString(dict, kGetParam);
        PyObject *getVisInfoFunc = PyDict_GetItemString(dict, kGetVisInfo);

        if (PyCallable_Check(getParamFunc))
        {
            plAutoUIBlock *autoUI = TRACKED_NEW plAutoUIBlock(PythonFile::GetClassDesc(), blockID, className, version);
            // test to see if it is a multi-modifier type class
            if (isMulti)
                autoUI->SetMultiModifierFlag(true);

            for (int i = numParams-1; i >= 0; i--)
            {
                PyObject *ret = PyObject_CallFunction(getParamFunc, "l", i);
                
                PyObject *visinfo = nil;
                int ddlParamID = -1;
                std::vector<std::string> vec;

                if (PyCallable_Check(getVisInfoFunc))
                {
                    visinfo = PyObject_CallFunction(getVisInfoFunc, "l", i);
                    if (visinfo && PyTuple_Check(visinfo))
                    {
                        IExtractVisInfo(visinfo, &ddlParamID, &vec);
                    }
                }

                if (ret)
                {
                    if (PyTuple_Check(ret))
                    {
                        int paramID = -1;
                        char *paramName = nil;
                        int paramType = kTypeUndefined;

                        // Get the param ID, name, and type
                        if (IGetTupleInt(ret, 0, paramID) &&
                            IGetTupleString(ret, 1, paramName) &&
                            IGetTupleInt(ret, 2, paramType))
                        {
                            // Get the type specific params and add the param to the AutoUI block
                            switch (paramType)
                            {
                            case kTypeInt:
                                IAddInt(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeFloat:
                                IAddFloat(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeString:
                                IAddString(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeBool:
                                IAddBool(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeSceneObj:
                                IAddSceneObj(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeSceneObjList:
                                IAddSceneObjList(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeActivator:
                                IAddActivator(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeActivatorList:
                                IAddActivatorList(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeResponder:
                                IAddResponder(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeResponderList:
                                IAddResponderList(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeDynamicText:
                                IAddDynamicText(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeGUIDialog:
                                IAddGUIDialog(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeExcludeRegion:
                                IAddExcludeRegion(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeAnimation:
                                IAddAnimation(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeAvatarBehavior:
                                IAddBehavior(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeMaterial:
                                IAddMaterial(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeGUIPopUpMenu:
                                IAddGUIPopUpMenu(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;

                            case kTypeGUISkin:
                                IAddGUISkin(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;
                            case kTypeWaterComponent:
                                IAddWaterComponent(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;
                            case kTypeSwimCurrentInterface:
                                IAddSwimCurrentInterface(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;
                            case kTypeDropDownList:
                                IAddDropDownList(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;
                            case kTypeClusterComponent:
                                IAddClusterComponent(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;
                            case kTypeMaterialAnimation:
                                IAddMaterialAnimation(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;
                            case kTypeGrassComponent:
                                IAddGrassComponent(autoUI, ret, paramName, paramID, ddlParamID, &vec);
                                break;
                            }
                        }
                    }

                    Py_DECREF(ret);
                }
            }

            PythonFile::AddAutoUIBlock(autoUI);
        }

        delete [] className;
        Py_DECREF(module);
    }
    else
    {
        // There was an error when importing the module
        // get the error message and put it in the log
        PyErr_Print();
        PyErr_Clear();
        PythonInterface::getOutputAndReset();
    }


    return false;
}

void plPythonMgr::IAddBool(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    hsBool def = false;
    IGetTupleInt(tuple, 3, def);

    autoUI->AddCheckBox(id, nil, paramName, vid, vstates, def);
}

void plPythonMgr::IAddInt(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    int def=0, min=0, max=100;

    IGetTupleInt(tuple, 3, def);

    PyObject *range = PyTuple_GetItem(tuple, 4);
    if (range && PyTuple_Check(range))
    {
        IGetTupleInt(range, 0, min);
        IGetTupleInt(range, 1, max);
    }

    autoUI->AddIntSpinner(id, nil, paramName, vid, vstates, def, min, max);
}

void plPythonMgr::IAddFloat(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    float def=0, min=0, max=1;

    IGetTupleFloat(tuple, 3, def);

    PyObject *range = PyTuple_GetItem(tuple, 4);
    if (range && PyTuple_Check(range))
    {
        IGetTupleFloat(range, 0, min);
        IGetTupleFloat(range, 1, max);
    }

    autoUI->AddFloatSpinner(id, nil, paramName, vid, vstates, def, min, max);
}

void plPythonMgr::IAddString(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    char *def = nil;
    IGetTupleString(tuple, 3, def);

    autoUI->AddEditBox(id, nil, paramName, vid, vstates, def);
}

void plPythonMgr::IAddSceneObj(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickNodeButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddSceneObjList(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickNodeList(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddActivator(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickActivatorButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddActivatorList(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickActivatorList(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddDynamicText(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickDynamicTextButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddGUIDialog(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickGUIDialogButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddExcludeRegion(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickExcludeRegionButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddWaterComponent(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickWaterComponentButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddSwimCurrentInterface(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickSwimCurrentInterfaceButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddClusterComponent(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickClusterComponentButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddAnimation(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickAnimationButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddBehavior(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickBehaviorButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddMaterial(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickMaterialButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddGUIPopUpMenu(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickGUIPopUpMenuButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddGUISkin(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickGUISkinButton(id, nil, paramName, vid, vstates);
}

#include "../MaxComponent/plResponderComponent.h"

void plPythonMgr::IAddResponder(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    std::vector<Class_ID> cids;
    cids.push_back(RESPONDER_CID);
    
    autoUI->AddPickComponentButton(id, nil, paramName, vid, vstates, &cids, true);
}

void plPythonMgr::IAddResponderList(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    std::vector<Class_ID> cids;
    cids.push_back(RESPONDER_CID);
    
    autoUI->AddPickComponentList(id, nil, paramName, vid, vstates, &cids);
}

void plPythonMgr::IAddMaterialAnimation(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickMaterialAnimationButton(id, nil, paramName, vid, vstates);
}

void plPythonMgr::IAddGrassComponent(plAutoUIBlock *autoUI, PyObject *objTuple, std::string paramName, int id, int vid, std::vector<std::string>* vstates)
{
    autoUI->AddPickGrassComponentButton(id, nil, paramName.c_str(), vid, vstates);
}

#include <direct.h>

void plPythonMgr::LoadPythonFiles()
{
    const char *clientPath = plMaxConfig::GetClientPath(false, true);
    if (clientPath)
    {
        char oldCwd[MAX_PATH];
        _getcwd(oldCwd, sizeof(oldCwd));
        _chdir(clientPath);

        // Get the path to the Python subdirectory of the client
        char pythonPath[MAX_PATH];
        strcpy(pythonPath, clientPath);
        strcat(pythonPath, "Python");

        PythonInterface::initPython();

        // Iterate through all the Python files in the folder
        hsFolderIterator folder(pythonPath);
        while (folder.NextFileSuffix(".py"))
        {
            // Get the filename without the ".py" (module name)
            const char *fullFileName = folder.GetFileName();
            char fileName[_MAX_FNAME];
            _splitpath(fullFileName, NULL, NULL, fileName, NULL);

            IQueryPythonFile(fileName);
        }

        PythonInterface::finiPython();

        _chdir(oldCwd);
    }
}

void plPythonMgr::IAddDropDownList(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates)
{
    PyObject *options = PyTuple_GetItem(tuple, 3);
    if (options && PyTuple_Check(options))
    {
        int size = PyTuple_Size(options);
        char* opt = nil;
        std::vector<std::string> optionsVec;

        for (int i = 0; i < size; i++)
        {
            IGetTupleString(options, i, opt);
            std::string str = opt;
            optionsVec.push_back(str);
        }

        autoUI->AddDropDownList(id, nil, paramName, vid, vstates, &optionsVec);
    }
}