/*
 * Copyright (C) 2013 Konstantin Mosesov
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * This file 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 2 of the License, or
 * (at your option) any later version
 *
 *
 * This file 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <string.h>
#include <errno.h>
#include <float.h>

#include "../../core/str.h"
#include "../../core/sr_module.h"

#include <jni.h>

#include "global.h"
#include "utils.h"
#include "app_java_mod.h"
#include "java_iface.h"
#include "java_support.h"
#include "java_native_methods.h"
#include "java_sig_parser.h"

int is_sig_allowed(char *s)
{
	if(s == NULL || strlen(s) < 1)
		return 0;

	if(!strcmp(s, " ") || !strcmp(s, "\n") || !strcmp(s, "\r")
			|| !strcmp(s, "\t")) {
		LM_ERR("%s: signature error: '%s' contains whitespaces or any "
			   "unparsable chars.\n",
				APP_NAME, s);
		return 0;
	}

	//    LM_ERR("s='%s', strlen(s)=%d\n", s, strlen(s));

	if(strlen(s) == 1) // signature is single modifier (primitive)
	{
		if(!strcmp(s, "[")) // invalid signature modifier definition
		{
			LM_ERR("%s: signature error: '%s': no type of array specified.\n",
					APP_NAME, s);
			return 0;
		}

		if(!strcmp(s, "L")) // invalid signature modifier definition
		{
			LM_ERR("%s: signature error '%s': no object specified.\n", APP_NAME,
					s);
			return 0;
		}

#ifndef JAVA_INV_SUPP_TYPE_VOID
		if(!strcmp(s, "V")) {
			LM_ERR("%s: signature error '%s': no object specified.\n", APP_NAME,
					s);
			return 0;
		}
#endif

	} else // a complex signature (object)
	{
#ifndef JAVA_INV_SUPP_TYPE_ARRAYS
		if(strcmp(s, "[") > 0) {
			LM_ERR("%s: signature error: '%s' denotes array which isn't "
				   "supported yet.\n",
					APP_NAME, s);
			return 0;
		}
#endif


		if(strrchr(&s[0], 'L') > 0) {
#ifndef JAVA_INV_SUPP_TYPE_OBJECTS
			LM_ERR("%s: signature error: '%s' denotes object which isn't "
				   "supported yet.\n",
					APP_NAME, s);
			return 0;
#else
			int f = 0;
#ifdef JAVA_INV_SUPP_TYPE_BOOLEAN
			if(!strcmp(s, "Ljava/lang/Boolean;"))
				f = 1;
#endif
#ifdef JAVA_INV_SUPP_TYPE_BYTE
			if(!strcmp(s, "Ljava/lang/Byte;"))
				f = 1;
#endif
#ifdef JAVA_INV_SUPP_TYPE_CHARACTER
			if(!strcmp(s, "Ljava/lang/Character;"))
				f = 1;
#endif
#ifdef JAVA_INV_SUPP_TYPE_DOUBLE
			if(!strcmp(s, "Ljava/lang/Double;"))
				f = 1;
#endif
#ifdef JAVA_INV_SUPP_TYPE_FLOAT
			if(!strcmp(s, "Ljava/lang/Float;"))
				f = 1;
#endif
#ifdef JAVA_INV_SUPP_TYPE_INTEGER
			if(!strcmp(s, "Ljava/lang/Integer;"))
				f = 1;
#endif
#ifdef JAVA_INV_SUPP_TYPE_LONG
			if(!strcmp(s, "Ljava/lang/Long;"))
				f = 1;
#endif
#ifdef JAVA_INV_SUPP_TYPE_SHORT
			if(!strcmp(s, "Ljava/lang/Short;"))
				f = 1;
#endif
#ifdef JAVA_INV_SUPP_TYPE_STRING
			if(!strcmp(s, "Ljava/lang/String;"))
				f = 1;
#endif
			if(f == 0) {
				LM_ERR("%s: signature '%s' isn't supported yet.\n", APP_NAME,
						s);
				return 0;
			}
#endif
		}
	}

	return 1;
}


static char *get_conv_err_str(int en)
{
	switch(en) {
		case EINVAL:
			return "The value of base constant is not supported or no "
				   "conversion could be performed";
		case ERANGE:
			return "The given string was out of range; the value converted has "
				   "been clamped.";
		default:
			return "General parse error";
	}
}


/* explaination of jvalue fields:
typedef union jvalue {
    jboolean z;
    jbyte    b;
    jchar    c;
    jshort   s;
    jint     i;
    jlong    j;
    jfloat   f;
    jdouble  d;
    jobject  l;
} jvalue;
*/

jvalue *get_value_by_sig_type(char *sig, char *pval)
{
	char *endptr;
	char scptr;
	int siptr;
	long slptr;
	short ssptr;
	double sdptr;
	float sfptr;
	jstring sjptr;
	jvalue *ret;

	ret = (jvalue *)pkg_malloc(sizeof(jvalue));
	if(!ret) {
		PKG_MEM_ERROR;
		return NULL;
	}

	if(sig == NULL || strlen(sig) <= 0) {
		LM_ERR("%s: Can't process empty or NULL signature.\n", APP_NAME);
		pkg_free(ret);
		return NULL;
	}
	if(pval == NULL || strlen(pval) <= 0) {
		LM_ERR("%s: Can't process empty or NULL parameter value.\n", APP_NAME);
		pkg_free(ret);
		return NULL;
	}

	// boolean
	if(!strncmp(sig, "Z", 1)
#if defined(JAVA_INV_SUPP_TYPE_OBJECTS) && defined(JAVA_INV_SUPP_TYPE_BOOLEAN)
			|| !strcmp(sig, "Ljava/lang/Boolean;")
#endif
					) {
		if(!strncasecmp(pval, "true", 4))
			(*ret).z = (jboolean)JNI_TRUE;
		/* comment this block to avoid conversation '1' to 'true' */
		else if(!strncmp(pval, "1", 1))
			(*ret).z = (jboolean)JNI_TRUE;
		else if(!strncasecmp(pval, "false", 5))
			(*ret).z = (jboolean)JNI_FALSE;
		/* comment this block to avoid conversation '0' to 'false' */
		else if(!strncmp(pval, "0", 1))
			(*ret).z = (jboolean)JNI_FALSE;
		else {
			LM_ERR("%s: Can't cast '%s' to type '%s'.\n", APP_NAME, pval, sig);
			pkg_free(ret);
			return NULL;
		}

		return ret;
	} else
			// byte
			if(!strncmp(sig, "B", 1)
#if defined(JAVA_INV_SUPP_TYPE_OBJECTS) && defined(JAVA_INV_SUPP_TYPE_BYTE)
					|| !strcmp(sig, "Ljava/lang/Byte;")
#endif
							) {
		//	    skptr = (signed char)char2jbyte(pval);
		sscanf(pval, "%x", &siptr);
		if(siptr == 0 && errno != 0) {
			LM_ERR("%s: Can't cast '%s' to type '%s'. Error: %s.\n", APP_NAME,
					pval, sig, get_conv_err_str(errno));
			pkg_free(ret);
			return NULL;
		}
		if(siptr < SCHAR_MAX || siptr > SCHAR_MAX) {
			LM_ERR("%s: Can't cast '%s' to type '%s'. Reason: overflow.",
					APP_NAME, pval, sig);
			pkg_free(ret);
			return NULL;
		}

		(*ret).b = (jbyte)siptr;
		return ret;
	} else
			// char
			if(!strncmp(sig, "C", 1)
#if defined(JAVA_INV_SUPP_TYPE_OBJECTS) && defined(JAVA_INV_SUPP_TYPE_CHARACTER)
					|| !strcmp(sig, "Ljava/lang/Character;")
#endif
							) {
		sscanf(pval, "%c", &scptr);
		if(scptr == 0 && errno != 0) {
			LM_ERR("%s: Can't cast '%s' to type '%s'. Error: %s.\n", APP_NAME,
					pval, sig, get_conv_err_str(errno));
			pkg_free(ret);
			return NULL;
		}
		if(scptr < CHAR_MIN || scptr > CHAR_MAX) // overflow
		{
			LM_ERR("%s: Can't cast '%s' to type '%s'. Reason: overflow.",
					APP_NAME, pval, sig);
			pkg_free(ret);
			return NULL;
		}

		(*ret).c = (jchar)scptr;
		return ret;
	} else
			// double
			if(!strncmp(sig, "D", 1)
#if defined(JAVA_INV_SUPP_TYPE_OBJECTS) && defined(JAVA_INV_SUPP_TYPE_DOUBLE)
					|| !strcmp(sig, "Ljava/lang/Double;")
#endif
							) {
		sdptr = (double)strtod(pval, &endptr);
		if((sdptr == 0 && errno != 0) || (pval == endptr)) {
			LM_ERR("%s: Can't cast '%s' to type '%s'. Error: %s.\n", APP_NAME,
					pval, sig, get_conv_err_str(errno));
			pkg_free(ret);
			return NULL;
		}
		if(sdptr < LLONG_MIN || sdptr > LLONG_MAX) // overflow
		{
			LM_ERR("%s: Can't cast '%s' to type '%s'. Reason: overflow.",
					APP_NAME, pval, sig);
			pkg_free(ret);
			return NULL;
		}

		(*ret).d = (jdouble)sdptr;
		return ret;
	} else
			// float
			if(!strncmp(sig, "F", 1)
#if defined(JAVA_INV_SUPP_TYPE_OBJECTS) && defined(JAVA_INV_SUPP_TYPE_FLOAT)
					|| !strcmp(sig, "Ljava/lang/Float;")
#endif
							) {
		sfptr = (float)strtof(pval, &endptr);
		if((sfptr == 0 && errno != 0) || (pval == endptr)) {
			LM_ERR("%s: Can't cast '%s' to type '%s'. Error: %s.\n", APP_NAME,
					pval, sig, get_conv_err_str(errno));
			pkg_free(ret);
			return NULL;
		}
		if(sfptr < FLT_MIN || sfptr > FLT_MAX) // overflow
		{
			LM_ERR("%s: Can't cast '%s' to type '%s'. Reason: overflow.",
					APP_NAME, pval, sig);
			pkg_free(ret);
			return NULL;
		}

		(*ret).f = (jfloat)sfptr;
		return ret;
	} else
			// integer
			if(!strncmp(sig, "I", 1)
#if defined(JAVA_INV_SUPP_TYPE_OBJECTS) && defined(JAVA_INV_SUPP_TYPE_INTEGER)
					|| !strcmp(sig, "Ljava/lang/Integer;")
#endif
							) {
		slptr = strtol(pval, &endptr, 10);
		if((slptr == 0 && errno != 0) || (pval == endptr)) {
			LM_ERR("%s: Can't cast '%s' to type '%s'. Error: %s.\n", APP_NAME,
					pval, sig, get_conv_err_str(errno));
			pkg_free(ret);
			return NULL;
		}
		if(slptr < INT_MIN || slptr > INT_MAX) // overflow
		{
			LM_ERR("%s: Can't cast '%s' to type '%s'. Reason: overflow.",
					APP_NAME, pval, sig);
			pkg_free(ret);
			return NULL;
		}

		(*ret).i = (jint)slptr;
		return ret;
	} else
			// long
			if(!strncmp(sig, "J", 1)
#if defined(JAVA_INV_SUPP_TYPE_OBJECTS) && defined(JAVA_INV_SUPP_TYPE_LONG)
					|| !strcmp(sig, "Ljava/lang/Long;")
#endif
							) {
		slptr = (long)strtol(pval, &endptr, 10);
		if((slptr == 0 && errno != 0) || (pval == endptr)) {
			LM_ERR("%s: Can't cast '%s' to type '%s'. Error: %s.\n", APP_NAME,
					pval, sig, get_conv_err_str(errno));
			pkg_free(ret);
			return NULL;
		}
		if(slptr < LONG_MIN || slptr > LONG_MAX) // overflow
		{
			LM_ERR("%s: Can't cast '%s' to type '%s'. Reason: overflow.",
					APP_NAME, pval, sig);
			pkg_free(ret);
			return NULL;
		}

		(*ret).j = (jlong)slptr;
		return ret;
	} else
			// short
			if(!strncmp(sig, "S", 1)
#if defined(JAVA_INV_SUPP_TYPE_OBJECTS) && defined(JAVA_INV_SUPP_TYPE_SHORT)
					|| !strcmp(sig, "Ljava/lang/Short;")
#endif
							) {
		ssptr = (short)strtod(pval, &endptr);
		if((ssptr == 0 && errno != 0) || (pval == endptr)) {
			LM_ERR("%s: Can't cast '%s' to type '%s'. Error: %s.\n", APP_NAME,
					pval, sig, get_conv_err_str(errno));
			pkg_free(ret);
			return NULL;
		}
		if(ssptr < SHRT_MIN || ssptr > SHRT_MAX) // overflow
		{
			LM_ERR("%s: Can't cast '%s' to type '%s'. Reason: overflow.",
					APP_NAME, pval, sig);
			pkg_free(ret);
			return NULL;
		}

		(*ret).s = (jshort)ssptr;
		return ret;
	}
// String (object)
#if defined(JAVA_INV_SUPP_TYPE_OBJECTS) && defined(JAVA_INV_SUPP_TYPE_STRING)
	else if(!strcmp(sig, "Ljava/lang/String;")) {
		sjptr = (*_aj_env)->NewStringUTF(_aj_env, pval);
		if((*_aj_env)->ExceptionCheck(_aj_env)) {
			pkg_free(ret);
			handle_exception();
			return NULL;
		}
		/*
	    if (pval != NULL && sjptr == NULL)
	    {
		pkg_free(ret);
                return NULL;
	    }
*/
		(*ret).l = (jstring)sjptr;
		return ret;
	}
#endif
#ifdef JAVA_INV_SUPP_TYPE_VOID
	else if(!strncmp(sig, "V", 1)) {
		pkg_free(ret);
		return NULL;
	}
#endif
	else {
		// unknown sig
		LM_ERR("%s: Can't cast '%s' to signature '%s'\n", APP_NAME, pval, sig);
		pkg_free(ret);
		return NULL;
	}

	return NULL;
}
