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

#pragma once

#include <string>
#include <vector>

#include "../log.hpp"
#include "../types.hpp"
#include "../misc_functions.hpp"

#define DATA_STRUCT_NONE				0
#define DATA_STRUCT_INT8				1
#define DATA_STRUCT_INT16				2
#define DATA_STRUCT_INT32				3
#define DATA_STRUCT_INT64				4
#define DATA_STRUCT_FLOAT				5
#define DATA_STRUCT_DOUBLE				6
#define DATA_STRUCT_COLOR				7
#define DATA_STRUCT_SINT8				8
#define DATA_STRUCT_SINT16				9
#define DATA_STRUCT_SINT32				10
#define DATA_STRUCT_CHAR				11
#define DATA_STRUCT_EQ2_8BIT_STRING		12
#define DATA_STRUCT_EQ2_16BIT_STRING	13
#define DATA_STRUCT_EQ2_32BIT_STRING	14
#define DATA_STRUCT_EQUIPMENT			15
#define DATA_STRUCT_ARRAY				16
#define DATA_STRUCT_ITEM				17
#define DATA_STRUCT_SINT64				18

class DataStruct
{
public:
	// Default constructor - initializes all member variables to default values
	DataStruct()
	{
		item_size = 0;
		type = 0;
		type2 = 0;
		length = 1;
		if_flag_set = false;
		if_flag_not_set = false;
		if_set = false;
		if_not_set = false;
		if_not_equals = false;
		if_equals = false;
		is_set = false;
		optional = false;
		oversized = 0;
		oversized_byte = 0;
		add = false;
		addType = 0;
		maxArraySize = 0;
		default_value = 0;
	}

	// Copy constructor - creates new DataStruct from existing one
	DataStruct(DataStruct* data_struct)
	{
		type = data_struct->GetType();
		type2 = data_struct->GetType2();
		length = data_struct->GetLength();
		name = data_struct->GetName();
		array_size_variable = data_struct->array_size_variable;
		default_value = data_struct->default_value;
		add = true;
		addType = type;
		oversized = data_struct->GetOversized();
		oversized_byte = data_struct->GetOversizedByte();
		maxArraySize = data_struct->GetMaxArraySize();
		if_flag_set = false;
		if_flag_not_set = false;
		if_set = false;
		if_not_set = false;
		if_not_equals = false;
		if_equals = false;
		optional = false;
		if (data_struct->GetIfSet())
			SetIfSetVariable(data_struct->GetIfSetVariable());
		if (data_struct->GetIfNotSet())
			SetIfNotSetVariable(data_struct->GetIfNotSetVariable());
		if (data_struct->GetIfNotEquals())
			SetIfNotEqualsVariable(data_struct->GetIfNotEqualsVariable());
		if (data_struct->GetIfEquals())
			SetIfEqualsVariable(data_struct->GetIfEqualsVariable());
		if (data_struct->GetIfFlagSet())
			SetIfFlagSetVariable(data_struct->GetIfFlagSetVariable());
		if (data_struct->GetIfFlagNotSet())
			SetIfFlagNotSetVariable(data_struct->GetIfFlagNotSetVariable());
		item_size = 0;
		is_set = false;
	}

	// Constructor with name and type strings
	DataStruct(const char* new_name, const char* new_type, int32 new_length, const char* new_type2)
	{
		name = std::string(new_name);
		type = 0;
		type2 = 0;
		SetType(new_type, &type);
		if (new_type2)
			SetType(new_type2, &type2);
		length = new_length;
		add = true;
		addType = type;
		if_set = false;
		if_not_set = false;
		is_set = false;
		if_not_equals = false;
		item_size = 0;
	}

	// Constructor with name and length only
	DataStruct(const char* new_name, int32 new_length)
	{
		name = std::string(new_name);
		length = new_length;
		if_set = false;
		if_not_set = false;
		is_set = false;
		item_size = 0;
	}

	// Constructor with name, type integers, and length
	DataStruct(const char* new_name, int8 new_type, int32 new_length, int8 new_type2)
	{
		name = std::string(new_name);
		type = new_type;
		length = new_length;
		type2 = new_type2;
		addType = type;
		if_set = false;
		if_not_set = false;
		is_set = false;
		item_size = 0;
	}

	// Converts type string to numeric type constant
	void SetType(const char* new_type, int8* output_type)
	{
		if (strlen(new_type) > 3 && strncasecmp("int", new_type, 3) == 0) {
			if (strncasecmp("int8", new_type, 4) == 0)
				*output_type = DATA_STRUCT_INT8;
			else if (strncasecmp("int16", new_type, 5) == 0)
				*output_type = DATA_STRUCT_INT16;
			else if (strncasecmp("int32", new_type, 5) == 0)
				*output_type = DATA_STRUCT_INT32;
			else if (strncasecmp("int64", new_type, 5) == 0)
				*output_type = DATA_STRUCT_INT64;
		}
		else if (strlen(new_type) > 4 && strncasecmp("sint", new_type, 4) == 0) {
			if (strncasecmp("sint8", new_type, 5) == 0)
				*output_type = DATA_STRUCT_SINT8;
			else if (strncasecmp("sint16", new_type, 6) == 0)
				*output_type = DATA_STRUCT_SINT16;
			else if (strncasecmp("sint32", new_type, 6) == 0)
				*output_type = DATA_STRUCT_SINT32;
			else if (strncasecmp("sint64", new_type, 6) == 0)
				*output_type = DATA_STRUCT_SINT64;
		}
		else if (strlen(new_type) == 4 && strncasecmp("char", new_type, 4) == 0)
			*output_type = DATA_STRUCT_CHAR;
		else if (strlen(new_type) == 5 && strncasecmp("float", new_type, 5) == 0)
			*output_type = DATA_STRUCT_FLOAT;
		else if (strlen(new_type) == 6 && strncasecmp("double", new_type, 6) == 0)
			*output_type = DATA_STRUCT_DOUBLE;
		else if (strlen(new_type) >= 5 && strncasecmp("EQ2_", new_type, 4) == 0) {
			if (strncasecmp("EQ2_8", new_type, 5) == 0)
				*output_type = DATA_STRUCT_EQ2_8BIT_STRING;
			else if (strncasecmp("EQ2_16", new_type, 6) == 0)
				*output_type = DATA_STRUCT_EQ2_16BIT_STRING;
			else if (strncasecmp("EQ2_32", new_type, 6) == 0)
				*output_type = DATA_STRUCT_EQ2_32BIT_STRING;
			else if (strncasecmp("EQ2_E", new_type, 5) == 0)
				*output_type = DATA_STRUCT_EQUIPMENT;
			else if (strncasecmp("EQ2_C", new_type, 5) == 0)
				*output_type = DATA_STRUCT_COLOR;
			else if (strncasecmp("EQ2_I", new_type, 5) == 0)
				*output_type = DATA_STRUCT_ITEM;
		}
		else if (strlen(new_type) >= 5) {
			if (strncasecmp("Array", new_type, 5) == 0)
				*output_type = DATA_STRUCT_ARRAY;
		}
		else
			LogWrite(PACKET__ERROR, 0, "Packet", "Invalid Type: %s", new_type);
	}

	// Setter methods
	void SetType(int8 new_type) { type = new_type; addType = type; }
	void SetMaxArraySize(int8 size) { maxArraySize = size; }
	void SetOversized(int8 val) { oversized = val; }
	void SetDefaultValue(int8 new_val) { default_value = new_val; }
	void SetName(const char* new_name) { name = std::string(new_name); }
	void SetLength(int32 new_length) { length = new_length; }
	void SetOversizedByte(int8 val) { oversized_byte = val; }
	void SetAddToStruct(bool val) { add = val; }
	void SetAddType(int8 new_type) { addType = new_type; }
	void SetArraySizeVariable(const char* new_name) { array_size_variable = std::string(new_name); }
	void SetIsSet(bool val) { is_set = val; }
	void SetIsOptional(bool val) { optional = val; }

	// Sets item size in bytes and marks as set if size > 0
	void SetItemSize(int32 val)
	{
		item_size = val;
		if (item_size)
			is_set = true;
		else
			is_set = false;
	}

	// Conditional variable setters
	void SetIfEqualsVariable(const char* variable)
	{
		if (variable) {
			if_equals = true;
			if_equals_variable = std::string(variable);
		}
		else
			if_equals = false;
	}

	void SetIfNotEqualsVariable(const char* variable)
	{
		if (variable) {
			if_not_equals = true;
			if_not_equals_variable = std::string(variable);
		}
		else
			if_not_equals = false;
	}

	void SetIfFlagNotSetVariable(const char* variable)
	{
		if (variable) {
			if_flag_not_set = true;
			if_flag_not_set_variable = std::string(variable);
		}
		else
			if_flag_not_set = false;
	}

	void SetIfFlagSetVariable(const char* variable)
	{
		if (variable) {
			if_flag_set = true;
			if_flag_set_variable = std::string(variable);
		}
		else
			if_flag_set = false;
	}

	void SetIfSetVariable(const char* variable)
	{
		if (variable) {
			if_set = true;
			if_set_variable = std::string(variable);
		}
		else
			if_set = false;
	}

	void SetIfNotSetVariable(const char* variable)
	{
		if (variable) {
			if_not_set = true;
			if_not_set_variable = std::string(variable);
		}
		else
			if_not_set = false;
	}

	// Getter methods
	const char* GetArraySizeVariable() { return array_size_variable.c_str(); }
	int32 GetItemSize() { return item_size; }
	bool GetIfSet() { return if_set; }
	bool GetIfNotSet() { return if_not_set; }
	bool GetIfEquals() { return if_equals; }
	bool GetIfNotEquals() { return if_not_equals; }
	bool GetIfFlagSet() { return if_flag_set; }
	bool GetIfFlagNotSet() { return if_flag_not_set; }
	bool IsSet() { return is_set; }
	bool IsOptional() { return optional; }
	bool AddToStruct() { return add; }
	int8 GetDefaultValue() { return default_value; }
	int8 GetType() { return type; }
	int8 GetType2() { return type2; }
	int8 GetOversized() { return oversized; }
	int8 GetOversizedByte() { return oversized_byte; }
	int8 GetMaxArraySize() { return maxArraySize; }
	int8 GetAddType() { return addType; }
	int32 GetLength() { return length; }
	const char* GetName() { return name.c_str(); }
	std::string GetStringName() { return name; }

	// Conditional variable getters
	const char* GetIfSetVariable()
	{
		if (if_set_variable.length() > 0)
			return if_set_variable.c_str();
		return 0;
	}

	const char* GetIfNotSetVariable()
	{
		if (if_not_set_variable.length() > 0)
			return if_not_set_variable.c_str();
		return 0;
	}

	const char* GetIfEqualsVariable()
	{
		if (if_equals_variable.length() > 0)
			return if_equals_variable.c_str();
		return 0;
	}

	const char* GetIfNotEqualsVariable()
	{
		if (if_not_equals_variable.length() > 0)
			return if_not_equals_variable.c_str();
		return 0;
	}

	const char* GetIfFlagSetVariable()
	{
		if (if_flag_set_variable.length() > 0)
			return if_flag_set_variable.c_str();
		return 0;
	}

	const char* GetIfFlagNotSetVariable()
	{
		if (if_flag_not_set_variable.length() > 0)
			return if_flag_not_set_variable.c_str();
		return 0;
	}

	// Appends variable name to existing variable list, avoiding duplicates
	std::string AppendVariable(std::string orig, const char* val)
	{
		if (!val)
			return orig;
		if (orig.length() == 0)
			return std::string(val);
		if (orig.find(",") < 0xFFFFFFFF) { // has more than one already
			std::string valstr = std::string(val);
			std::vector<std::string>* varnames = SplitString(orig, ',');
			if (varnames) {
				for (int32 i = 0; i < varnames->size(); i++) {
					if (valstr.compare(varnames->at(i)) == 0) {
						return orig; // already in the variable, no need to append
					}
				}
				safe_delete(varnames);
			}
		}
		return orig.append(",").append(val);
	}

	// Calculates total data size in bytes based on type and length
	int32 GetDataSizeInBytes()
	{
		int32 ret = 0;
		switch (type) {
		case DATA_STRUCT_INT8:
			ret = length * sizeof(int8);
			break;
		case DATA_STRUCT_INT16:
			ret = length * sizeof(int16);
			break;
		case DATA_STRUCT_INT32:
			ret = length * sizeof(int32);
			break;
		case DATA_STRUCT_INT64:
			ret = length * sizeof(int64);
			break;
		case DATA_STRUCT_SINT8:
			ret = length * sizeof(sint8);
			break;
		case DATA_STRUCT_SINT16:
			ret = length * sizeof(sint16);
			break;
		case DATA_STRUCT_SINT32:
			ret = length * sizeof(sint32);
			break;
		case DATA_STRUCT_SINT64:
			ret = length * sizeof(sint64);
			break;
		case DATA_STRUCT_FLOAT:
			ret = length * sizeof(float);
			break;
		case DATA_STRUCT_DOUBLE:
			ret = length * sizeof(double);
			break;
		case DATA_STRUCT_ARRAY:
			// Array elements won't have a size so get out now to avoid the warning.
			break;
		default:
			LogWrite(PACKET__WARNING, 0, "DataStruct", "Tried retrieving a data size from an unsupported data struct type in GetDataSizeInBytes()");
			break;
		}
		return ret;
	}

	// Adds variable to if-set condition list
	void AddIfSetVariable(const char* val)
	{
		if (val) {
			if_set_variable = AppendVariable(if_set_variable, val);
			is_set = true;
		}
	}

	// Adds variable to if-not-set condition list
	void AddIfNotSetVariable(const char* val)
	{
		if (val) {
			if_not_set_variable = AppendVariable(if_not_set_variable, val);
			if_not_set = true;
		}
	}

private:
	bool is_set;							// Whether this data structure contains data
	bool if_not_set;						// Conditional inclusion based on variable not set
	bool optional;							// Whether this field is optional
	bool if_set;							// Conditional inclusion based on variable set
	bool if_not_equals;						// Conditional inclusion based on variable not equals
	bool if_equals;							// Conditional inclusion based on variable equals
	bool if_flag_set;						// Conditional inclusion based on flag set
	bool if_flag_not_set;					// Conditional inclusion based on flag not set
	std::string if_flag_not_set_variable;	// Variable name for flag not set condition
	std::string if_flag_set_variable;		// Variable name for flag set condition
	std::string if_not_equals_variable;		// Variable name for not equals condition
	std::string if_equals_variable;			// Variable name for equals condition
	std::string if_not_set_variable;		// Variable name for not set condition
	std::string if_set_variable;			// Variable name for set condition
	int8 oversized;							// Threshold for oversized data handling
	int8 oversized_byte;					// Byte marker for oversized data
	bool add;								// Whether to include in packet structure
	int8 addType;							// Type to use when adding to packet
	int8 maxArraySize;						// Maximum allowed array size
	std::string array_size_variable;		// Variable name containing array size
	std::string name;						// Name identifier of this data structure
	int8 type;								// Primary data type
	int8 default_value;						// Default value for initialization
	int8 type2;								// Secondary data type (for special cases)
	int32 length;							// Number of elements/length
	int32 item_size;						// Size in bytes for item data
};