using System;
using System.Globalization;
using System.Text;
using Decal.Adapter.NetParser;
using Decal.Adapter.Support;

namespace Decal.Adapter;

/// <summary>
/// Represents Message data
/// </summary>
public class MessageStruct : MarshalByRefObject
{
	internal struct MessageField
	{
		internal string Name;

		internal MemberParserType Type;

		internal object Value;

		internal int Offset;

		internal int Length;
	}

	internal byte[] mData;

	internal int mOffset;

	internal int mLength;

	internal MemberParser mParser;

	internal MessageStruct mParent;

	internal int mIndex;

	internal bool mParsed;

	internal int mCount;

	internal MessageField[] mFields;

	/// <summary>
	/// Returns the number of fields (or vector length)
	/// </summary>
	public virtual int Count
	{
		get
		{
			if (!mParsed)
			{
				Parse();
			}
			return mCount;
		}
	}

	/// <summary>
	/// Returns the specified field data
	/// </summary>
	/// <param name="index">Field index</param>
	/// <returns>Field value</returns>
	public virtual object this[int index]
	{
		get
		{
			if (!mParsed)
			{
				Parse();
			}
			if (index >= 0 && index < mCount)
			{
				return mFields[index].Value;
			}
			return null;
		}
	}

	/// <summary>
	/// Returns the specified field data
	/// </summary>
	/// <param name="name">Field name</param>
	/// <returns>Field value</returns>
	public virtual object this[string name]
	{
		get
		{
			if (!mParsed)
			{
				Parse();
			}
			int num = IndexFromName(name);
			if (num >= 0 && num < mCount)
			{
				return mFields[num].Value;
			}
			return null;
		}
	}

	/// <summary>
	/// Returns the raw bytes for this field
	/// </summary>
	public virtual byte[] RawData
	{
		get
		{
			if (mParent != null)
			{
				return mParent.RawValue(mIndex);
			}
			byte[] array = (byte[])Array.CreateInstance(typeof(byte), mData.Length);
			Buffer.BlockCopy(mData, 0, array, 0, mData.Length);
			return array;
		}
	}

	/// <summary>
	/// Returns the next object in the (parent) vector
	/// </summary>
	public virtual object Next
	{
		get
		{
			if (mParent == null)
			{
				return null;
			}
			return mParent[mIndex + 1];
		}
	}

	/// <summary>
	/// Returns the parent field
	/// </summary>
	public virtual MessageStruct Parent => mParent;

	internal MessageStruct()
	{
	}

	internal MessageStruct(byte[] Data, int Offset, MemberParser Parser)
	{
		mData = (byte[])Array.CreateInstance(typeof(byte), Data.Length);
		Buffer.BlockCopy(Data, 0, mData, 0, mData.Length);
		mOffset = Offset;
		mParser = Parser;
		mCount = -1;
	}

	internal MessageStruct(byte[] Data, int Offset, MemberParser Parser, MessageStruct Parent, int Index)
	{
		mData = Data;
		mOffset = Offset;
		mParser = Parser;
		mParent = Parent;
		mIndex = Index;
		mCount = -1;
	}

	internal MessageStruct(byte[] Data, int Offset, MemberParser Parser, int Length, MessageStruct Parent, int Index)
	{
		mData = Data;
		mOffset = Offset;
		mParser = Parser;
		mParent = Parent;
		mIndex = Index;
		mCount = Length;
	}

	internal int ObjectToIndex(object vIndex)
	{
		string text = vIndex as string;
		int num = -1;
		num = (string.IsNullOrEmpty(text) ? Util.UnboxTo<int>(vIndex) : IndexFromName(text));
		if (num >= 0 && num < mCount)
		{
			return num;
		}
		return -1;
	}

	/// <summary>
	/// Return the field name for the specified index
	/// </summary>
	/// <param name="index">Field index</param>
	/// <returns>Name of the field</returns>
	public virtual string Name(int index)
	{
		if (!mParsed)
		{
			Parse();
		}
		if (index >= 0 && index < mCount)
		{
			return mFields[index].Name;
		}
		return null;
	}

	/// <summary>
	/// Returns the passed in value?
	/// </summary>
	/// <param name="memberName"></param>
	/// <returns></returns>
	public virtual string Name(string memberName)
	{
		if (!mParsed)
		{
			Parse();
		}
		int num = IndexFromName(memberName);
		if (num >= 0 && num < mCount)
		{
			return mFields[num].Name;
		}
		return null;
	}

	/// <summary>
	/// Returns the specified child structure
	/// </summary>
	/// <param name="index">Field index</param>
	/// <returns>MessageStruct for the specified field</returns>
	public virtual MessageStruct Struct(int index)
	{
		if (!mParsed)
		{
			Parse();
		}
		if (index >= 0 && index < mCount)
		{
			MemberParserType type = mFields[index].Type;
			if (type == MemberParserType.Struct || type == MemberParserType.Vector)
			{
				return mFields[index].Value as MessageStruct;
			}
		}
		return null;
	}

	/// <summary>
	/// Returns the specified child structure
	/// </summary>
	/// <param name="name">Field name</param>
	/// <returns>MessageStruct for the specified field</returns>
	public virtual MessageStruct Struct(string name)
	{
		if (!mParsed)
		{
			Parse();
		}
		int num = IndexFromName(name);
		if (num >= 0 && num < mCount)
		{
			MemberParserType type = mFields[num].Type;
			if (type == MemberParserType.Struct || type == MemberParserType.Vector)
			{
				return mFields[num].Value as MessageStruct;
			}
		}
		return null;
	}

	/// <summary>
	/// Returns the specified field value
	/// </summary>
	/// <typeparam name="FieldType">Type of the field</typeparam>
	/// <param name="index">Field index</param>
	/// <returns>Field value cast to the specified FieldType</returns>
	public virtual FieldType Value<FieldType>(int index)
	{
		if (!mParsed)
		{
			Parse();
		}
		if (index >= 0 && index < mCount)
		{
			return Util.UnboxTo<FieldType>(mFields[index].Value);
		}
		return default(FieldType);
	}

	/// <summary>
	/// Returns the specified field value
	/// </summary>
	/// <typeparam name="FieldType">Type of the field</typeparam>
	/// <param name="name">Field name</param>
	/// <returns>Field value cast to the specified FieldType</returns>
	public virtual FieldType Value<FieldType>(string name)
	{
		if (!mParsed)
		{
			Parse();
		}
		int num = IndexFromName(name);
		if (num >= 0 && num < mCount)
		{
			return Util.UnboxTo<FieldType>(mFields[num].Value);
		}
		return default(FieldType);
	}

	/// <summary>
	/// Returns the raw bytes of the specified field
	/// </summary>
	/// <param name="index">Field index</param>
	/// <returns>Raw field value</returns>
	public virtual byte[] RawValue(int index)
	{
		if (!mParsed)
		{
			Parse();
		}
		if (index >= 0 && index < mCount)
		{
			int length = mFields[index].Length;
			byte[] array = (byte[])Array.CreateInstance(typeof(byte), length);
			Buffer.BlockCopy(mData, mFields[index].Offset, array, 0, length);
			return array;
		}
		return null;
	}

	/// <summary>
	/// Returns the raw bytes of the specified field
	/// </summary>
	/// <param name="name">Field name</param>
	/// <returns>Raw field value</returns>
	public virtual byte[] RawValue(string name)
	{
		if (!mParsed)
		{
			Parse();
		}
		int num = IndexFromName(name);
		if (num >= 0 && num < mCount)
		{
			int length = mFields[num].Length;
			byte[] array = (byte[])Array.CreateInstance(typeof(byte), length);
			Buffer.BlockCopy(mData, mFields[num].Offset, array, 0, length);
			return array;
		}
		return null;
	}

	internal int IndexFromName(string Name)
	{
		int num = mCount;
		for (int i = 0; i < num; i++)
		{
			if (string.Compare(Name, mFields[i].Name, ignoreCase: true, CultureInfo.InvariantCulture) == 0)
			{
				return i;
			}
		}
		return -1;
	}

	internal void Parse()
	{
		if (mCount == -1)
		{
			ParseStruct();
		}
		else
		{
			ParseVector();
		}
	}

	internal void ParseStruct()
	{
		int length = ParseCounter(mParser);
		mFields = (MessageField[])Array.CreateInstance(typeof(MessageField), length);
		mParsed = true;
		int ByteIndex = mOffset;
		mCount = 0;
		ParseHelper(mParser, ref mCount, ref ByteIndex);
		mLength = ByteIndex - mOffset;
		MessageField[] sourceArray = mFields;
		mFields = (MessageField[])Array.CreateInstance(typeof(MessageField), mCount);
		Array.Copy(sourceArray, mFields, mCount);
	}

	internal void ParseVector()
	{
		int num = mCount;
		mFields = (MessageField[])Array.CreateInstance(typeof(MessageField), num);
		mParsed = true;
		int num2 = mOffset;
		for (int i = 0; i < num; i++)
		{
			mFields[i].Name = i.ToString();
			mFields[i].Offset = num2;
			mFields[i].Type = MemberParserType.Struct;
			MessageStruct messageStruct = new MessageStruct(mData, num2, mParser, this, i);
			messageStruct.ParseStruct();
			mFields[i].Value = messageStruct;
			mFields[i].Length = messageStruct.mLength;
			num2 += messageStruct.mLength;
		}
		mLength = num2 - mOffset;
	}

	internal int ParseCounter(MemberParser Parser)
	{
		int num = 0;
		while (Parser != null)
		{
			num = ((Parser.MemberType != MemberParserType.Case) ? (num + 1) : (num + ParseCounter(Parser.Child)));
			Parser = Parser.Next;
		}
		return num;
	}

	internal void ParseHelper(MemberParser Parser, ref int FieldIndex, ref int ByteIndex)
	{
		Encoding encoding = Encoding.GetEncoding(1252);
		while (Parser != null)
		{
			if (Parser.PreAlignment != 0)
			{
				int num = ByteIndex % Parser.PreAlignment;
				if (num != 0)
				{
					ByteIndex += Parser.PreAlignment - num;
				}
			}
			bool flag = Parser.Condition == MemberParserCondition.None;
			if (!flag)
			{
				MessageStruct messageStruct = this;
				object obj;
				do
				{
					obj = messageStruct[Parser.ConditionField];
					if (obj != null)
					{
						break;
					}
					messageStruct = messageStruct.mParent;
				}
				while (messageStruct != null);
				if (obj != null)
				{
					long num2 = 0L;
					Type type = obj.GetType();
					if (type.Equals(typeof(int)))
					{
						num2 = Convert.ToInt64(obj);
						num2 &= 0xFFFFFFFFu;
					}
					else if (type.Equals(typeof(short)))
					{
						num2 = Convert.ToInt64(obj);
						num2 &= 0xFFFF;
					}
					else if (type.Equals(typeof(byte)))
					{
						num2 = Convert.ToInt64(obj);
						num2 &= 0xFF;
					}
					else if (type.Equals(typeof(long)))
					{
						num2 = Convert.ToInt64(obj);
					}
					num2 ^= Parser.ConditionXor;
					num2 &= Parser.ConditionAnd;
					switch (Parser.Condition)
					{
					case MemberParserCondition.EQ:
						flag = num2 == Parser.ConditionResult;
						break;
					case MemberParserCondition.NE:
						flag = num2 != Parser.ConditionResult;
						break;
					case MemberParserCondition.GE:
						flag = num2 >= Parser.ConditionResult;
						break;
					case MemberParserCondition.GT:
						flag = num2 > Parser.ConditionResult;
						break;
					case MemberParserCondition.LE:
						flag = num2 <= Parser.ConditionResult;
						break;
					case MemberParserCondition.LT:
						flag = num2 < Parser.ConditionResult;
						break;
					}
				}
			}
			if (flag)
			{
				mFields[FieldIndex].Name = Parser.MemberName;
				mFields[FieldIndex].Offset = ByteIndex;
				mFields[FieldIndex].Type = Parser.MemberType;
				switch (Parser.MemberType)
				{
				case MemberParserType.BYTE:
					mFields[FieldIndex].Value = mData[ByteIndex++];
					break;
				case MemberParserType.WORD:
					mFields[FieldIndex].Value = BitConverter.ToInt16(mData, ByteIndex);
					ByteIndex += 2;
					break;
				case MemberParserType.PackedWORD:
				{
					int num6 = mData[ByteIndex++];
					if ((num6 & 0x80) != 0)
					{
						num6 = ((num6 & 0x7F) << 8) | mData[ByteIndex++];
					}
					mFields[FieldIndex].Value = num6;
					break;
				}
				case MemberParserType.DWORD:
					mFields[FieldIndex].Value = BitConverter.ToInt32(mData, ByteIndex);
					ByteIndex += 4;
					break;
				case MemberParserType.PackedDWORD:
				{
					int num6 = BitConverter.ToInt16(mData, ByteIndex);
					ByteIndex += 2;
					if ((num6 & 0x8000) != 0)
					{
						num6 = ((num6 & 0x7FFF) << 16) | (BitConverter.ToInt16(mData, ByteIndex) & 0xFFFF);
						ByteIndex += 2;
					}
					mFields[FieldIndex].Value = num6;
					break;
				}
				case MemberParserType.QWORD:
					mFields[FieldIndex].Value = BitConverter.ToInt64(mData, ByteIndex);
					ByteIndex += 8;
					break;
				case MemberParserType.@float:
					mFields[FieldIndex].Value = BitConverter.ToSingle(mData, ByteIndex);
					ByteIndex += 4;
					break;
				case MemberParserType.@double:
					mFields[FieldIndex].Value = BitConverter.ToDouble(mData, ByteIndex);
					ByteIndex += 8;
					break;
				case MemberParserType.String:
				{
					int num6 = BitConverter.ToInt16(mData, ByteIndex);
					ByteIndex += 2;
					if (num6 == -1)
					{
						num6 = BitConverter.ToInt32(mData, ByteIndex);
						ByteIndex += 4;
					}
					StringBuilder stringBuilder = new StringBuilder(num6);
					for (int j = 0; j < num6; j++)
					{
						stringBuilder.Append(encoding.GetChars(mData, ByteIndex++, 1));
					}
					mFields[FieldIndex].Value = stringBuilder.ToString();
					ByteIndex = (ByteIndex + 3) & -4;
					break;
				}
				case MemberParserType.WString:
				{
					int num6 = mData[ByteIndex++];
					if ((num6 & 0x80) != 0)
					{
						num6 = ((num6 & 0x7F) << 8) | mData[ByteIndex++];
					}
					StringBuilder stringBuilder = new StringBuilder(num6);
					for (int i = 0; i < num6; i++)
					{
						stringBuilder.Append(BitConverter.ToChar(mData, ByteIndex));
						ByteIndex += 2;
					}
					mFields[FieldIndex].Value = stringBuilder.ToString();
					break;
				}
				case MemberParserType.Struct:
				{
					MessageStruct messageStruct = new MessageStruct(mData, ByteIndex, Parser.Child, this, FieldIndex);
					messageStruct.ParseStruct();
					ByteIndex += messageStruct.mLength;
					mFields[FieldIndex].Value = messageStruct;
					break;
				}
				case MemberParserType.Vector:
				{
					MessageStruct messageStruct = this;
					object obj;
					do
					{
						obj = messageStruct[Parser.LengthField];
						if (obj != null)
						{
							break;
						}
						messageStruct = messageStruct.mParent;
					}
					while (messageStruct != null);
					long num4 = 0L;
					if (obj != null)
					{
						Type type2 = obj.GetType();
						if (type2.Equals(typeof(int)))
						{
							num4 = Convert.ToInt64(obj);
							num4 &= 0xFFFFFFFFu;
						}
						else if (type2.Equals(typeof(short)))
						{
							num4 = Convert.ToInt64(obj);
							num4 &= 0xFFFF;
						}
						else if (type2.Equals(typeof(byte)))
						{
							num4 = Convert.ToInt64(obj);
							num4 &= 0xFF;
						}
						else if (type2.Equals(typeof(long)))
						{
							num4 = Convert.ToInt64(obj);
						}
					}
					long num5 = Parser.LengthMask;
					num4 &= num5;
					if (num5 != 0L)
					{
						while ((num5 & 1) == 0L)
						{
							num4 >>= 1;
							num5 >>= 1;
						}
					}
					messageStruct = new MessageStruct(mData, ByteIndex, Parser.Child, (int)num4 + Parser.LengthDelta, this, FieldIndex);
					messageStruct.ParseVector();
					ByteIndex += messageStruct.mLength;
					mFields[FieldIndex].Value = messageStruct;
					break;
				}
				case MemberParserType.Case:
				{
					int num3 = FieldIndex;
					ParseHelper(Parser.Child, ref FieldIndex, ref ByteIndex);
					if (FieldIndex > num3)
					{
						FieldIndex--;
					}
					break;
				}
				}
				mFields[FieldIndex].Length = ByteIndex - mFields[FieldIndex].Offset;
			}
			if (Parser.PostAlignment != 0)
			{
				int num7 = ByteIndex % Parser.PostAlignment;
				if (num7 != 0)
				{
					num7 = Parser.PostAlignment - num7;
					ByteIndex += num7;
					if (flag)
					{
						mFields[FieldIndex].Length += num7;
					}
				}
			}
			if (flag)
			{
				FieldIndex++;
			}
			Parser = Parser.Next;
		}
	}
}