De/serializing packets

    public sealed class TypeIterator<TType, TAttribute, TIterator, TMethods>
        where TType : class
        where TAttribute : IterableAttribute
        where TMethods : class
    {
        public Action<TType, TIterator> AccessIteration { get; private set; }
        public Action<TType, TIterator> AssignIteration { get; private set; }

        private Dictionary<Type, string> aliases = new Dictionary<Type, string>();

        public TypeIterator(Dictionary<Type, string> typeAliases)
        {
            foreach (var kvp in typeAliases)
                aliases.Add(kvp.Key, kvp.Value);
            AccessIteration = CreateAccessIterator();
            AssignIteration = CreateAssignIterator();
        }

        private Comparison<Tuple<IterableAttribute, PropertyInfo>> comparer = (x, y) =>
        {
            return x.Item1.Position - y.Item1.Position;
        };

        private List<PropertyInfo> GetSortedProperties()
        {
            List<Tuple<IterableAttribute, PropertyInfo>> tuples = new List<Tuple<IterableAttribute, PropertyInfo>>();
            foreach (var property in typeof(TType).GetProperties())
            {
                IterableAttribute attribute;
                try
                {
                    attribute = property.GetCustomAttributes(typeof(TAttribute), false)[0] as IterableAttribute;
                    if (attribute == null)
                        continue;
                }
                catch { continue; }
                tuples.Add(new Tuple<IterableAttribute, PropertyInfo>(attribute, property));
            }
            tuples.Sort(comparer);
            List<PropertyInfo> result = new List<PropertyInfo>();
            foreach (var tuple in tuples)
                result.Add(tuple.Item2);
            return result;
        }

        private Action<TType, TIterator> CreateAccessIterator()
        {
            var instance = Expression.Parameter(typeof(TType));
            var iterator = Expression.Parameter(typeof(TIterator));
            List<Expression> calls = new List<Expression>();
            foreach (var property in GetSortedProperties())
            {
                object attribute;
                try
                {
                    attribute = property.GetCustomAttributes(typeof(TAttribute), false)[0];
                }
                catch { continue; }
                var constant = Expression.Constant(attribute);
                var methodInfo = typeof(TMethods).GetMethod("Accessor", new Type[] { typeof(TIterator), typeof(TAttribute), property.PropertyType });

                var access = Expression.Property(instance, property.Name);
                var call = Expression.Call(methodInfo, iterator, constant, access);
                calls.Add(call);
            }
            var body = Expression.Block(calls);
            var exp = Expression.Lambda<Action<TType, TIterator>>(body, instance, iterator).Compile();
            return exp;
        }

        private Action<TType, TIterator> CreateAssignIterator()
        {
            var instance = Expression.Parameter(typeof(TType));
            var iterator = Expression.Parameter(typeof(TIterator));
            List<Expression> calls = new List<Expression>();
            foreach (var property in GetSortedProperties())
            {
                object attribute;
                try
                {
                    attribute = property.GetCustomAttributes(typeof(TAttribute), false)[0];
                }
                catch { continue; }
                string alias;
                if (!aliases.TryGetValue(property.PropertyType, out alias))
                    alias = property.PropertyType.Name;
                var constant = Expression.Constant(attribute);
                var methodInfo = typeof(TMethods).GetMethod("Read" + alias, new Type[] { typeof(TIterator), typeof(TAttribute) });
                if (methodInfo == null)
                {
                    Console.WriteLine("cant find Get" + alias);
                }
                var access = Expression.Property(instance, property.Name);
                var call = Expression.Call(methodInfo, iterator, constant);
                var assign = Expression.Assign(access, call);
                calls.Add(assign);
            }
            var body = Expression.Block(calls);
            var exp = Expression.Lambda<Action<TType, TIterator>>(body, instance, iterator).Compile();
            return exp;
        }
    }

    [AttributeUsage(AttributeTargets.Property)]
    public class IterableAttribute : Attribute
    {
        public int Position { get; set; }

        public IterableAttribute(int position)
        {
            Position = position;
        }
    }

public class PacketSerializer<TType> where TType : class
    {
        public static readonly Dictionary<Type, string> Aliases = new Dictionary<Type, string>()
        {
            { typeof(List<string>), "StringList" },
            { typeof(byte[]), "ByteArray" }
        };


        private TypeIterator<TType, PacketFieldAttribute, Packet, SerializationMethods> iterator;

        public PacketSerializer()
        {
            iterator = new TypeIterator<TType, PacketFieldAttribute, Packet, SerializationMethods>(Aliases);
        }

        public void Serialize(TType structure, Packet writer)
        {
            iterator.AccessIteration(structure, writer);
        }

        public void Deserialize(TType structure, Packet reader)
        {
            iterator.AssignIteration(structure, reader);
        }
    }

    public enum VariableLengthSize
    {
        None,
        OneByte,
        TwoBytes,
        FourBytes,
    }
    public class PacketFieldAttribute : FieldAttribute
    {
        public VariableLengthSize BytesForLength { get; set; }
        public int FixedSize { get; set; }

        public PacketFieldAttribute(int position) : base(position)
        {
        }
    }

public class SerializationMethods
    {
        public static void Accessor(Packet packet, PacketFieldAttribute attribute, short value)
        {
            packet.Write(value);
        }

        public static void Accessor(Packet packet, PacketFieldAttribute attribute, ushort value)
        {
            packet.Write(value);
        }

        public static void Accessor(Packet packet, PacketFieldAttribute attribute, string value)
        {
            if (attribute.FixedSize == 0)
            {
                switch (attribute.BytesForLength)
                {
                    case VariableLengthSize.OneByte:
                        packet.Encoding.GetByteCount(value);
                        packet.Write((byte)packet.Encoding.GetByteCount(value));
                        packet.Write(value);
                        break;
                    case VariableLengthSize.TwoBytes:
                        packet.Encoding.GetByteCount(value);
                        packet.Write((ushort)packet.Encoding.GetByteCount(value));
                        packet.Write(value);
                        break;
                    case VariableLengthSize.FourBytes:
                        packet.Encoding.GetByteCount(value);
                        packet.Write((uint)packet.Encoding.GetByteCount(value));
                        packet.Write(value);
                        break;
                }
            }
            else if (attribute.FixedSize > 0)
            {
                packet.WriteCString(value, attribute.FixedSize);
            }
            else
            {
                throw new InvalidOperationException();
            }
        }

        public static ushort ReadUInt16(Packet packet, PacketFieldAttribute attribute)
        {
            return packet.ReadUInt16();
        }

        public static short ReadInt16(Packet packet, PacketFieldAttribute attribute)
        {
            return packet.ReadInt16();
        }


        public static string ReadString(Packet packet, PacketFieldAttribute attribute)
        {
            if (attribute.BytesForLength > 0)
                switch (attribute.BytesForLength)
                {
                    case VariableLengthSize.OneByte:
                        return packet.ReadString(packet.ReadByte());
                    case VariableLengthSize.TwoBytes:
                        return packet.ReadString(packet.ReadUInt16());
                    case VariableLengthSize.FourBytes:
                        return packet.ReadString(packet.ReadInt32());
                }
            else if (attribute.FixedSize > 0)
            {
                return packet.ReadString(attribute.FixedSize);
            }
            throw new InvalidOperationException();
        }

    }

    public class MsgAccount
    {
        [PacketField(0)]
        public ushort Length { get; set; }

        [PacketField(1)]
        public ushort Type { get; set; }

        [PacketField(2, FixedSize = 16)]
        public string Username { get; set; }

        [PacketField(3, FixedSize = 16)]
        public string Password { get; set; }

        [PacketField(4, FixedSize = 16)]
        public string ServerName { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            PacketSerializer<MsgAccount> serializer = new PacketSerializer<MsgAccount>();
            MsgAccount account = new MsgAccount()
            {
                Length = 52,
                Type = 1086, //or maybe not?
                Username = "user",
                Password = "Password",
                ServerName = "Tornado"
            };
            Packet p = new Packet(52);
            serializer.Serialize(account, p);

            Console.WriteLine($"Length: {BitConverter.ToInt16(p.Buffer, 0)}");
            Console.WriteLine($"Type: {BitConverter.ToInt16(p.Buffer, 2)}");
            Console.WriteLine($"Username: {Encoding.ASCII.GetString(p.Buffer, 4, 16)}");
            Console.WriteLine($"Password: {Encoding.ASCII.GetString(p.Buffer, 20, 16)}");
            Console.WriteLine($"Server: {Encoding.ASCII.GetString(p.Buffer, 36, 16)}");

            Console.ReadLine();
        }
    }

//
//  Copyright (c) CptSky <[Only registered and activated users can see links. Click Here To Register...]>
//  All rights reserved.
//
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the organization nor the names of its contributors
//       may be used to endorse or promote products derived from this software
//       without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//  DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
//  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//

using System;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text;
using COServer.Core;

namespace COServer.Protocol
{
    /// <summary>
    /// Base class of all network messages.
    /// </summary>
    public abstract unsafe class Msg
    {
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        protected struct MsgHeader
        {
            public ushort Length;
            public ushort Type;
        }

        public delegate void Handler<T>(in object client, in T msg) where T : Msg<T>;

        public static readonly int HeaderSize = sizeof(MsgHeader);
        public static readonly int MinSize = HeaderSize;
        public static readonly int MaxSize = 4096;

        public static Encoding Encoding => Encoding.GetEncoding(1252);

        private static readonly Func<int, Msg> factoryFct;

        static Msg()
        {
            // code pages are not part of .NET Core
            // register the provider for CP-1252
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

            // find all the messages in the assembly and generate the factory
            var assembly = Assembly.GetAssembly(typeof(Msg));
            var msgTypes = assembly.GetTypes().Where(t => t.IsSubclassOf(typeof(Msg)) && !t.IsGenericType).ToArray();

            {
                var typeParam = Expression.Parameter(typeof(int), "type");
                var msgVar = Expression.Variable(typeof(Msg), "msg");

                var switchCases = new SwitchCase[msgTypes.Length];
                var defaultCase = Expression.Assign(msgVar, Expression.Constant(null, typeof(Msg)));

                for (int i = 0; i < msgTypes.Length; ++i)
                {
                    var createFunction = msgTypes[i].BaseType.GetMethod("Create", BindingFlags.Public | BindingFlags.Static);
                    var testValue = msgTypes[i].GetField("Type", BindingFlags.Public | BindingFlags.Static)?.GetValue(null);

                    if (createFunction == null)
                        throw new NotImplementedException($"Create function is not implemented by {msgTypes[i].BaseType.Name}.");

                    if (testValue == null)
                        throw new NotImplementedException($"Type constant is not defined by {msgTypes[i].Name}.");

                    switchCases[i] = Expression.SwitchCase(
                        Expression.Assign(msgVar, Expression.Call(null, createFunction)),
                        Expression.Constant(testValue));
                }

                var switchExpr = Expression.Switch(typeParam, defaultCase, switchCases);
                var returnExpr = Expression.Assign(msgVar, msgVar); // not truly a return, but equivalent

                var expr = Expression.Block(new[] { msgVar }, switchExpr, returnExpr);
                factoryFct = Expression.Lambda<Func<int, Msg>>(expr, typeParam).Compile();
            }
        }

        public static Msg Create(int type)
        {
            return factoryFct(type);
        }

        public static (ushort, ushort) Peek(byte[] buf, int offset, int len)
        {
            {
                if (buf == null)
                    throw new ArgumentNullException(nameof(buf));
                if (offset < 0)
                    throw new ArgumentOutOfRangeException(nameof(offset), $"{nameof(offset)} must be greater than or equal to 0.");
                if (len < HeaderSize)
                    throw new ArgumentOutOfRangeException(nameof(len), $"{nameof(len)} must be greater than or equal to {HeaderSize}.");
            }
            Contract.EndContractBlock();

            return Peek(buf.AsSpan(offset, len));
        }

        public static (ushort, ushort) Peek(Span<byte> buf)
        {
            {
                if (buf == null)
                    throw new ArgumentNullException(nameof(buf));
                if (buf.Length < HeaderSize)
                    throw new ArgumentOutOfRangeException(nameof(buf.Length), $"{nameof(buf.Length)} must be greater than or equal to {HeaderSize}.");
            }
            Contract.EndContractBlock();

            fixed (byte* pinnedData = &buf.GetPinnableReference())
            {
                MsgHeader* header = (MsgHeader*)pinnedData;
                return (header->Type, header->Length);
            }
        }

        public int Serialize(byte[] buf, int offset, int len)
        {
            {
                if (buf == null)
                    throw new ArgumentNullException(nameof(buf));
                if (offset < 0)
                    throw new ArgumentOutOfRangeException(nameof(offset), $"{nameof(offset)} must be greater than or equal to 0.");
                if (len < MinSize)
                    throw new ArgumentOutOfRangeException(nameof(len), $"{nameof(len)} must be greater than or equal to {MinSize}.");
            }
            Contract.EndContractBlock();

            return Serialize(buf.AsSpan(offset, len));
        }

        public int Serialize(Span<byte> buf)
        {
            {
                if (buf == null)
                    throw new ArgumentNullException(nameof(buf));
                if (buf.Length < MinSize)
                    throw new ArgumentOutOfRangeException(nameof(buf.Length), $"{nameof(buf.Length)} must be greater than or equal to {MinSize}.");
            }
            Contract.EndContractBlock();

            if (CopyTo(buf))
            {
                fixed (byte* pinnedBuffer = &buf.GetPinnableReference())
                    return ((MsgHeader*)pinnedBuffer)->Length;
            }

            return 0;
        }

        public int Deserialize(byte[] buf, int offset, int len)
        {
            {
                if (buf == null)
                    throw new ArgumentNullException(nameof(buf));
                if (offset < 0)
                    throw new ArgumentOutOfRangeException(nameof(offset), $"{nameof(offset)} must be greater than or equal to 0.");
                if (len < MinSize)
                    throw new ArgumentOutOfRangeException(nameof(len), $"{nameof(len)} must be greater than or equal to {MinSize}.");
            }
            Contract.EndContractBlock();

            return Deserialize(buf.AsSpan(offset, len));
        }

        public int Deserialize(ReadOnlySpan<byte> buf)
        {
            {
                if (buf == null)
                    throw new ArgumentNullException(nameof(buf));
                if (buf.Length < MinSize)
                    throw new ArgumentOutOfRangeException(nameof(buf.Length), $"{nameof(buf.Length)} must be greater than or equal to {MinSize}.");
            }
            Contract.EndContractBlock();

            if (CopyFrom(buf))
            {
                fixed (byte* pinnedBuffer = &buf.GetPinnableReference())
                    return ((MsgHeader*)pinnedBuffer)->Length;
            }

            return 0;
        }

        public abstract void Recycle();
        public abstract void Process(object client);

        protected abstract bool CopyTo(Span<byte> buf);
        protected abstract bool CopyFrom(ReadOnlySpan<byte> buf);
    }

    /// <summary>
    /// Base class of all network messages.
    /// </summary>
    public abstract class Msg<T> : Msg
        where T : Msg<T>
    {
        /// <summary>
        /// The messages.
        /// </summary>
        private static ObjectPool<T> messages;

        public static Handler<T> Handler { get; set; } = (in object sender, in T msg) => throw new NotImplementedException();

        static Msg()
        {
            messages = new ObjectPool<T>();
        }

        public static T Create()
        {
            Contract.Ensures(Contract.Result<T>() != null);
            return messages.Get();
        }

        public override void Recycle()
        {
            messages.Put((T)this);
        }

        public override void Process(object client)
        {
            Handler.Invoke(client, (T)this);
        }
    }
}

//
//  Copyright (c) CptSky <[Only registered and activated users can see links. Click Here To Register...]>
//  All rights reserved.
//
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the organization nor the names of its contributors
//       may be used to endorse or promote products derived from this software
//       without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//  DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
//  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//

using System;
using System.Diagnostics.Contracts;
using System.Runtime.InteropServices;
using System.Text;
using COServer.Core.Extensions;
using COServer.Cryptography;

namespace COServer.Protocol
{
    public sealed unsafe class MsgAccount : Msg<MsgAccount>
    {
        public static readonly int Type = 1051;

        public const int MaxAccountLength = 16;
        public const int MaxPasswordLength = 16;
        public const int MaxServerLength = 16;

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        private struct MsgInfo
        {
            public MsgHeader Header;
            public fixed byte Account[MaxAccountLength];
            public fixed byte Password[MaxPasswordLength];
            public fixed byte Server[MaxServerLength];
        };

        private static readonly RC5 cipher = new RC5();

        private MsgInfo msg;

        public string Account
        {
            get
            {
                fixed (MsgInfo* pinnedMsg = &msg)
                    return Encoding.GetCString(pinnedMsg->Account, MaxAccountLength); ;
            }
            set
            {
                {
                    if (value == null)
                        throw new ArgumentNullException(nameof(value));
                    if (value.Length >= MaxAccountLength)
                        throw new ArgumentException($"{nameof(value)} must have a length less than {MaxAccountLength}.", nameof(value));
                }
                Contract.EndContractBlock();

                fixed (MsgInfo* pinnedMsg = &msg)
                    Encoding.GetBytes(value, pinnedMsg->Account, MaxAccountLength);
            }
        }

        public string Password
        {
            get
            {
                byte* decryptedPassword = stackalloc byte[MaxPasswordLength];
                fixed (MsgInfo* pinnedMsg = &msg)
                    Buffer.MemoryCopy(pinnedMsg->Password, decryptedPassword, MaxPasswordLength, MaxPasswordLength);
                cipher.Decrypt(new Span<byte>(decryptedPassword, MaxPasswordLength).ToArray());

                return Encoding.GetCString(decryptedPassword, MaxPasswordLength);
            }
            set
            {
                {
                    if (value == null)
                        throw new ArgumentNullException(nameof(value));
                    if (value.Length >= MaxPasswordLength)
                        throw new ArgumentException($"{nameof(value)} must have a length less than {MaxPasswordLength}.", nameof(value));
                }
                Contract.EndContractBlock();

                byte* encryptedPassword = stackalloc byte[MaxPasswordLength];
                Encoding.GetBytes(value, encryptedPassword, MaxPasswordLength);
                cipher.Encrypt(new Span<byte>(encryptedPassword, MaxPasswordLength).ToArray());

                fixed (MsgInfo* pinnedMsg = &msg)
                    Buffer.MemoryCopy(encryptedPassword, pinnedMsg->Password, MaxPasswordLength, MaxPasswordLength);
            }
        }

        public string Server
        {
            get
            {
                fixed (MsgInfo* pinnedMsg = &msg)
                    return Encoding.GetCString(pinnedMsg->Server, MaxServerLength); ;
            }
            set
            {
                {
                    if (value == null)
                        throw new ArgumentNullException(nameof(value));
                    if (value.Length >= MaxServerLength)
                        throw new ArgumentException($"{nameof(value)} must have a length less than {MaxServerLength}.", nameof(value));
                }
                Contract.EndContractBlock();

                fixed (MsgInfo* pinnedMsg = &msg)
                    Encoding.GetBytes(value, pinnedMsg->Server, MaxServerLength);
            }
        }

        protected override bool CopyTo(Span<byte> buf)
        {
            // ensure the header is properly updated
            msg.Header.Type = (ushort)Type;
            msg.Header.Length = (ushort)sizeof(MsgInfo);

            fixed (MsgInfo* pinnedMsg = &msg)
            {
                var msgData = new Span<byte>(pinnedMsg, sizeof(MsgInfo));
                return msgData.TryCopyTo(buf);
            }
        }

        protected override bool CopyFrom(ReadOnlySpan<byte> buf)
        {
            fixed (MsgInfo* pinnedMsg = &msg)
            {
                var msgData = new Span<byte>(pinnedMsg, sizeof(MsgInfo));
                return buf.TryCopyTo(msgData);
            }
        }
    }
}

//
//  Copyright (c) CptSky <[Only registered and activated users can see links. Click Here To Register...]>
//  All rights reserved.
//
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the organization nor the names of its contributors
//       may be used to endorse or promote products derived from this software
//       without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//  DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
//  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//

using System;
using System.Diagnostics.Contracts;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Text;
using COServer.Core.Extensions;

namespace COServer.Protocol
{
    public enum Channel : ushort
    {
        None = 0,
        Normal = 2000,
        Private = 2001,
        Action = 2002,
        Team = 2003,
        Syndicate = 2004,
        System = 2005,
        Family = 2006,
        Talk = 2007,
        Yelp = 2008,
        Friend = 2009,
        Global = 2010,
        GM = 2011,
        Whisper = 2012,
        Ghost = 2013,
        Serve = 2014,
        Register = 2100,
        Entrance = 2101,
        Shop = 2102,
        PetTalk = 2103,
        CryOut = 2104,
        WebPage = 2105,
        NewMessage = 2106,
        Task = 2107,
        SynWar_First = 2108,
        SynWar_Next = 2109,
        LeaveWord = 2110,
        SynAnnounce = 2111,
        MessageBox = 2112,
        Reject = 2113,
        SynTenet = 2114,
        MsgTrade = 2201,
        MsgFriend = 2202,
        MsgTeam = 2203,
        MsgSyn = 2204,
        MsgOther = 2205,
        MsgSystem = 2206,
        Broadcast = 2500,
    };

    public enum Style : ushort
    {
        None = 0,
        Flash = 2,
        Blast = 8,
        FlashAndBlast = 10,
    };

    public sealed unsafe class MsgTalk : Msg<MsgTalk>
    {
        public static readonly int Type = 1004;

        public const int MaxNameLength = 15;
        public const int MaxWordsLength = 255;

        private const int MaxStringPackLength = 320;

        private const int SpeakerStringIdx = 0;
        private const int HearerStringIdx = 1;
        private const int EmotionStringIdx = 2;
        private const int WordsStringIdx = 3;

        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        private struct MsgInfo
        {
            public MsgHeader Header;
            public int Color;
            public ushort Channel;
            public ushort Style;
            public int Time;
            public uint Look1;
            public uint Look2;
            public fixed byte StringPack[MaxStringPackLength]; // Speaker, Hearer, Emotion, Words
        };

        private MsgInfo msg;

        public Color Color
        {
            get => Color.FromArgb(msg.Color);
            set => msg.Color = value.ToArgb();
        }

        public Channel Channel
        {
            get => (Channel)msg.Channel;
            set => msg.Channel = (ushort)value;
        }

        public Style Style
        {
            get => (Style)msg.Style;
            set => msg.Style = (ushort)value;
        }

        public int Time
        {
            get => msg.Time;
            set => msg.Time = value;
        }

        public string Speaker
        {
            get
            {
                fixed (MsgInfo* pinnedMsg = &msg)
                {
                    var stringPack = new Span<byte>(pinnedMsg->StringPack, MaxStringPackLength);
                    var packer = new StringPacker(stringPack);
                    return packer[SpeakerStringIdx];
                }
            }
        }

        public string Hearer
        {
            get
            {
                fixed (MsgInfo* pinnedMsg = &msg)
                {
                    var stringPack = new Span<byte>(pinnedMsg->StringPack, MaxStringPackLength);
                    var packer = new StringPacker(stringPack);
                    return packer[HearerStringIdx];
                }
            }
        }

        public string Emotion
        {
            get
            {
                fixed (MsgInfo* pinnedMsg = &msg)
                {
                    var stringPack = new Span<byte>(pinnedMsg->StringPack, MaxStringPackLength);
                    var packer = new StringPacker(stringPack);
                    return packer[EmotionStringIdx];
                }
            }
        }

        public string Words
        {
            get
            {
                fixed (MsgInfo* pinnedMsg = &msg)
                {
                    var stringPack = new Span<byte>(pinnedMsg->StringPack, MaxStringPackLength);
                    var packer = new StringPacker(stringPack);
                    return packer[WordsStringIdx];
                }
            }
        }

        public static MsgTalk Create(string speaker, string hearer, string words, Channel channel, Color color)
        {
            var msg = Create();

            msg.Color = color;
            msg.Channel = channel;
            msg.Style = Style.None;
            msg.Time = Environment.TickCount;

            msg.ResetStringPack();
            msg.PushString(speaker);
            msg.PushString(hearer);
            msg.PushString(String.Empty);
            msg.PushString(words);

            return msg;
        }

        private void ResetStringPack()
        {
            // reset count to zero
            msg.StringPack[0] = 0;
        }

        private void PushString(string str)
        {
            fixed (MsgInfo* pinnedMsg = &msg)
            {
                var stringPack = new Span<byte>(pinnedMsg->StringPack, MaxStringPackLength);
                var packer = new StringPacker(stringPack);

                packer.Push(str);
            }
        }

        protected override bool CopyTo(Span<byte> buf)
        {
            // ensure the header is properly updated
            fixed (MsgInfo* pinnedMsg = &msg)
            {
                var stringPack = new Span<byte>(pinnedMsg->StringPack, MaxStringPackLength);
                var packer = new StringPacker(stringPack);

                msg.Header.Type = (ushort)Type;
                msg.Header.Length = (ushort)(sizeof(MsgInfo) - MaxStringPackLength + packer.Length);
            }

            fixed (MsgInfo* pinnedMsg = &msg)
            {
                var msgData = new Span<byte>(pinnedMsg, sizeof(MsgInfo));
                return msgData.TryCopyTo(buf);
            }
        }

        protected override bool CopyFrom(ReadOnlySpan<byte> buf)
        {
            fixed (MsgInfo* pinnedMsg = &msg)
            {
                var msgData = new Span<byte>(pinnedMsg, sizeof(MsgInfo));

                var stringPack = new Span<byte>(pinnedMsg->StringPack, MaxStringPackLength);
                var packer = new StringPacker(stringPack);

                return buf.TryCopyTo(msgData) && packer.Count == 4;
            }
        }
    }
}

//
//  Copyright (c) CptSky <[Only registered and activated users can see links. Click Here To Register...]>
//  All rights reserved.
//
//  Redistribution and use in source and binary forms, with or without
//  modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of the organization nor the names of its contributors
//       may be used to endorse or promote products derived from this software
//       without specific prior written permission.
//
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//  DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
//  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//

using System;

namespace COServer.Protocol
{
    /// <summary>
    /// String packer.
    /// </summary>
    public ref struct StringPacker
    {
        /// <summary>
        /// The buffer used by the packer.
        /// </summary>
        /// <remarks>Strings will be encoded using the <see cref="Msg.Encoding"/>.</remarks>
        private Span<byte> buffer;

        /// <summary>
        /// Get the number of packed strings.
        /// </summary>
        public byte Count
        {
            get => buffer[0];
            private set => buffer[0] = value;
        }

        /// <summary>
        /// Get the total length (in bytes) used in the buffer to store the packed strings.
        /// </summary>
        /// <exception cref="IndexOutOfRangeException">The buffer is malformed and the packer tried to access an index which is out of range.</exception>
        public int Length
        {
            get
            {
                int length = 1;

                for (int i = 0, pos = 1; i < Count; ++i)
                {
                    length += 1 + buffer[pos];
                    pos += 1 + buffer[pos];
                }

                return length;
            }
        }

        /// <summary>
        /// Construct a new packer using the specified buffer.
        /// </summary>
        /// <param name="buffer">
        /// The buffer used by the packer.
        /// It can be already initialized, in which case the packer can be used to unpack strings.
        /// </param>
        /// <exception cref="ArgumentException"></exception>
        public StringPacker(Span<byte> buffer)
        {
            if (buffer.Length < 1)
                throw new ArgumentException($"Buffer is too small to be used by a ${nameof(StringPacker)}", nameof(buffer));

            this.buffer = buffer;
        }

        /// <summary>
        /// Push a string into the pack.
        /// </summary>
        /// <param name="str">The string to push.</param>
        /// <exception cref="ArgumentNullException"><paramref name="str"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentException"><paramref name="str"/> is exceeding 255 characters when encoded using <see cref="Msg.Encoding"/></exception>
        /// <exception cref="InvalidOperationException">The pack is full.</exception>
        /// <exception cref="IndexOutOfRangeException">The packer tried to access an index which is out of range. The buffer is too small or is malformed.</exception>
        public void Push(string str)
        {
            if (str == null)
                throw new ArgumentNullException(nameof(str));

            if (Count == byte.MaxValue)
                throw new InvalidOperationException($"Cannot pack more than {byte.MaxValue} strings.");

            Span<byte> bytes = Msg.Encoding.GetBytes(str);
            if (bytes.Length > byte.MaxValue)
                throw new ArgumentException($"Length of the string is greater than the imposed limit ({byte.MaxValue}).", nameof(str));

            Span<byte> dest = buffer.Slice(1);
            for (byte i = 0; i < Count; ++i)
                dest = dest.Slice(1 + dest[0]);

            dest[0] = (byte)bytes.Length;
            bytes.CopyTo(dest.Slice(1));
            ++Count;
        }

        /// <summary>
        /// Pop a string from the pack.
        /// </summary>
        /// <remarks>Bytes previously used by the popped string won't be zero-filled.</remarks>
        /// <exception cref="InvalidOperationException">The pack is empty.</exception>
        public void Pop()
        {
            if (Count == 0)
                throw new InvalidOperationException($"Cannot pop a string, there is none.");

            --Count;
        }

        /// <summary>
        /// Get the string at the specified <paramref name="index"/>.
        /// </summary>
        /// <param name="index">The index of the string to retrieve from the pack.</param>
        /// <returns></returns>
        public unsafe string GetString(byte index)
        {
            if (index >= Count)
                throw new IndexOutOfRangeException($"{index} is out of range. There are {Count} packed strings in the pack.");

            int pos = 1;
            for (int i = 0; i < index; ++i)
                pos += 1 + buffer[pos];

            byte length = buffer[pos++];
            Span<byte> bytes = buffer.Slice(pos);

            if (bytes.Length >= length)
            {
                fixed (byte* pinnedBytes = bytes)
                    return Msg.Encoding.GetString(pinnedBytes, length);
            }

            return String.Empty;
        }

        public string this[byte index] => GetString(index);
    }
}

public int ProcessOutgoingData(Span<byte> data)
{
    int serializedBytes = 0;

    Msg? msg;
    while (outgoingQueue.TryPeek(out msg))
    {
        var msgData = data.Slice(serializedBytes);
        var msgSize = msg.Serialize(msgData);

        if (msgSize > 0)
        {
            serializedBytes += msgSize;
            while (!outgoingQueue.TryDequeue(out msg)) ;
            // TODO recycle the message
        }
        else
        {
            // cannot fit the next msg
            break;
        }
    }

    cipher.Encrypt(data.Slice(0, serializedBytes));
    return serializedBytes;
}

if (data.Length >= Msg.HeaderSize)
{
    var (type, length) = Msg.Peek(data);
    if (data.Length >= length)
    {
        Msg msg = Msg.Create(type);
        if (msg.Deserialize(data) != length)
        {
            connection.Disconnect();
        }

        // TODO queue the message
        data = data.Slice(length);
        continue;
    }
}