public abstract class DofusMitm : AbstractMitm
    {
        protected ISerializer Serializer;
        protected IMessageMap MessageMap;
        private Func<FrameParser> _createNewFrameParser;

        public uint InstanceId { get; set; }

        protected DofusMitm(int localPort, string remoteHostname, int remotePort) : base(localPort, remoteHostname,
            remotePort)
        {
            Serializer = ServiceLocator.Container.Resolve<ISerializer>();
            MessageMap = ServiceLocator.Container.Resolve<IMessageMap>();
            _createNewFrameParser = () => ServiceLocator.Container.Resolve<FrameParser>();
        }

        public abstract bool OnClientMessage(int messageId, DofusReader messageData); // if returns true : forward message
        public abstract bool OnServerMessage(int messageId, DofusReader messageData); // if returns true : forward message

        public override void OnClientData(TcpClient client, byte[] buffer, int size) => _onDofusData(Origin.Client, buffer, size, OnClientMessage, Server.GetStream());
        public override void OnServerData(TcpClient server, byte[] buffer, int size) => _onDofusData(Origin.Remote, buffer, size, OnServerMessage, Client.GetStream());

        public void SendMessageTo<T>(TcpClient dst, T message, Origin origin)
        {
            try
            {
                var messageId = MessageMap.GetIdFrom(message);
                var messageData = new DofusWriter();
                Serializer.Serialize(message, messageData);

                ++InstanceId;

                dst.GetStream().Write(FrameHelpers.Pack(messageId, messageData.GetData(),origin,
                    origin == Origin.Client ? InstanceId : 0));

                var to = origin == Origin.Client ? Origin.Remote : Origin.Client;
                Console.WriteLine($"{typeof(T).Name} successfully sent to {to}");
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }

        private void _onDofusData(Origin origin, byte[] buffer, int size, Func<int, DofusReader, bool> onMessage, NetworkStream toWrite)
        {
            var frameParser = _createNewFrameParser();
            Console.WriteLine($"{size} bytes received from {origin}, trying to parse frame...");
            try
            {
                using (var reader = new DofusReader(new MemoryStream(buffer, 0, size)))
                {
                    while (frameParser.TryParse(reader, origin))
                    {
                        if (frameParser.InstanceId.Value != 0) InstanceId = InstanceId;
                        Console.WriteLine($"Frame successfully parsed ! MessageId : {frameParser.MessageId.Value}, Data length : {frameParser.Length}");
                        using (var dataReader = new DofusReader(new MemoryStream(frameParser.Data)))
                        {
                            var shouldForward = onMessage(frameParser.MessageId.Value, dataReader);
                            if (!shouldForward)
                            {
                                frameParser = _createNewFrameParser();
                                continue;
                            }

                            toWrite.Write(origin == Origin.Client
                                ? FrameHelpers.Pack(frameParser.MessageId.Value, frameParser.Data, origin, InstanceId)
                                : FrameHelpers.Pack(frameParser.MessageId.Value, frameParser.Data));
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
    }