/* ------------------------------------------------
Copyright 2020 AT&T Intellectual Property
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
 ------------------------------------------- */

#include "schemaparser_impl.h"
#include<string.h>

namespace mc_schema{

int type_size(int dt){
	switch(dt){
	case INT_TYPE:
		return(sizeof(int));
	case UINT_TYPE:
	case USHORT_TYPE:
	case BOOL_TYPE:
	case IP_TYPE:
		return(sizeof(unsigned int));
	case ULLONG_TYPE:
		return(sizeof(unsigned long long int));
	case LLONG_TYPE:
		return(sizeof(long long int));
	case FLOAT_TYPE:
		return(sizeof(double));
	case IPV6_TYPE:
		return(sizeof(mc_ipv6_str));
	case TIMEVAL_TYPE:
		return(sizeof(timeval));
	case VSTR_TYPE:
		return(sizeof(mc_string));	
	default:
		return(UNDEFINED_TYPE);
	}
	return(UNDEFINED_TYPE);
};

int assign_type_from_string(std::string st){
//		convert to upper case
	std::for_each(st.begin(), st.end(), [](char & c) {
		c = ::toupper(c);
	});

	if(st == "BOOL"){
		return BOOL_TYPE;
	}
	if(st == "USHORT"){
		return USHORT_TYPE;
	}
	if(st == "UINT"){
		return UINT_TYPE;
	}
	if(st == "INT"){
		return INT_TYPE;
	}
	if(st == "ULLONG"){
		return ULLONG_TYPE;
	}
	if(st == "LLONG"){
		return LLONG_TYPE;
	}
	if(st == "FLOAT"){
		return FLOAT_TYPE;
	}
	if(st == "STRING" || st == "V_STR"){
		return VSTR_TYPE;		
	}
	if(st == "TIMEVAL"){
		return TIMEVAL_TYPE;
	}
	if(st == "IP"){
		return IP_TYPE;
	}
	if(st == "IPV6"){
		return IPV6_TYPE;
	}
	return 0;
}

std::string type_to_string(int typ){
	switch(typ){
	case BOOL_TYPE:
		return "BOOL";
	case USHORT_TYPE:
		return "USHORT";
	case UINT_TYPE:
		return "UINT";
	case INT_TYPE:
		return "INT";
	case ULLONG_TYPE:
		return  "ULLONG";
	case LLONG_TYPE:
		return "LLONG";
	case FLOAT_TYPE:
		return "FLOAT";
	case VSTR_TYPE:
		return "STRING";
	case TIMEVAL_TYPE:
		return "TIMEVAL";
	case IP_TYPE:
		return "IP";
	case IPV6_TYPE:
		return "IPV6_TYPE";
	default:
		return "UNDEFINED";
	}
	return "UNDEFINED";
}
	
//		there is a casting function
bool is_castable(int src, int dst){
	switch(src){
	case BOOL_TYPE:
		switch(dst){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case USHORT_TYPE:
		switch(dst){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case UINT_TYPE:
		switch(dst){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case INT_TYPE:
		switch(dst){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case ULLONG_TYPE:
		switch(dst){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case LLONG_TYPE:
		switch(dst){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case FLOAT_TYPE:
		switch(dst){
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case VSTR_TYPE:
		switch(dst){
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case TIMEVAL_TYPE:
		switch(dst){
		case TIMEVAL_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case IP_TYPE:
		switch(dst){
		case IP_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case IPV6_TYPE:
		switch(dst){
		case IPV6_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	default:
		return false;
	}
	return false;
}

//		cast without loss of information
bool is_compatible(int src, int dst){
	switch(src){
	case BOOL_TYPE:
		switch(dst){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case USHORT_TYPE:
		switch(dst){
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case UINT_TYPE:
		switch(dst){
		case UINT_TYPE:
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case INT_TYPE:
		switch(dst){
		case INT_TYPE:
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case ULLONG_TYPE:
		switch(dst){
		case ULLONG_TYPE:
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case LLONG_TYPE:
		switch(dst){
		case LLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case FLOAT_TYPE:
		switch(dst){
		case FLOAT_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case VSTR_TYPE:
		switch(dst){
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case TIMEVAL_TYPE:
		switch(dst){
		case TIMEVAL_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case IP_TYPE:
		switch(dst){
		case IP_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	case IPV6_TYPE:
		switch(dst){
		case IPV6_TYPE:
		case VSTR_TYPE:
			return true;
		default:
			return false;
		}
	default:
		return false;
	}
	return false;
}

//////////////////////////////////////////////////////
//		Field_entry

std::string field_entry::load_from_json(mc_json::json_value *froot){
	this->init();
	for(mc_json::json_value *fparts=froot->first_child; fparts!=NULL; fparts=fparts->next_sibling){
		if(strcmp(fparts->name, "name")==0){
			if(fparts->type!=mc_json::JSON_STRING){
				return "Error, the name of a field must be a string ("+std::to_string(fparts->type)+")";
			}
			name = fparts->string_value;
		}
		if(strcmp(fparts->name, "type")==0){
			if(fparts->type!=mc_json::JSON_STRING){
				return "Error, the type of a field must be a string ("+std::to_string(fparts->type)+")";
			}
			type = fparts->string_value;
		}
		if(strcmp(fparts->name, "pos")==0){
			if(fparts->type!=mc_json::JSON_STRING){
				return "Error, the pos of a field must be an int ("+std::to_string(fparts->type)+")";
			}
			pos = atoi(fparts->string_value);
		}
		if(strcmp(fparts->name, "is_ts")==0){
			if(fparts->type!=mc_json::JSON_BOOL){
				return "Error, the is_ts of a field must be a bool ("+std::to_string(fparts->type)+")";
			}
			is_ts = fparts->int_value;
		}
	}
	return "";
}

	
	


int tuple_access_info::init(field_entry *fe){
	field_name = fe->name;
	pdt = assign_type_from_string(fe->type);
	is_ts = fe->is_ts;
	offset = 0;
	return(pdt);
};

std::string tuple_access_info::to_string(){
	std::string ret = field_name+": offset="+std::to_string(offset)+", type="+type_to_string(pdt);
	if(is_ts){
		ret+=", is_ts";
	}
	return ret;
}

//////////////////////////////////////////////////////////////////
//		query_rep implementation
/////////////////////////////////////////////////////////////////


std::string _query_rep::init(const mc_json::json_value *strm){
	min_tuple_size = 0;

	if(strm->type != mc_json::JSON_OBJECT){
		return "Error, json stream must be a dict ("+std::to_string(strm->type)+").";
	}
	this->name = strm->name;
	for(mc_json::json_value *sparts=strm->first_child; sparts!=NULL; sparts=sparts->next_sibling){
//keys
		if(strcmp(sparts->name, "keys")==0){
			if(sparts->type != mc_json::JSON_ARRAY){
				return "Error, the keys in stream must be an array (" +std::to_string(sparts->type)+ ").";
				}
				for(mc_json::json_value *kparts=sparts->first_child; kparts!=NULL; kparts=kparts->next_sibling){
					if(kparts->type != mc_json::JSON_STRING){
						return "Error, the key entries in a stream must all be strings (" +std::to_string(kparts->type)+").";
					}
					keys.push_back(kparts->string_value);
				}
			}
// fields
		if(strcmp(sparts->name, "fields")==0){
			if(sparts->type != mc_json::JSON_ARRAY){
				return "Error, the fields in a stream must all be dict (" +std::to_string(sparts->type )+ ").";
			}
			for(mc_json::json_value *field=sparts->first_child; field!=NULL; field=field->next_sibling){
				if(field->type != mc_json::JSON_OBJECT){
					return "Error, the field entries in a stream must all be dicts (" +std::to_string(field->type )+ ").";
				}
				field_entry fe;
				std::string err = fe.load_from_json(field);
				if(err!=""){
					return "Error loading stream "+std::string(this->name)+": "+err;
				}
				tuple_access_info tai;
				int pdt = tai.init(&fe);
				if(pdt==UNDEFINED_TYPE){
					err = "Error in field "+fe.name+" of stream "+this->name+", unknown type "+fe.type;
					return err;
				}
				field_info.push_back(tai);
			}
		}
	}

	return "";
}


int _query_rep::finalize(){
	int f;
	int curr_pos = 0;
	int fld_undefined = 0;
	for(f=0;f<field_info.size();++f){
		field_info[f].offset = curr_pos;
		int sz = type_size(field_info[f].pdt);
		if(sz==0) fld_undefined = 1;
		curr_pos += sz;
	}
	min_tuple_size = curr_pos;
	if(fld_undefined) return(-1);
	else return(0);
}

//		Return a text representation
std::string _query_rep::to_string(){
	std::string ret = name + ": keys=[";
	for(int k=0;k<keys.size();++k){
		if(k>0)
			ret+=",";
		ret += keys[k];
	}
	ret += "], fields=\n";
	for(int f=0;f<field_info.size();++f){
		ret += field_info[f].to_string()+"\n";
	}
	ret+="\tmin_size="+std::to_string(min_tuple_size)+"\n";
	return ret;
}

//		Number of fields
int  _query_rep::get_num_fields(){
	return field_info.size();
}

//		name of ith field (starting at zero)
std::string _query_rep::get_field_name(int i){
	return field_info[i].field_name;
}

//		lookup field index by name, -1 if not found
int _query_rep::get_index_of_field(std::string name){
	for(int i=0;i<field_info.size();++i){
		if(field_info[i].field_name==name)
			return i;
	}
	return -1;
}

//		lookup field handle by name, offset is -1 if not found
field_handle _query_rep::get_handle_of_field(std::string name){
	field_handle ret;
	ret.offset = -1;
	for(int i=0;i<field_info.size();++i){
		if(field_info[i].field_name==name){
			ret.offset = field_info[i].offset;
			ret.type = field_info[i].pdt;
			return ret;
		}
	}
	return ret;
}


//		data type of ith field.
int _query_rep::get_type(int i){
	if(i<0 || i>=field_info.size())
		return UNDEFINED_TYPE;
	return field_info[i].pdt;
}

std::string _query_rep::get_type_name(int i){
	return type_to_string(this->get_type(i));
}

//		byte offset of ith field in a data block
int _query_rep::get_offset(int i){
	if(i<0 || i>field_info.size())
		return 0;
	return field_info[i].offset;
}

//		byte offset of ith field in a data block
field_handle _query_rep::get_handle(int i){
	field_handle ret;
	ret.offset = -1;
	if(i<0 || i>field_info.size())
		return ret;
	ret.offset = field_info[i].offset;
	ret.type = field_info[i].pdt;
	return ret;
}




//////////////////////////////////////////////////////////////////
//	mc_schemas implementation

//		n is a char buffer holding the json description of the stream schemas
_mc_schemas::_mc_schemas(const char *n) : mc_schemas() {
	this->init(n);
}
//		n is a string holding the json description of the stream schemas
_mc_schemas::_mc_schemas(std::string s){
	this->init(s.c_str());
}

void _mc_schemas::init(const char *n){
	nib_str = strdup(n);

	char *errorPos = 0;
	char *errorDesc = 0;
	int errorLine = 0;
	mc_json::block_allocator allocator(1 << 10); // 1 KB per block
	mc_json::json_value *jroot = mc_json::json_parse(nib_str, &errorPos, (const char**)&errorDesc, &errorLine, &allocator);

	if(jroot->type != mc_json::JSON_OBJECT){
		err =  "Error, root of the nib json must be a dict.";
		return ; 
	}

	for(mc_json::json_value *stream=jroot->first_child; stream!=NULL; stream=stream->next_sibling){
		if(stream->type != mc_json::JSON_OBJECT){
			err = "Error, the streams in the nib json must all be dict (" +std::to_string(stream->type )+ ").";
			return ;
		}
		std::string stream_name = stream->name;
		_query_rep *qr = new _query_rep();
		std::string stream_err = qr->init(stream);
		if(stream_err == ""){
			qr->finalize();
			qreps[stream_name] = qr;
		}else{
			qerrs[stream_name] = stream_err;
			delete qr;
		}
	}
}

//		true if there are any errors.
bool _mc_schemas::has_errors(){
	if(err!="")
		return true;
	if(qerrs.size()>0)
		return true;
	return false;
}

//		string with the error reports.  empty if there is no error.
std::string _mc_schemas::get_errors(){
	std::string ret = this->err;
	for(auto mi=qerrs.begin(); mi!=qerrs.end(); ++mi){
		if(err!="")
			err += "\n";
		err += (*mi).first+": "+(*mi).second;
	}
	return err;
}

//		return the names of the parsed streams.
std::vector<std::string> _mc_schemas::get_streams(){
	std::vector<std::string> ret;
	for(auto mi=qreps.begin(); mi!=qreps.end(); ++mi){
		ret.push_back(mi->first);
	}
	return ret;
}

//		return the names of the unsucessfully parsed streams
std::vector<std::string> _mc_schemas::get_error_streams(){
	std::vector<std::string> ret;
	for(auto mi=qerrs.begin(); mi!=qerrs.end(); ++mi){
		ret.push_back(mi->first);
	}
	return ret;
}

//		true if some stream was parsed successful or not
bool _mc_schemas::stream_found(std::string s){
	if(qreps.count(s)+qerrs.count(s) > 0)
		return true;
	return false;
}

//		true if there is a stream with name s which parsed successfully
bool _mc_schemas::stream_ok(std::string s){
	return qreps.count(s) > 0;
}

//		return the error associated with a stream, if any.
std::string _mc_schemas::get_stream_error(std::string s){
	if(qerrs.count(s)>0)
		return qerrs[s];
	if(qreps.count(s)>0)
		return "";
	return "not_found";
}

//		Get the query representation of a successfully parsed stream
query_rep *_mc_schemas::get_query_rep(std::string s){
	if(qreps.count(s)>0)
		return qreps[s];
	return NULL;
}

//	Destructor
_mc_schemas::~_mc_schemas(){
	free(nib_str);
	for(auto q=qreps.begin(); q!=qreps.end();++q){
		delete q->second;
	}
}


////////////
//	mc_schemas factory
mc_schemas *new_mc_schemas(std::string s){
	return new _mc_schemas(s);
}
mc_schemas *new_mc_schemas(const char *s){
	return new _mc_schemas(s);
}


////////////////////////////////////////////
//			Direct tuple access functions.

unsigned int unpack_uint(void *data, int len, int offset, int *problem){
	unsigned int retval;
	if(offset+sizeof(unsigned int) > len){
		*problem = 1;
		return(0);
	}
	memcpy(&retval, ((char *)data)+offset, sizeof(unsigned int));
	return(retval);
}
unsigned int unpack_ushort(void *data, int len, int offset, int *problem){
	unsigned int retval;
	if(offset+sizeof(unsigned int) > len){
		*problem = 1;
		return(0);
	}
	memcpy(&retval, ((char *)data)+offset, sizeof(unsigned int));
	return(retval);
}
unsigned int unpack_bool(void *data, int len, int offset, int *problem){
	unsigned int retval;
	if(offset+sizeof(unsigned int) > len){
		*problem = 1;
		return(0);
	}
	memcpy(&retval, ((char *)data)+offset, sizeof(unsigned int));
	return(retval);
}
int unpack_int(void *data, int len, int offset, int *problem){
	int retval;
	if(offset+sizeof(int) > len){
		*problem = 1;
		return(0);
	}
	memcpy(&retval, ((char *)data)+offset, sizeof(unsigned int));
	return(retval);
}
unsigned long long int unpack_ullong(void *data, int len, int offset, int *problem){
	unsigned long long int retval;
	if(offset+sizeof(unsigned long long int) > len){
		*problem = 1;
		return(0);
	}
	memcpy(&retval, ((char *)data)+offset, sizeof(unsigned long long int));
	return(retval);
}
long long int unpack_llong(void *data, int len, int offset, int *problem){
	long long int retval;
	if(offset+sizeof(long long int) > len){
		*problem = 1;
		return(0);
	}
	memcpy(&retval, ((char *)data)+offset, sizeof(long long int));
	return(retval);
}
double unpack_float(void *data, int len, int offset, int *problem){
	double retval;
	if(offset+sizeof(double) > len){
		*problem = 1;
		return(0);
	}
	memcpy(&retval, ((char *)data)+offset, sizeof(double));
	return(retval);
}
timeval unpack_timeval(void *data, int len, int offset, int *problem){
	timeval retval;
	if(offset+sizeof(timeval) > len){
		*problem = 1;
		retval.tv_sec = 0;
		retval.tv_usec = 0;
		return(retval);
	}
	memcpy(&retval, ((char *)data)+offset, sizeof(timeval));
	return(retval);
}
mc_string unpack_vstr(void *data,  int len, int offset, int *problem){
	mc_string retval;
	vstring32 unpack_s;

	if(offset+sizeof( vstring32) > len){
		*problem = 1;
		return(retval);
	}

	memcpy(&unpack_s, ((char *)data)+offset, sizeof(vstring32));

	retval.length = unpack_s.length;

	if(unpack_s.offset + retval.length > len){
		*problem = 1;
		return(retval);
	}
	retval.data = (char *)data + unpack_s.offset;
	return(retval);
}

struct mc_ipv6_str unpack_ipv6(void *data,  int len, int offset, int *problem){
        struct mc_ipv6_str retval;
        if(offset+sizeof(mc_ipv6_str) > len){
        	*problem = 1;
        	return(retval);
        }
        memcpy(&retval, ((char *)data)+offset, sizeof(mc_ipv6_str));
        return(retval);
}


access_result get_field_by_index(query_rep *qr, int index,
			void * data, int len){
	access_result retval;
	retval.field_data_type = UNDEFINED_TYPE;
	int problem = 0;

	if(index >= qr->get_num_fields()){
		return(retval);
	}

	switch(qr->get_type(index)){
	case UINT_TYPE:
		retval.r.ui = unpack_uint(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = UINT_TYPE;
		break;
	case IP_TYPE:
		retval.r.ui = unpack_uint(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = IP_TYPE;
		break;
	case INT_TYPE:
		retval.r.i = unpack_int(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = INT_TYPE;
		break;
	case ULLONG_TYPE:
		retval.r.ul = unpack_ullong(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = ULLONG_TYPE;
		break;
	case LLONG_TYPE:
		retval.r.l = unpack_llong(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = LLONG_TYPE;
		break;
	case USHORT_TYPE:
		retval.r.ui = unpack_ushort(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = USHORT_TYPE;
		break;
	case FLOAT_TYPE:
		retval.r.f = unpack_float(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = FLOAT_TYPE;
		break;
	case BOOL_TYPE:
		retval.r.ui = unpack_bool(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = BOOL_TYPE;
		break;
	case VSTR_TYPE:
		retval.r.vs = unpack_vstr(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = VSTR_TYPE;
		break;
	case TIMEVAL_TYPE:
		retval.r.t = unpack_timeval(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = TIMEVAL_TYPE;
		break;
	case IPV6_TYPE:
		retval.r.ip6 = unpack_ipv6(data,  len,
			qr->get_offset(index), &problem);
		if(!problem) retval.field_data_type = IPV6_TYPE;
		break;
	case UNDEFINED_TYPE:
		break;
	}
	return(retval);
}

access_result get_field_by_handle(field_handle f, void * data, int len){
	access_result retval;
	retval.field_data_type = UNDEFINED_TYPE;
	int problem = 0;

	switch(f.type){
	case UINT_TYPE:
		retval.r.ui = unpack_uint(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = UINT_TYPE;
		break;
	case IP_TYPE:
		retval.r.ui = unpack_uint(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = IP_TYPE;
		break;
	case INT_TYPE:
		retval.r.i = unpack_int(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = INT_TYPE;
		break;
	case ULLONG_TYPE:
		retval.r.ul = unpack_ullong(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = ULLONG_TYPE;
		break;
	case LLONG_TYPE:
		retval.r.l = unpack_llong(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = LLONG_TYPE;
		break;
	case USHORT_TYPE:
		retval.r.ui = unpack_ushort(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = USHORT_TYPE;
		break;
	case FLOAT_TYPE:
		retval.r.f = unpack_float(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = FLOAT_TYPE;
		break;
	case BOOL_TYPE:
		retval.r.ui = unpack_bool(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = BOOL_TYPE;
		break;
	case VSTR_TYPE:
		retval.r.vs = unpack_vstr(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = VSTR_TYPE;
		break;
	case TIMEVAL_TYPE:
		retval.r.t = unpack_timeval(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = TIMEVAL_TYPE;
		break;
	case IPV6_TYPE:
		retval.r.ip6 = unpack_ipv6(data,  len, f.offset, &problem);
		if(!problem) retval.field_data_type = IPV6_TYPE;
		break;
	case UNDEFINED_TYPE:
		break;
	}
	return(retval);
}

int get_field_int(field_handle f, void * data, int len){
	access_result a = get_field_by_handle(f, data, len);
	switch(f.type){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
			return (int)(a.r.ui);
		case INT_TYPE:
		case IP_TYPE:
			return (int)(a.r.i);
		case LLONG_TYPE:
			return (int)(a.r.l);
		case ULLONG_TYPE:
			return (int)(a.r.ul);
		case FLOAT_TYPE:
		case VSTR_TYPE:
		case TIMEVAL_TYPE:
		case IPV6_TYPE:
			return 0;
		default:
			return 0;
	}
	return 0;
}

unsigned int get_field_uint(field_handle f, void * data, int len){
	access_result a = get_field_by_handle(f, data, len);
	switch(f.type){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
			return (unsigned int)(a.r.ui);
		case INT_TYPE:
		case IP_TYPE:
			return (unsigned int)(a.r.i);
		case LLONG_TYPE:
			return (unsigned int)(a.r.l);
		case ULLONG_TYPE:
			return (unsigned int)(a.r.ul);
		case FLOAT_TYPE:
		case VSTR_TYPE:
		case TIMEVAL_TYPE:
		case IPV6_TYPE:
			return 0;
		default:
			return 0;
	}
	return 0;
}

long long int get_field_llong(field_handle f, void * data, int len){
	access_result a = get_field_by_handle(f, data, len);
	switch(f.type){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
			return (long long int)(a.r.ui);
		case INT_TYPE:
		case IP_TYPE:
			return (long long int)(a.r.i);
		case LLONG_TYPE:
			return (long long int)(a.r.l);
		case ULLONG_TYPE:
			return (long long int)(a.r.ul);
		case FLOAT_TYPE:
		case VSTR_TYPE:
		case TIMEVAL_TYPE:
		case IPV6_TYPE:
			return 0;
		default:
			return 0;
	}
	return 0;
}
			
unsigned long long int get_field_ullong(field_handle f, void * data, int len){
	access_result a = get_field_by_handle(f, data, len);
	switch(f.type){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
			return (unsigned long long int)(a.r.ui);
		case INT_TYPE:
		case IP_TYPE:
			return (unsigned long long int)(a.r.i);
		case LLONG_TYPE:
			return (unsigned long long int)(a.r.l);
		case ULLONG_TYPE:
			return (unsigned long long int)(a.r.ul);
		case FLOAT_TYPE:
		case VSTR_TYPE:
		case TIMEVAL_TYPE:
		case IPV6_TYPE:
			return 0;
		default:
			return 0;
	}
	return 0;
}

double get_field_float(field_handle f, void * data, int len){
	access_result a = get_field_by_handle(f, data, len);
	switch(f.type){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
			return (unsigned long long int)(a.r.ui);
		case INT_TYPE:
		case IP_TYPE:
			return (unsigned long long int)(a.r.i);
		case LLONG_TYPE:
			return (unsigned long long int)(a.r.l);
		case ULLONG_TYPE:
			return (unsigned long long int)(a.r.ul);
		case FLOAT_TYPE:
		case VSTR_TYPE:
		case TIMEVAL_TYPE:
		case IPV6_TYPE:
			return 0;
		default:
			return 0;
	}
	return 0;
}
timeval get_field_timeval(field_handle f, void * data, int len){
	access_result a = get_field_by_handle(f, data, len);
	switch(f.type){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case IP_TYPE:
		case LLONG_TYPE:
		case ULLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
		case IPV6_TYPE:
			a.r.t.tv_sec = 0;
			a.r.t.tv_usec = 0;
			return a.r.t;
		case TIMEVAL_TYPE:
			return a.r.t;
		default:
			a.r.t.tv_sec = 0;
			a.r.t.tv_usec = 0;
			return a.r.t;
	}
	a.r.t.tv_sec = 0;
	a.r.t.tv_usec = 0;
	return a.r.t;
}

mc_ipv6_str get_field_ipv6(field_handle f, void * data, int len){
	access_result a = get_field_by_handle(f, data, len);
	switch(f.type){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
		case INT_TYPE:
		case IP_TYPE:
		case LLONG_TYPE:
		case ULLONG_TYPE:
		case FLOAT_TYPE:
		case VSTR_TYPE:
		case TIMEVAL_TYPE:
			a.r.ip6.v[0] = 0;
			a.r.ip6.v[1] = 0;
			a.r.ip6.v[2] = 0;
			a.r.ip6.v[3] = 0;
			return a.r.ip6;
		case IPV6_TYPE:
			return a.r.ip6;
		default:
			a.r.ip6.v[0] = 0;
			a.r.ip6.v[1] = 0;
			a.r.ip6.v[2] = 0;
			a.r.ip6.v[3] = 0;
			return a.r.ip6;
	}
	a.r.ip6.v[0] = 0;
	a.r.ip6.v[1] = 0;
	a.r.ip6.v[2] = 0;
	a.r.ip6.v[3] = 0;
	return a.r.ip6;
}
	

std::string get_field_string(field_handle f, void * data, int len){
	access_result a = get_field_by_handle(f, data, len);
	switch(f.type){
		case BOOL_TYPE:
		case USHORT_TYPE:
		case UINT_TYPE:
			return std::to_string(a.r.ui);
		case INT_TYPE:
		case IP_TYPE:
			return std::to_string(a.r.i);
		case LLONG_TYPE:
			return std::to_string(a.r.l);
		case ULLONG_TYPE:
			return std::to_string(a.r.ul);
		case FLOAT_TYPE:
			return std::to_string(a.r.f);
		case VSTR_TYPE:{
			std::string rets(a.r.vs.data, a.r.vs.length);
			return rets;
		}
		case TIMEVAL_TYPE:{
			double tv = a.r.t.tv_sec + ((double)a.r.t.tv_usec)/1000000.0;
			return std::to_string(tv);
		}
		case IPV6_TYPE:{
			char buf[100];
			sprintf(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x",
				a.r.ip6.v[0] >> 16, (a.r.ip6.v[0]) & 0xffff,
				a.r.ip6.v[1] >> 16, (a.r.ip6.v[1]) & 0xffff,
				a.r.ip6.v[2] >> 16, (a.r.ip6.v[2]) & 0xffff,
				a.r.ip6.v[3] >> 16, (a.r.ip6.v[3]) & 0xffff
			);
			return buf;
		}
		default:
			return "";
	}
	return "";
}
		
}