/*
 * Hunt - A refined core library for D programming language.
 *
 * Copyright (C) 2018-2019 HuntLabs
 *
 * Website: https://www.huntlabs.net/
 *
 * Licensed under the Apache-2.0 License.
 *
 */


deprecated("It's buggy. Use hunt.serialization.JsonSerializer instead.")
module hunt.util.Serialize;

import std.traits;
import std.string;
import core.stdc.string;
import std.stdio;
import std.bitmanip;
import std.math;
public import std.json;

public:
enum IGNORE = 1024;

class UnIgnoreArray{
	
	void setUnIgnore(T)()
	{
		_unIgnore[T.stringof] = true;
	}

	bool ignore(T)()
	{
		return T.stringof !in _unIgnore;
	}

private:
	bool[string] _unIgnore;
}


private:

class RefClass
{
	size_t[size_t] map;
	void*[] arr;
	uint level;
	bool ignore;	 				///  all class or struct ignore or not. 
	UnIgnoreArray unIgnore;			///  part class unignore. 
}

enum MAGIC_KEY = "o0o0o";

enum bool isType(T1, T2) = is(T1 == T2) || is(T1 == ImmutableOf!T2)
		|| is(T1 == ConstOf!T2) || is(T1 == InoutOf!T2)
		|| is(T1 == SharedOf!T2) || is(T1 == SharedConstOf!T2) || is(T1 == SharedInoutOf!T2);

enum bool isSignedType(T) = isType!(T, byte) || isType!(T, short) || isType!(T,
			int) || isType!(T, long);
enum bool isUnsignedType(T) = isType!(T, ubyte) || isType!(T, ushort)
		|| isType!(T, uint) || isType!(T, ulong);
enum bool isBigSignedType(T) = isType!(T, int) || isType!(T, long);
enum bool isBigUnsignedType(T) = isType!(T, uint) || isType!(T, ulong);

//unsigned
ulong[] byte_dots = [1 << 7, 1 << 14, 1 << 21, 1 << 28, cast(ulong) 1 << 35,
	cast(ulong) 1 << 42, cast(ulong) 1 << 49, cast(ulong) 1 << 56, cast(ulong) 1 << 63,];

//signed
ulong[] byte_dots_s = [1 << 6, 1 << 13, 1 << 20, 1 << 27, cast(ulong) 1 << 34,
	cast(ulong) 1 << 41, cast(ulong) 1 << 48, cast(ulong) 1 << 55, cast(ulong) 1 << 62,];

ubyte getbytenum(ulong v)
{
	ubyte i = 0;
	for (; i < byte_dots.length; i++)
	{
		if (v < byte_dots[i])
		{
			break;
		}
	}
	return cast(ubyte)(i + 1);
}

ubyte getbytenums(ulong v)
{
	ubyte i = 0;
	for (; i < byte_dots_s.length; i++)
	{
		if (v < byte_dots_s[i])
		{
			break;
		}
	}

	return cast(ubyte)(i + 1);
}

//signed
byte[] toVariant(T)(T t) if (isSignedType!T)
{
	bool symbol = false;
	if (t < 0)
		symbol = true;

	ulong val = cast(ulong) abs(t);

	ubyte num = getbytenums(val);

	ubyte[] var;
	if(num == 1)
	{
		if (symbol)
			val = val | 0x40;
	}
	else{
		for (size_t i = num; i > 1; i--)
		{
			auto n = val / (byte_dots_s[i - 2] * 2);
			if (symbol && i == num)
				n = n | 0x40;
			var ~= cast(ubyte) n;
			val = (val % (byte_dots_s[i - 2] * 2));
		}
	}

	var ~= cast(ubyte)(val | 0x80);
	return cast(byte[]) var;
}

T toT(T)(const byte[] b, out long index) if (isSignedType!T)
{
	T val = 0;
	ubyte i = 0;
	bool symbol = false;

	if(b.length == 1)
	{
		val = (b[i] & 0x3F);
		if (b[i] & 0x40)
			symbol = true;
	}
	else
	{
		for (i = 0; i < b.length; i++)
		{
			if (i == 0)
			{
				val = (b[i] & 0x3F);
				if (b[i] & 0x40)
					symbol = true;			
			}
			else
			{
				val = cast(T)((val << 7) + (b[i] & 0x7F));
			}
		
			if (b[i] & 0x80)
				break;
		}
	}

	index = i + 1;
	if (symbol)
		return cast(T)(val * -1);
	else
		return val;
}

//unsigned
byte[] toVariant(T)(T t) if (isUnsignedType!T)
{
	ubyte num = getbytenum(cast(ulong) t);
	T val = t;
	ubyte[] var;
	for (size_t i = num; i > 1; i--)
	{
		auto n = val / (byte_dots[i - 2]);
		var ~= cast(ubyte) n;
		val = val % (byte_dots[i - 2]);
	}
	var ~= cast(ubyte)(val | 0x80);
	return cast(byte[]) var;
}

//unsigned
T toT(T)(const byte[] b, out long index) if (isUnsignedType!T)
{
	T val = 0;
	ubyte i = 0;
	for (i = 0; i < b.length; i++)
	{

		val = cast(T)((val << 7) + (b[i] & 0x7F));
		if (b[i] & 0x80)
			break;
	}
	index = i + 1;
	return val;
}

byte getbasictype(long size)
{
	if (size == 1)
		return 0;
	else if (size == 2)
		return 1;
	else if (size == 4)
		return 2;
	else if (size == 8)
		return 3;
	else
		assert(0);
}

byte getbasicsize(byte type)
{
	if (type == 0)
		return 1;
	else if (type == 1)
		return 2;
	else if (type == 2)
		return 4;
	else if (type == 3)
		return 8;
	else
		assert(0);
}

string serializeMembers(T)()
{
	string str;
	foreach (m; FieldNameTuple!T)
	{
		static if (__traits(getProtection, __traits(getMember, T, m)) == "public")
		{
			str ~= "data ~= serialize(t." ~ m ~ " , stack , level + 1);";
		}
	}
	return str;
}

string unserializeMembers(T)()
{
	string str;
	// str ~= "long parse = 0; ";
	foreach (m; FieldNameTuple!T)
	{
		static if (__traits(getProtection, __traits(getMember, T, m)) == "public")
		{
			str ~= " if ( index < parse_index)";
			str ~= "{";
			str ~= "t." ~ m ~ " = unserialize!(typeof(t." ~ m
				~ "))(data[cast(uint)index .. data.length] , parse , stack); ";
			str ~= "index += parse; }";
		}

	}
	return str;
}

string getsizeMembers(T)()
{
	string str;
	foreach (m; FieldNameTuple!T)
	{
		static if (__traits(getProtection, __traits(getMember, T, m)) == "public")
		{
		str ~= "total += getsize(t." ~ m ~ " , stack , level + 1);";
		}		
	}
	return str;
}

///////////////////////////////////////////////////////////
// basic
// type 		  size
//  0     - 		1
//  1	 -			2
//  2	 -			4
//  3	 - 			8
//	data
///////////////////////////////////////////////////////////
///
byte[] serialize(T)(T t, RefClass stack, uint level)
		if (isScalarType!T && !isBigSignedType!T && !isBigUnsignedType!T && !is(T == enum))
{
	byte[] data;
	data.length = T.sizeof + 1;
	data[0] = getbasictype(T.sizeof);
	memcpy(data.ptr + 1, &t, T.sizeof);
	return data;
}

T unserialize(T)(const byte[] data, out long parse_index, RefClass stack)
		if (isScalarType!T && !isBigSignedType!T && !isBigUnsignedType!T && !is(T == enum))
{
	assert(cast(byte) T.sizeof == getbasicsize(data[0]));

	T value;
	memcpy(&value, data.ptr + 1, T.sizeof);

	parse_index = T.sizeof + 1;
	return value;
}

size_t getsize(T)(T t, RefClass stack, uint level)
		if (isScalarType!T && !isBigSignedType!T && !isBigUnsignedType!T && !is(T == enum))
{
	return T.sizeof + 1;
}

///////////////////////////////////////////////////////////
// variant
// type 		  size
//  5 (4)    - 		
//  6 (8)	 -
//	data
///////////////////////////////////////////////////////////
byte[] serialize(T)(T t, RefClass stack, uint level)
		if (isBigSignedType!T || isBigUnsignedType!T)
{
	byte[] data = toVariant!T(t);
	long index;
	byte[1] h;
	h[0] = (T.sizeof == 4) ? 5 : 8;
	return h ~ data;
}

T unserialize(T)(const byte[] data, out long parse_index, RefClass stack)
		if (isBigSignedType!T || isBigUnsignedType!T)
{
	assert((T.sizeof == 4 ? 5 : 8) == data[0]);
	long index;
	T t = toT!T(data[1 .. $], index);
	parse_index = index + 1;
	return t;
}

size_t getsize(T)(T t, RefClass stack, uint level) if (isBigSignedType!T)
{
	return getbytenums(abs(t)) + 1;
}

size_t getsize(T)(T t, RefClass stack, uint level) if (isBigUnsignedType!T)
{
	return getbytenum(abs(t)) + 1;
}

// TString
// 1 type 7
// [uint] variant 
//  data

byte[] serialize(T)(T str, RefClass stack, uint level) if (is(T == string))
{
	byte[] data;
	uint len = cast(uint) str.length;
	byte[] dlen = toVariant(len);
	data.length = 1 + dlen.length + len;

	data[0] = 7;
	memcpy(data.ptr + 1, dlen.ptr, dlen.length);
	memcpy(data.ptr + 1 + dlen.length, str.ptr, len);
	return data;
}

string unserialize(T)(const byte[] data, out long parse_index, RefClass stack)
		if (is(T == string))
{
	assert(data[0] == 7);
	long index;
	uint len = toT!uint(data[1 .. $], index);
	parse_index += 1 + index + len;
	return cast(T)(data[cast(size_t)(1 + index) .. cast(size_t) parse_index].dup);
}

size_t getsize(T)(T str, RefClass stack, uint level) if (is(T == string))
{
	uint len = cast(uint) str.length;
	return cast(size_t)(1 + toVariant(len).length + str.length);
}

// TUnion			don't support TUnion
// 1 type 6
// 1 len 
// 	 data

/*
byte[] serialize(T)(T t) if(is(T == union))
{
	byte[] data;
	data.length = T.sizeof + 2;
	data[0] = 5;
	data[1] = T.sizeof;
	memcpy(data.ptr + 2 , &t , T.sizeof);
	return data;
}
T unserialize(T)(const byte[] data ) if(is(T == union))
{
	long parser_index;
	return unserialize!T(data , parser_index);
}
T unserialize(T)(const byte[] data , out long parse_index) if(is(T == union))
{
	assert(data[0] == 5);
	
	T value;
	byte len;
	memcpy(&len , data.ptr + 1 , 1);
	parse_index = 2 + len;
	memcpy(&value , data.ptr + 2 , len);
	return value;
}
size_t getsize(T)(T t) if(is(T == union))
{
	return 2 + T.sizeof;
}
*/

// TSArray
// 1 type 8
// size[uint] variant
// len[uint] variant
// data

byte[] serialize(T)(T t, RefClass stack, uint level) if (isStaticArray!T)
{
	byte[1] header;
	header[0] = 8;
	uint uSize = cast(uint) t.length;
	byte[] dh = cast(byte[]) header;
	dh ~= toVariant(uSize);

	byte[] data;
	for (size_t i = 0; i < uSize; i++)
	{
		data ~= serialize(t[i], stack, level + 1);
	}
	uint len = cast(uint) data.length;
	dh ~= toVariant(len);
	return dh ~ data;
}

T unserialize(T)(const byte[] data, out long parse_index, RefClass stack)
		if (isStaticArray!T)
{
	assert(data[0] == 8);
	T value;
	uint uSize;
	uint len;
	long index1;
	long index2;
	uSize = toT!uint(data[1 .. $], index1);

	len = toT!uint(data[cast(size_t)(index1 + 1) .. $], index2);
	parse_index += 1 + index1 + index2;

	long index = parse_index;
	long parse = 0;
	for (size_t i = 0; i < uSize; i++)
	{
		parse = 0;
		value[i] = unserialize!(typeof(value[0]))(data[cast(size_t) index .. data.length],
				parse, stack);
		index += parse;
	}

	parse_index += len;

	return value;
}

size_t getsize(T)(T t, RefClass stack, uint level) if (isStaticArray!T)
{
	long total = 1;
	total += getbytenum(t.length);
	uint uSize = cast(uint) t.length;
	for (size_t i = 0; i < uSize; i++)
	{
		total += getsize(t[i], stack, level + 1);
	}
	total += getbytenum(total);
	return total;
}

//  TDArray
// 1  type 9
// size[uint]	variant
// length[uint]	variant
// data

byte[] serialize(T)(T t, RefClass stack, uint level)
		if (isDynamicArray!T && !is(T == string) && !is(T == enum))
{
	byte[1] header;
	header[0] = 9;

	uint uSize = cast(uint) t.length;
	byte[] dh = cast(byte[]) header;
	dh ~= toVariant(uSize);

	byte[] data;
	for (size_t i = 0; i < uSize; i++)
	{
		data ~= serialize(t[i], stack, level + 1);
	}
	uint len = cast(uint) data.length;
	dh ~= toVariant(len);

	return dh ~ data;
}

T unserialize(T)(const byte[] data, out long parse_index, RefClass stack)
		if (isDynamicArray!T && !is(T == string) && !is(T == enum))
{
	assert(data[0] == 9);

	T value;
	uint uSize;
	uint len;
	long index1;
	long index2;
	uSize = toT!uint(data[1 .. $], index1);
	len = toT!uint(data[cast(size_t)(1 + index1) .. $], index2);

	parse_index += 1 + index1 + index2;
	value.length = uSize;
	ulong index = parse_index;
	long parse = 0;
	for (size_t i = 0; i < uSize; i++)
	{
		value[i] = unserialize!(typeof(value[0]))(data[cast(size_t) index .. data.length],
				parse, stack);
		index += parse;
	}
	parse_index += len;

	return value;
}

size_t getsize(T)(T t, RefClass stack, uint level)
		if (isDynamicArray!T && !is(T == string) && !is(T == enum) )
{
	long total = 1;
	total += getbytenum(t.length);
	uint uSize = cast(uint) t.length;
	for (size_t i = 0; i < uSize; i++)
	{
		total += getsize(t[i], stack, level + 1);
	}
	total += getbytenum(total);
	return total;
}

// TStruct
// 1 type 10
// [uint] variant
// data

byte[] serialize(T)(T t, RefClass stack, uint level) if (is(T == struct))
{
	byte[1] header;
	header[0] = 10;
	byte[] data;

	mixin(serializeMembers!T());
	byte[] dh = cast(byte[]) header;
	uint len = cast(uint) data.length;
	dh ~= toVariant(len);
	return dh ~ data;
}

T unserialize(T)(const byte[] data, out long parse_index, RefClass stack)
		if (is(T == struct))
{
	assert(data[0] == 10);

	T t;
	long index1;
	uint len = toT!uint(data[1 .. $], index1);

	parse_index = 1 + index1 + len;
	long index = 1 + index1;
	long parse = 0; 
	mixin(unserializeMembers!T());

	return t;
}

size_t getsize(T)(T t, RefClass stack, uint level) if (is(T == struct))
{
	long total = 1;

	mixin(getsizeMembers!T());

	total += getbytenum(total);
	return cast(uint) total;
}

// TClass 
// 1 type 11
// [uint] len variant
//	data

// TClass ref
// 1 type 12
// id variant

byte[] serialize(T, bool isRecursive=true)(T t, RefClass stack, uint level) if (is(T == class))
{
	byte[1] header;
	size_t* id = null;

	if (t !is null)
	{
		id = t.toHash() in stack.map;
	}

	if (id == null)
	{
		header[0] = 11;
		byte[] data;
		byte[] dh = cast(byte[]) header;
		if (t !is null)
		{
			stack.map[t.toHash()] = stack.map.length;
			static if(isRecursive) {
				static foreach(S; BaseClassesTuple!(T)) {
					mixin(serializeMembers!S());
				}
			}
			mixin(serializeMembers!T());
		}
		uint len = cast(uint) data.length;
		dh ~= toVariant(len);

		return dh ~ data;
	}
	else
	{
		header[0] = 12;
		byte[] dh = cast(byte[]) header;
		dh ~= toVariant(*id);
		return dh;
	}

}

T unserialize(T)(const byte[] data, out long parse_index, RefClass stack)
		if (is(T == class) && !isAbstractClass!T)
{
	if(data.length < 2)
		return T.init;
		
	assert(data[0] == 11 || data[0] == 12);

	if (data[0] == 11)
	{
		long index1;
		uint len = toT!uint(data[1 .. $], index1);
		if (len == 0)
			return null;
		T t = new T;
		parse_index = index1 + 1 + len;
		long index = index1 + 1;
		stack.arr ~= cast(void*) t;

		long parse = 0; 

		static foreach(S; BaseClassesTuple!(T)) {
			mixin(unserializeMembers!S());
		}
		mixin(unserializeMembers!T());

		return t;
	}
	else
	{
		long index1;
		size_t id = toT!size_t(data[1 .. $], index1);
		parse_index += index1 + 1;
		return cast(T) stack.arr[id];
	}

}

size_t getsize(T)(T t, RefClass stack, uint level) if (is(T == class))
{
	long total = 1;

	size_t* id = null;

	if (t !is null)
	{
		id = t.toHash() in stack.map;
	}

	if (id == null)
	{
		if (t !is null)
		{
			stack.map[t.toHash()] = stack.map.length;
			mixin(getsizeMembers!T());
		}

		total += getbytenum(total - 1);
		return total;
	}
	else
	{
		return getbytenum(*id) + 1;
	}

}

// AssociativeArray
// 1 type 13
// [uint] len variant
// (k,v)

byte[] serialize(T)(T t, RefClass stack, uint level) if (isAssociativeArray!T)
{
	byte[1] header;
	header[0] = 13;
	byte[] dh;
	dh ~= cast(byte[]) header;
	byte[] data;
	foreach (k, v; t)
	{
		data ~= serialize(k, stack, level + 1);
		data ~= serialize(v, stack, level + 1);
	}
	uint len = cast(uint) data.length;
	dh ~= toVariant(len);
	return dh ~ data;
}

T unserialize(T)(const byte[] data, out long parse_index, RefClass stack)
		if (isAssociativeArray!T)
{
	assert(data[0] == 13);

	T t;
	long index1;
	uint len = toT!uint(data[1 .. $], index1);

	parse_index = index1 + 1 + len;
	long index = index1 + 1;
	while (index < parse_index)
	{
		long out_len;
		auto k = unserialize!(KeyType!T)(data[index .. $], out_len, stack);
		index += out_len;
		out_len = 0;
		auto v = unserialize!(ValueType!T)(data[index .. $], out_len, stack);
		index += out_len;
		t[k] = v;
	}
	return t;
}

size_t getsize(T)(T t, RefClass stack, uint level) if (isAssociativeArray!T)
{
	long total = 1;
	foreach (k, v; t)
	{
		total += serialize(k).length;
		total += serialize(v).length;
	}
	total += getbytenum(total - 1);
	return total;
}

// named enum
// 1 type 14
// 2 [uint] len 
// 3 other
byte[] serialize(T)(T t, RefClass stack, uint level) if (is(T == enum))
{
	byte[1] header;
	header[0] = 14;
	byte[] dh;
	dh ~= cast(byte[]) header;
	OriginalType!T v = cast(OriginalType!T)t;
	byte[] data =  serialize(v);
	uint len = cast(uint)data.length;
	dh ~= toVariant(len);
	return dh ~ data;
}

T unserialize(T)(const byte[] data, out long parse_index, RefClass stack)
		if (is(T == enum))
{
	assert(data[0] == 14);

	T t;
	long index1;
	uint len = toT!uint(data[1 .. $], index1);

	parse_index = index1 + 1 + len;
	long index = index1 + 1;
	while (index < parse_index)
	{
		long out_len = 0;
		t = cast(T)unserialize!(OriginalType!T)(data[index .. $], out_len, stack);
		index += out_len;
	}
	return t;
}

size_t getsize(T)(T t, RefClass stack, uint level) if (is(T == enum))
{
	long total = 1;
	
	total += serialize(cast(OriginalType!T)t).length;
	
	total += getbytenum(total - 1);
	return total;
}



public:

T unserialize(T)(const(ubyte)[] data ) {
	return unserialize!(T)(cast(const byte[])data);
}

T unserialize(T)(const byte[] data )
{
	long parse_index;
	return unserialize!T(data, parse_index);
}

T unserialize(T)(const(ubyte)[] data, out long parse_index ) {
	return unserialize!(T)(cast(const byte[])data, parse_index);
}

T unserialize(T)(const byte[] data, out long parse_index )
{
	RefClass stack = new RefClass();
	return unserialize!T(data, parse_index, stack);
}

byte[] serialize(T)(T t ) if (!is(T == class))
{
	RefClass stack = new RefClass();
	return serialize!T(t, stack, 0);
}

byte[] serialize(T, bool isRecursive=true)(T t ) if (is(T == class))
{
	RefClass stack = new RefClass();
	return serialize!(T, isRecursive)(t, stack, 0);
}

size_t getsize(T)(T t )
{
	RefClass stack = new RefClass();
	return getsize!T(t, stack, 0);
}

//////////////////////////////////////////////////////////////////json///////////////////////////
private:
enum bool isFloatType(T) = isType!(T, float) || isType!(T, double);

JSONValue toJson(T)(T t, RefClass stack, uint level)
		if (isSignedType!T || isUnsignedType!T || is(T == string) || is(T == bool) || isFloatType!T)
{
	return JSONValue(t);
}

// uinteger
T toObject(T)(JSONValue v, RefClass stack) if (isUnsignedType!T)
{
	if(v.type() == JSONType.uinteger)
		return cast(T) v.uinteger;
	else
		return T.init;
}

// integer
T toObject(T)(JSONValue v, RefClass stack) if (isSignedType!T)
{
	if(v.type() == JSONType.integer)
		return cast(T) v.integer;
	else
		return T.init;
}

// string
T toObject(T)(JSONValue v, RefClass stack) if (is(T == string))
{
	if(v.type() == JSONType..string)
		return v.str;
	else
		return T.init;
}

// bool
T toObject(T)(JSONValue v, RefClass stack) if (is(T == bool))
{
	if(v.type() == JSONType.true_ || v.type() == JSONType.false_)
		return v.type() == JSONType.true_;
	else
		return T.init;
}

// floating
T toObject(T)(JSONValue v, RefClass stack) if (isFloatType!T)
{
	if(v.type() == JSONType.float_)
		return cast(T) v.floating;
	else
		return  T.init;
}


// array
JSONValue toJson(T)(T t, RefClass stack, uint level)
		if (isStaticArray!T || (isDynamicArray!T && !is(T == string) && !is(T == enum)))
{
	JSONValue[] j;
	foreach (e; t)
	{
		j ~= toJson(e, stack, level);
	}

	return JSONValue(j);
}

T toObject(T)(JSONValue v, RefClass stack) if (isStaticArray!T)
{
	T t;
	if(v.type() == JSONType.array)
	{
		for (size_t i = 0; i < t.length; i++)
		{
			t[i] = toObject!(typeof(t[i]))(v.array[i], stack);
		}
	}
	return t;
	
}

T toObject(T)(JSONValue v, RefClass stack) if (isDynamicArray!T && !is(T == string)&& !is(T == enum))
{
	T t;
	if(v.type() == JSONType.array)
	{
		t.length = v.array.length;
		for (size_t i = 0; i < t.length; i++)
		{
			t[i] = toObject!(typeof(t[i]))(v.array[i], stack);
		}
	}
	return t;
}

// struct & class

string toJsonMembers(T , bool ignore)()
{
	string str;
	foreach (m; FieldNameTuple!T)
	{
		static if (__traits(getProtection, __traits(getMember, T, m)) == "public")
		{
			if(!ignore || !hasUDA!(__traits(getMember , T , m) ,IGNORE ))
			{
				str ~= "j[\"" ~ m ~ "\"] = toJson(t." ~ m ~ " , stack , level + 1);";
			}	
		}
	}
	return str;
}

string toJsonMembersAll(T)()
{
	string str;
	foreach (m; FieldNameTuple!T)
	{
		static if (__traits(getProtection, __traits(getMember, T, m)) == "public")
		{		
			str ~= "j[\"" ~ m ~ "\"] = toJson(t." ~ m ~ " , stack , level + 1);";
		}
	}
	return str;
}



string toObjectMembers(T)()
{
	string str;
	foreach (m; FieldNameTuple!T)
	{
		static if (__traits(getProtection, __traits(getMember, T, m)) == "public")
		{
			str ~= " if ( \"" ~ m ~ "\"  in j )";
			str ~= "t." ~ m ~ " = toObject!(typeof(t." ~ m ~ "))(j[\"" ~ m ~ "\"] , stack);";
		}

	}
	return str;
}

JSONValue toJson(T)(T t, RefClass stack, uint level) if (is(T == struct))
{
	JSONValue j;

	static if (is(T == JSONValue))
	{
		return t;
	}
	else{
		bool ignore = (stack.unIgnore is null)? stack.ignore :(stack.unIgnore.ignore!T);

		if(ignore)
			mixin(toJsonMembers!(T,true));
		else
			mixin(toJsonMembers!(T,false));
		return j;
	}
}

T toObject(T)(JSONValue j, RefClass stack) if (is(T == struct))
{
	static if (is(T == JSONValue))
	{
		return j;
	}
	else
	{
		T t;
		if(j.type() == JSONType.object)
		{
			mixin(toObjectMembers!T);
		}
		return t;
	}
}

JSONValue toJson(T)(T t, RefClass stack, uint level) if (is(T == class))
{
	if (t is null || level >= stack.level)
	{
		return JSONValue(null);
	}

	auto id = t.toHash() in stack.map;
	if (id == null)
	{
		stack.map[t.toHash()] = stack.map.length;
		JSONValue j;
		bool ignore = (stack.unIgnore is null)? stack.ignore :(stack.unIgnore.ignore!T);

		if(ignore)
			mixin(toJsonMembers!(T,true));
		else
			mixin(toJsonMembers!(T,false));
		return j;
	}
	else
	{
		JSONValue j;
		j[MAGIC_KEY] = *id;
		return j;
	}
}

T toObject(T)(JSONValue j, RefClass stack) if (is(T == class))
{
	if ( j.type() != JSONType.object)
		return T.init;
	assert(j.type() == JSONType.object);

	if (MAGIC_KEY in j)
	{
		return cast(T) stack.arr[j[MAGIC_KEY].uinteger];
	}
	else
	{
		T t = new T;
		stack.arr ~= cast(void*) t;
		mixin(toObjectMembers!T);
		return t;
	}
}

//AssociativeArray
JSONValue toJson(T)(T t, RefClass stack, uint level) if (isAssociativeArray!T)
{
	JSONValue j;
	import std.conv;

	foreach (k, v; t)
		j[to!string(k)] = toJson(v, stack, level);
	return j;
}

T toObject(T)(JSONValue j, RefClass stack) if (isAssociativeArray!T)
{
	import std.conv;
	if ( j.type() != JSONType.object)
		return T.init;
	T t;
	foreach (k, v; j.object)
	{
		t[to!(KeyType!T)(k)] = toObject!(ValueType!T)(v, stack);
	}
	return t;
}

//enum
JSONValue toJson(T)(T t, RefClass stack, uint level) if (is(T == enum))
{
	
	auto j =  JSONValue(cast(OriginalType!T)t);
	writeln(j.type());
	return j;
}

T toObject(T)(JSONValue j, RefClass stack) if (is(T == enum))
{
	import std.conv;
	writeln(j , " " , j.type() , typeid(T));
	OriginalType!T val;
	static if (is(OriginalType!T == string ))
	{
		if(j.type() == JSONType..string)
			val = cast(OriginalType!T)j.str;
		else
			return T.init;
	}
	else static if (is(OriginalType!T == int))
	{
		if(j.type() == JSONType.integer)
			val = cast(OriginalType!T)j.integer;
		else if(j.type() == JSONType.uinteger)
			val = cast(OriginalType!T)j.uinteger;
		else
			return T.init;
	}

	return cast(T)val;	
}

public:

JSONValue toJson(T)(T t , uint level = uint.max , bool ignore = true)
{
	RefClass stack = new RefClass();
	stack.level = level;
	stack.ignore = ignore;
	return toJson!T(t, stack, 0);
}

JSONValue toJson(T)(T t   , UnIgnoreArray array  ,  uint level = uint.max)
{
	RefClass stack = new RefClass();
	stack.level = level;
	stack.unIgnore = array;
	return toJson!T(t, stack, 0);
}

T toObject(T)(JSONValue j)
{
	RefClass stack = new RefClass();
	return toObject!T(j, stack);
}

deprecated("Use toJson instead.")
alias toJSON = toJson;

deprecated("Using toObject instead.")
alias toOBJ = toObject;

/// toTextString
/**
Takes a tree of JSON values and returns the serialized string.

Any Object types will be serialized in a key-sorted order.

If `pretty` is false no whitespaces are generated.
If `pretty` is true serialized string is formatted to be human-readable.
Set the $(LREF JSONOptions.specialFloatLiterals) flag is set in `options` to encode NaN/Infinity as strings.
*/
string toTextString(const ref JSONValue root, in bool pretty = false, in JSONOptions options = JSONOptions.none) @safe
{
	import std.array;
	import std.conv;
	import std.string;

    auto json = appender!string();

    void toStringImpl(Char)(string str) @safe
    {
        json.put('"');

        foreach (Char c; str)
        {
            switch (c)
            {
                case '"':       json.put("\\\"");       break;
                case '\\':      json.put("\\\\");       break;

                case '/':
                    if (!(options & JSONOptions.doNotEscapeSlashes))
                        json.put('\\');
                    json.put('/');
                    break;

                case '\b':      json.put("\\b");        break;
                case '\f':      json.put("\\f");        break;
                case '\n':      json.put("\\n");        break;
                case '\r':      json.put("\\r");        break;
                case '\t':      json.put("\\t");        break;
                default:
                {
                    import std.ascii : isControl;
                    import std.utf : encode;

                    // Make sure we do UTF decoding iff we want to
                    // escape Unicode characters.
                    assert(((options & JSONOptions.escapeNonAsciiChars) != 0)
                        == is(Char == dchar), "JSONOptions.escapeNonAsciiChars needs dchar strings");

                    with (JSONOptions) if (isControl(c) ||
                        ((options & escapeNonAsciiChars) >= escapeNonAsciiChars && c >= 0x80))
                    {
                        // Ensure non-BMP characters are encoded as a pair
                        // of UTF-16 surrogate characters, as per RFC 4627.
                        wchar[2] wchars; // 1 or 2 UTF-16 code units
                        size_t wNum = encode(wchars, c); // number of UTF-16 code units
                        foreach (wc; wchars[0 .. wNum])
                        {
                            json.put("\\u");
                            foreach_reverse (i; 0 .. 4)
                            {
                                char ch = (wc >>> (4 * i)) & 0x0f;
                                ch += ch < 10 ? '0' : 'A' - 10;
                                json.put(ch);
                            }
                        }
                    }
                    else
                    {
                        json.put(c);
                    }
                }
            }
        }

        json.put('"');
    }

    void toString(string str) @safe
    {
        // Avoid UTF decoding when possible, as it is unnecessary when
        // processing JSON.
        if (options & JSONOptions.escapeNonAsciiChars)
            toStringImpl!dchar(str);
        else
            toStringImpl!char(str);
    }

    void toValue(ref const JSONValue value, ulong indentLevel) @safe
    {
        void putTabs(ulong additionalIndent = 0)
        {
            if (pretty)
                foreach (i; 0 .. indentLevel + additionalIndent)
                    json.put("    ");
        }
        void putEOL()
        {
            if (pretty)
                json.put('\n');
        }
        void putCharAndEOL(char ch)
        {
            json.put(ch);
            putEOL();
        }

        final switch (value.type)
        {
            case JSONType.object:
                auto obj = value.objectNoRef;
                if (!obj.length)
                {
                    json.put("{}");
                }
                else
                {
                    putCharAndEOL('{');
                    bool first = true;

                    void emit(R)(R names)
                    {
                        foreach (name; names)
                        {
                            auto member = obj[name];
                            if (!first)
                                putCharAndEOL(',');
                            first = false;
                            putTabs(1);
                            toString(name);
                            json.put(':');
                            if (pretty)
                                json.put(' ');
                            toValue(member, indentLevel + 1);
                        }
                    }

                    import std.algorithm.sorting : sort;
                    // @@@BUG@@@ 14439
                    // auto names = obj.keys;  // aa.keys can't be called in @safe code
                    auto names = new string[obj.length];
                    size_t i = 0;
                    foreach (k, v; obj)
                    {
                        names[i] = k;
                        i++;
                    }
                    sort(names);
                    emit(names);

                    putEOL();
                    putTabs();
                    json.put('}');
                }
                break;

            case JSONType.array:
                auto arr = value.arrayNoRef;
                if (arr.empty)
                {
                    json.put("[]");
                }
                else
                {
                    putCharAndEOL('[');
                    foreach (i, el; arr)
                    {
                        if (i)
                            putCharAndEOL(',');
                        putTabs(1);
                        toValue(el, indentLevel + 1);
                    }
                    putEOL();
                    putTabs();
                    json.put(']');
                }
                break;

            case JSONType..string:
                toString(value.str);
                break;

            case JSONType.integer:
                json.put(to!string(value.integer));
                break;

            case JSONType.uinteger:
                json.put(to!string(value.uinteger));
                break;

            case JSONType.float_:
                import std.math : isNaN, isInfinity;

                auto val = value.floating;

                if (val.isNaN)
                {
                    if (options & JSONOptions.specialFloatLiterals)
                    {
                        toString(JSONFloatLiteral.nan);
                    }
                    else
                    {
                        throw new JSONException(
                            "Cannot encode NaN. Consider passing the specialFloatLiterals flag.");
                    }
                }
                else if (val.isInfinity)
                {
                    if (options & JSONOptions.specialFloatLiterals)
                    {
                        toString((val > 0) ?  JSONFloatLiteral.inf : JSONFloatLiteral.negativeInf);
                    }
                    else
                    {
                        throw new JSONException(
                            "Cannot encode Infinity. Consider passing the specialFloatLiterals flag.");
                    }
                }
                else
                {
                    import std.format : format;
                    // The correct formula for the number of decimal digits needed for lossless round
                    // trips is actually:
                    //     ceil(log(pow(2.0, double.mant_dig - 1)) / log(10.0) + 1) == (double.dig + 2)
                    // Anything less will round off (1 + double.epsilon)
                    json.put("%s".format(val));
                }
                break;

            case JSONType.true_:
                json.put("true");
                break;

            case JSONType.false_:
                json.put("false");
                break;

            case JSONType.null_:
                json.put("null");
                break;
        }
    }

    toValue(root, 0);
    return json.data;
}


/**
*/
mixin template SerializationMember(T) {
	import std.traits;
	debug(HUNT_DEBUG_MORE) import hunt.logging;

    alias baseClasses = BaseClassesTuple!T;

    static if(baseClasses.length == 1 && is(baseClasses[0] == Object)) {
        ubyte[] serialize() {
            ubyte[] bytes = cast(ubyte[]).serialize!(T, false)(this);
            debug(HUNT_DEBUG_MORE) 
				tracef("this level (%s), length: %d, data: %(%02X %)", T.stringof, bytes.length, bytes);
            return bytes;
        }
        
		// void deserialize(ubyte[] data) {

    	// }
    } else {
		// pragma(msg, T.stringof);
        override ubyte[] serialize() {
            auto bytes = cast(ubyte[])hunt.util.Serialize.serialize!(T, false)(this);
            debug(HUNT_DEBUG_MORE) 
				tracef("current level (%s), length: %d, data: %(%02X %)", T.stringof, bytes.length, bytes);
            
            ubyte[] data = super.serialize();
            data[1] = cast(ubyte)(data[1] + bytes.length - 2);
            data ~= bytes[2..$];
            debug(HUNT_DEBUG_MORE) 
				tracef("all levels (%s), length: %d, data: %(%02X %)", T.stringof, data.length, data);

            // auto bytes = cast(ubyte[])hunt.util.Serialize.serialize(this);
            // tracef("length: %d, data: %(%02X %)", bytes.length, bytes);
            return data;
        }    

		// override void deserialize(ubyte[] data) {

    	// }
    }


}


// only for , nested , new T
/*
version (unittest)
{
	//test struct
		void test1(T)(T t)
		{
			assert(unserialize!T(serialize(t)) == t);
			assert(serialize(t).length == getsize(t));
			assert(toObject!T(toJson(t)) == t);
		}
		struct T1
		{
			bool b;
			byte ib;
			ubyte ub;
			short ish;
			ushort ush;
			int ii;
			uint ui;
			long il;
			ulong ul;
			string s;
			uint[10] sa;
			long[] sb;
		}
		struct T2
		{
			string n;
			T1[] t;
		}
		struct T3
		{
			T1 t1;
			T2 t2;
			string[] name;
		}
		//test class
		class C
		{
			int age;
			string name;
			T3 t3;
			override bool opEquals(Object c)
			{
				auto c1 = cast(C) c;
				return age == c1.age && name == c1.name && t3 == c1.t3;
			}
			C clone()
			{
				auto c = new C();
				c.age = age;
				c.name = name;
				c.t3 = t3;
				return c;
			}
		}
		class C2
		{
			C[] c;
			C c1;
			T1 t1;
			override bool opEquals(Object c)
			{
				auto c2 = cast(C2) c;
				return this.c == c2.c && c1 == c2.c1 && t1 == c2.t1;
			}
		}
		//ref test
		class School
		{
			string name;
			User[] users;
			override bool opEquals(Object c)
			{
				auto school = cast(School) c;
				return school.name == this.name;
			}
		}
		class User
		{
			int age;
			string name;
			School school;
			override bool opEquals(Object c)
			{
				auto user = cast(User) c;
				return user.age == this.age && user.name == this.name && user.school == this.school;
			}
		}
		struct J{
			string data;
			JSONValue val;
		
		}

		enum MONTH
		{
			M1,
			M2
		}

		enum WEEK : int
		{
			K1 = 1,
			K2 = 2
		}

		enum DAY : string
		{
			D1 = "one",
			D2 = "two"
		}

		class Date1
		{
			MONTH month;
			WEEK week;
			DAY day;
			override bool opEquals(Object c)
			{
				auto date = cast(Date1) c;
				return date.month == this.month && date.week == this.week && date.day == this.day;
			}

		}

		void test_enum_ser()
		{
			Date1 date = new Date1();
			date.month = MONTH.M2;
			date.week = WEEK.K2;
			date.day = DAY.D2;
			test1(date);
			
		}

		void test_json_ser()
		{
			J j;
			j.data = "test";
			j.val = "FUC";
			toObject!J(toJson(j));
		}
		void test_ref_class()
		{
			School school = new School();
			User user1 = new User();
			user1.age = 30;
			user1.name = "zhangyuchun";
			user1.school = school;
			User user2 = new User();
			user2.age = 31;
			user2.name = "wulishan";
			user2.school = school;
			school.name = "putao";
			school.users ~= user1;
			school.users ~= user2;
			test1(user1);
			test1(user2);
		}
		void test_struct_class_array()
		{
			T1 t;
			t.b = true;
			t.ib = -11;
			t.ub = 128 + 50;
			t.ish = -50;
			t.ush = (1 << 15) + 50;
			t.ii = -50;
			t.ui = (1 << 31) + 50;
			t.il = (cast(long) 1 << 63) - 50;
			t.ul = (cast(long) 1 << 63) + 50;
			t.s = "test";
			t.sa[0] = 10;
			t.sa[1] = 100;
			t.sb ~= 10;
			t.sb ~= 100;
			test1(t);
			T2 t2;
			t2.t ~= t;
			t2.t ~= t;
			t2.n = "testt2";
			test1(t2);
			T3 t3;
			t3.t1 = t;
			t3.t2 = t2;
			t3.name ~= "123";
			t3.name ~= "456";
			test1(t3);
			C c1 = new C();
			c1.age = 100;
			c1.name = "test";
			c1.t3 = t3;
			test1(c1);
			C2 c2 = new C2();
			c2.c ~= c1;
			c2.c ~= c1.clone();
			c2.c1 = c1.clone();
			c2.t1 = t;
			test1(c2);
			C2 c3 = null;
			test1(c3);
			string[string] map1 = ["1" : "1", "2" : "2"];
			string[int] map2 = [1 : "1", 2 : "2"];
			T1[string] map3;
			T1 a1;
			a1.ib = 1;
			T1 a2;
			a2.ib = 2;
			map3["1"] = a1;
			map3["2"] = a2;
			test1(map1);
			test1(map2);
			test1(map3);
		}
	
}
unittest
{
	import std.stdio;
	long index;
	void test(T)(T v)
	{
		long index;
		byte[] bs = toVariant(v);
		long length = bs.length;
		bs ~= ['x', 'y'];
		assert(toT!T(bs, index) == v && index == length);
		assert(toObject!T(toJson(v)) == v);
	}
	//test variant
	//unsigned
	{
		ubyte j0 = 0;
		ubyte j1 = 50;
		ubyte j2 = (1 << 7) + 50;
		ubyte j3 = 0xFF;
		ushort j4 = (1 << 14) + 50;
		ushort j5 = 0xFFFF;
		uint j6 = (1 << 21) + 50;
		uint j7 = (1 << 28) + 50;
		uint j8 = 128;
		uint j9 = 0xFFFFFFFF;
		{
		}
		ulong j10 = (cast(ulong) 1 << 35) + 50;
		ulong j11 = (cast(ulong) 1 << 42) + 50;
		ulong j12 = (cast(ulong) 1 << 49) + 50;
		ulong j13 = (cast(ulong) 1 << 56) + 50;
		ulong j14 = j9 + j10 + j11 + j12;
		ulong j15 = 0xFFFFFFFFFFFFFFFF;
		test(j0);
		test(j1);
		test(j2);
		test(j3);
		test(j4);
		test(j5);
		test(j6);
		test(j7);
		test(j8);
		test(j9);
		test(j10);
		test(j11);
		test(j12);
		test(j13);
		test(j14);
		test(j15);
	}
	//signed
	{
		byte i0 = 0;
		byte i1 = (1 << 6) + 50;
		byte i2 = (1 << 7) - 1;
		byte i3 = -i2;
		byte i4 = -i1;
		test(i0);
		test(i1);
		test(i2);
		test(i3);
		test(i4);
		short i5 = (1 << 7) + 50;
		short i6 = (1 << 14) + 50;
		short i7 = -i5;
		short i8 = -i6;
		test(i5);
		test(i6);
		test(i7);
		test(i8);
		int i9 = (1 << 16) + 50;
		int i10 = (1 << 25) + 50;
		int i11 = (1 << 30) + 50;
		int i12 = 64;
		int i13 = -i10;
		int i14 = -i11;
		int i15 = i9 + i10 + i11;
		int i16 = -i15;
		test(i9);
		test(i10);
		test(i11);
		test(i12);
		test(i13);
		test(i14);
		test(i15);
		test(i16);
		long i17 = (cast(long) 1 << 32) + 50;
		long i18 = (cast(long) 1 << 48) + 50;
		long i19 = (cast(long) 1 << 63) + 50;
		long i20 = i17 + i18 + i19;
		long i21 = -i17;
		long i22 = -i20;
		test(i17);
		test(i18);
		test(i19);
		test(i20);
		test(i21);
		test(i22);
		int i23 = -11;
		test(i23);
	}
	//test serialize
	//basic: byte ubyte short ushort int uint long ulong
	{
		byte b1 = 123;
		byte b2 = -11;
		ubyte b3 = 233;
		short s1 = -11;
		short s2 = (1 << 8) + 50;
		short s3 = (1 << 15) - 50;
		ushort s4 = (1 << 16) - 50;
		int i1 = -11;
		int i2 = (1 << 16) + 50;
		int i3 = (1 << 31) - 50;
		uint i4 = (1 << 31) + 50;
		long l1 = -11;
		long l2 = (cast(long) 1 << 32) + 50;
		long l3 = (cast(long) 1 << 63) - 50;
		ulong l4 = (cast(long) 1 << 63) + 50;
		test1(b1);
		test1(b2);
		test1(b3);
		test1(s1);
		test1(s2);
		test1(s3);
		test1(s4);
		test1(i1);
		test1(i2);
		test1(i3);
		test1(i4);
		test1(l1);
		test1(l2);
		test1(l3);
		test1(l4);
	}
	//test string
	{
		string s1 = "";
		string s2 = "1";
		string s3 = "123";
		test1(s1);
		test1(s2);
		test1(s3);
	}
	//test static arrary
	{
		string[5] sa;
		sa[0] = "test0";
		sa[1] = "test1";
		sa[2] = "test2";
		sa[3] = "test3";
		sa[4] = "test4";
		test1(sa);
	}
	//test dynamic arrary
	{
		string[] sa;
		sa ~= "test1";
		sa ~= "test2";
		sa ~= "test3";
		sa ~= "test4";
		test1(sa);
		string[] sa2;
		test1(sa2);
	}
	//test enum \ struct \ class \ associative array
	test_enum_ser();
	test_struct_class_array();
	test_ref_class();
	test_json_ser();
	////unsigned
		uint ut1 = 1 << 7;
		uint ut2 = 1 << 14;
		uint ut3 = 1 << 21;
		uint ut4 = 1 << 28;
//signed
		int it1 = 1 << 6;
		int it2 = 1 << 13;
		int it3 = 1 << 20;
		int it4 = 1 << 27;
		test1(ut1);
		test1(ut2);
		test1(ut3);
		test1(ut4);
		test1(it1);
		test1(it2);
		test1(it3);
		test1(it4);
}
*/