/// <summary>
        /// Clear a punish to the specified <see cref="Player"/>.
        /// </summary>
        /// <param name="player">The <see cref="Collections.Player"/> player.</param>
        /// <param name="type"> the <see cref="Enums.PunishType"/>.</param>
        /// <param name="id"> the punish id.</param>
        /// <param name="server"> the server port.</param>
        public static void ClearPunishment(Collections.Player player, PunishType?type, int id, int server)
        {
            switch (type)
            {
            case PunishType.Ban:
                Ban ban = BanCollection.FindOne(b => b.Target == player && b.BanId == id && b.Server == server);

                JsonManager.PunishToCache(type, JsonConvert.SerializeObject(ban), player, ActionType.Remove);

                if (player.IsBanned())
                {
                    BanHandler.RemoveBan($"{player.Id}@{player.Authentication}", BanHandler.BanType.IP);
                }

                BanCollection.Delete(ban.Id);
                break;

            case PunishType.Kick:
                Kick kick = KickCollection.FindOne(k => k.Target == player && k.KickId == id && k.Server == server);

                JsonManager.PunishToCache(type, JsonConvert.SerializeObject(kick), player, ActionType.Remove);

                KickCollection.Delete(kick.Id);
                break;

            case PunishType.Mute:
                Mute mute = MuteCollection.FindOne(m => m.Target == player && m.MuteId == id && m.Server == server);

                JsonManager.PunishToCache(type, JsonConvert.SerializeObject(mute), player, ActionType.Remove);

                if (player.IsMuted())
                {
                    MuteHandler.RevokePersistentMute($"{player.Id}@{player.Authentication}");
                }

                MuteCollection.Delete(mute.Id);
                break;

            case PunishType.Warn:
                Warn warn = WarnCollection.FindOne(w => w.Target == player && w.WarnId == id && w.Server == server);

                JsonManager.PunishToCache(type, JsonConvert.SerializeObject(warn), player, ActionType.Remove);

                WarnCollection.Delete(warn.Id);
                break;

            case PunishType.SoftWarn:
                SoftWarn softWarn = SoftWarnCollection.FindOne(sw => sw.Target == player && sw.SoftWarnId == id && sw.Server == server);

                JsonManager.PunishToCache(type, JsonConvert.SerializeObject(softWarn), player, ActionType.Remove);

                SoftWarnCollection.Delete(softWarn.Id);
                break;

            case PunishType.SoftBan:
                SoftBan softBan = SoftBanCollection.FindOne(sb => sb.Target == player && sb.SoftBanId == id && sb.Server == server);

                JsonManager.PunishToCache(type, JsonConvert.SerializeObject(softBan), player, ActionType.Remove);

                SoftBanCollection.Delete(softBan.Id);
                break;

            case PunishType.WatchList:
                WatchList watchList = WatchListCollection.FindOne(wl => wl.Target == player && wl.WatchListId == id && wl.Server == server);

                JsonManager.PunishToCache(type, JsonConvert.SerializeObject(watchList), player, ActionType.Remove);

                WatchListCollection.Delete(watchList.Id);
                break;
            }
        }