#!/bin/bash

################################################################################
################################################################################
################################################################################
################################################################################
#######This file is an unholy mess. It's being replaced as you read this.#######
################################################################################
################################################################################
################################################################################
################################################################################

if [[ ! -f "/opt/zentific/include/zentific-server.zxdl" ]]; then
	echo  "--------------------------------------------------------------"
	echo -e "\n"
	echo  "  Error: please install the minimum zentific core required"
	echo  "	  from zrpc with:"
	echo  "	  ./configure --enable-zrpc=no && make && make install" 
	echo -e "\n"
	echo  "--------------------------------------------------------------"
	exit 1
fi


TMP=`mktemp`
ZXDLTMP=`mktemp`
cat "/opt/zentific/include/zentific-server.zxdl" > $ZXDLTMP
sed -i 's#//.*$##' $ZXDLTMP
cat $ZXDLTMP | ../comment-remove.sed.sh > $TMP
mv $TMP $ZXDLTMP

# delete trailing whitespace (spaces, tabs) from end of each line
sed -i 's/[ \t]*$//' $ZXDLTMP

# delete BOTH leading and trailing whitespace from each line
sed -i 's/^[ \t]*//;s/[ \t]*$//' $ZXDLTMP

#delete blank lines
sed -i '/^$/d' $ZXDLTMP

#convert all multiple spaces to single
tr -s ' ' < $ZXDLTMP > $TMP
mv "${TMP}" "${ZXDLTMP}"
cp "${ZXDLTMP}" /tmp/zxdl-processing

#list related functions

function listfuncs() {
	FUNCTIONS=$( for i in /opt/zentific/include/function*.h; do [[ `echo $i | grep 'functions-debug'` ]] && continue; egrep '^[A-Za-z0-9_]' $i | egrep '\s*_' ; done | grep -v static | grep '^GSList' | grep -v '_getConsoleLockVmsBySession' | sed -e 's#\*##' -e 's#(# #' | awk '{print $2}')

	for i in $FUNCTIONS; do 
		SIGNATURE=
		TYPE=$(python ../zxdl-parse.py $i); 
		SIGNATURE=`egrep "${i}\b" /opt/zentific/include/function*.h | sed -e 's#(# (#' | sed -e 's#^.*:# #'  -e 's#;##' -e 's#'"${i}"'##' -e 's#'"${TYPE}"'##' -e 's#GSList##' -e 's#'"*"'##g' -e 's#[ ]*(#(#'`
		echo NAME="'${i}'" TYPE="'${TYPE}'" SIGNATURE="'${SIGNATURE}'"; 
	done
	SIGNATURE=
}

function nonlistfuncs() {

	for i in /opt/zentific/include/function*.h; do
		[[ `echo $i | grep 'functions-debug'` ]] && continue;

		NAMES=`egrep '^[A-Za-z0-9_]' $i | egrep '\s*_' | sort -u |  egrep -v '(make_|inline|zxr|zentific_session|static)' | grep -v '^GSList'  | sed -e 's#(# (#' | sed -e 's#\*##' | awk '{print $2}'`

		for n in $NAMES; do
			SIGNATURE=
			TYPE=`egrep "$n " /opt/zentific/include/function*.h | sed -e 's#(# (#' | sed -e 's#\*##' -e 's#:# #' | awk '{print $2}'`
			SIGNATURE=`egrep "$n " /opt/zentific/include/function*.h | sed -e 's#(# (#' | sed -e 's#^.*:# #'  -e 's#;##' -e 's#'"${n}"'##' -e 's#'"${TYPE}"'##' -e 's#[ ]*(#(#' -e 's#'"*"'##g'`
			echo NAME="'$n'" TYPE="'$TYPE'" SIGNATURE="'${SIGNATURE}'"
		done

		SIGNATURE=
		
	done

}

FTMP=`mktemp`
nonlistfuncs > $FTMP
listfuncs >> $FTMP 

#get rid of ^M characters coming from stay files edited by someone (??) in windows
sed -ie 's#
##g' $FTMP

#clear it
:>jobmodule-callbacks.c
:>jobmodule-callback-defs.c
:>../modules/zpy-generated.c

cat >> ../modules/zpy-generated.c <<EOFgen
/* zensched: scheduler for Zentific
 * Copyright (C) 2008, 2009, 2010, 2011 Zentific LLC and AUTHORS
 *
 * All rights reserved.
 * Use is subject to license terms.
 *
 * Please visit http://zentific.com for news and updates
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 */

EOFgen

/bin/echo -e "#include <Common.h>\n" >> ../modules/zpy-generated.c
/bin/echo -e "#include \"zpy-generated.h\"\n" >> ../modules/zpy-generated.c
/bin/echo -e "#include \"zpy.h\"\n" >> ../modules/zpy-generated.c

while read n t s; do
	eval $n
	eval $t
	eval $s

	#strip leading underscore from function name
	ORIGNAME="${NAME}"
	NAME=$(echo "$NAME"|sed -e 's#^_##')
	#strip leading spaces, __UNUSED__ const, collapse multiple spaces
	SIGNATURE=$(echo ${SIGNATURE} | sed -e 's#[ ]*(#(#' -e 's#__UNUSED__##g' -e 's#const##g' -e 's#( #(#' | tr -s ' ' )

	FPTR=$(egrep "( |\*)(${NAME}|${ORIGNAME}) " /opt/zentific/include/* | sed -e 's#.*:##' | sed -r 's#[_]?'"${NAME}"' #(*'"${NAME}"')#')
	if [[ "${ORIGNAME}" != "${ORIGNAME/_/}" ]]; then
		HOOK="ret->${NAME} = ${ORIGNAME};"
	elif [[ "${NAME}" == "${ORIGNAME}" ]]; then
		HOOK="ret->${NAME} = ${ORIGNAME};"
	else
		HOOK="ret->${NAME} = _${ORIGNAME};"
	fi
	echo -e "\t${HOOK}" >> jobmodule-callbacks.c
	echo -e "\t${FPTR}" >> jobmodule-callback-defs.c
	
	#will we accept input? if no, use __UNUSED__ in funct signature
	ARGS_ATTR=
	if [[ "${SIGNATURE}" == "(GError error)" ]]; then
		ARGS_ATTR=" __UNUSED__"
	fi

	#output basic function start
cat >> ../modules/zpy-generated.c <<EOFgen

PyObject * py_${NAME}(PyObject *self __UNUSED__, PyObject *args${ARGS_ATTR}) {

	GError *error	= NULL;
	PyObject *py_ret= NULL;
EOFgen

	#if func return type is an array in the zxdl, we're using GSLists, so add a var 
	#unusual but useful construction meaning "if type contains 'array'"
        if [[ "${TYPE}" != "${TYPE/array/}" ]]; then
cat >> ../modules/zpy-generated.c <<EOFgen
	GSList *head	= NULL;
	GSList *c_ret	= NULL;
EOFgen
	elif [[ "${TYPE}" == "int" ]]; then
cat >> ../modules/zpy-generated.c <<EOFgen
	int c_ret	= -1;
EOFgen
	elif [[ "${TYPE}" == "gboolean" ]]; then
cat >> ../modules/zpy-generated.c <<EOFgen
	gboolean c_ret	= FALSE;
EOFgen
	elif [[ "${TYPE}" == "char" ]]; then
cat >> ../modules/zpy-generated.c <<EOFgen
	char * c_ret	= NULL;
EOFgen
	else 
cat >> ../modules/zpy-generated.c <<EOFgen
	${TYPE} * c_ret	= NULL;
EOFgen
	fi

cat >> ../modules/zpy-generated.c <<EOFgen

        if (!zmcb) {
                ERR( "Python module: %s - callback structure invalid", __func__);
		goto err;
        }

        if(!zmcb->${NAME}) {
                ERR( "Python module: %s - callback function invalid", __func__);
		goto err;
        }
EOFgen

	#remove all but commas, and count them.
	# wc returns an extra for the terminal char, but that's actually our desired number
	SIGNATURE=$(echo $SIGNATURE | sed -e 's#[()]##g')
	NUMPARAMS=$(echo $SIGNATURE | sed -e 's#[A-Za-z_ ]##g' | wc -c)

	PARSEFORMAT=
	PARSEPARAMS=
	POSTPARSEARGS=
	PARSEVARS=
	PARSEARGS=
	CFUNCARGS=
	LISTTYPE=
	FOREACHFREE=
	POSTEXECFREE=
	for p in `seq 1 $NUMPARAMS`; do
		ERRAMP=
		PARAM=`echo $SIGNATURE | awk 'BEGIN { FS = "," } ; { print $'${p}' }' |tr -s ' ' | sed -e 's#^[ ]*##' `
		PARAMT=`echo $PARAM | awk '{print $1}'`
		PARAMN=`echo $PARAM | awk '{print $2}'`
			
		if [[ "$PARAMT" == "int" ]]; then
			PARSEFORMAT="${PARSEFORMAT}i"
			PARSEARGS="${PARSEARGS}, &${PARAMN}"
			PARSEVARS="${PARSEVARS}\n\tint ${PARAMN}\t= -1;"
		elif [[ "$PARAMT" == "char" ]]; then
			PARSEFORMAT="${PARSEFORMAT}s"
			PARSEVARS="${PARSEVARS}\n\tchar * ${PARAMN}\t= NULL;"
			PARSEARGS="${PARSEARGS}, &${PARAMN}"
		elif [[ "$PARAMT" == "GError" ]]; then
			ERRAMP="&"
		elif [[ "$PARAMT" == "gboolean" ]]; then
			PARSEFORMAT="${PARSEFORMAT}i"
			PARSEVARS="${PARSEVARS}\n\tgboolean ${PARAMN}\t= FALSE;"
			PARSEARGS="${PARSEARGS}, &${PARAMN}"
		elif [[ "$PARAMT" == "GSList" ]]; then

			LISTTYPE=$(echo "${TYPE}" | sed -e 's#[<> ]##g' -e 's#array##')
			LISTTYPE=$(python ../zxdl-parse.py "${NAME}" "${PARAMN}" | awk '{print $2}'); 
			
			#handle special cases (e.g. functions in the functions-*.h headers,
			#	but never called from the zxdl
			if [[ "x${LISTTYPE}" == "x" && "${NAME}" != "${NAME/Disk/}" ]]; then
				LISTTYPE="DISK"
			elif [[ "x${LISTTYPE}" == "x" && "${NAME}" != "${NAME/NetIf/}" ]]; then
				LISTTYPE="NETIF"
			fi

			PARSEFORMAT="${PARSEFORMAT}O"
			PARSEVARS="${PARSEVARS}\n\tGSList * ${PARAMN}\t= NULL;"
			PARSEVARS="${PARSEVARS}\n\tPyObject * py${PARAMN}\t= NULL;"
			PARSEARGS="${PARSEARGS}, &py${PARAMN}"

			if [[ "${LISTTYPE}" == "int" ]]; then
				POSTPARSEARGS="if(!(${POSTPARSEARGS}\n\t${PARAMN} = PyList_to_GSList(py${PARAMN}, (dictconv)NULL, (intconv)PyInt_toGSListEntry))) {\n\t\tgoto err;\n\t}"
			elif [[ "${LISTTYPE}" == "string" ]]; then
				POSTPARSEARGS="if(!(${POSTPARSEARGS}\n\t${PARAMN} = PyList_to_GSList(py${PARAMN}, (dictconv)_to_string, (intconv)NULL))) {\n\t\tgoto err;\n\t}"
			else 
				POSTPARSEARGS="if(!(${POSTPARSEARGS}\n\t${PARAMN} = PyList_to_GSList(py${PARAMN}, (dictconv)dict_to_${LISTTYPE}, (intconv)NULL))) {\n\t\tgoto err;\n\t}"
			fi
		else #object 
			PARSEFORMAT="${PARSEFORMAT}O&"
			PARSEVARS="${PARSEVARS}\n\t${PARAMT} *${PARAMN}\t= NULL;"
			PARSEARGS="${PARSEARGS}, dict_arg_to_${PARAMT}, &${PARAMN}"

			POSTEXECFREE="${PARAMT}_free(${PARAMN});"
		fi
		
		if [[ "${CFUNCARGS}x" == "x" ]]; then 
			CFUNCARGS="${ERRAMP}${PARAMN}"
		else
			CFUNCARGS="${CFUNCARGS}, ${ERRAMP}${PARAMN}"
		fi
		
	done

cat >> ../modules/zpy-generated.c <<EOFgen
	`/bin/echo -e "${PARSEVARS}"`

	if(!PyArg_ParseTuple(args, "$PARSEFORMAT"$PARSEARGS))
		goto err;
EOFgen

if [[ "${POSTPARSEARGS}x" != "x" ]]; then
cat >> ../modules/zpy-generated.c <<EOFgen
	`/bin/echo -e "${POSTPARSEARGS}"`

EOFgen
	fi

cat >> ../modules/zpy-generated.c <<EOFgen
	
	Py_BEGIN_ALLOW_THREADS
	c_ret = zmcb->${NAME}(${CFUNCARGS});
	Py_END_ALLOW_THREADS

	`/bin/echo -e "${POSTEXECFREE}"`

	if(error){
		goto err;
	}

EOFgen

	#HANDLE OUTPUT
	if [[ "${TYPE}" != "${TYPE/array/}" ]]; then

		convfunc=
		FOREACHFREE=
		arraytype=$(echo ${TYPE} | sed -e 's#array<##' -e 's#>##')
		
		if [[ "${arraytype}" == "string" ]]; then
			convfunc="PyString_FromString"
			FOREACHFREE="g_slist_foreach(head, (GFunc)free, NULL);"
		elif [[ "${arraytype}" == "int" ]]; then
			convfunc="PyInt_FromGSListEntry"
			FOREACHFREE="head = c_ret;\n\tg_slist_free(head);"
		else 
			convfunc="${arraytype}_to_dict"
			FOREACHFREE="head = c_ret;\n\tg_slist_foreach(head, (GFunc)${arraytype}_free, NULL);\n\tg_slist_free(head);"
		fi

cat >> ../modules/zpy-generated.c <<EOFgen

        py_ret = GSList_to_PyList(c_ret, (pydatacb)${convfunc});

	`/bin/echo -e "${FOREACHFREE}"`

EOFgen

	elif [[ "${TYPE}" == "int" ]]; then
cat >> ../modules/zpy-generated.c <<EOFgen

	py_ret = Py_BuildValue("i", c_ret);
EOFgen
	elif [[ "${TYPE}" == "char" ]]; then

cat >> ../modules/zpy-generated.c <<EOFgen

	if(c_ret){
		py_ret = Py_BuildValue("s#", c_ret, strlen(c_ret));
		free(c_ret);
	} else {
		Py_INCREF(Py_None);
		py_ret = Py_None;
	}
EOFgen
	elif [[ "${TYPE}" == "gboolean" ]]; then
cat >> ../modules/zpy-generated.c <<EOFgen

	if(c_ret){
		Py_INCREF(Py_True);
		py_ret = Py_True;
	} else {
		Py_INCREF(Py_False);
		py_ret = Py_False;
	}
EOFgen
	else	
cat >> ../modules/zpy-generated.c <<EOFgen

	/* TYPE_to_dict can set an exception if necessary.
	 * otherwise, Py_BuildValue will set SystemError if 
	 * the conversion function returns null
	 */
	py_ret = Py_BuildValue("O&", ${TYPE}_to_dict, c_ret);

	${TYPE}_free(c_ret);
	
EOFgen
	fi

cat >> ../modules/zpy-generated.c <<EOFgen

	if(PyErr_Occurred()){
		ERR("Python module (%s): interpreter error encountered", __func__);
		goto err;
	}

	return py_ret;

err:
	`/bin/echo -e "${FOREACHFREE}"`

	Py_XDECREF(py_ret);

	PyErr_SetFromGError(error);

	if(error){
		ERR("Python module (%s) - internal scheduler error encountered: '%s'", __func__, error->message);
		g_clear_error(&error);
	}

	return NULL;

}
EOFgen

done < $FTMP

#clear and regenerate headers
cat > ../modules/zpy-generated.h <<EOFgen
#include <Python.h>
#include "zentific.h"
#include "defines.h"
#include "jobcommon.h"
#include "zpy-typewrappers.h"
 
extern zModCallbacks *zmcb;
EOFgen

grep '^[A-Za-z]' ../modules/zpy-generated.c | grep -v 'err:' | sed -e 's#{#;#' >> ../modules/zpy-generated.h

## FUNCTION wrapper exposures via PyMethodDef
: > ../modules/zpy-wrapper-defs.c
for f in $(grep ' py_.*{' ../modules/zpy-generated.c | sed -e 's#\*# #' -e 's#(# #' | awk '{print $2}'); do
	trimmed=${f/py_/}
	echo "{\"${trimmed}\", ${f}, METH_VARARGS, \"Function wrapper around C _${trimmed}\"}," >> ../modules/zpy-wrapper-defs.c
done

## EXCEPTIONS : declaration, initialization, and conversion
: > ../modules/zpy-exc-defs.c
: > ../modules/zpy-exc-init.c
: > ../modules/zpy-exc-conv.c
exceptions=`mktemp`
exceptionconv=`mktemp`
exceptioninit=`mktemp`
for err in $(grep _XMLRPC_ERROR /opt/zentific/include/Common.h  | awk '{print $1}' | sed -e 's#_XMLRPC_ERROR_##'); do 
	
	#camelcase ugliness	
	# almost equivalent :  sed -E "s/(^|_)([a-z])/\u\2/g"
	string=$(echo $err | tr A-Z a-z | sed -e 's#_# #g');
	string=($string);
	string=${string[@]^};
	string=$(echo $string | sed -e 's# ##g');

	#exception declaration
	echo "static PyObject * PyExc_${string};" >> $exceptions

	#exception initialization
	echo >> $exceptioninit
	echo -e "\tPyExc_${string} = PyErr_NewException(\"zpymod.${string}\", NULL, NULL);" >> $exceptioninit
	echo -e "\tPy_INCREF(PyExc_${string});" >> $exceptioninit
	echo -e "\tPyModule_AddObject(m, \"${string}\", PyExc_${string});" >> $exceptioninit
	echo >> $exceptioninit
	

	#exception conversion
	echo -e "\tcase ZERR(${err}):" >> $exceptionconv
	echo -e "\t\texc = PyExc_${string};" >> $exceptionconv
	echo -e "\t\tbreak;" >> $exceptionconv

done
mv $exceptions ../modules/zpy-exc-defs.c
mv $exceptioninit ../modules/zpy-exc-init.c
mv $exceptionconv ../modules/zpy-exc-conv.c