#include <my_config.h>
#include <cmath>
#include <iostream>
#include <sstream>
using namespace std;

#include "idb_mysql.h"

namespace
{
inline double cvtArgToDouble(int t, const char* v)
{
    double d = 0.0;

    switch (t)
    {
        case INT_RESULT:
            d = (double)(*((long long*)v));
            break;

        case REAL_RESULT:
            d = *((double*)v);
            break;

        case DECIMAL_RESULT:
        case STRING_RESULT:
            d = strtod(v, 0);
            break;

        case ROW_RESULT:
            break;
    }

    return d;
}
inline long long cvtArgToInt(int t, const char* v)
{
    long long ll = 0;

    switch (t)
    {
        case INT_RESULT:
            ll = *((long long*)v);
            break;

        case REAL_RESULT:
            ll = (long long)(*((double*)v));
            break;

        case DECIMAL_RESULT:
        case STRING_RESULT:
            ll = strtoll(v, 0, 0);
            break;

        case ROW_RESULT:
            break;
    }

    return ll;
}
inline string cvtArgToString(int t, const char* v)
{
    string str;

    switch (t)
    {
        case INT_RESULT:
        {
            long long ll;
            ll = *((long long*)v);
            ostringstream oss;
            oss << ll;
            str = oss.str();
            break;
        }

        case REAL_RESULT:
        {
            double d;
            d = *((double*)v);
            ostringstream oss;
            oss << d;
            str = oss.str();
            break;
        }

        case DECIMAL_RESULT:
        case STRING_RESULT:
            str = v;
            break;

        case ROW_RESULT:
            break;
    }

    return str;
}
}

/****************************************************************************
 * UDF function interface for MariaDB connector to recognize is defined in
 * this section. MariaDB's UDF function creation guideline needs to be followed.
 *
 * Three interface need to be defined on the connector for each UDF function.
 *
 * XXX_init: To allocate the necessary memory for the UDF function and validate
 *           the input.
 * XXX_deinit: To clean up the memory.
 * XXX: The function implementation.
 * Detailed instruction can be found at MariaDB source directory:
 * ~/sql/udf_example.cc.
 *
 * Please note that the implementation of the function defined on the connector
 * will only be called when all the input arguments are constant. e.g.,
 * mcs_add(2,3). That way, the function does not run in a distributed fashion
 * and could be slow. If there is a need for the UDF function to run with
 * pure constant input, then one needs to put a implementation in the XXX
 * body, which is very similar to the ones in getXXXval API. If there's no
 * such need for a given UDF, then the XXX interface can just return a dummy
 * result because this function will never be called.
 */
extern "C"
{
    /**
     * MCS_ADD connector stub
     */
#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    my_bool mcs_add_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
    {
        if (args->arg_count != 2)
        {
            strcpy(message, "mcs_add() requires two argument");
            return 1;
        }

        return 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void mcs_add_deinit(UDF_INIT* initid)
    {
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    double mcs_add(UDF_INIT* initid, UDF_ARGS* args, char* is_null, char* error)
    {
        double op1, op2;

        op1 = cvtArgToDouble(args->arg_type[0], args->args[0]);
        op2 = cvtArgToDouble(args->arg_type[1], args->args[1]);

        return op1 + op2;
    }

    /**
     * MCS_ISNULL connector stub
     */

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    my_bool mcs_isnull_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
    {
        if (args->arg_count != 1)
        {
            strcpy(message, "mcs_isnull() requires one argument");
            return 1;
        }

        return 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void mcs_isnull_deinit(UDF_INIT* initid)
    {
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    long long mcs_isnull(UDF_INIT* initid, UDF_ARGS* args, char* is_null, char* error)
    {
        return 0;
    }

    /**
     * ALLNULL connector stub
     */
    struct allnull_data
    {
        ulonglong	totalQuantity;
        ulonglong	totalNulls;
    };

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    my_bool allnull_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
    {
        struct allnull_data* data;
//	if (args->arg_count != 1)
//	{
//		strcpy(message,"allnull() requires one argument");
//		return 1;
//	}

        if (!(data = (struct allnull_data*) malloc(sizeof(struct allnull_data))))
        {
            strmov(message, "Couldn't allocate memory");
            return 1;
        }

        data->totalQuantity	= 0;
        data->totalNulls	= 0;

        initid->ptr = (char*)data;

        return 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void allnull_deinit(UDF_INIT* initid)
    {
        free(initid->ptr);
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    long long allnull(UDF_INIT* initid, UDF_ARGS* args __attribute__((unused)),
                      char* is_null, char* error __attribute__((unused)))
    {
        struct allnull_data* data = (struct allnull_data*)initid->ptr;
        return data->totalQuantity > 0 && data->totalNulls == data->totalQuantity;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void
    allnull_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
                  char* message __attribute__((unused)))
    {
        struct allnull_data* data = (struct allnull_data*)initid->ptr;
        data->totalQuantity = 0;
        data->totalNulls    = 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void
    allnull_add(UDF_INIT* initid, UDF_ARGS* args,
                char* is_null,
                char* message __attribute__((unused)))
    {
        struct allnull_data* data = (struct allnull_data*)initid->ptr;
        const char* word = args->args[0];
        data->totalQuantity++;

        if (!word)
        {
            data->totalNulls++;
        }
    }

    /**
     * SSQ connector stub
     */
    struct ssq_data
    {
        double	sumsq;
    };

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    my_bool ssq_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
    {
        struct ssq_data* data;

        if (args->arg_count != 1)
        {
            strcpy(message, "ssq() requires one argument");
            return 1;
        }

        if (!(data = (struct ssq_data*) malloc(sizeof(struct ssq_data))))
        {
            strmov(message, "Couldn't allocate memory");
            return 1;
        }

        data->sumsq	= 0;

        initid->ptr = (char*)data;
        return 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void ssq_deinit(UDF_INIT* initid)
    {
        free(initid->ptr);
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void
    ssq_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
              char* message __attribute__((unused)))
    {
        struct ssq_data* data = (struct ssq_data*)initid->ptr;
        data->sumsq = 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void
    ssq_add(UDF_INIT* initid, UDF_ARGS* args,
            char* is_null,
            char* message __attribute__((unused)))
    {
        struct ssq_data* data = (struct ssq_data*)initid->ptr;
        double val = cvtArgToDouble(args->arg_type[0], args->args[0]);
        data->sumsq = val * val;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    long long ssq(UDF_INIT* initid, UDF_ARGS* args __attribute__((unused)),
                  char* is_null, char* error __attribute__((unused)))
    {
        struct ssq_data* data = (struct ssq_data*)initid->ptr;
        return data->sumsq;
    }

//=======================================================================

    /**
     * MEDIAN connector stub
     */
#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    my_bool median_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
    {
        if (args->arg_count != 1)
        {
            strcpy(message, "median() requires one argument");
            return 1;
        }

        /*
        	if (!(data = (struct ssq_data*) malloc(sizeof(struct ssq_data))))
        	{
        		strmov(message,"Couldn't allocate memory");
        		return 1;
        	}
        	data->sumsq	= 0;

        	initid->ptr = (char*)data;
        */
        return 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void median_deinit(UDF_INIT* initid)
    {
//	free(initid->ptr);
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void
    median_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
                 char* message __attribute__((unused)))
    {
//	struct ssq_data* data = (struct ssq_data*)initid->ptr;
//	data->sumsq = 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void
    median_add(UDF_INIT* initid, UDF_ARGS* args,
               char* is_null,
               char* message __attribute__((unused)))
    {
//	struct ssq_data* data = (struct ssq_data*)initid->ptr;
//	double val = cvtArgToDouble(args->arg_type[0], args->args[0]);
//	data->sumsq = val*val;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    long long median(UDF_INIT* initid, UDF_ARGS* args __attribute__((unused)),
                     char* is_null, char* error __attribute__((unused)))
    {
//	struct ssq_data* data = (struct ssq_data*)initid->ptr;
//	return data->sumsq;
        return 0;
    }

    /**
     * avg_mode connector stub
     */
#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    my_bool avg_mode_init(UDF_INIT* initid, UDF_ARGS* args, char* message)
    {
        if (args->arg_count != 1)
        {
            strcpy(message, "avg_mode() requires one argument");
            return 1;
        }

        /*
        	if (!(data = (struct ssq_data*) malloc(sizeof(struct ssq_data))))
        	{
        		strmov(message,"Couldn't allocate memory");
        		return 1;
        	}
        	data->sumsq	= 0;

        	initid->ptr = (char*)data;
        */
        return 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void avg_mode_deinit(UDF_INIT* initid)
    {
//	free(initid->ptr);
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void
    avg_mode_clear(UDF_INIT* initid, char* is_null __attribute__((unused)),
                   char* message __attribute__((unused)))
    {
//	struct ssq_data* data = (struct ssq_data*)initid->ptr;
//	data->sumsq = 0;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    void
    avg_mode_add(UDF_INIT* initid, UDF_ARGS* args,
                 char* is_null,
                 char* message __attribute__((unused)))
    {
//	struct ssq_data* data = (struct ssq_data*)initid->ptr;
//	double val = cvtArgToDouble(args->arg_type[0], args->args[0]);
//	data->sumsq = val*val;
    }

#ifdef _MSC_VER
    __declspec(dllexport)
#endif
    long long avg_mode(UDF_INIT* initid, UDF_ARGS* args __attribute__((unused)),
                       char* is_null, char* error __attribute__((unused)))
    {
//	struct ssq_data* data = (struct ssq_data*)initid->ptr;
//	return data->sumsq;
        return 0;
    }
}
// vim:ts=4 sw=4: