public virtual void OnLogin(IAuthClient client)
		{
			var addr = client.ClientAddress;
			if (addr == null)
			{
				// client disconnected
				return;
            }

            LastIP = addr.GetAddressBytes();
            LastLogin = DateTime.Now;
			Locale = client.Info.Locale;
			ClientVersion = client.Info.Version.ToString();
			//UpdateAndFlush(); TODO: I believe this saves the value to the database

			AuthCommandHandler.AutoExecute(this);

			var evt = LoggedIn;
			if (evt != null)
			{
				evt(this, client);
			}

			s_log.Info("Account \"{0}\" logged in from {1}.", Name, client.ClientAddress);
		}

		/// <summary>
		/// Sends an authentication challenge error to the client.
		/// </summary>
		/// <param name="client">the client</param>
		/// <param name="error">the authentication challenge error to send</param>
		public static void SendAuthChallengeErrorReply(IAuthClient client, AccountStatus error)
		{
			using (var packet = new AuthPacketOut(AuthServerOpCode.AUTH_LOGON_CHALLENGE))
			{
				packet.Write((byte)0x00);
				packet.Write((byte)error);

				client.Send(packet);
			}
		}

		/// <summary>
		/// Sends an authentication challenge success reply to the client.
		/// </summary>
		/// <param name="client">the client</param>
		public static void SendAuthChallengeSuccessReply(IAuthClient client)
		{
			using (var packet = new AuthPacketOut(AuthServerOpCode.AUTH_LOGON_CHALLENGE))
			{
				packet.Write((byte)AccountStatus.Success);
				// Grunt command
				packet.Write((byte)0x00);

				client.Authenticator.WriteServerChallenge(packet);

                //var rand = new BigInteger(new Random(Environment.TickCount), 128);
                //packet.WriteBigInt(rand, 16);
                Random rand = new Random(Environment.TickCount);
                byte[] randbytes = new byte[16];              
                rand.NextBytes(randbytes);           
                packet.Write(randbytes);            
                
                const byte securityFlag = 0x0;
				packet.Write(securityFlag);

				// Require PIN input
                //if ((securityFlag & 0x1) == 0x1)
                //{
                //    packet.WriteInt(0);
                //    packet.Write(new byte[16]);
                //}

                // Matrix input
                //if ((securityFlag & 0x2) == 0x2)
                //{
                //    packet.Write((byte)0);
                //    packet.Write((byte)0);
                //    packet.Write((byte)0);
                //    packet.Write((byte)0);
                //    packet.Write(0UL);
                //}
				// Require Security Token input
                //if ((securityFlag & 0x4) == 0x4)
                //{
                //    packet.Write((byte)1);
                //}

				client.Send(packet);
			}
		}

		public static void AuthChallengeRequest(IAuthClient client, AuthPacketIn packet)
		{
			packet.SkipBytes(6); // Skip game name and packet size

			client.Info = ClientInformation.ReadFromPacket(packet);

			// Account-names are always sent upper-case by the client (make sure, the tradition is kept alive)
			var accName = packet.ReadPascalString().ToUpper();

			s_log.Debug(Resources.AccountChallenge, accName);

			client.AccountName = accName;
			AuthenticationServer.Instance.AddMessage(new Message1<IAuthClient>(client, AuthChallengeRequestCallback));
		}

		/// <summary>
		/// Check for bans and already logged in Accounts, else continue the journey
		/// </summary>
		/// <param name="client"></param>
		private static void AuthChallengeRequestCallback(IAuthClient client)
		{
			if (!client.IsConnected)
			{
				// Client disconnected in the meantime
				return;
			}

			if (BanMgr.IsBanned(client.ClientAddress))
			{
				OnLoginError(client, AccountStatus.AccountBanned);	
			}
			//else if (client.Server.IsAccountLoggedIn(client.AccountName))
			//{
			//    OnLoginError(client, AccountStatus.AccountInUse);
			//}
			else
			{
			    var acctQuery = new Action(() =>
			    {
			        var acc = AccountMgr.GetAccount(client.AccountName);
			        QueryAccountCallback(client, acc);
			    });

				AuthenticationServer.Instance.AddMessage(acctQuery);
			}
		}

		/// <summary>
		/// Called when the given client failed to login due to the given reason.
		/// Delays, fires the LoginFailed event and sends the reply.
		/// </summary>
		/// <param name="client"></param>
		/// <param name="error"></param>
		public static void OnLoginError(IAuthClient client, AccountStatus error)
		{
			OnLoginError(client, error, false);
		}

		public static void AuthProofRequest(IAuthClient client, AuthPacketIn packet)
		{
			if (client.Authenticator == null)
			{
				client.Server.DisconnectClient(client);
			}
			else
			{
				if (client.Authenticator.IsClientProofValid(packet))
				{
					if (client.IsAutocreated)
					{
						// Their stuff matched, which means they gave us the same password
						// as their username, which is what must occur to autocreate. Create
						// the account for them before proceeding.

						s_log.Debug(Resources.AutocreatingAccount, client.CurrentUser);

						string role;
						if (IPAddress.IsLoopback(client.ClientAddress))
						{
							// local users get the highest role
							role = RoleGroupInfo.HighestRole.Name;
						}
						else
						{
							// remote users get default role
							role = AuthServerConfiguration.DefaultRole;
						}

						var acctCreateQuery = QueryFactory.CreateResultQuery(
							() => AccountMgr.Instance.CreateAccount(
							          client.CurrentUser,
							          client.Authenticator.SRP.Credentials.GetBytes(20),
							          null,
							          role,
							          ClientId.Wotlk
							          ),
							AutocreateAccountCallback,
							client
							);

						client.Server.EnqueueTask(acctCreateQuery);
					}
					else
					{
						// The following was sent twice
						var authInfo = new AuthenticationInfo {
							SessionKey = client.Authenticator.SRP.SessionKey.GetBytes(40),
							Salt = client.Authenticator.SRP.Salt.GetBytes(32),
							Verifier = client.Authenticator.SRP.Verifier.GetBytes(),
							SystemInformation = ClientInformation.Serialize(client.ClientInfo)
						};

						client.Server.StoreAuthenticationInfo(client.CurrentUser, authInfo);

						SendAuthProofSuccessReply(client);
					}
				}
				else
				{
					s_log.Debug(Resources.InvalidClientProof, client.CurrentUser);

					OnLoginError(client, AccountStatus.InvalidInformation);
				}
			}
		}

		public static void AuthReconnectChallenge(IAuthClient client, AuthPacketIn packet)
		{
			SendAuthReconnectChallenge(client);
		}

		public static void SendAuthReconnectChallenge(IAuthClient client)
		{
			//using (var packet = new AuthPacketOut(AuthServerOpCode.AUTH_RECONNECT_CHALLENGE))
			//{
			//    //client.Authenticator.WriteReconnectChallenge(packet);
			//    client.Send(packet);
			//}

			// drop silently for now
			OnLoginError(client, AccountStatus.Failure, true);
		}

        /// <summary>
        /// Writes the realm information to the specified packet.
        /// </summary>
        /// <param name="packet">the packet to write the realm info to</param>
        public void WriteRealm(IAuthClient client, AuthPacketOut packet)
        {
			var status = Status;
			var flags = Flags;
			var name = Name;
			if (!ClientVersion.IsSupported(client.Info.Version))
			{
				flags = RealmFlags.Offline;
				name += " [" + ClientVersion.BasicString + "]";
			}
            else if (Flags.HasFlag(RealmFlags.Offline) && Status == RealmStatus.Locked)
            {
            	var acc = client.Account;
                var role = acc.Role;
                if (role.IsStaff)
                {
                    status = RealmStatus.Open;
                	flags = RealmFlags.None;
                }
			}

            // TODO: Change char-count to amount of Characters of the querying account on this Realm
			packet.Write((byte)ServerType);
            packet.Write((byte)status);
            packet.Write((byte)flags);
            packet.WriteCString(name);
            packet.WriteCString(AddressString);
            packet.Write(Population);
            packet.Write(Chars);
            packet.Write((byte)Category);
            packet.Write((byte)0x00); // realm separator?
        }

		/// <summary>
		/// Client passed login challenge and can be logged in
		/// </summary>
		/// <param name="client"></param>
		private static void LoginClient(IAuthClient client)
		{
			var acc = client.Account;

			if (acc == null)
			{
				// Pass and username are identical so an Account can be auto-created
				// the corresponding check happened before
				s_log.Debug(Resources.AutocreatingAccount, client.AccountName);

				if (AccountMgr.DoesAccountExist(client.AccountName))
				{
					// account was already created								
					SendAuthProofErrorReply(client, AccountStatus.Failure);
					return;
				}
				acc = AutoCreateAccount(client);
			}

			var authInfo = new AuthenticationInfo
			{
				SessionKey = client.Authenticator.SRP.SessionKey.GetBytes(40),
				Salt = client.Authenticator.SRP.Salt.GetBytes(32),
				Verifier = client.Authenticator.SRP.Verifier.GetBytes(),
				SystemInformation = ClientInformation.Serialize(client.Info)
			};
			client.Server.StoreAuthenticationInfo(client.AccountName, authInfo);

			acc.OnLogin(client);
			SendAuthProofSuccessReply(client);
		}

		/// <summary>
		/// Called when the given client failed to login due to the given reason.
		/// Delays, fires the LoginFailed event and sends the reply.
		/// </summary>
		/// <param name="client"></param>
		/// <param name="error"></param>
		private static void OnLoginError(IAuthClient client, AccountStatus error)
		{
			TimeoutWaitHandle delayHandle;
			if (!failedLogins.TryGetValue(client.ClientAddress, out delayHandle))
			{
				failedLogins.Add(client.ClientAddress, delayHandle = new TimeoutWaitHandle(DateTime.Now));
			}
			else
			{
				delayHandle.LastAttempt = DateTime.Now;
			}

			ThreadPool.RegisterWaitForSingleObject(delayHandle.Handle, (state, timedOut) => {
				if (client.IsConnected)
				{
					var evt = LoginFailed;
					if (evt != null)
					{
						evt(client, error);
					}
					SendAuthProofErrorReply(client, error);
				}
			}, null, LoginFailedDelay, true);
		}

		public AuthPacketMessage(Action<IAuthClient, AuthPacketIn> handler, IAuthClient client, AuthPacketIn packet)
		{
			m_handler = handler;
			m_client = client;
			m_packet = packet;
		}

		public static void SendAuthReconnectChallenge(IAuthClient client)
		{
			using (var packet = new AuthPacketOut(AuthServerOpCode.AUTH_RECONNECT_CHALLENGE))
			{
				client.Authenticator.WriteReconnectChallenge(packet);
			}
		}

		public static void AuthReconnectProof(IAuthClient client, AuthPacketIn packet)
		{
			AuthenticationInfo authInfo;
			if (AuthenticationServer.Instance.GetAuthenticationInfo(client.CurrentUser, out authInfo))
			{
				if (client.Authenticator.IsReconnectProofValid(packet, authInfo))
				{
					SendAuthReconnectProof(client);
				}
			}

		}

		private static void AutocreateAccountCallback(IAuthClient client, Account acct)
		{
			if (acct == null)
			{
				OnLoginError(client, AccountStatus.InvalidInformation);

				return;
			}

			var authInfo = new AuthenticationInfo {
				SessionKey = client.Authenticator.SRP.SessionKey.GetBytes(40),
				Salt = client.Authenticator.SRP.Salt.GetBytes(32),
				Verifier = client.Authenticator.SRP.Verifier.GetBytes(),
				SystemInformation = ClientInformation.Serialize(client.ClientInfo)
			};

			client.Server.StoreAuthenticationInfo(client.CurrentUser, authInfo);

			SendAuthProofSuccessReply(client);
		}

		private static void QueryAccountCallback(IAuthClient client, Account acct)
		{
			if (!client.IsConnected)
			{
				return;
			}

			var accName = client.AccountName;

			if (acct == null)
			{
				// Account doesn't exist yet -> Check for auto creation
				if (AuthServerConfiguration.AutocreateAccounts)
				{
					if (!AccountMgr.NameValidator(ref accName))
					{
						OnLoginError(client, AccountStatus.InvalidInformation);
						return;
					}

					// Fill in this client's info with the username they gave.
					// We have to go through the authentication phase, and if 
					// the password ends up matching the username, we know it's
					// an autocreation attempt.

					var passHash = SecureRemotePassword.GenerateCredentialsHash(accName, accName);

					client.Authenticator = new Authenticator(new SecureRemotePassword(accName, passHash, true));
					SendAuthChallengeSuccessReply(client);
				}
				else
				{
					OnLoginError(client, AccountStatus.InvalidInformation);
				}
			}
			else
			{
				// check if Account may be used
				if (acct.CheckActive())
				{
					client.Account = acct;
					client.Authenticator = new Authenticator(new SecureRemotePassword(accName, acct.Password, true));
					SendAuthChallengeSuccessReply(client);
				}
				else
				{
 					// Account has been deactivated
					if (client.Account.StatusUntil == null)
					{
						// temporarily suspended
						OnLoginError(client, AccountStatus.AccountBanned);
					}
					else
					{
						// deactivated
						OnLoginError(client, AccountStatus.AccountFrozen);
					}
				}
			}
		}

 public static void RealmListRequest(IAuthClient client, PacketIn packet)
 {
     SendRealmList(client);
 }

		public static void AuthProofRequest(IAuthClient client, AuthPacketIn packet)
		{
			if (client.Authenticator == null)
			{
				client.Server.DisconnectClient(client);
			}
			else if (client.IsConnected)
			{
                if (client.Authenticator.IsClientProofValid(packet))
                {
                    AuthenticationServer.Instance.AddMessage(() =>
                    {
                    	LoginClient(client);
                    });
                }
                else
                {
                    s_log.Debug(Resources.InvalidClientProof, client.AccountName);

                    OnLoginError(client, AccountStatus.InvalidInformation);
                }
			}
		}

        /// <summary>
        /// Sends the realm list to the client.
        /// </summary>
        /// <param name="client">the Session the incoming packet belongs to</param>
        public static void SendRealmList(IAuthClient client)
        {
			if (client.Account == null)
			{
				AuthenticationHandler.OnLoginError(client, AccountStatus.Failure);
				return;
			}
            using (var packet = new AuthPacketOut(AuthServerOpCode.REALM_LIST))
            {
            	packet.Position += 2;							// Packet length
                packet.Write(0);								// Unknown Value (0x0000)
            	//var cpos = packet.Position;
            	//packet.Position = cpos + 2;

            	packet.Write((short)AuthenticationServer.RealmCount);

            	//var count = 0;
                foreach (var realm in AuthenticationServer.Realms)
                {
                	// check for client version
                	//if (realm.ClientVersion.IsSupported(client.Info.Version))
                	realm.WriteRealm(client, packet);
                }

            	//packet.Write((byte)0x15);
                packet.Write((byte)0x10);
				packet.Write((byte)0x00);

				//packet.Position = cpos;
				//packet.WriteShort(count);

                packet.Position = 1;
                packet.Write((short)packet.TotalLength - 3);

                client.Send(packet);
            }
        }