//****************************************************************************//
// FILENAME:    MY_PY.CPP                                                     //
//                                                                            //
// DESCRIPTION:                                                               //
//                                                                            //
// DATE:                                                                      //
//****************************************************************************//
#include <python.h>
#include <Forms.hpp>
#include "my_py.h"
#include "xylogger.h"
#include "XMLDataLogger.h"

#define INFO 2

//****************************************************************************//
// EXTERNAL GLOBAL VARIABLES
//****************************************************************************//
extern Xy_XML_Data_Logger* pXMLLogger;

//****************************************************************************//
// GLOBAL VARIABLES
//****************************************************************************//
INIT            DLL_Py_Initialize;
VERSION         DLL_Py_GetVersion;
STR_STR         DLL_PyString_FromString;
IMPORT_IMPORT   DLL_PyImport_Import;
MODULE_DICT     DLL_PyModule_GetDict;
ITEM_STR        DLL_PyDict_GetItemString;
CALLABLE_CHK    DLL_PyCallable_Check;
TURPLE_NEW      DLL_PyTuple_New;
INT_FRM_LONG    DLL_PyInt_FromLong;
ERR_PRINT       DLL_PyErr_Print;
TUPLE_ITEM      DLL_PyTuple_SetItem;
OBJ_OBJ         DLL_PyObject_CallObject;
INT_AS_LONG     DLL_PyInt_AsLong;
PARSE_TUPLE     DLL_PyArg_ParseTuple;
RUN_SIMPLE_STR  DLL_PyRun_SimpleString;
INIT_MODULE_PY  DLL_Py_InitModule;
DECREF_PY       DLL_Py_DECREF;
INCREF_PY       DLL_Py_INCREF;
FINALIZE        DLL_Py_Finalize;
NONE_PY         DLL_Py_None;
BUILD_VALUE     DLL_Py_BuildValue;

HINSTANCE dllhandle;

PyObject *pName, *pModule, *pDict, *pFunc, *pArgs, *pValue;

//****************************************************************************//
// LOCAL GLOBAL VARIABLES
//****************************************************************************//
static PyMethodDef logMethods[] =
{
    {   "CaptureStdout",            log_CaptureStdout,              METH_VARARGS,   "Logs stdout"                   },
    {   "CaptureStderr",            log_CaptureStderr,              METH_VARARGS,   "Logs stderr"                   },
    {   "CaptureStdin",             log_CaptureStdin,               METH_VARARGS,   "Logs stdin"                    },

    {   "UDP_Enable",               log_UDP_Enable,                 METH_VARARGS,   "Logs UDP_Enable"               },
    {   "UDP_Disable",              log_UDP_Disable,                METH_VARARGS,   "Logs UDP_Disable"              },
    {   "Sockets_Enable",           log_Sockets_Enable,             METH_VARARGS,   "Logs Sockets_Enable"           },
    {   "Sockets_Disable",          log_Sockets_Disable,            METH_VARARGS,   "Logs Sockets_Disable"          },
    {   "InterProcessComms",        log_InterProcessComms,          METH_VARARGS,   "Logs InterProcessComms"        },
    {   "TurnOnOffXyratexLogger",   log_TurnOnOffXyratexLogger,     METH_VARARGS,   "Logs TurnOnOffXyratexLogger"   },
    {   "Version",                  log_Version,                    METH_VARARGS,   "Logs Version"                  },
    {   "AbortXMLLog",              log_AbortXMLLog,                METH_VARARGS,   "Logs AbortXMLLog"              },

    {   "WriteXMLLogtoLocation",    log_WriteXMLLogtoLocation,      METH_VARARGS,   "Logs WriteXMLLogtoLocation,"   },
    {   "WriteHeaderStructure",     log_WriteHeaderStructure,       METH_VARARGS,   "Logs WriteHeaderStructure"     },
    {   "GetXMLLogLocation",        log_GetXMLLogLocation,          METH_VARARGS,   "Logs GetXMLLogLocation"        },

    {   "WriteTestHeader",          log_WriteTestHeader,            METH_VARARGS,   "Logs WriteTestHeader"          },
    {   "WriteTestReport",          log_WriteTestReport,            METH_VARARGS,   "Logs WriteTestReport"          },
    {   "WriteFinalTestReport",     log_WriteFinalTestReport,       METH_VARARGS,   "Logs WriteFinalTestReport"     },
    {   "WriteAnalogueMeasurement", log_WriteAnalogueMeasurement,   METH_VARARGS,   "Logs WriteAnalogueMeasurement" },

    {   "WriteDigitalMeasurement",  log_WriteDigitalMeasurement,    METH_VARARGS,   "Logs WriteDigitalMeasurement"  },

    {   "WriteDebugRecord",         log_WriteDebugRecord,           METH_VARARGS,   "Logs WriteDebugRecord"         },
    {   "WriteToXyLoggerOnly",      log_WriteToXyLoggerOnly,        METH_VARARGS,   "Logs WriteToXyLoggerOnly"      },
    {   "WriteTraceData",           log_WriteTraceData,             METH_VARARGS,   "Logs WriteTraceData"           },
    {   "WriteTableRecordHeader",   log_WriteTableRecordHeader,     METH_VARARGS,   "Logs WriteTableRecordHeader"   },


    {   "WriteTableRow",            log_WriteTableRow,              METH_VARARGS,   "Logs WriteTableRow"            },
    {   "EndTableRecord",           log_EndTableRecord,             METH_VARARGS,   "Logs EndTableRecord"           },
    {   "WriteNonStandardRecord",   log_WriteNonStandardRecord,     METH_VARARGS,   "Logs WriteNonStandardRecord"   },

    {   NULL,                       NULL,                           0,              NULL                            }
};

static int (*GUI_LOG)(int, char *Text,...) = NULL;
static char* argv[8] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
const int PY_NUM_ARGS = 8;



PyMODINIT_FUNC initlog(void)
{
    if (DLL_Py_InitModule("log", logMethods,NULL, NULL, PYTHON_API_VERSION) == NULL)
    {
        //xyLog(SEV_INFO,"FAIL Py_InitModule()");
        return;
    }

    pXMLLogger = new Xy_XML_Data_Logger;
    return;
}



//****************************************************************************//
// Function Name:   py_main()
// Paramater:       void
// Return Value:    int
//
// Description:
//****************************************************************************//
int py_main(    char* PyEnv,
                char* PyModule,
                char* PyFn,
                int (*pt2OutFunction)(int, char *Text,...),
                char *PartNumber,
                char *SerialNumber,
                char *Concessions,
                char *TestCode,
                char *Operator,
                char *TestRigBarcode,
                char *LogFilePath,
                char *LogFileName )
{
    argv[0] = PartNumber;
    argv[1] = SerialNumber;
    argv[2] = Concessions;
    argv[3] = TestCode;
    argv[4] = Operator;
    argv[5] = TestRigBarcode;
    argv[6] = LogFilePath;
    argv[7] = LogFilePath;

    if(pt2OutFunction == NULL)
		return 1;

    GUI_LOG = pt2OutFunction;

    // Print Params    pipe
    //GUI_LOG(INFO,"PyEnv[%s] PyMod[%s] PyFn[%s]\n", PyEnv, PyModule, PyFn);
    //GUI_LOG(INFO,"Barcode[%s] Serial No.[%d]\n",Barcode, SubParts);
    //GUI_LOG(INFO,"Test Code[%s] Operator[%s]\n",TestCode, Operator);
    //GUI_LOG(INFO,"Log File Path[%s] Lof File Name[%s]\n", LogFilePath, LogFileName);
    
    /* Load the Test library dll*/
    dllhandle = LoadLibrary("python26.dll");

    if (dllhandle != NULL)
    {
        // Load Python functions
        LoadPyFunctions();

        // Init
        DLL_Py_Initialize();

        PyObject *m;
        m = DLL_Py_InitModule("log", logMethods, NULL, NULL, PYTHON_API_VERSION);
        if (m == NULL)
        {
            GUI_LOG(INFO,"FAIL DLL_Py_InitModule()");
        }
        DLL_PyRun_SimpleString( //"import cmath\n"	// TRIED HERE!!! 'import cmath'
								"import log\n"
                                "import sys\n"
                                "class StdoutCatcher:\n"
                                "\tdef write(self, str):\n"
                                "\t\tlog.CaptureStdout(str)\n"
                                "class StderrCatcher:\n"
                                "\tdef write(self, str):\n"
                                "\t\tlog.CaptureStderr(str)\n"
                                "sys.stdout = StdoutCatcher()\n"
                                "sys.stderr = StderrCatcher()\n");

        // Version
        //GUI_LOG(INFO,"Python Version %s\n",DLL_Py_GetVersion()); //get the dll version but only if it loads ok else we crash!

        // Build the name object
        pName = DLL_PyString_FromString(PyModule);

        // Load the module object
        pModule = DLL_PyImport_Import(pName);

        // pDict is a borrowed reference
        pDict = DLL_PyModule_GetDict(pModule);

        // pFunc is also a borrowed reference
        pFunc = DLL_PyDict_GetItemString(pDict, PyFn);

        if (DLL_PyCallable_Check(pFunc))
        {
            // Prepare the argument list for the call
            pArgs = DLL_PyTuple_New(PY_NUM_ARGS);
            for (int i = 0; i < PY_NUM_ARGS; i++)
            {
                pValue = DLL_PyString_FromString(argv[i]);
                if (!pValue)
                {
                    DLL_PyErr_Print();
                    return 1;
                }
                DLL_PyTuple_SetItem(pArgs, i, pValue);
            }
            pValue = DLL_PyObject_CallObject(pFunc, pArgs);	// CALLED HERE!!! python scripted containing 'import cmath'

            if (pArgs != NULL)
            {
                DLL_Py_DECREF(pArgs);
            }

            if (pValue != NULL)
            {
                GUI_LOG(INFO,"Return of call : %d\n", DLL_PyInt_AsLong(pValue));
                DLL_Py_DECREF(pValue);
            }
            else
            {
                DLL_PyErr_Print();
                GUI_LOG(INFO,"Error in call\n");
            }
        }
        else
        {
            DLL_PyErr_Print();
            GUI_LOG(INFO,"Error in call\n");
        }
        // Clean up
        DLL_Py_DECREF(pModule);
        DLL_Py_DECREF(pName);

        // Finish the Python Interpreter
        //DLL_Py_Finalize();
    }
    else
    {
        GUI_LOG(INFO,"Failed to launch test dll (python26)\nMissing file?\n");
    }
    return 0;
}
//****************************************************************************//
// Function Name:   LoadPyFunctions()
// Paramater:       void
// Return Value:    void
//
// Description:
//****************************************************************************//
void LoadPyFunctions(void)
{
    // Get Initialize fn
    DLL_Py_Initialize = (INIT) GetProcAddress(dllhandle, "Py_Initialize"); //borland
    if(DLL_Py_Initialize == NULL)
        GUI_LOG(INFO,"Get DLL_Py_Initialize Failed!\n");
    // Get Version fn
    DLL_Py_GetVersion = (VERSION) GetProcAddress(dllhandle, "Py_GetVersion"); //borland
    if(DLL_Py_GetVersion == NULL)
        GUI_LOG(INFO,"Get DLL_Py_GetVersion Failed!\n");
    // Get StrFromStr fn
    DLL_PyString_FromString = (STR_STR) GetProcAddress(dllhandle, "PyString_FromString"); //borland
    if(DLL_PyString_FromString == NULL)
        GUI_LOG(INFO,"Get PyString_FromString Failed!\n");
    // Get PyImport_Import fn
    DLL_PyImport_Import = (IMPORT_IMPORT) GetProcAddress(dllhandle, "PyImport_Import"); //borland
    if(DLL_PyImport_Import == NULL)
        GUI_LOG(INFO,"Get PyImport_Import Failed!\n");
    // Get PyModule_GetDict fn
    DLL_PyModule_GetDict = (MODULE_DICT) GetProcAddress(dllhandle, "PyModule_GetDict"); //borland
    if(DLL_PyModule_GetDict == NULL)
        GUI_LOG(INFO,"Get PyModule_GetDict Failed!\n");
    // Get PyDict_GetItemString fn
    DLL_PyDict_GetItemString = (ITEM_STR) GetProcAddress(dllhandle, "PyDict_GetItemString"); //borland
    if(DLL_PyDict_GetItemString == NULL)
        GUI_LOG(INFO,"Get PyDict_GetItemString Failed!\n");
    // Get PyCallable_Check fn
    DLL_PyCallable_Check = (CALLABLE_CHK) GetProcAddress(dllhandle, "PyCallable_Check"); //borland
    if(DLL_PyCallable_Check == NULL)
        GUI_LOG(INFO,"Get PyCallable_Check Failed!\n");
    // Gert PyTuple_New fn
    DLL_PyTuple_New = (TURPLE_NEW) GetProcAddress(dllhandle, "PyTuple_New"); //borland
    if(DLL_PyTuple_New == NULL)
        GUI_LOG(INFO,"Get PyTuple_New Failed!\n");
    // Get PyInt_FromLongPyInt_FromLong fn
    DLL_PyInt_FromLong = (INT_FRM_LONG) GetProcAddress(dllhandle, "PyInt_FromLong"); //borland
    if(DLL_PyInt_FromLong == NULL)
        GUI_LOG(INFO,"Get PyInt_FromLong Failed!");
    // Get PyErr_Print fn
    DLL_PyErr_Print = (ERR_PRINT) GetProcAddress(dllhandle, "PyErr_Print"); //borland
    if(DLL_PyErr_Print == NULL)
        GUI_LOG(INFO,"Get PyErr_Print Failed!\n");
    // Get PyTuple_SetItem fn
    DLL_PyTuple_SetItem = (TUPLE_ITEM) GetProcAddress(dllhandle, "PyTuple_SetItem"); //borland
    if(DLL_PyTuple_SetItem == NULL)
        GUI_LOG(INFO,"Get PyTuple_SetItem Failed!\n");
    // Get PyObject_CallObject fn
    DLL_PyObject_CallObject = (OBJ_OBJ) GetProcAddress(dllhandle, "PyObject_CallObject"); //borland
    if(DLL_PyObject_CallObject == NULL)
        GUI_LOG(INFO,"Get PyObject_CallObject Failed!\n");
    // Get PyInt_AsLong fn
    DLL_PyInt_AsLong = (INT_AS_LONG) GetProcAddress(dllhandle, "PyInt_AsLong"); //borland
    if(DLL_PyInt_AsLong == NULL)
        GUI_LOG(INFO,"Get PyObject_CallObject Failed!\n");
    // Get PyArg_ParseTuple fn
    DLL_PyArg_ParseTuple = (PARSE_TUPLE) GetProcAddress(dllhandle, "PyArg_ParseTuple"); //borland
    if(DLL_PyArg_ParseTuple == NULL)
        GUI_LOG(INFO,"Get PyArg_ParseTuple Failed!\n");
    // Get Py_InitModule fn
    DLL_Py_InitModule = (INIT_MODULE_PY) GetProcAddress(dllhandle, "Py_InitModule4"); //borland
    if(DLL_Py_InitModule == NULL)
        GUI_LOG(INFO,"Get Py_InitModule Failed!\n");
    // Get Py_DECREF fn
    DLL_Py_DECREF = (DECREF_PY) GetProcAddress(dllhandle, "Py_DecRef"); //borland
    if(DLL_Py_DECREF == NULL)
        GUI_LOG(INFO,"Get Py_DECREF Failed!\n");
    // Get Py_INCREF fn
    DLL_Py_INCREF = (INCREF_PY) GetProcAddress(dllhandle, "Py_IncRef"); //borland
    if(DLL_Py_INCREF == NULL)
        GUI_LOG(INFO,"Get Py_INCREF Failed!\n");
    //Get Py_Finalize fn
    DLL_Py_Finalize = (FINALIZE) GetProcAddress(dllhandle, "Py_Finalize"); //borland
    if(DLL_Py_Finalize == NULL)
        GUI_LOG(INFO,"Get Py_Finalize Failed!\n");
    // Get Py_None fn
    DLL_Py_None = (NONE_PY) GetProcAddress(dllhandle, "_Py_NoneStruct"); //borland
    if(DLL_Py_None == NULL)
        GUI_LOG(INFO,"Get Py_None Failed!\n");
    // Get PyRun_SimpleString fn
    DLL_PyRun_SimpleString = (RUN_SIMPLE_STR) GetProcAddress(dllhandle, "PyRun_SimpleString"); //borland
    if(DLL_PyRun_SimpleString == NULL)
        GUI_LOG(INFO,"Get PyRun_SimpleString Failed!\n");
    // Get Py_BuildValue fn
    DLL_Py_BuildValue = (BUILD_VALUE) GetProcAddress(dllhandle, "Py_BuildValue"); //borland
    if(DLL_Py_BuildValue == NULL)
        GUI_LOG(INFO,"Get Py_BuildValue Failed!\n");
}

//****************************************************************************//
// Function Name:   log_CaptureStdout()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
static PyObject* log_CaptureStdout(PyObject* self, PyObject* pArgs)
{
    char* LogStr = NULL;

    if (!DLL_PyArg_ParseTuple(pArgs, "s", &LogStr))
        return NULL;

    if(*LogStr != '\n')
        GUI_LOG(INFO, "%s\n", LogStr);

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_CaptureStderr()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_CaptureStderr(PyObject* self, PyObject* pArgs)
{
    char* LogStr = NULL;

    if (!DLL_PyArg_ParseTuple(pArgs, "s", &LogStr))
        return NULL;

    if(*LogStr != '\n')
        GUI_LOG(INFO, "%s\n", LogStr);

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_CaptureStdin()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_CaptureStdin(PyObject* self, PyObject* pArgs)
{
    char* LogStr = NULL;
    char ReplyStr[] = "C Reply to Python Request User Input:\0";
    int length = strlen(ReplyStr);
    int res = 0;
    FILE * fp = NULL;

    if (!DLL_PyArg_ParseTuple(pArgs, "s", &LogStr))
        return NULL;

    if(*LogStr != '\n')
    {
        // Display message for user to check connector position.
        if(MessageBox(  Application->Handle,
                        LogStr,
                        "Python Request User Input",
                        MB_ICONEXCLAMATION|MB_OKCANCEL|MB_TOPMOST|MB_SETFOREGROUND) != IDOK)
        {
            GUI_LOG(INFO, "USER CANCEL");
        }
        // create cout for python
        if((fp = fopen("cout.log", "w")) == NULL)
        {
            GUI_LOG(INFO, "Error creating cout.log");
        }

        if((res = fwrite(ReplyStr, length, 1, fp)) == length)
        {
            GUI_LOG(INFO, "Error writing to cout.log");
        }
        fclose(fp);
    }
    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}
////////////////////////////////////////////////////////////////////////////////
// XML PYTHON CALL FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
//****************************************************************************//
// Function Name:   log_UDP_Enable()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_UDP_Enable(PyObject* self, PyObject* pArgs)
{
    int Port = 0;
    char* Host = NULL;

    if (!DLL_PyArg_ParseTuple(pArgs, "is", &Port, &Host))
        return NULL;

    pXMLLogger->UDP_Enable(Port, Host);

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_UDP_Disable()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_UDP_Disable(PyObject* self, PyObject* pArgs)
{
    pXMLLogger->UDP_Disable();

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_Sockets_Enable()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_Sockets_Enable(PyObject* self, PyObject* pArgs)
{
    int Port = 0;
    char* Host = NULL;

    if (!DLL_PyArg_ParseTuple(pArgs, "is",&Port, &Host))
        return NULL;

    pXMLLogger->Sockets_Enable(Port, Host);

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_Sockets_Disable()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_Sockets_Disable(PyObject* self, PyObject* pArgs)
{
    pXMLLogger->Sockets_Disable();

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_InterProcessComms()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_InterProcessComms(PyObject* self, PyObject* pArgs)
{
    char* pMessageClassName = NULL;

    if (!DLL_PyArg_ParseTuple(pArgs, "s", &pMessageClassName))
        return NULL;

    if(*pMessageClassName != '\n')
        pXMLLogger->InterProcessComms(pMessageClassName);

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_TurnOnOffXyratexLogger()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_TurnOnOffXyratexLogger(PyObject* self, PyObject* pArgs)
{
    char cBool = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "b", &cBool))
        return NULL;

    pXMLLogger->TurnOnOffXyratexLogger(cBool);

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_Version()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_Version(PyObject* self, PyObject* pArgs)
{
    double Version = 0.0;

    Version = pXMLLogger->Version();
    return DLL_Py_BuildValue("d", Version);
}

//****************************************************************************//
// Function Name:   log_AbortXMLLog()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_AbortXMLLog(PyObject* self, PyObject* pArgs)
{
    pXMLLogger->AbortXMLLog();

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_WriteXMLLogtoLocation()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteXMLLogtoLocation(PyObject* self, PyObject* pArgs)
{
    char* Path = NULL;
    char* FileName = NULL;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "ss", &Path, &FileName))
        return NULL;

    Res = pXMLLogger->WriteXMLLogtoLocation(Path, FileName);

    return DLL_Py_BuildValue("i", Res);
}

//****************************************************************************//
// Function Name:   log_GetXMLLogLocation()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_GetXMLLogLocation(PyObject* self, PyObject* pArgs)
{
    char* Path = NULL;
    char* FileName = NULL;
    int MaxChars = 0;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "ssi", &Path, &FileName, &MaxChars))
        return NULL;

    Res = pXMLLogger->GetXMLLogLocation(Path, FileName, MaxChars);

    return DLL_Py_BuildValue("i", Res);
}
//****************************************************************************//
// Function Name:   log_WriteHeaderStructure()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteHeaderStructure(PyObject* self, PyObject* pArgs)
{
    FileHeaderStructure *pFHS =  new FileHeaderStructure;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "sssssisisssss",   &(pFHS->Description),
                                                        &(pFHS->Test_Code),
                                                        &(pFHS->Operator),
                                                        &(pFHS->Test_Station),
                                                        &(pFHS->Retest_Reason),
                                                        &(pFHS->Number_Retry),
                                                        &(pFHS->RMA),
                                                        &(pFHS->RMA_LOOP),
                                                        &(pFHS->Serial_Num),
                                                        &(pFHS->Part_Number),
                                                        &(pFHS->Sub_Parts),
                                                        &(pFHS->Concessions),
                                                        &(pFHS->Comment)))
        return NULL;

    Res = pXMLLogger->WriteHeaderStructure(pFHS);
    delete pFHS;
    return DLL_Py_BuildValue("i", Res);
}



//****************************************************************************//
// Function Name:   log_WriteTestHeader()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteTestHeader(PyObject* self, PyObject* pArgs)
{
    int TestNumber = 0;
    char* LogStr = NULL;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "is", &TestNumber,&LogStr))
        return NULL;

    if(*LogStr != '\n')
        Res = pXMLLogger->WriteTestHeader(TestNumber, LogStr);

    return DLL_Py_BuildValue("i", Res);
}

//****************************************************************************//
// Function Name:   log_WriteTestReport()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteTestReport(PyObject* self, PyObject* pArgs)
{
    int TestReturnCode = 0;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "i", &TestReturnCode))
        return NULL;

    Res = pXMLLogger->WriteTestReport(TestReturnCode);
    return DLL_Py_BuildValue("i", Res);
}

//****************************************************************************//
// Function Name:   log_WriteFinalTestReport()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteFinalTestReport(PyObject* self, PyObject* pArgs)
{
    FinalTestReport* TestReport =  new FinalTestReport;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "ss", &(TestReport->Version_Test),&(TestReport->Return_Code)))
        return NULL;

    Res = pXMLLogger->WriteFinalTestReport(TestReport);
    delete TestReport;
    return DLL_Py_BuildValue("i", Res);
}

//****************************************************************************//
// Function Name:   log_WriteAnalogueMeasurement()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteAnalogueMeasurement(PyObject* self, PyObject* pArgs)
{
    float Measurement = 0.0;
    float Nominal = 0.0;
    float LowLimit = 0.0;
    float HighLimit = 0.0;
    char* Unit = NULL;
    char* Description = NULL;
    char type_descriptor = 0;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "ffffssb", &Measurement,
                                                &Nominal,
                                                &LowLimit,
                                                &HighLimit,
                                                &Unit,
                                                &Description,
                                                &type_descriptor))
        return NULL;

    Res = pXMLLogger->WriteAnalogueMeasurement( &Measurement,
                                                &Nominal,
                                                &LowLimit,
                                                &HighLimit,
                                                Unit,
                                                Description,
                                                type_descriptor);
    return DLL_Py_BuildValue("i", Res);
}

//****************************************************************************//
// Function Name:   log_WriteDigitalMeasurement()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteDigitalMeasurement(PyObject* self, PyObject* pArgs)
{
    int ActualValue = 0;
    int ExpectedValue = 0;
    char* Description = NULL;
    char type_descriptor = 0;
    char format_specifier = 0;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "iisbb",   &ActualValue,
                                                &ExpectedValue,
                                                &Description,
                                                &type_descriptor,
                                                &format_specifier))
        return NULL;

    Res = pXMLLogger->WriteDigitalMeasurement(  &ActualValue,
                                                &ExpectedValue,
                                                Description,
                                                type_descriptor,
                                                format_specifier);
    return DLL_Py_BuildValue("i", Res);
}

//****************************************************************************//
// Function Name:   log_WriteDebugRecord()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteDebugRecord(PyObject* self, PyObject* pArgs)
{
    char* LogStr = NULL;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "s", &LogStr))
        return NULL;

    if(*LogStr != '\n')
        Res = pXMLLogger->WriteDebugRecord(LogStr);

    return DLL_Py_BuildValue("i", Res);
}

//****************************************************************************//
// Function Name:   log_WriteToXyLoggerOnly()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteToXyLoggerOnly(PyObject* self, PyObject* pArgs)
{
    char* LogStr = NULL;

    if (!DLL_PyArg_ParseTuple(pArgs, "s", &LogStr))
        return NULL;

    if(*LogStr != '\n')
        pXMLLogger->WriteToXyLoggerOnly(LogStr);

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_WriteTraceData()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteTraceData(PyObject* self, PyObject* pArgs)
{
    char* LogStr = NULL;

    if (!DLL_PyArg_ParseTuple(pArgs, "s", &LogStr))
        return NULL;

    if(*LogStr != '\n')
        GUI_LOG(INFO, LogStr);

    DLL_Py_DECREF(DLL_Py_None);
    return DLL_Py_None;
}

//****************************************************************************//
// Function Name:   log_WriteTableRecordHeader()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteTableRecordHeader(PyObject* self, PyObject* pArgs)
{
    TableRecordStructure *pTRS = new TableRecordStructure;
    int TableID = 0;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "sbsi", &(pTRS->TableName),&(pTRS->Table_Delimiter),&(pTRS->Table_Label),&TableID))
        return NULL;

    Res = pXMLLogger->WriteTableRecordHeader(pTRS, &TableID);
    delete pTRS;
    return DLL_Py_BuildValue("i", Res);
}

//****************************************************************************//
// Function Name:   log_WriteTableRow()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteTableRow(PyObject* self, PyObject* pArgs)
{
    int TableID = 0;
    const char *pRowData = NULL;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "is", &TableID, &pRowData))
        return NULL;

    Res = pXMLLogger->WriteTableRow(TableID, pRowData);
    return DLL_Py_BuildValue("i", Res);
}
//****************************************************************************//
// Function Name:   log_EndTableRecord()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_EndTableRecord(PyObject* self, PyObject* pArgs)
{
    int TableID = 0;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "i", &TableID))
        return NULL;

    Res = pXMLLogger->EndTableRecord(TableID);
    return DLL_Py_BuildValue("i", Res);
}
//****************************************************************************//
// Function Name:   log_WriteNonStandardRecord()
// Paramater:       PyObject* self, PyObject* pArgs
// Return Value:    PyObject*
//
// Description:
//****************************************************************************//
PyObject* log_WriteNonStandardRecord(PyObject* self, PyObject* pArgs)
{
    NonStandardRecordStructure *pNSRS = new NonStandardRecordStructure;
    int Res = 0;

    if (!DLL_PyArg_ParseTuple(pArgs, "sbs", &(pNSRS->Extra_Description), &(pNSRS->Extra_Type), &(pNSRS->PathAndFileName)))
        return NULL;

    Res = pXMLLogger->WriteNonStandardRecord(pNSRS);
    delete pNSRS;
    return DLL_Py_BuildValue("i", Res);
}