// Copyright (C) 2007 EQ2EMulator Development Team, GPL v3+

// Template data getter/setter functions for PacketStruct

// Template functions for setting generic data with conditional type handling
template<class Data> void setData(DataStruct* data_struct, Data* data, int32 index, bool use_second_type = false)
{
	if (!data_struct)
		return;
	data_struct->SetIsOptional(false);
	int8 type_to_use = (use_second_type) ? data_struct->GetType2() : data_struct->GetType();
	if (type_to_use >= DATA_STRUCT_EQ2_8BIT_STRING && type_to_use <= DATA_STRUCT_EQ2_32BIT_STRING) {
		if (type_to_use == DATA_STRUCT_EQ2_8BIT_STRING) {
			setSmallString(data_struct, data, index);
		}
		else if (type_to_use == DATA_STRUCT_EQ2_16BIT_STRING) {
			setMediumString(data_struct, data, index);
		}
		else {
			setLargeString(data_struct, data, index);
		}
	}
	else {
		if (data_struct && index == 0 && data_struct->GetLength() > 1) {
			if (type_to_use == DATA_STRUCT_CHAR) {
				for (int32 i = 0; data && i < data_struct->GetLength() && i < strlen(data); i++)
					setData(data_struct, data[i], i);
			}
			else {
				for (int32 i = 0; i < data_struct->GetLength(); i++)
					setData(data_struct, data[i], i);
			}
		}
		else
			setData(data_struct, *data, index);
	}
}

// Template function for setting data by value with type conversion
template<class Data> void setData(DataStruct* data_struct, Data data, int32 index, bool use_second_type = false)
{
	if (data_struct && index < data_struct->GetLength()) {
		data_struct->SetIsOptional(false);
		int8 type_to_use = (use_second_type) ? data_struct->GetType2() : data_struct->GetType();
		if (use_second_type) {
			data_struct->SetType(type_to_use);
		}
		switch (type_to_use) {
		case DATA_STRUCT_INT8:
			setDataType(data_struct, (int8)data, index);
			break;
		case DATA_STRUCT_INT16:
			setDataType(data_struct, (int16)data, index);
			break;
		case DATA_STRUCT_INT32:
			setDataType(data_struct, (int32)data, index);
			break;
		case DATA_STRUCT_INT64:
			setDataType(data_struct, (int64)data, index);
			break;
		case DATA_STRUCT_SINT8:
			setDataType(data_struct, (sint8)data, index);
			break;
		case DATA_STRUCT_SINT16:
			setDataType(data_struct, (sint16)data, index);
			break;
		case DATA_STRUCT_SINT32:
			setDataType(data_struct, (sint32)data, index);
			break;
		case DATA_STRUCT_SINT64:
			setDataType(data_struct, (sint64)data, index);
			break;
		case DATA_STRUCT_CHAR:
			setDataType(data_struct, (char)data, index);
			break;
		case DATA_STRUCT_FLOAT:
			setDataType(data_struct, (float)data, index);
			break;
		case DATA_STRUCT_DOUBLE:
			setDataType(data_struct, (double)data, index);
			break;
		case DATA_STRUCT_COLOR:
			setColor(data_struct, *((EQ2_Color*)&data), index);
			break;
		case DATA_STRUCT_EQUIPMENT:
			setEquipmentByName(data_struct, *((EQ2_EquipmentItem*)&data), index);
			break;
		case DATA_STRUCT_ITEM:
			break;
		}
	}
}

// Template functions for setting data by name
template<class Data> void setSubstructSubstructDataByName(const char* substruct_name1, const char* substruct_name2, const char* name, Data data, int32 substruct_index1 = 0, int32 substruct_index2 = 0, int32 index = 0)
{
	char tmp[15] = { 0 };
	sprintf(tmp, "_%i_%i", substruct_index1, substruct_index2);
	std::string name2 = std::string(substruct_name1).append("_").append(substruct_name2).append("_").append(name).append(tmp);
	setData(findStruct(name2.c_str(), index), data, index);
}

template<class Data> void setSubstructDataByName(const char* substruct_name, const char* name, Data data, int32 substruct_index = 0, int32 index = 0)
{
	char tmp[10] = { 0 };
	sprintf(tmp, "_%i", substruct_index);
	std::string name2 = std::string(substruct_name).append("_").append(name).append(tmp);
	setData(findStruct(name2.c_str(), index), data, index);
}

template<class Data> void setSubstructColorByName(const char* substruct_name, const char* name, Data data, int32 substruct_index = 0, int32 index = 0)
{
	char tmp[10] = { 0 };
	sprintf(tmp, "_%i", substruct_index);
	std::string name2 = std::string(substruct_name).append("_").append(name).append(tmp);
	setColor(findStruct(name2.c_str(), index), data, index);
}

template<class Data> void setSubstructArrayDataByName(const char* substruct_name, const char* name, Data data, int32 index = 0, int32 substruct_index = 0)
{
	char tmp[10] = { 0 };
	sprintf(tmp, "_%i", substruct_index);
	std::string name2 = std::string(substruct_name).append("_").append(name).append(tmp);
	setData(findStruct(name2.c_str(), substruct_index, index), data, index);
}

template<class Data> void setSubstructArrayColorByName(const char* substruct_name, const char* name, Data data, int32 substruct_index = 0, int32 index = 0)
{
	char tmp[10] = { 0 };
	sprintf(tmp, "_%i", substruct_index);
	std::string name2 = std::string(substruct_name).append("_").append(name).append(tmp);
	setColor(findStruct(name2.c_str(), index, substruct_index), data, index);
}

template<class Data> void setDataByName(const char* name, Data data, int32 index = 0, bool use_second_type = false)
{
	setData(findStruct(name, index), data, index, use_second_type);
}

template<class Data> void setDataByName(const char* name, Data* data, int32 index = 0, bool use_second_type = false)
{
	setData(findStruct(name, index), data, index, use_second_type);
}

template<class Data> void setSubArrayDataByName(const char* name, Data data, int32 index1 = 0, int32 index2 = 0, int32 index3 = 0)
{
	char tmp[20] = { 0 };
	sprintf(tmp, "%i_%i", index1, index2);
	std::string name2 = std::string(name).append(tmp);
	setData(findStruct(name2.c_str(), index2, index3), data, index3);
}

template<class Data> void setArrayDataByName(const char* name, Data data, int32 index1 = 0, int32 index2 = 0, bool use_second_type = false)
{
	char tmp[10] = { 0 };
	sprintf(tmp, "_%i", index1);
	std::string name2 = std::string(name).append(tmp);
	setData(findStruct(name2.c_str(), index1, index2), data, index2, use_second_type);
}

template<class Data> void setSubArrayLengthByName(const char* name, Data data, int32 index1 = 0, int32 index2 = 0)
{
	char tmp[10] = { 0 };
	sprintf(tmp, "_%i", index1);
	std::string name2 = std::string(name).append(tmp);
	DataStruct* data_struct = findStruct(name2.c_str(), index2);
	setData(data_struct, data, index2);
	UpdateArrayByArrayLength(data_struct, index2, data);
}

template<class Data> void setArrayLengthByName(const char* name, Data data, int32 index = 0)
{
	DataStruct* data_struct = findStruct(name, index);
	setData(data_struct, data, index);
	UpdateArrayByArrayLength(data_struct, index, data);
}

template<class Data> void setSubstructArrayLengthByName(const char* substruct_name, const char* name, Data data, int32 substruct_index = 0, int32 index = 0)
{
	char tmp[10] = { 0 };
	sprintf(tmp, "_%i", substruct_index);
	std::string name2 = std::string(substruct_name).append("_").append(name).append(tmp);

	DataStruct* data_struct = findStruct(name2.c_str(), index);
	setData(data_struct, data, index);
	UpdateArrayByArrayLength(data_struct, index, data);
}

// Getter functions by name for all data types
int8 getType_int8_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_int8(data_struct, index, force);
}

int16 getType_int16_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_int16(data_struct, index, force);
}

int32 getType_int32_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_int32(data_struct, index, force);
}

int64 getType_int64_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_int64(data_struct, index, force);
}

sint8 getType_sint8_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_sint8(data_struct, index, force);
}

sint16 getType_sint16_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_sint16(data_struct, index, force);
}

sint32 getType_sint32_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_sint32(data_struct, index, force);
}

sint64 getType_sint64_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_sint64(data_struct, index, force);
}

float getType_float_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_float(data_struct, index, force);
}

double getType_double_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_double(data_struct, index, force);
}

char getType_char_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_char(data_struct, index, force);
}

EQ2_8BitString getType_EQ2_8BitString_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_EQ2_8BitString(data_struct, index, force);
}

EQ2_16BitString getType_EQ2_16BitString_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_EQ2_16BitString(data_struct, index, force);
}

EQ2_32BitString getType_EQ2_32BitString_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_EQ2_32BitString(data_struct, index, force);
}

EQ2_Color getType_EQ2_Color_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_EQ2_Color(data_struct, index, force);
}

EQ2_EquipmentItem getType_EQ2_EquipmentItem_ByName(const char* name, int32 index = 0, bool force = false)
{
	DataStruct* data_struct = findStruct(name, index);
	return getType_EQ2_EquipmentItem(data_struct, index, force);
}

// Getter functions by data structure for all data types
int8 getType_int8(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_INT8) || force)) {
		int8* ptr = (int8*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

int16 getType_int16(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_INT16) || force)) {
		int16* ptr = (int16*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

int32 getType_int32(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_INT32) || force)) {
		int32* ptr = (int32*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

int64 getType_int64(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_INT64) || force)) {
		int64* ptr = (int64*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

sint8 getType_sint8(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_SINT8) || force)) {
		sint8* ptr = (sint8*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

sint16 getType_sint16(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_SINT16) || force)) {
		sint16* ptr = (sint16*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

sint32 getType_sint32(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_SINT32) || force)) {
		sint32* ptr = (sint32*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

sint64 getType_sint64(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_SINT64) || force)) {
		sint64* ptr = (sint64*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

float getType_float(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_FLOAT) || force)) {
		float* ptr = (float*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

double getType_double(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_DOUBLE) || force)) {
		double* ptr = (double*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

char getType_char(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_CHAR) || force)) {
		char* ptr = (char*)GetStructPointer(data_struct);
		return ptr[index];
	}
	return 0;
}

EQ2_8BitString getType_EQ2_8BitString(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_EQ2_8BIT_STRING) || force)) {
		EQ2_8BitString* ptr = (EQ2_8BitString*)GetStructPointer(data_struct);
		return ptr[index];
	}
	EQ2_8BitString ret;
	ret.size = 0;
	return ret;
}

EQ2_16BitString getType_EQ2_16BitString(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_EQ2_16BIT_STRING) || force)) {
		EQ2_16BitString* ptr = (EQ2_16BitString*)GetStructPointer(data_struct);
		return ptr[index];
	}
	EQ2_16BitString ret;
	ret.size = 0;
	return ret;
}

EQ2_32BitString getType_EQ2_32BitString(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_EQ2_32BIT_STRING) || force)) {
		EQ2_32BitString* ptr = (EQ2_32BitString*)GetStructPointer(data_struct);
		return ptr[index];
	}
	EQ2_32BitString ret;
	ret.size = 0;
	return ret;
}

EQ2_Color getType_EQ2_Color(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_COLOR) || force)) {
		EQ2_Color* ptr = (EQ2_Color*)GetStructPointer(data_struct);
		return ptr[index];
	}
	EQ2_Color ret;
	ret.blue = 0;
	ret.red = 0;
	ret.green = 0;
	return ret;
}

EQ2_EquipmentItem getType_EQ2_EquipmentItem(DataStruct* data_struct, int32 index = 0, bool force = false)
{
	if (data_struct && ((data_struct->GetType() == DATA_STRUCT_EQUIPMENT) || force)) {
		EQ2_EquipmentItem* ptr = (EQ2_EquipmentItem*)GetStructPointer(data_struct);
		return ptr[index];
	}
	EQ2_EquipmentItem ret;
	ret.color.blue = 0;
	ret.color.red = 0;
	ret.color.green = 0;
	ret.highlight.blue = 0;
	ret.highlight.red = 0;
	ret.highlight.green = 0;
	ret.type = 0;
	return ret;
}