/// <summary>
        /// Creates a <see cref="IIncomingPhysicalMessageContext" /> based on the current context.
        /// </summary>
        public static IIncomingPhysicalMessageContext CreateIncomingPhysicalMessageContext(this StageConnector<ITransportReceiveContext, IIncomingPhysicalMessageContext> stageConnector, IncomingMessage incomingMessage, ITransportReceiveContext sourceContext)
        {
            Guard.AgainstNull(nameof(incomingMessage), incomingMessage);
            Guard.AgainstNull(nameof(sourceContext), sourceContext);

            return new IncomingPhysicalMessageContext(incomingMessage, sourceContext);
        }

        public void HandleCommand(IRCServer server, string command, IncomingMessage msg)
        {
            CommandManager commands = CommandManager.GetInstance();
            if (!msg.HasMessage())
            {

                msg.SendChat("Available commands: " + commands.AvailableCommands());
                return;
            }

            string cmd = msg.Message.ToLower();
            if (!commands.HasCommand(cmd))
            {
                msg.SendChat("No help for command: " + cmd);
            }
            else
            {
                string help = commands.GetCommand(cmd).Help();
                if (help == null || help.Equals(""))
                {
                    msg.SendChat("No help available for: " + cmd);
                }
                else
                {
                    msg.SendChat("Help for " + cmd + ": " + help);
                }
            }
        }

        protected override void OnRun(IncomingMessage message)
        {
            ServerEnvelopeObject envelope = Manager.Serializer.GetObject<ServerEnvelopeObject>(message.Data);
            GameMessageType gmt = (GameMessageType)Enum.ToObject(typeof(GameMessageType), envelope.InnerOperationCode);

            switch (gmt)
            {
                case GameMessageType.Server_ReceiveTableListingRequest:
                    OnTableListingRequest(Manager.Serializer.GetObject<TableListingRequest>(envelope.InnerData), envelope.RouteInfo);
                    break;

                case GameMessageType.Server_ReceiveJoinTableRequest:
                    OnJoinTableRequest(envelope);
                    break;

                default:
                    IncomingGameMessageQueueItem defaultItem = new IncomingGameMessageQueueItem();
                    defaultItem.OperationCode = (GameMessageType)envelope.InnerOperationCode;
                    defaultItem.Data = envelope.InnerData;
                    defaultItem.RouteInfo = envelope.RouteInfo;

                    Manager.Tables[defaultItem.RouteInfo.TableId].PlayerPortal.IncomingQueue.Add(defaultItem);
                    break;
            }

            message.WasMessageHandled = true;
        }

        public static RequestResponseStateLookup.State? TryRemoveResponseStateBasedOnCorrelationId(this IIncomingContext context, IncomingMessage message, RequestResponseStateLookup lookup)
        {
            var correlationId = context.GetCorrelationId();

            if (correlationId == null)
            {
                return null;
            }

            string version;
            var checkMessageIntent = true;

            if (message.Headers.TryGetValue(Headers.NServiceBusVersion, out version))
            {
                Version parsedVersion;
                if (Version.TryParse(version, out parsedVersion))
                {
                    if (parsedVersion < minimumVersionThatSupportMessageIntent_Reply)
                    {
                        checkMessageIntent = false;
                    }
                }
            }

            var messageIntentEnum = message.GetMesssageIntent();
            if (checkMessageIntent && messageIntentEnum != MessageIntentEnum.Reply)
            {
                return null;
            }

            RequestResponseStateLookup.State state;
            return lookup.TryRemove(correlationId, out state) ? (RequestResponseStateLookup.State?) state : null;
        }

        public void HandleCommand(IRCServer server, string command, IncomingMessage message)
        {
            if (!message.HasMessage())
            {
                // bad syntax
                return;
            }

            if (COMMAND_REGEX.IsMatch(message.Message))
            {
                Match m = COMMAND_REGEX.Match(message.Message);
                string cmd = m.Groups[1].Value;

                if (cmd.Equals("about"))
                {
                    if (m.Groups[2].Value == null || m.Groups[2].Value.Equals(""))
                    {
                        message.SendChat("Need context");
                    }

                    string markov = MarkovDatabaseAdapter.MarkovFind(m.Groups[2].Value, m.Groups[3].Value);
                    if (markov == null || markov.Equals(""))
                    {
                        message.SendChat("I can't :(");
                    }
                    else
                    {
                        message.SendChat(markov);
                    }
                }
            }
        }

        private static void ProcessRequestCategoryListings(Habbo sender, IncomingMessage message)
        {
            bool excludeFullRooms = message.PopWiredBoolean();
            int categoryID = message.PopWiredInt32();

            Category category = CoreManager.ServerCore.GetNavigator().GetCategory(categoryID);

            if (category == null)
                new MNavigatorCategoryListing // TODO: Remove this. Maybe even throw an exception?
                    {
                        ID = categoryID,
                        ExcludeFullRooms = excludeFullRooms,
                        Name = "Non-Existant Category",
                        ParentID = categoryID,
                        IsPublicCategory = true,
                        Listings = new Listing[0],
                        UnknownA = 0,
                        UnknownB = 10000,
                        UnknownC = 0
                    }.Send(sender);
            else
                new MNavigatorCategoryListing
                {
                    ID = categoryID,
                    ExcludeFullRooms = excludeFullRooms,
                    Name = category.Name,
                    ParentID = (category.PrimaryCategory != null ? category.PrimaryCategory.ID : category.ID),
                    IsPublicCategory = category.IsPublicCategory,
                    Listings = category.GetListings(),

                    UnknownA = 0,
                    UnknownB = 10000,
                    UnknownC = 0
                }.Send(sender);
        }

 internal static void ProcessBalanceRequest(Habbo sender, IncomingMessage message)
 {
     new MCreditBalance
         {
             Balance = sender.Credits
         }.Send(sender);
 }

        internal static void ProcessSSOTicket(Habbo sender, IncomingMessage message)
        {
            ClassicIncomingMessage classicMessage = (ClassicIncomingMessage)message;

            Habbo fullHabbo = CoreManager.ServerCore.HabboDistributor.GetHabboFromSSOTicket(classicMessage.PopPrefixedString());

            if (fullHabbo == null)
            {
                new MConnectionClosed
                {
                    Reason = ConnectionClosedReason.InvalidSSOTicket
                }.Send(sender);

                sender.Socket.Disconnect("Invalid SSO Ticket");
            }
            else
            {
                // If this Habbo is already logged in...
                if (fullHabbo.LoggedIn)
                {
                    // Disconnect them.
                    new MConnectionClosed
                        {
                            Reason = ConnectionClosedReason.ConcurrentLogin
                        }.Send(fullHabbo);
                    fullHabbo.Socket.Disconnect("Concurrent Login");
                }

                LoginMerge(fullHabbo, sender);
            }
        }

        private OutgoingMessage Subscribe(IncomingMessage requestMessage)
        {
            var toHeader = requestMessage.GetHeader<ToHeader>();
            var subscriptionManagerReference = new EndpointReference(toHeader.Uri);
            var request = requestMessage.GetPayload<SubscribeRequest>();            
            var responseMessage = new OutgoingMessage()
                .AddHeader(new ActionHeader(Constants.SubscribeResponseAction), false);

            var expiration = CalculateExpiration(request.Expires);
            var filterInstance = GetFilterInstance(request);
            var identifier = GenerateUniqueSubscriptionIdentifier();
            var subscription = new Subscription(expiration, _requestHandler, filterInstance, subscriptionManagerReference, requestMessage);
            _activeSubscriptions.Add(identifier, subscription);
            OnSubscribed(identifier, subscription);

            //R7.2.4-1
            var body = new SubscribeResponse
                           {
                               SubscriptionManager = subscriptionManagerReference,
                               EnumerationContext = request.Delivery.Mode == Delivery.DeliveryModePull
                                                        ? new EnumerationContextKey(
                                                              identifier)
                                                        : null,
                               Expires = expiration
                           };
            responseMessage.SetBody(new SerializerBodyWriter(body));
            return responseMessage;
        }

        static bool HasReachedMaxTime(IncomingMessage message)
        {
            string timestampHeader;

            if (!message.Headers.TryGetValue(Headers.DelayedRetriesTimestamp, out timestampHeader))
            {
                return false;
            }

            if (string.IsNullOrEmpty(timestampHeader))
            {
                return false;
            }

            try
            {
                var handledAt = DateTimeExtensions.ToUtcDateTime(timestampHeader);

                var now = DateTime.UtcNow;
                if (now > handledAt.AddDays(1))
                {
                    return true;
                }
            }
                // ReSharper disable once EmptyGeneralCatchClause
                // this code won't usually throw but in case a user has decided to hack a message/headers and for some bizarre reason
                // they changed the date and that parse fails, we want to make sure that doesn't prevent the message from being
                // forwarded to the error queue.
            catch (Exception)
            {
            }

            return false;
        }

 internal static void ProcessSessionRequest(Habbo sender, IncomingMessage message)
 {
     new MSessionParams
     {
         A = 9,
         B = 0,
         C = 0,
         D = 1,
         E = 1,
         F = 3,
         G = 0,
         H = 2,
         I = 1,
         J = 4,
         K = 0,
         L = 5,
         DateFormat = "dd-MM-yyyy",
         M = "",
         N = 7,
         O = false,
         P = 8,
         URL = "http://null",
         Q = "",
         R = 9,
         S = false
     }.Send(sender);
 }

        public async Task<int> Retry(IncomingMessage message, TimeSpan delay, TransportTransaction transportTransaction)
        {
            var outgoingMessage = new OutgoingMessage(message.MessageId, new Dictionary<string, string>(message.Headers), message.Body);

            var currentDelayedRetriesAttempt = message.GetDelayedDeliveriesPerformed() + 1;

            outgoingMessage.SetCurrentDelayedDeliveries(currentDelayedRetriesAttempt);
            outgoingMessage.SetDelayedDeliveryTimestamp(DateTime.UtcNow);

            UnicastAddressTag messageDestination;
            List<DeliveryConstraint> deliveryConstraints = null;
            if (timeoutManagerAddress == null)
            {
                // transport supports native deferred messages, directly send to input queue with delay constraint:
                deliveryConstraints = new List<DeliveryConstraint>(1)
                {
                    new DelayDeliveryWith(delay)
                };
                messageDestination = new UnicastAddressTag(endpointInputQueue);
            }
            else
            {
                // transport doesn't support native deferred messages, reroute to timeout manager:
                outgoingMessage.Headers[TimeoutManagerHeaders.RouteExpiredTimeoutTo] = endpointInputQueue;
                outgoingMessage.Headers[TimeoutManagerHeaders.Expire] = DateTimeExtensions.ToWireFormattedString(DateTime.UtcNow + delay);
                messageDestination = new UnicastAddressTag(timeoutManagerAddress);
            }

            var transportOperations = new TransportOperations(new TransportOperation(outgoingMessage, messageDestination, deliveryConstraints: deliveryConstraints));

            await dispatcher.Dispatch(transportOperations, transportTransaction, new ContextBag()).ConfigureAwait(false);

            return currentDelayedRetriesAttempt;
        }

 internal void InvokeMessageHasBeenSentToErrorQueue(IncomingMessage message, Exception exception, string errorQueue)
 {
     MessageSentToErrorQueue?.Invoke(this, new FailedMessage(
         message.MessageId,
         new Dictionary<string, string>(message.Headers),
         CopyOfBody(message.Body), exception, errorQueue));
 }

 public override void HandleIncomingMessage(IncomingMessage message)
 {
     if (message is CredentialsMessage)
     {
         CredentialsMessage cm = message as CredentialsMessage;
         if (AuthenticationHandler.Authenticate(cm.Credentials))
         {
             _session.ClientId.Credentials = cm.Credentials;
             _session.Communication.SendAuthenticationAccepted();
             _session.State = new PairingState(_session);
         }
         else
         {
             _session.Communication.SendAuthenticationRejected();
         }
     }
     else if (message is ClientPausedMessage ||
          message is ClientResumedMessage)
     {
         // Ignore, but not reject!
     }
     else
     {
         string errorMsg = string.Format("Message type '{0}' is not supported at this point", message.GetType().Name);
         Debug.WriteLine(errorMsg);
         throw new NotSupportedException(errorMsg);
     }
 }

        public void TestIncomingBasic()
        {
            Message message = LoadMessage("simple.eml");
            DirectAddressCollection rcpto = new DirectAddressCollection(
                new DirectAddress[] {
                    new DirectAddress("[email protected]"),
                    new DirectAddress("[email protected]")
                    }
                );
            
            IncomingMessage incoming = new IncomingMessage(message, rcpto, new DirectAddress("[email protected]"));
            Assert.True(incoming.Recipients.Count == 2);
            
            DirectAddressCollection routingRecipients = incoming.GetRecipientsInRoutingHeaders();
            Assert.True(routingRecipients.Count == 1);
            
            Assert.False(incoming.AreAddressesInRoutingHeaders(rcpto));
            incoming.Recipients.Remove(x => MimeStandard.Equals(x.Address, "[email protected]"));
            Assert.True(incoming.AreAddressesInRoutingHeaders(rcpto));
            
            message.ToValue = "[email protected]";
            incoming = new IncomingMessage(message, rcpto, new DirectAddress("[email protected]"));
            Assert.False(incoming.AreAddressesInRoutingHeaders(rcpto));

            message.ToValue = "[email protected]";
            incoming = new IncomingMessage(message, rcpto, new DirectAddress("[email protected]"));
            Assert.False(incoming.AreAddressesInRoutingHeaders(rcpto));
        }

        public void Handle(IncomingMessage msg)
        {
            string lastSeenEvent = null;

            if (msg.Command.Equals("PRIVMSG"))
            {
                lastSeenEvent = "saying: " + msg.Message;
            }
            else if (msg.Command.Equals("JOIN"))
            {
                lastSeenEvent = "joining " + msg.Message;
            }
            else if (msg.Command.Equals("PART"))
            {
                lastSeenEvent = "leaving " + msg.TargetParams + ": " + msg.Message;
            }
            else if (msg.Command.Equals("QUIT"))
            {
                lastSeenEvent = "quitting: " + msg.Message;
            }
            else if (msg.Command.Equals("NICK"))
            {
                lastSeenEvent = "changing nick to: " + msg.TargetParams;
            }
            if (lastSeenEvent != null)
            {
                string nick = msg.Sender.ToLower();
                Database.SetKeyValue(msg.Server, "lastseen.time." + nick, Environment.TickCount);
                Database.SetKeyValue(msg.Server, "lastseen.event." + nick, lastSeenEvent);
            }
        }

 private OutgoingMessage Pull(IncomingMessage requestMessage)
 {
     var response = CreatePullResponse();
     var request = requestMessage.GetPayload<PullRequest>();
     IPullHandler handler;
     var context = request.EnumerationContext.Text;
     lock (_handlers)
     {
         if (!_handlers.TryGetValue(context, out handler))
         {
             throw new InvalidEnumerationContextFaultException();
         }
     }
     var maxElements = GetMaxElements(request);
     var maxTime = GetMaxTime(request);
     var pullResult = handler.Pull(maxElements, maxTime, context);
     var items = new EnumerationItemList(pullResult.Items, pullResult.EnumerationMode);
     if (pullResult.EndOfSequence)
     {
         handler.Dispose();
         lock (_handlers)
         {
             _handlers.Remove(context);
         }
     }
     response.SetBody(
         new SerializerBodyWriter(new PullResponse
                                      {
                                          Items = items,
                                          EndOfSequence = pullResult.EndOfSequence ? new EndOfSequence() : null,
                                          EnumerationContext = pullResult.EndOfSequence ? null : request.EnumerationContext
                                      }));
     return response;
 }

 internal static void ProcessEncryptionRequest(Habbo sender, IncomingMessage message)
 {
     new MSetupEncryption
     {
         UnknownA = false
     }.Send(sender);
 }

        protected override void OnRun(IncomingMessage message)
        {
            JoinTableRequest request = Manager.Serializer.GetObject<JoinTableRequest>(message.Data);

            RouteInfo routeInfo = Manager.GetRouteInfo(request.PlayerName);

            string gameServerId = Manager.GetServerWithTable(request.TableToJoin);

            //-- Stop people trying to bring down the server by sending join requests to tables that do not exist.
            if (string.IsNullOrEmpty(gameServerId) == false)
            {
                IPEndPoint serverEndpoint = Manager.ResolveServer(gameServerId);

                //-- Has the destination server been found?
                if (serverEndpoint != null)
                {
                    Manager.SendEnvelopeObjectToServer(GameMessageType.Server_ReceiveJoinTableRequest,
                        Manager.Serializer.GetBytes(request),
                        serverEndpoint.ToList(),
                        routeInfo);
                }
                else
                {
                    ServerUIShell.WriteLine("-IPEndPoint for server could not be resolved (" + gameServerId + ")");
                }
            }

            message.WasMessageHandled = true;
        }

        public void Handle(IncomingMessage msg)
        {
            IRCServer server = msg.Server;
            string ourNick = server.Nick;

            if (msg.Command.Equals("NICK"))
            {
                string whoChanging = msg.Sender;
                string changingTo = msg.Target;
                if (whoChanging.Equals(ourNick))
                {
                    server.Nick = changingTo;
                    server.SetAttemptNickChange(false);
                }
                else
                {
                    // update user nick list
                }
            }
            else if (msg.Command.Equals("ERROR"))
            {
                server.Dispose();
            }
            else
            {
                string raw = msg.Raw;
                switch (msg.Command)
                {
                    // nick change
                    case "433":
                        if (server.Connected)
                        {
                            // are we attempting a nick name change?
                            if (server.IsAttemptNickChange())
                            {

                                server.Nick = server.LastNick;
                                server.SetAttemptNickChange(false);
                            }

                        }
                        else
                        {
                            string nick;
                            if (server.Nick.Equals(server.AltNick))
                            {
                                nick = server.AltNick + 1;
                            }
                            else
                            {
                                nick = server.AltNick;
                            }
                            server.Nick = nick;

                        }
                        break;
                }
            }
        }