/*************************************************************************/
/*  packed_data_container.cpp                                            */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                    http://www.godotengine.org                         */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/
#include "packed_data_container.h"

#include "io/marshalls.h"
#include "core_string_names.h"


Variant PackedDataContainer::getvar(const Variant& p_key, bool *r_valid) const {

	bool err=false;
	Variant ret = _key_at_ofs(0,p_key,err);
	if (r_valid)
		*r_valid=!err;
	return ret;
}

int PackedDataContainer::size() const {

	return _size(0);
};

Variant PackedDataContainer::_iter_init_ofs(const Array& p_iter,uint32_t p_offset) {

	Array ref=p_iter;
	uint32_t size = _size(p_offset);
	if (size==0 || ref.size()!=1)
		return false;
	else {
		ref[0]=0;
		return true;
	}


}

Variant PackedDataContainer::_iter_next_ofs(const Array& p_iter,uint32_t p_offset){

	Array ref=p_iter;
	uint32_t size = _size(p_offset);
	if (ref.size()!=1)
		return false;
	int pos = ref[0];
	if (pos<0 || pos>=size)
		return false;
	pos+=1;
	ref[0]=pos;
	return pos!=size;

}

Variant PackedDataContainer::_iter_get_ofs(const Variant& p_iter,uint32_t p_offset){

	uint32_t size = _size(p_offset);
	int pos=p_iter;
	if (pos<0 || pos>=size)
		return Variant();

	PoolVector<uint8_t>::Read rd=data.read();
	const uint8_t *r=&rd[p_offset];
	uint32_t type = decode_uint32(r);

	bool err=false;
	if (type==TYPE_ARRAY) {

		uint32_t vpos = decode_uint32(rd.ptr() + p_offset+8+pos*4);
		return _get_at_ofs(vpos,rd.ptr(),err);

	} else if (type==TYPE_DICT) {

		uint32_t vpos = decode_uint32(rd.ptr() + p_offset+8+pos*12+4);
		return _get_at_ofs(vpos,rd.ptr(),err);
	} else {
		ERR_FAIL_V(Variant());
	}
}


Variant PackedDataContainer::_get_at_ofs(uint32_t p_ofs,const uint8_t *p_buf,bool &err) const {

	uint32_t type = decode_uint32(p_buf + p_ofs);

	if (type==TYPE_ARRAY ||  type==TYPE_DICT) {

		Ref<PackedDataContainerRef> pdcr = memnew( PackedDataContainerRef );
		Ref<PackedDataContainer> pdc = Ref<PackedDataContainer>((PackedDataContainer*)this);

		pdcr->from=pdc;
		pdcr->offset=p_ofs;
		return pdcr;
	} else {

		Variant v;
		Error rerr = decode_variant(v,p_buf + p_ofs,datalen-p_ofs,NULL);

		if (rerr!=OK) {

			err=true;
			ERR_FAIL_COND_V(err!=OK,Variant());
		}
		return v;
	}

}

uint32_t PackedDataContainer::_type_at_ofs(uint32_t p_ofs) const {

	PoolVector<uint8_t>::Read rd=data.read();
	const uint8_t *r=&rd[p_ofs];
	uint32_t type = decode_uint32(r);

	return type;
};

int PackedDataContainer::_size(uint32_t p_ofs) const {

	PoolVector<uint8_t>::Read rd=data.read();
	const uint8_t *r=&rd[p_ofs];
	uint32_t type = decode_uint32(r);

	if (type==TYPE_ARRAY) {

		uint32_t len = decode_uint32(r+4);
		return len;

	} else if (type==TYPE_DICT) {

		uint32_t len = decode_uint32(r+4);
		return len;
	};

	return -1;
};

Variant PackedDataContainer::_key_at_ofs(uint32_t p_ofs,const Variant& p_key,bool &err) const {

	PoolVector<uint8_t>::Read rd=data.read();
	const uint8_t *r=&rd[p_ofs];
	uint32_t type = decode_uint32(r);


	if (type==TYPE_ARRAY) {

		if (p_key.is_num()) {

			int idx=p_key;
			uint32_t len = decode_uint32(r+4);
			if (idx<0 || idx>=len) {
				err=true;
				return Variant();
			}
			uint32_t ofs = decode_uint32(r+8+4*idx);
			return _get_at_ofs(ofs,rd.ptr(),err);

		} else {
			err=true;
			return Variant();
		}

	} else if (type==TYPE_DICT) {

		uint32_t hash=p_key.hash();
		uint32_t len = decode_uint32(r+4);

		bool found=false;
		for(int i=0;i<len;i++) {
			uint32_t khash=decode_uint32(r+8+i*12+0);
			if (khash==hash) {
				Variant key = _get_at_ofs(decode_uint32(r+8+i*12+4),rd.ptr(),err);
				if (err)
					return Variant();
				if (key==p_key) {
					//key matches, return value
					return _get_at_ofs(decode_uint32(r+8+i*12+8),rd.ptr(),err);
				}
				found=true;
			} else {
				if (found)
					break;
			}
		}

		err=true;
		return Variant();

	} else {

		err=true;
		return Variant();
	}


}

uint32_t PackedDataContainer::_pack(const Variant& p_data, Vector<uint8_t>& tmpdata, Map<String,uint32_t>& string_cache) {

	switch(p_data.get_type()) {

		case Variant::STRING: {

			String s = p_data;
			if (string_cache.has(s)) {
				return string_cache[s];
			}

			string_cache[s]=tmpdata.size();

		}; //fallthrough
		case Variant::NIL:
		case Variant::BOOL:
		case Variant::INT:
		case Variant::REAL:
		case Variant::VECTOR2:
		case Variant::RECT2:
		case Variant::VECTOR3:
		case Variant::TRANSFORM2D:
		case Variant::PLANE:
		case Variant::QUAT:
		case Variant::RECT3:
		case Variant::BASIS:
		case Variant::TRANSFORM:
		case Variant::IMAGE:
		case Variant::INPUT_EVENT:
		case Variant::POOL_BYTE_ARRAY:
		case Variant::POOL_INT_ARRAY:
		case Variant::POOL_REAL_ARRAY:
		case Variant::POOL_STRING_ARRAY:
		case Variant::POOL_VECTOR2_ARRAY:
		case Variant::POOL_VECTOR3_ARRAY:
		case Variant::POOL_COLOR_ARRAY:
		case Variant::NODE_PATH: {

			uint32_t pos = tmpdata.size();
			int len;
			encode_variant(p_data,NULL,len);
			tmpdata.resize(tmpdata.size()+len);
			encode_variant(p_data,&tmpdata[pos],len);
			return pos;

		} break;
		// misc types
		case Variant::_RID:
		case Variant::OBJECT: {

			return _pack(Variant(),tmpdata,string_cache);
		} break;
		case Variant::DICTIONARY: {

			Dictionary d=p_data;
			//size is known, use sort
			uint32_t pos = tmpdata.size();
			int len=d.size();
			tmpdata.resize(tmpdata.size()+len*12+8);
			encode_uint32(TYPE_DICT,&tmpdata[pos+0]);
			encode_uint32(len,&tmpdata[pos+4]);

			List<Variant> keys;
			d.get_key_list(&keys);
			List<DictKey> sortk;

			for(List<Variant>::Element *E=keys.front();E;E=E->next()) {

				DictKey dk;
				dk.hash=E->get().hash();
				dk.key=E->get();
				sortk.push_back(dk);
			}

			sortk.sort();

			int idx=0;
			for(List<DictKey>::Element *E=sortk.front();E;E=E->next()) {

				encode_uint32(E->get().hash,&tmpdata[pos+8+idx*12+0]);
				uint32_t ofs = _pack(E->get().key,tmpdata,string_cache);
				encode_uint32(ofs,&tmpdata[pos+8+idx*12+4]);
				ofs = _pack(d[E->get().key],tmpdata,string_cache);
				encode_uint32(ofs,&tmpdata[pos+8+idx*12+8]);
				idx++;
			}

			return pos;



		} break;
		case Variant::ARRAY: {

			Array a=p_data;
			//size is known, use sort
			uint32_t pos = tmpdata.size();
			int len=a.size();
			tmpdata.resize(tmpdata.size()+len*4+8);
			encode_uint32(TYPE_ARRAY,&tmpdata[pos+0]);
			encode_uint32(len,&tmpdata[pos+4]);

			for(int i=0;i<len;i++) {

				uint32_t ofs = _pack(a[i],tmpdata,string_cache);
				encode_uint32(ofs,&tmpdata[pos+8+i*4]);
			}

			return pos;


		} break;

		default: {}
	}

	return OK;
}

Error PackedDataContainer::pack(const Variant& p_data) {

	Vector<uint8_t> tmpdata;
	Map<String,uint32_t> string_cache;
	_pack(p_data,tmpdata,string_cache);
	datalen=tmpdata.size();
	data.resize(tmpdata.size());
	PoolVector<uint8_t>::Write w = data.write();
	copymem(w.ptr(),tmpdata.ptr(),tmpdata.size());

	return OK;
}


void PackedDataContainer::_set_data(const PoolVector<uint8_t>& p_data) {

	data=p_data;
	datalen=data.size();

}

PoolVector<uint8_t> PackedDataContainer::_get_data() const {
	return data;
}


Variant PackedDataContainer::_iter_init(const Array& p_iter) {


	return _iter_init_ofs(p_iter,0);
}

Variant PackedDataContainer::_iter_next(const Array& p_iter){

	return _iter_next_ofs(p_iter,0);

}
Variant PackedDataContainer::_iter_get(const Variant& p_iter){

	return _iter_get_ofs(p_iter,0);
}


void PackedDataContainer::_bind_methods() {

	ClassDB::bind_method(_MD("_set_data"),&PackedDataContainer::_set_data);
	ClassDB::bind_method(_MD("_get_data"),&PackedDataContainer::_get_data);
	ClassDB::bind_method(_MD("_iter_init"),&PackedDataContainer::_iter_init);
	ClassDB::bind_method(_MD("_iter_get"),&PackedDataContainer::_iter_get);
	ClassDB::bind_method(_MD("_iter_next"),&PackedDataContainer::_iter_next);
	ClassDB::bind_method(_MD("pack:Error","value"),&PackedDataContainer::pack);
	ClassDB::bind_method(_MD("size"),&PackedDataContainer::size);

	ADD_PROPERTY( PropertyInfo(Variant::POOL_BYTE_ARRAY,"__data__"),"_set_data","_get_data");
}


PackedDataContainer::PackedDataContainer() {

	datalen=0;
}


//////////////////


Variant PackedDataContainerRef::_iter_init(const Array& p_iter) {


	return from->_iter_init_ofs(p_iter,offset);
}

Variant PackedDataContainerRef::_iter_next(const Array& p_iter){

	return from->_iter_next_ofs(p_iter,offset);

}
Variant PackedDataContainerRef::_iter_get(const Variant& p_iter){

	return from->_iter_get_ofs(p_iter,offset);
}

bool PackedDataContainerRef::_is_dictionary() const {

	return from->_type_at_ofs(offset) == PackedDataContainer::TYPE_DICT;
};

void PackedDataContainerRef::_bind_methods() {

	ClassDB::bind_method(_MD("size"),&PackedDataContainerRef::size);
	ClassDB::bind_method(_MD("_iter_init"),&PackedDataContainerRef::_iter_init);
	ClassDB::bind_method(_MD("_iter_get"),&PackedDataContainerRef::_iter_get);
	ClassDB::bind_method(_MD("_iter_next"),&PackedDataContainerRef::_iter_next);
	ClassDB::bind_method(_MD("_is_dictionary"),&PackedDataContainerRef::_is_dictionary);
}


Variant PackedDataContainerRef::getvar(const Variant& p_key, bool *r_valid) const {

	bool err=false;
	Variant ret = from->_key_at_ofs(offset,p_key,err);
	if (r_valid)
		*r_valid=!err;
	return ret;
}

int PackedDataContainerRef::size() const {

	return from->_size(offset);
};

PackedDataContainerRef::PackedDataContainerRef() {

}