using System;
using System.Text;
using QCRPG.Framework;

namespace QCRPG.TSL.BT.Packets;

public class SlcLogIdLeRxVerbose : PacketBase
{
	public class UserFieldsWrapper
	{
		public enum LogIdEnum
		{
			SLC_LOG,
			InvalidLogIdValue
		}

		public static class LogIdInfo
		{
			public static LogIdEnum ValueToLogId(uint value)
			{
				if (value == 0)
				{
					return LogIdEnum.SLC_LOG;
				}
				return LogIdEnum.InvalidLogIdValue;
			}

			public static uint LogIdToValue(LogIdEnum enumItem)
			{
				if (enumItem == LogIdEnum.SLC_LOG)
				{
					return 0u;
				}
				return uint.MaxValue;
			}

			public static string LogIdToString(LogIdEnum enumItem)
			{
				if (enumItem == LogIdEnum.SLC_LOG)
				{
					return "SLC_LOG";
				}
				return "Invalid LogId Value";
			}

			public static string LogIdToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("0x0 = SLC_LOG");
				return stringBuilder.ToString();
			}
		}

		public enum SlcLogIdEnum
		{
			RX,
			InvalidSlcLogIdValue
		}

		public static class SlcLogIdInfo
		{
			public static SlcLogIdEnum ValueToSlcLogId(uint value)
			{
				if (value == 19)
				{
					return SlcLogIdEnum.RX;
				}
				return SlcLogIdEnum.InvalidSlcLogIdValue;
			}

			public static uint SlcLogIdToValue(SlcLogIdEnum enumItem)
			{
				if (enumItem == SlcLogIdEnum.RX)
				{
					return 19u;
				}
				return uint.MaxValue;
			}

			public static string SlcLogIdToString(SlcLogIdEnum enumItem)
			{
				if (enumItem == SlcLogIdEnum.RX)
				{
					return "RX";
				}
				return "Invalid SlcLogId Value";
			}

			public static string SlcLogIdToDescription()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("0x13 = RX");
				return stringBuilder.ToString();
			}
		}

		private const uint _SlcLogId = 19u;

		private uint _SeqNum;

		private uint _LogsLostDrop;

		private uint _ProdId;

		private uint _LogId;

		private uint _LogFormatLevel;

		private uint _Timestamp;

		private uint _SlcFmtSpecifier;

		private uint _CxmAbort;

		private uint _LateCommand;

		private uint _MoreData;

		private uint _SlcSeqNum;

		private uint _Nesn;

		private uint _Llid;

		private uint _Length;

		public uint SeqNum
		{
			get
			{
				return _SeqNum;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for SeqNum is 0xFF");
				}
				_SeqNum = value;
			}
		}

		public uint LogsLostDrop
		{
			get
			{
				return _LogsLostDrop;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for LogsLostDrop is 0xFF");
				}
				_LogsLostDrop = value;
			}
		}

		public uint ProdId
		{
			get
			{
				return _ProdId;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for ProdId is 0xFF");
				}
				_ProdId = value;
			}
		}

		public uint LogId
		{
			get
			{
				return _LogId;
			}
			set
			{
				if (value > 65535)
				{
					throw new Exception("Maximum possible value for LogId is 0xFFFF");
				}
				if (LogIdInfo.ValueToLogId(value) == LogIdEnum.InvalidLogIdValue)
				{
					throw new Exception("Invalid LogId value");
				}
				_LogId = value;
			}
		}

		public uint LogFormatLevel
		{
			get
			{
				return _LogFormatLevel;
			}
			set
			{
				if (value > 255)
				{
					throw new Exception("Maximum possible value for LogFormatLevel is 0xFF");
				}
				_LogFormatLevel = value;
			}
		}

		public uint Timestamp
		{
			get
			{
				return _Timestamp;
			}
			set
			{
				_Timestamp = value;
			}
		}

		public uint SlcFmtSpecifier
		{
			get
			{
				return _SlcFmtSpecifier;
			}
			set
			{
				if (value > 3)
				{
					throw new Exception("Maximum possible value for SlcFmtSpecifier is 0x3");
				}
				_SlcFmtSpecifier = value;
			}
		}

		public uint SlcLogId => 19u;

		public uint CxmAbort
		{
			get
			{
				return _CxmAbort;
			}
			set
			{
				if (value > 3)
				{
					throw new Exception("Maximum possible value for CxmAbort is 0x3");
				}
				_CxmAbort = value;
			}
		}

		public uint LateCommand
		{
			get
			{
				return _LateCommand;
			}
			set
			{
				if (value > 1)
				{
					throw new Exception("Maximum possible value for LateCommand is 0x1");
				}
				_LateCommand = value;
			}
		}

		public uint MoreData
		{
			get
			{
				return _MoreData;
			}
			set
			{
				if (value > 1)
				{
					throw new Exception("Maximum possible value for MoreData is 0x1");
				}
				_MoreData = value;
			}
		}

		public uint SlcSeqNum
		{
			get
			{
				return _SlcSeqNum;
			}
			set
			{
				if (value > 1)
				{
					throw new Exception("Maximum possible value for SlcSeqNum is 0x1");
				}
				_SlcSeqNum = value;
			}
		}

		public uint Nesn
		{
			get
			{
				return _Nesn;
			}
			set
			{
				if (value > 1)
				{
					throw new Exception("Maximum possible value for Nesn is 0x1");
				}
				_Nesn = value;
			}
		}

		public uint Llid
		{
			get
			{
				return _Llid;
			}
			set
			{
				if (value > 3)
				{
					throw new Exception("Maximum possible value for Llid is 0x3");
				}
				_Llid = value;
			}
		}

		public uint Length
		{
			get
			{
				return _Length;
			}
			set
			{
				if (value > 65535)
				{
					throw new Exception("Maximum possible value for Length is 0xFFFF");
				}
				_Length = value;
			}
		}

		public LogIdEnum GetLogIdAsLogIdEnum()
		{
			return LogIdInfo.ValueToLogId(_LogId);
		}

		public void SetLogIdAsLogIdEnum(LogIdEnum enumItem)
		{
			LogId = LogIdInfo.LogIdToValue(enumItem);
		}

		public SlcLogIdEnum GetSlcLogIdAsSlcLogIdEnum()
		{
			return SlcLogIdInfo.ValueToSlcLogId(19u);
		}
	}

	private Type[] expectedResponseTypes = new Type[0];

	private PacketInfoBase info;

	private uint _AclheaderSeqnumPadding;

	private uint _LogformatlevelTimestampPadding;

	private uint _LogLength;

	private uint _Rfu2;

	public UserFieldsWrapper _UserFields = new UserFieldsWrapper();

	public override PacketType Type => PacketType.EnhancedLog;

	public override Type[] ExpectedResponseTypes => expectedResponseTypes;

	public override PacketInfoBase Info
	{
		get
		{
			if (info == null)
			{
				info = new SlcLogIdLeRxVerboseInfo(this);
			}
			return info;
		}
	}

	public uint AclheaderSeqnumPadding
	{
		get
		{
			return _AclheaderSeqnumPadding;
		}
		set
		{
			if (value > 16777215)
			{
				throw new Exception("Maximum possible value for AclheaderSeqnumPadding is 0xFFFFFF");
			}
			_AclheaderSeqnumPadding = value;
		}
	}

	public uint LogformatlevelTimestampPadding
	{
		get
		{
			return _LogformatlevelTimestampPadding;
		}
		set
		{
			if (value > 255)
			{
				throw new Exception("Maximum possible value for LogformatlevelTimestampPadding is 0xFF");
			}
			_LogformatlevelTimestampPadding = value;
		}
	}

	public uint LogLength
	{
		get
		{
			ToBitString();
			return _LogLength;
		}
	}

	public uint Rfu2
	{
		get
		{
			return _Rfu2;
		}
		set
		{
			if (value > 255)
			{
				throw new Exception("Maximum possible value for Rfu2 is 0xFF");
			}
			_Rfu2 = value;
		}
	}

	public UserFieldsWrapper UserFields => _UserFields;

	protected override bool FromBitBuilder(ref BitBuilder bitBuilder)
	{
		AclheaderSeqnumPadding = bitBuilder.RemoveBitsAsUint(24);
		UserFields.SeqNum = bitBuilder.RemoveBitsAsUint(8);
		UserFields.LogsLostDrop = bitBuilder.RemoveBitsAsUint(8);
		UserFields.ProdId = bitBuilder.RemoveBitsAsUint(8);
		UserFields.LogId = bitBuilder.RemoveBitsAsUintLittleEndian(16);
		UserFields.LogFormatLevel = bitBuilder.RemoveBitsAsUint(8);
		LogformatlevelTimestampPadding = bitBuilder.RemoveBitsAsUint(8);
		UserFields.Timestamp = bitBuilder.RemoveBitsAsUintLittleEndian(32);
		_LogLength = bitBuilder.RemoveBitsAsUintLittleEndian(16);
		int numberOfBits = bitBuilder.GetNumberOfBits();
		if (numberOfBits > _LogLength * 8 + 7)
		{
			return false;
		}
		if (numberOfBits < _LogLength * 8)
		{
			return false;
		}
		UserFields.SlcFmtSpecifier = bitBuilder.RemoveBitsAsUint(2);
		if (bitBuilder.RemoveBitsAsUint(6) != UserFields.SlcLogId)
		{
			return false;
		}
		UserFields.CxmAbort = bitBuilder.RemoveBitsAsUint(2);
		UserFields.LateCommand = bitBuilder.RemoveBitsAsUint(1);
		UserFields.MoreData = bitBuilder.RemoveBitsAsUint(1);
		UserFields.SlcSeqNum = bitBuilder.RemoveBitsAsUint(1);
		UserFields.Nesn = bitBuilder.RemoveBitsAsUint(1);
		UserFields.Llid = bitBuilder.RemoveBitsAsUint(2);
		UserFields.Length = bitBuilder.RemoveBitsAsUintLittleEndian(16);
		Rfu2 = bitBuilder.RemoveBitsAsUint(8);
		if (bitBuilder.GetNumberOfBits() > 7)
		{
			return false;
		}
		return true;
	}

	public override string ToBitString()
	{
		BitBuilder bitBuilder = new BitBuilder();
		bitBuilder.AddBitsAsUint(AclheaderSeqnumPadding, 24);
		bitBuilder.AddBitsAsUint(UserFields.SeqNum, 8);
		bitBuilder.AddBitsAsUint(UserFields.LogsLostDrop, 8);
		bitBuilder.AddBitsAsUint(UserFields.ProdId, 8);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.LogId, 16);
		bitBuilder.AddBitsAsUint(UserFields.LogFormatLevel, 8);
		bitBuilder.AddBitsAsUint(LogformatlevelTimestampPadding, 8);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.Timestamp, 32);
		int numberOfBits = bitBuilder.GetNumberOfBits();
		bitBuilder.AddBitsAsUintLittleEndian(0u, 16);
		bitBuilder.AddBitsAsUint(UserFields.SlcFmtSpecifier, 2);
		bitBuilder.AddBitsAsUint(UserFields.SlcLogId, 6);
		bitBuilder.AddBitsAsUint(UserFields.CxmAbort, 2);
		bitBuilder.AddBitsAsUint(UserFields.LateCommand, 1);
		bitBuilder.AddBitsAsUint(UserFields.MoreData, 1);
		bitBuilder.AddBitsAsUint(UserFields.SlcSeqNum, 1);
		bitBuilder.AddBitsAsUint(UserFields.Nesn, 1);
		bitBuilder.AddBitsAsUint(UserFields.Llid, 2);
		bitBuilder.AddBitsAsUintLittleEndian(UserFields.Length, 16);
		bitBuilder.AddBitsAsUint(Rfu2, 8);
		_LogLength = (uint)((bitBuilder.GetNumberOfBits() - numberOfBits - 16) / 8);
		if ((bitBuilder.GetNumberOfBits() - numberOfBits - 16) % 8 != 0)
		{
			_LogLength++;
		}
		bitBuilder.ChangeBitsAsUintLittleEndian(numberOfBits, _LogLength, 16);
		return bitBuilder.ToString();
	}
}
