TFM-4.3-Reloaded/src/main/java/me/StevenLawson/TotalFreedomMod/ban/BanManager.java

package me.StevenLawson.TotalFreedomMod.ban;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.UUID;
import me.StevenLawson.TotalFreedomMod.Log;
import me.StevenLawson.TotalFreedomMod.TotalFreedomMod;
import me.StevenLawson.TotalFreedomMod.ban.Ban.BanType;
import me.StevenLawson.TotalFreedomMod.config.Configuration;
import me.StevenLawson.TotalFreedomMod.config.ConfigurationEntry;
import me.StevenLawson.TotalFreedomMod.manager.UUIDManager;
import me.StevenLawson.TotalFreedomMod.manager.UUIDManager.TFM_UuidResolver;
import me.StevenLawson.TotalFreedomMod.util.Utilities;
import org.bukkit.entity.Player;

public class BanManager {

	private static final List<Ban> ipBans;
	private static final List<Ban> uuidBans;
	private static final List<UUID> unbannableUUIDs;

	static {
		ipBans = new ArrayList<Ban>();
		uuidBans = new ArrayList<Ban>();
		unbannableUUIDs = new ArrayList<UUID>();
	}

	private BanManager() {
		throw new AssertionError();
	}

	public static void load() {
		ipBans.clear();
		uuidBans.clear();
		unbannableUUIDs.clear();

		final Configuration config = new Configuration(TotalFreedomMod.plugin, "bans.yml", true);
		config.load();

		for (String banString : config.getStringList("ips")) {
			try {
				addIpBan(new Ban(banString, BanType.IP));
			} catch (RuntimeException ex) {
				Log.warning("Could not load IP ban: " + banString);
			}
		}

		for (String banString : config.getStringList("uuids")) {
			try {
				addUuidBan(new Ban(banString, BanType.UUID));
			} catch (RuntimeException ex) {
				Log.warning("Could not load UUID ban: " + banString);
			}
		}

		// Save the config
		save();
		Log.info("Loaded " + ipBans.size() + " IP bans and " + uuidBans.size() + " UUID bans");

		@SuppressWarnings("unchecked") final TFM_UuidResolver resolver = new TFM_UuidResolver(
			(List<String>) ConfigurationEntry.UNBANNABLE_USERNAMES.getList());

		for (UUID uuid : resolver.call().values()) {
			unbannableUUIDs.add(uuid);
		}

		Log.info("Loaded " + unbannableUUIDs.size() + " unbannable UUIDs");
	}

	public static void save() {
		final Configuration config = new Configuration(TotalFreedomMod.plugin, "bans.yml", true);
		config.load();

		final List<String> newIpBans = new ArrayList<String>();
		final List<String> newUuidBans = new ArrayList<String>();

		for (Ban savedBan : ipBans) {
			if (!savedBan.isExpired()) {
				newIpBans.add(savedBan.toString());
			}
		}

		for (Ban savedBan : uuidBans) {
			if (!savedBan.isExpired() && !unbannableUUIDs.contains(
				UUID.fromString(savedBan.getSubject()))) {
				newUuidBans.add(savedBan.toString());
			}
		}

		config.set("ips", newIpBans);
		config.set("uuids", newUuidBans);

		// Save config
		config.save();
	}

	public static List<Ban> getIpBanList() {
		return Collections.unmodifiableList(ipBans);
	}

	public static List<Ban> getUuidBanList() {
		return Collections.unmodifiableList(uuidBans);
	}

	public static Ban getByIp(String ip) {
		for (Ban ban : ipBans) {
			if (ban.isExpired()) {
				continue;
			}

			wildcardCheck:
			if (ban.getSubject().contains("*")) {
				final String[] subjectParts = ban.getSubject().split("\\.");
				final String[] ipParts = ip.split("\\.");

				for (int i = 0; i < 4; i++) {
					if (!(subjectParts[i].equals("*") || subjectParts[i].equals(ipParts[i]))) {
						break wildcardCheck;
					}
				}

				return ban;
			}

			if (ban.getSubject().equals(ip)) {
				return ban;
			}
		}
		return null;
	}

	public static Ban getByUuid(UUID uuid) {
		for (Ban ban : uuidBans) {
			if (ban.getSubject().equalsIgnoreCase(uuid.toString())) {
				if (ban.isExpired()) {
					continue;
				}

				return ban;
			}
		}
		return null;
	}

	public static void unbanIp(String ip) {
		final Ban ban = getByIp(ip);

		if (ban == null) {
			return;
		}

		removeBan(ban);
		save();
	}

	public static void unbanUuid(UUID uuid) {
		final Ban ban = getByUuid(uuid);

		if (ban == null) {
			return;
		}

		removeBan(ban);
	}

	public static boolean isIpBanned(String ip) {
		return getByIp(ip) != null;
	}

	public static boolean isUuidBanned(UUID uuid) {
		return getByUuid(uuid) != null;
	}

	public static void addUuidBan(Player player) {
		addUuidBan(new Ban(UUIDManager.getUniqueId(player), player.getName()));
	}

	public static void addUuidBan(Ban ban) {
		if (!ban.isComplete()) {
			throw new RuntimeException("Could not add UUID ban, Invalid format!");
		}

		if (ban.isExpired()) {
			return;
		}

		if (uuidBans.contains(ban)) {
			return;
		}

		if (unbannableUUIDs.contains(UUID.fromString(ban.getSubject()))) {
			return;
		}

		uuidBans.add(ban);
		save();
	}

	public static void addIpBan(Player player) {
		addIpBan(new Ban(Utilities.getIp(player), player.getName()));
	}

	public static void addIpBan(Ban ban) {
		if (!ban.isComplete()) {
			throw new RuntimeException("Could not add IP ban, Invalid format!");
		}

		if (ban.isExpired()) {
			return;
		}

		if (ipBans.contains(ban)) {
			return;
		}

		ipBans.add(ban);
		save();
	}

	public static void removeBan(Ban ban) {
		final Iterator<Ban> ips = ipBans.iterator();
		while (ips.hasNext()) {
			if (ips.next().getSubject().equalsIgnoreCase(ban.getSubject())) {
				ips.remove();
			}
		}

		final Iterator<Ban> uuids = uuidBans.iterator();
		while (uuids.hasNext()) {
			if (uuids.next().getSubject().equalsIgnoreCase(ban.getSubject())) {
				uuids.remove();
			}
		}

		save();
	}

	public static void purgeIpBans() {
		ipBans.clear();
		save();
	}

	public static void purgeUuidBans() {
		uuidBans.clear();
		save();
	}
}