PacketData

using System;
using System.Collections.Generic;

namespace DataTypes {
    public struct PacketData {
        public static readonly int        _packetLength = 184;
        private readonly       List<byte> rawData;
        private                int        position;
        private static         int        packetNum;
        public readonly        int        command;

    #region Add data
        public void AddData(string value) {
            AddBytes(BinaryToolz.GetBytes(value));
        }

        public string GetString() {
            var length = GetByte();
            return BinaryToolz.BytesToUTF(Extract(length));
        }

        public void AddData(uint data) {
            AddBytes(BitConverter.GetBytes(data));
        }

        public uint GetUint() {
            return BitConverter.ToUInt32(Extract(4), 0);
        }

        public void AddData(int data) {
            AddBytes(BitConverter.GetBytes(data));
        }

        public int GetInt() {
            return BitConverter.ToInt32(Extract(4), 0);
        }

        public void AddData(byte data) {
            AddBytes(data);
        }

        public byte GetByte() {
            return rawData[position++];
        }

        public void AddData(float value) {
            AddBytes(BitConverter.GetBytes(value));
        }

        public float GetFloat() {
            return BitConverter.ToSingle(Extract(4), 0);
        }

        public void AddData(double value) {
            AddBytes(BitConverter.GetBytes(value));
        }

        public double GetDouble() {
            return BitConverter.ToDouble(Extract(8), 0);
        }

        public void AddData(long value) {
            AddBytes(BitConverter.GetBytes(value));
        }

        public long GetLong() {
            return BitConverter.ToInt64(Extract(8), 0);
        }

        public void AddData(bool value) {
            AddBytes(BitConverter.GetBytes(value));
        }

        public bool GetBool() {
            return BitConverter.ToBoolean(Extract(1), 0);
        }

        public void AddData(INetworkPacket data) {
            AddBytes(data.GetBytes());
        }

        public void AddData(byte[] data) {
            AddBytes(BitConverter.GetBytes(data.Length));
            foreach (var i in data)
                AddBytes(BitConverter.GetBytes(i));
        }

        public byte[] GetByteArray() {
            var l = GetInt();
            var a = new byte[l];
            for (var i = 0; i < l; i++) {
                a[i] = GetByte();
            }

            return a;
        }

        public void AddData(int[] data) {
            AddBytes(BitConverter.GetBytes(data.Length));
            foreach (var i in data)
                AddBytes(BitConverter.GetBytes(i));
        }

        public int[] GetIntArray() {
            var l = GetInt();
            var a = new int[l];
            for (var i = 0; i < l; i++) {
                a[i] = GetInt();
            }

            return a;
        }

        public void AddData(double[] data) {
            AddBytes(BitConverter.GetBytes(data.Length));
            foreach (var i in data)
                AddBytes(BitConverter.GetBytes(i));
        }

        public double[] GetDoubleArray() {
            var l = GetInt();
            var a = new double[l];
            for (var i = 0; i < l; i++) {
                a[i] = GetDouble();
            }

            return a;
        }

        public void AddData(float[] data) {
            AddBytes(BitConverter.GetBytes(data.Length));
            foreach (var i in data)
                AddBytes(BitConverter.GetBytes(i));
        }

        public float[] GetFloatArray() {
            var l = GetInt();
            var a = new float[l];
            for (var i = 0; i < l; i++) {
                a[i] = GetFloat();
            }

            return a;
        }
    #endregion

    #region Public
        public PacketData(byte[] data = null) {
            rawData = new List<byte>(_packetLength);
            command = -1;
            if (data != null) {
                if (data.Length != _packetLength) throw new Exception("Incorrect packet length!");
                rawData.AddRange(data);
                position = 0;
                command  = GetInt();
                packetNum--;
            }

            packetNum++;
            position = 0;
            for (var i = 0; i < _packetLength; i++)
                rawData.Add(0);
        }

        public byte[] GetPacketBytes() {
            return rawData.ToArray();
        }

        public byte[] ToArray() {
            return GetPacketBytes();
        }
    #endregion

    #region Internal
        private void AddBytes(byte[] data) {
            if (data.Length + position > _packetLength) throw new Exception("Can not add bytes to PacketData (overflow length)");
            foreach (var b in data) {
                rawData[position++] = b;
            }
        }

        private void AddBytes(byte data) {
            if (position + 1 > _packetLength) throw new Exception("Can not add bytes to PacketData (overflow length)");
            rawData[position++] = data;
        }

        private void InsertBytes(byte[] data) {
            rawData.InsertRange(0, data);
        }

        private byte[] Extract(int length) {
            if (position - length < 0) throw new Exception("Read to many data from packet!");
            var res = new byte[length];
            for (var i = 0; i < length; i++)
                res[i] = rawData[position++];
            return res;
        }
    #endregion

    #region Static generators
        public static byte[] ExtractSubarray(byte[] array, int offset, int length) {
            var result = new byte[length];
            Array.Copy(array, offset, result, 0, length);
            return result;
        }

        public static PacketData[] SplitToPackets(byte[] data) {
            var list = new List<PacketData>(5);
            var pos  = 0;
            while (data.Length - pos >= _packetLength) {
                list.Add(new PacketData(ExtractSubarray(data, pos, _packetLength)));
                pos += _packetLength;
            }

            return list.ToArray();
        }

        /// <summary>
        /// Пакет для коннекта с сервером
        /// </summary>
        /// <param name="version">Версия клиента</param>
        /// <returns>Массив пакетов</returns>
        public static PacketData[] Handshake(int version) {
            var pd = new PacketData();
            pd.AddData(0x00000001);  // код команды
            pd.AddData(0x00000001);  // количество пакетов
            pd.AddData(packetNum++); // номер пакета
            pd.AddData(0x1829af91);
            pd.AddData(0x359de321);
            pd.AddData(0x49ea2231);
            pd.AddData(0x546f21a1);
            pd.AddData(0x35647da1);
            pd.AddData(version); // номер версии клиента
            return new[] {pd};
        }
    #endregion
    }
}