/// <summary>
        /// Handles incoming packet.
        /// </summary>
        /// <param name="p">Received <see cref="Packet"/> object.</param>
        internal static void Handle( Packet p )
        {
            switch ( p.FirstOpcode )
            {
                case ServiceLayer.Identity:
                    {
                        switch ( p.SecondOpcode )
                        {
                            case ServiceLayer.InitializeRequest:
                                {
                                    return; // login service not handles incoming connections.
                                }
                            case ServiceLayer.InitializeResponse: // connection init response
                                {
                                    InitializeResponse data = new InitializeResponse(p);

                                    switch ( data.Answer )
                                    {
                                        case InitializeResponse.Accepted:
                                            {
                                                CacheServiceConnection.Connection.SetRemoteService(data.RemoteServiceID, ( ServiceType )data.RemoteServiceType);
                                                Logger.WriteLine(Source.InnerNetwork, "Authorized on {0} (0x{1})", CacheServiceConnection.Connection.ServiceType, CacheServiceConnection.Connection.ServiceID.ToString("x2"));

                                                // send set-settings request
                                                CacheServiceConnection.Send
                                                    (
                                                        new SetSettingsRequest().ToPacket
                                                        (
                                                            new LoginServiceSettings
                                                                (
                                                                    Settings.Default.ServiceUniqueID,
                                                                    Settings.Default.LoginServiceAutoCreateUsers,
                                                                    Settings.Default.LoginServiceDefaultAccessLevel
                                                                )
                                                        )
                                                    );

                                                return;
                                            }
                                        case InitializeResponse.Rejected:
                                            {
                                                Logger.WriteLine(Source.InnerNetwork, "Connection rejected by {0} (0x{1})", ( ServiceType )data.RemoteServiceType, data.RemoteServiceID);
                                                return;
                                            }
                                    }

                                    return;
                                }
                            case ServiceLayer.SetSettingsRequest:
                                {
                                    return; // login service not handles remote service settings request
                                }
                            case ServiceLayer.SetSettingsResponse:
                                {
                                    SetSettingsResponse response = new SetSettingsResponse(p);

                                    switch ( response.Response )
                                    {
                                        case SetSettingsResponse.Accepted:
                                            {
                                                Logger.WriteLine(Source.InnerNetwork, "Cache service accepted service settings.");
                                                //UserConnectionsListener.Enable(); // start listen incoming user connections
                                                return;
                                            }
                                        default:
                                            {
                                                Service.Terminate(new ServiceShutdownEventArgs("Cache service rejected settings setup."));
                                                return;
                                            }
                                    }
                                }
                            default:
                                {
                                    Logger.WriteLine("Unknown packet received on layer 0x{0}: {1}", ServiceLayer.Identity.ToString("x2"), p.ToString());
                                    return;
                                }
                        }
                    }
                case UserDataLayer.Identity:
                    {
                        switch ( p.SecondOpcode )
                        {
                            case UserDataLayer.UserAuthenticationResponse:
                                {
                                    UserAuthenticationResponse response = new UserAuthenticationResponse(p);
                                    QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);

                                    if ( QueuedRequest.IsValid(request) )
                                    {
                                        switch ( response.Response )
                                        {
                                            case UserAuthenticationResponseType.UserAccepted: // accepted or created by cache
                                                {
                                                    request.UserConnection.Session.AccountID = response.UserID;
                                                    request.UserConnection.Session.LastWorld = response.LastWorldID;

                                                    if ( response.AccessLevel < Settings.Default.LoginServiceAllowedAccessLevel )
                                                    {
                                                        request.Send(LoginFailed.ToPacket(UserAuthenticationResponseType.AccessFailed));
                                                        UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                                                        return;
                                                    }

                                                    long requestId = long.MinValue;

                                                    if ( QueuedRequestsPool.Enqueue(request.UserConnection, ref requestId) )
                                                    {
                                                        CacheServiceConnection.Send
                                                            (
                                                                new CacheUserSessionRequest
                                                                    (
                                                                        requestId,
                                                                        request.UserConnection.Session
                                                                    ).ToPacket()
                                                            );
                                                    }
                                                    else
                                                    {
                                                        Logger.WriteLine(Source.InnerNetwork, "Failed to send CacheUserSessionRequest to cache service, request was not enqueued by QueuedRequestsPool ?...");
                                                        UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                                                    }

                                                    return;
                                                }
                                            default:
                                                {
                                                    request.Send(LoginFailed.ToPacket(response.Response));
                                                    UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                                                    return;
                                                }
                                        }
                                    }

                                    break;
                                }
                            case UserDataLayer.CacheUserSessionResponse:
                                {
                                    CacheUserSessionResponse response = new CacheUserSessionResponse(p);
                                    QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);

                                    if ( QueuedRequest.IsValid(request) )
                                    {
                                        switch ( response.Response )
                                        {
                                            case CacheUserSessionResponse.Failed:
                                                {
                                                    Logger.WriteLine("Failed to cache user session data on cache server side");
                                                    request.Send(LoginFailed.ToPacket(UserAuthenticationResponseType.SystemError));
                                                    UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                                                    return;
                                                }
                                            case CacheUserSessionResponse.Accepted:
                                                {
                                                    request.Send(LoginOk.ToPacket(request.UserConnection.Session));
                                                    return;
                                                }
                                        }
                                    }
                                    else
                                    {
                                        Logger.WriteLine(Source.OuterNetwork, "Failed to send ServerPackets.WorldsList to client, request was not dequeued by QueuedRequestsPool ?...");
                                        UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                                    }

                                    return;
                                }
                            case UserDataLayer.WorldsListResponse:
                                {
                                    WorldsListResponse response = new WorldsListResponse(p);
                                    QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);

                                    if ( QueuedRequest.IsValid(request) )
                                        request.Send(ServerList.ToPacket(request.UserConnection.Session.LastWorld, response.Data));
                                    else
                                    {
                                        Logger.WriteLine(Source.OuterNetwork, "Failed to send ServerPackets.WorldsList to client, request was not dequeued by QueuedRequestsPool ?...");
                                        UserConnectionsListener.CloseActiveConnection(request.UserConnection);
                                    }

                                    return;
                                }
                            case UserDataLayer.JoinWorldResponse:
                                {
                                    JoinWorldResponse response = new JoinWorldResponse(p);
                                    QueuedRequest request = QueuedRequestsPool.Dequeue(response.RequestID);

                                    if ( QueuedRequest.IsValid(request) )
                                    {
                                        switch ( response.Result )
                                        {
                                            case JoinWorldRequestResult.Accepted:
                                                {
                                                    request.UserConnection.Send(PlayAccepted.ToPacket(request.UserConnection.Session));
                                                    break;
                                                }
                                            default:
                                                {
                                                    request.UserConnection.Send(PlayFail.ToPacket(response.Result));
                                                    break;
                                                }
                                        }
                                    }

                                    UserConnectionsListener.CloseConnectionWithoutLogout(request.UserConnection);

                                    return;
                                }
                        }

                        break;
                    }
            }

            Logger.WriteLine("Unknown packet received from {0} service on layer 0x{1}:{2}{3}", ServiceType.LoginService, p.FirstOpcode.ToString("x2"), Environment.NewLine, p.ToString());
        }
        /// <summary>
        /// User authentication request processing.
        /// </summary>
        /// <param name="netRequest"><see cref="UserAuthenticationRequest"/> to verify user data from.</param>
        /// <param name="settings"><see cref="LoginServiceSettings"/> object.</param>
        /// <returns><see cref="UserAuthenticationResponse"/> struct.</returns>
        public override UserAuthenticationResponse User_Auth( UserAuthenticationRequest netRequest, LoginServiceSettings settings )
        {
            MsSqlDataCommand msdc = new MsSqlDataCommand
            (
                "[User_Auth]",
                CommandType.StoredProcedure,
                new SqlParameter("@login", SqlDbType.VarChar, 0x10) { Value = netRequest.Login },
                new SqlParameter("@password", SqlDbType.VarChar, 0x2f) { Value = netRequest.Password },
                new SqlParameter("@uid", SqlDbType.Int) { Direction = ParameterDirection.Output },
                new SqlParameter("@last_world", SqlDbType.TinyInt) { Direction = ParameterDirection.Output },
                new SqlParameter("@access_level", SqlDbType.TinyInt) { Direction = ParameterDirection.Output }
            );

            SetConnection(ref msdc, m_ActiveConnections.Next());

            msdc.ExecuteNonQuery();

            int uid = TypesConverter.GetInt(msdc.Parameters["@uid"].Value, int.MinValue);

            UserAuthenticationResponse rsp = new UserAuthenticationResponse(netRequest.RequestID, UserAuthenticationResponseType.UserOrPasswordWrong);

            switch ( uid )
            {
                case int.MinValue: // conversion error
                    {
                        rsp.Response = UserAuthenticationResponseType.SystemError;
                        break;
                    }
                case -2: // invalid credentials
                    break;
                case -1: // login doesn't exist
                    {
                        if ( settings != null && settings.AutoCreateUser )
                        {
                            // creating user
                            uid = User_Create(netRequest.Login, netRequest.Password, settings.DefaultAccessLevel);

                            switch ( uid )
                            {
                                case int.MinValue: // conversion error
                                case -2: // db insert error
                                    {
                                        rsp.Response = UserAuthenticationResponseType.SystemError;
                                        break;
                                    }
                                case -1: // login already exists
                                    break;
                                default: // user created
                                    {
                                        rsp.Response = UserAuthenticationResponseType.UserAccepted;
                                        rsp.UserID = uid;
                                        rsp.AccessLevel = settings.DefaultAccessLevel;
                                        rsp.LastWorldID = TypesConverter.GetByte(msdc.Parameters["@last_world"].Value, 1);
                                        break;
                                    }
                            }
                        }
                        else
                            goto case -2;
                        break;
                    }
                default:
                    {
                        rsp.Response = UserAuthenticationResponseType.UserAccepted;
                        rsp.UserID = uid;
                        rsp.LastWorldID = TypesConverter.GetByte(msdc.Parameters["@last_world"].Value, 1);
                        rsp.AccessLevel = TypesConverter.GetByte(msdc.Parameters["@access_level"].Value, 0);
                        break;
                    }
            }

            ReleaseCommand(msdc);

            return rsp;
        }