path: root/EssentialsGroupManager/src/org/anjocaido/groupmanager/dataholder/WorldDataHolder.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.anjocaido.groupmanager.dataholder;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.anjocaido.groupmanager.GroupManager;
import org.anjocaido.groupmanager.data.Group;
import org.anjocaido.groupmanager.data.User;
import org.anjocaido.groupmanager.events.GMGroupEvent;
import org.anjocaido.groupmanager.events.GMSystemEvent;
import org.anjocaido.groupmanager.events.GMUserEvent;
import org.anjocaido.groupmanager.events.GMUserEvent.Action;
import org.anjocaido.groupmanager.permissions.AnjoPermissionsHandler;
import org.bukkit.Server;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.PluginManager;
import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.constructor.SafeConstructor;
import org.yaml.snakeyaml.reader.UnicodeReader;

/**
 * One instance of this should exist per world/mirror it contains all functions
 * to manage these data sets and points to the relevant users and groups
 * objects.
 * 
 * @author gabrielcouto, ElgarL
 */
public class WorldDataHolder {

	/**
	 * World name
	 */
	protected String name;
	/**
	 * The actual groups holder
	 */
	protected GroupsDataHolder groups = new GroupsDataHolder();
	/**
	 * The actual users holder
	 */
	protected UsersDataHolder users = new UsersDataHolder();
	
	/**
	 * List of UUID's associated with this user name.
	 */
	protected static Map<String, Set<String>> nameToUUIDLookup = new TreeMap<String, Set<String>>();
	/**
     *
     */
	protected AnjoPermissionsHandler permissionsHandler;

	/**
	 * Prevent direct instantiation
	 * 
	 * @param worldName
	 */
	public WorldDataHolder(String worldName) {

		name = worldName;
	}

	/**
	 * The main constructor for a new WorldDataHolder
	 * 
	 * @param worldName
	 * @param groups
	 * @param users
	 */
	public WorldDataHolder(String worldName, GroupsDataHolder groups, UsersDataHolder users) {

		this.name = worldName;
		this.groups = groups;
		this.users = users;

		// this.defaultGroup = defaultGroup;
	}

	/**
	 * update the dataSource to point to this object.
	 * 
	 * This should be called whenever a set of world data is fetched.
	 */
	public void updateDataSource() {

		this.groups.setDataSource(this);
		this.users.setDataSource(this);
	}

	/**
	 * Search for a user. If it doesn't exist, create a new one with default
	 * group.
	 * 
	 * @param userId the UUID String or name of the user
	 * @return class that manage that user permission
	 */
	public User getUser(String userId) {
		
		if (getUsers().containsKey(userId.toLowerCase())) {
			return getUsers().get(userId.toLowerCase());
		}
		
		// Legacy name matching
		if (userId.length() < 36) {

			// Search for a name to UUID match
			for (String uid : getUUIDLookup(userId)) {
				
				User user = getUsers().get(uid);
				
				if (user.getLastName().equalsIgnoreCase(userId)) {
					return user;
				}
			}
			
		}
		
		// No user account found so create a new one.
		User newUser = createUser(userId);
		
		return newUser;
	}
	
	/**
	 * *** Internal GM use only ***
	 * This is called when a player joins to update/add their UUID.
	 * 
	 * @param uUID the player objects UUID.
	 * @param currentName the name they have just logged in with.
	 * @return the user object for this player.
	 */
	public User getUser(String uUID, String currentName) {
		
		// Check for a UUID account
		User user = getUsers().get(uUID.toLowerCase());
		
		if (user != null) {
			
			user.setLastName(currentName);
			return user;
			
		}
		
		// Search for a LastName match
		for (String uid : getUUIDLookup(currentName)) {
			
			User usr = getUsers().get(uid);
			
			if (usr.getLastName().equalsIgnoreCase(currentName) && usr.getUUID().equalsIgnoreCase(usr.getLastName())) {
				
				// Clone this user so we can set it's uUID
				user = usr.clone(uUID, currentName);
				
				// Delete it and replace with the new clone.
				this.removeUser(usr.getUUID());
				this.addUser(user);
				
				return getUsers().get(uUID.toLowerCase());
			}
			
		}
			
		
		// No user account found so create a new one.
		User newUser = createUser(uUID);
		newUser.setLastName(currentName);
		
		return newUser;
	}

	/**
	 * Add a user to the list. If it already exists, overwrite the old.
	 * 
	 * @param theUser the user you want to add to the permission list
	 */
	public void addUser(User theUser) {

		if (theUser.getDataSource() != this) {
			theUser = theUser.clone(this);
		}
		if (theUser == null) {
			return;
		}
		if ((theUser.getGroup() == null)) {
			theUser.setGroup(groups.getDefaultGroup());
		}
		removeUser(theUser.getUUID());
		getUsers().put(theUser.getUUID().toLowerCase(), theUser);
		
		// Store for name to UUID lookups.
		//putUUIDLookup(theUser.getLastName(), theUser.getUUID().toLowerCase());
		
		setUsersChanged(true);
		if (GroupManager.isLoaded())
			GroupManager.getGMEventHandler().callEvent(theUser, Action.USER_ADDED);
	}

	/**
	 * Removes the user from the list. (he might become a default user)
	 * 
	 * @param userId the UUID or username for the user to remove
	 * @return true if it had something to remove
	 */
	public boolean removeUser(String userId) {

		if (getUsers().containsKey(userId.toLowerCase())) {
			
			User user = getUser(userId.toLowerCase());
			
			// Remove the name to UUID lookup for this user object.
			removeUUIDLookup(user.getLastName(), user.getUUID());
			
			getUsers().remove(userId.toLowerCase());
			
			setUsersChanged(true);
			
			if (GroupManager.isLoaded())
				GroupManager.getGMEventHandler().callEvent(userId, GMUserEvent.Action.USER_REMOVED);
			
			return true;
		}
		return false;
	}

	/**
	 * 
	 * @param userId
	 * @return true if we have data for this player.
	 */
	public boolean isUserDeclared(String userId) {

		return getUsers().containsKey(userId.toLowerCase());
	}

	/**
	 * Change the default group of the file.
	 * 
	 * @param group the group you want make default.
	 */
	public void setDefaultGroup(Group group) {

		if (!getGroups().containsKey(group.getName().toLowerCase()) || (group.getDataSource() != this)) {
			addGroup(group);
		}
		groups.setDefaultGroup(getGroup(group.getName()));
		setGroupsChanged(true);
		if (GroupManager.isLoaded())
			GroupManager.getGMEventHandler().callEvent(GMSystemEvent.Action.DEFAULT_GROUP_CHANGED);
	}

	/**
	 * Returns the default group of the file
	 * 
	 * @return the default group
	 */
	public Group getDefaultGroup() {

		return groups.getDefaultGroup();
	}

	/**
	 * Returns a group of the given name
	 * 
	 * @param groupName the name of the group
	 * @return a group if it is found. null if not found.
	 */
	public Group getGroup(String groupName) {

		if (groupName.toLowerCase().startsWith("g:"))
			return GroupManager.getGlobalGroups().getGroup(groupName);
		else
			return getGroups().get(groupName.toLowerCase());
	}

	/**
	 * Check if a group exists. Its the same of getGroup, but check if it is
	 * null.
	 * 
	 * @param groupName the name of the group
	 * @return true if exists. false if not.
	 */
	public boolean groupExists(String groupName) {

		if (groupName.toLowerCase().startsWith("g:"))
			return GroupManager.getGlobalGroups().hasGroup(groupName);
		else
			return getGroups().containsKey(groupName.toLowerCase());
	}

	/**
	 * Add a group to the list
	 * 
	 * @param groupToAdd
	 */
	public void addGroup(Group groupToAdd) {

		if (groupToAdd.getName().toLowerCase().startsWith("g:")) {
			GroupManager.getGlobalGroups().addGroup(groupToAdd);
			GroupManager.getGMEventHandler().callEvent(groupToAdd, GMGroupEvent.Action.GROUP_ADDED);
			return;
		}

		if (groupToAdd.getDataSource() != this) {
			groupToAdd = groupToAdd.clone(this);
		}
		removeGroup(groupToAdd.getName());
		getGroups().put(groupToAdd.getName().toLowerCase(), groupToAdd);
		setGroupsChanged(true);
		if (GroupManager.isLoaded())
			GroupManager.getGMEventHandler().callEvent(groupToAdd, GMGroupEvent.Action.GROUP_ADDED);
	}

	/**
	 * Remove the group from the list
	 * 
	 * @param groupName
	 * @return true if had something to remove. false the group was default or
	 *         non-existant
	 */
	public boolean removeGroup(String groupName) {

		if (groupName.toLowerCase().startsWith("g:")) {
			return GroupManager.getGlobalGroups().removeGroup(groupName);
		}

		if (getDefaultGroup() != null && groupName.equalsIgnoreCase(getDefaultGroup().getName())) {
			return false;
		}
		if (getGroups().containsKey(groupName.toLowerCase())) {
			getGroups().remove(groupName.toLowerCase());
			setGroupsChanged(true);
			if (GroupManager.isLoaded())
				GroupManager.getGMEventHandler().callEvent(groupName.toLowerCase(), GMGroupEvent.Action.GROUP_REMOVED);
			return true;
		}
		return false;

	}

	/**
	 * Creates a new User with the given name and adds it to this holder.
	 * 
	 * @param userId the UUID or username you want
	 * @return null if user already exists. or new User
	 */
	public User createUser(String userId) {

		if (getUsers().containsKey(userId.toLowerCase())) {
			return null;
		}
		User newUser = new User(this, userId);
		newUser.setGroup(groups.getDefaultGroup(), false);
		addUser(newUser);
		setUsersChanged(true);
		return newUser;
	}

	/**
	 * Creates a new Group with the given name and adds it to this holder
	 * 
	 * @param groupName the groupname you want
	 * @return null if group already exists. or new Group
	 */
	public Group createGroup(String groupName) {

		if (groupName.toLowerCase().startsWith("g:")) {
			Group newGroup = new Group(groupName);
			return GroupManager.getGlobalGroups().newGroup(newGroup);
		}

		if (getGroups().containsKey(groupName.toLowerCase())) {
			return null;
		}

		Group newGroup = new Group(this, groupName);
		addGroup(newGroup);
		setGroupsChanged(true);
		return newGroup;
	}

	/**
	 * 
	 * @return a collection of the groups
	 */
	public Collection<Group> getGroupList() {

		synchronized (getGroups()) {
			return new ArrayList<Group>(getGroups().values());
		}
	}

	/**
	 * 
	 * @return a collection of the users
	 */
	public Collection<User> getUserList() {

		synchronized (getUsers()) {
			return new ArrayList<User>(getUsers().values());
		}
	}

	/**
	 * reads the file again
	 */
	public void reload() {

		try {
			reloadGroups();
			reloadUsers();
		} catch (Exception ex) {
			Logger.getLogger(WorldDataHolder.class.getName()).log(Level.SEVERE, null, ex);
		}
	}

	/**
	 * Refresh Group data from file
	 */
	public void reloadGroups() {

		GroupManager.setLoaded(false);
		try {
			// temporary holder in case the load fails.
			WorldDataHolder ph = new WorldDataHolder(this.getName());

			loadGroups(ph, getGroupsFile());
			// transfer new data
			resetGroups();
			for (Group tempGroup : ph.getGroupList()) {
				tempGroup.clone(this);
			}
			this.setDefaultGroup(getGroup(ph.getDefaultGroup().getName()));
			this.removeGroupsChangedFlag();
			this.setTimeStampGroups(getGroupsFile().lastModified());

			ph = null;
		} catch (Exception ex) {
			Logger.getLogger(WorldDataHolder.class.getName()).log(Level.WARNING, null, ex);
		}
		GroupManager.setLoaded(true);
		GroupManager.getGMEventHandler().callEvent(GMSystemEvent.Action.RELOADED);
	}

	/**
	 * Refresh Users data from file
	 */
	public void reloadUsers() {

		GroupManager.setLoaded(false);
		try {
			// temporary holder in case the load fails.
			WorldDataHolder ph = new WorldDataHolder(this.getName());
			// copy groups for reference
			for (Group tempGroup : this.getGroupList()) {
				tempGroup.clone(ph);
			}
			// setup the default group before loading user data.
			ph.setDefaultGroup(ph.getGroup(getDefaultGroup().getName()));
			loadUsers(ph, getUsersFile());
			// transfer new data
			resetUsers();
			for (User tempUser : ph.getUserList()) {
				tempUser.clone(this);
			}
			this.removeUsersChangedFlag();
			this.setTimeStampUsers(getUsersFile().lastModified());

			ph = null;
		} catch (Exception ex) {
			Logger.getLogger(WorldDataHolder.class.getName()).log(Level.WARNING, null, ex);
		}
		GroupManager.setLoaded(true);
		GroupManager.getGMEventHandler().callEvent(GMSystemEvent.Action.RELOADED);
	}

	public void loadGroups(File groupsFile) {

		GroupManager.setLoaded(false);
		try {
			setGroupsFile(groupsFile);
			loadGroups(this, groupsFile);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			throw new IllegalArgumentException("The file which should contain groups does not exist!\n" + groupsFile.getPath());
		} catch (IOException e) {
			e.printStackTrace();
			throw new IllegalArgumentException("Error accessing the groups file!\n" + groupsFile.getPath());
		}

		GroupManager.setLoaded(true);
	}

	public void loadUsers(File usersFile) {

		GroupManager.setLoaded(false);
		try {
			setUsersFile(usersFile);
			loadUsers(this, usersFile);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			throw new IllegalArgumentException("The file which should contain users does not exist!\n" + usersFile.getPath());
		} catch (IOException e) {
			e.printStackTrace();
			throw new IllegalArgumentException("Error accessing the users file!\n" + usersFile.getPath());
		}

		GroupManager.setLoaded(true);
	}

	/**
	 * Returns a NEW data holder containing data read from the files
	 * 
	 * @param worldName
	 * @param groupsFile
	 * @param usersFile
	 * 
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	public static WorldDataHolder load(String worldName, File groupsFile, File usersFile) throws FileNotFoundException, IOException {

		WorldDataHolder ph = new WorldDataHolder(worldName);

		GroupManager.setLoaded(false);
		if (groupsFile != null)
			loadGroups(ph, groupsFile);
		if (usersFile != null)
			loadUsers(ph, usersFile);
		GroupManager.setLoaded(true);

		return ph;
	}

	/**
	 * Updates the WorldDataHolder from the Groups file
	 * 
	 * @param ph
	 * @param groupsFile
	 * 
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	protected static void loadGroups(WorldDataHolder ph, File groupsFile) throws FileNotFoundException, IOException {

		// READ GROUPS FILE

		Yaml yamlGroups = new Yaml(new SafeConstructor());
		Map<String, Object> groupsRootDataNode;

		if (!groupsFile.exists()) {
			throw new IllegalArgumentException("The file which should contain groups does not exist!\n" + groupsFile.getPath());
		}
		FileInputStream groupsInputStream = new FileInputStream(groupsFile);
		try {
			groupsRootDataNode = (Map<String, Object>) yamlGroups.load(new UnicodeReader(groupsInputStream));
			if (groupsRootDataNode == null) {
				throw new NullPointerException();
			}
		} catch (Exception ex) {
			throw new IllegalArgumentException("The following file couldn't pass on Parser.\n" + groupsFile.getPath(), ex);
		} finally {
			groupsInputStream.close();
		}

		// PROCESS GROUPS FILE

		Map<String, List<String>> inheritance = new HashMap<String, List<String>>();
		Map<String, Object> allGroupsNode = null;

		/*
		 * Fetch all groups under the 'groups' entry.
		 */
		try {
			allGroupsNode = (Map<String, Object>) groupsRootDataNode.get("groups");
		} catch (Exception ex) {
			throw new IllegalArgumentException("Your " + groupsFile.getPath() + " file is invalid. See console for details.", ex);
		}

		if (allGroupsNode == null) {
			throw new IllegalArgumentException("You have no groups in " + groupsFile.getPath() + ".");
		}

		Iterator<String> groupItr = allGroupsNode.keySet().iterator();
		String groupKey;
		Integer groupCount = 0;

		/*
		 * loop each group entry and process it's data.
		 */
		while (groupItr.hasNext()) {

			try {
				groupCount++;
				// Attempt to fetch the next group name.
				groupKey = groupItr.next();
			} catch (Exception ex) {
				throw new IllegalArgumentException("Invalid group name for group entry (" + groupCount + ") in file: " + groupsFile.getPath(), ex);
			}

			/*
			 * Fetch this groups child nodes
			 */
			Map<String, Object> thisGroupNode = null;

			try {
				thisGroupNode = (Map<String, Object>) allGroupsNode.get(groupKey);
			} catch (Exception ex) {
				throw new IllegalArgumentException("Invalid child nodes for group '" + groupKey + "' in file: " + groupsFile.getPath(), ex);
			}

			/*
			 * Create a new group with this name in the assigned data source.
			 */
			Group thisGrp = ph.createGroup(groupKey);

			if (thisGrp == null) {
				throw new IllegalArgumentException("I think this Group was declared more than once: " + groupKey + " in file: " + groupsFile.getPath());
			}

			// DEFAULT NODE

			Object nodeData = null;
			try {
				nodeData = thisGroupNode.get("default");
			} catch (Exception ex) {
				throw new IllegalArgumentException("Bad format found in 'permissions' for group: " + groupKey + " in file: " + groupsFile.getPath());
			}

			if (nodeData == null) {
				/*
				 * If no 'default' node is found do nothing.
				 */
			} else if ((Boolean.parseBoolean(nodeData.toString()))) {
				/*
				 * Set this as the default group. Warn if some other group has
				 * already claimed that position.
				 */
				if (ph.getDefaultGroup() != null) {
					GroupManager.logger.warning("The group '" + thisGrp.getName() + "' is claiming to be default where '" + ph.getDefaultGroup().getName() + "' already was.");
					GroupManager.logger.warning("Overriding first default request in file: " + groupsFile.getPath());
				}
				ph.setDefaultGroup(thisGrp);
			}

			// PERMISSIONS NODE

			nodeData = null;
			try {
				nodeData = thisGroupNode.get("permissions");
			} catch (Exception ex) {
				throw new IllegalArgumentException("Bad format found in 'permissions' for '" + groupKey + "' in file: " + groupsFile.getPath());
			}

			if (nodeData == null) {
				/*
				 * If no permissions node is found, or it's empty do nothing.
				 */
			} else {
				/*
				 * There is a permission list Which seems to hold some data
				 */
				if (nodeData instanceof List) {
					/*
					 * Check each entry and add it as a new permission.
					 */
					try {
						for (Object o : ((List) nodeData)) {
							try {
								/*
								 * Only add this permission if it's not empty.
								 */
								if (!o.toString().isEmpty())
									thisGrp.addPermission(o.toString());

							} catch (NullPointerException ex) {
								// Ignore this entry as it's null. It can be
								// safely dropped
							}
						}
					} catch (Exception ex) {
						throw new IllegalArgumentException("Invalid formatting found in 'permissions' section for group: " + thisGrp.getName() + " in file: " + groupsFile.getPath(), ex);
					}

				} else if (nodeData instanceof String) {
					/*
					 * Only add this permission if it's not empty.
					 */
					if (!nodeData.toString().isEmpty())
						thisGrp.addPermission((String) nodeData);

				} else {
					throw new IllegalArgumentException("Unknown type of 'permissions' node(Should be String or List<String>) for group:  " + thisGrp.getName() + " in file: " + groupsFile.getPath());
				}
				/*
				 * Sort all permissions so they are in the correct order for
				 * checking.
				 */
				thisGrp.sortPermissions();
			}

			// INFO NODE

			nodeData = null;
			try {
				nodeData = thisGroupNode.get("info");
			} catch (Exception ex) {
				throw new IllegalArgumentException("Bad format found in 'info' section for group: " + groupKey + " in file: " + groupsFile.getPath());
			}

			if (nodeData == null) {
				/*
				 * No info section was found, so leave all variables as
				 * defaults.
				 */
				GroupManager.logger.warning("The group '" + thisGrp.getName() + "' has no 'info' section!");
				GroupManager.logger.warning("Using default values: " + groupsFile.getPath());

			} else if (nodeData instanceof Map) {
				try {
					if (nodeData != null) {
						thisGrp.setVariables((Map<String, Object>) nodeData);
					}
				} catch (Exception ex) {
					throw new IllegalArgumentException("Invalid formatting found in 'info' section for group: " + thisGrp.getName() + " in file: " + groupsFile.getPath(), ex);
				}

			} else
				throw new IllegalArgumentException("Unknown entry found in 'info' section for group: " + thisGrp.getName() + " in file: " + groupsFile.getPath());

			// INHERITANCE NODE

			nodeData = null;
			try {
				nodeData = thisGroupNode.get("inheritance");
			} catch (Exception ex) {
				throw new IllegalArgumentException("Bad format found in 'inheritance' section for group: " + groupKey + " in file: " + groupsFile.getPath());
			}

			if (nodeData == null || nodeData instanceof List) {
				if (nodeData == null) {
					/*
					 * If no inheritance node is found, or it's empty do
					 * nothing.
					 */
				} else if (nodeData instanceof List) {

					try {
						for (String grp : (List<String>) nodeData) {
							if (inheritance.get(groupKey) == null) {
								inheritance.put(groupKey, new ArrayList<String>());
							}
							inheritance.get(groupKey).add(grp);
						}

					} catch (Exception ex) {
						throw new IllegalArgumentException("Invalid formatting found in 'inheritance' section for group: " + thisGrp.getName() + " in file: " + groupsFile.getPath(), ex);
					}

				}
			} else
				throw new IllegalArgumentException("Unknown entry found in 'inheritance' section for group: " + thisGrp.getName() + " in file: " + groupsFile.getPath());

			// END GROUP

		}

		if (ph.getDefaultGroup() == null) {
			throw new IllegalArgumentException("There was no Default Group declared in file: " + groupsFile.getPath());
		}

		/*
		 * Build the inheritance map and recored any errors
		 */
		for (String group : inheritance.keySet()) {
			List<String> inheritedList = inheritance.get(group);
			Group thisGroup = ph.getGroup(group);
			if (thisGroup != null)
				for (String inheritedKey : inheritedList) {
					if (inheritedKey != null) {
						Group inheritedGroup = ph.getGroup(inheritedKey);
						if (inheritedGroup != null) {
							thisGroup.addInherits(inheritedGroup);
						} else
							GroupManager.logger.warning("Inherited group '" + inheritedKey + "' not found for group " + thisGroup.getName() + ". Ignoring entry in file: " + groupsFile.getPath());
					}
				}
		}

		ph.removeGroupsChangedFlag();
		// Update the LastModified time.
		ph.setGroupsFile(groupsFile);
		ph.setTimeStampGroups(groupsFile.lastModified());

		// return ph;
	}

	/**
	 * Updates the WorldDataHolder from the Users file
	 * 
	 * @param ph
	 * @param usersFile
	 * 
	 * @throws FileNotFoundException
	 * @throws IOException
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	protected static void loadUsers(WorldDataHolder ph, File usersFile) throws FileNotFoundException, IOException {

		// READ USERS FILE
		Yaml yamlUsers = new Yaml(new SafeConstructor());
		Map<String, Object> usersRootDataNode;
		if (!usersFile.exists()) {
			throw new IllegalArgumentException("The file which should contain users does not exist!\n" + usersFile.getPath());
		}
		FileInputStream usersInputStream = new FileInputStream(usersFile);
		try {
			usersRootDataNode = (Map<String, Object>) yamlUsers.load(new UnicodeReader(usersInputStream));
			if (usersRootDataNode == null) {
				throw new NullPointerException();
			}
		} catch (Exception ex) {
			throw new IllegalArgumentException("The following file couldn't pass on Parser.\n" + usersFile.getPath(), ex);
		} finally {
			usersInputStream.close();
		}

		// PROCESS USERS FILE

		Map<String, Object> allUsersNode = null;

		/*
		 * Fetch all child nodes under the 'users' entry.
		 */
		try {
			allUsersNode = (Map<String, Object>) usersRootDataNode.get("users");
		} catch (Exception ex) {
			throw new IllegalArgumentException("Your " + usersFile.getPath() + " file is invalid. See console for details.", ex);
		}

		// Load users if the file is NOT empty

		if (allUsersNode != null) {

			Iterator<String> usersItr = allUsersNode.keySet().iterator();
			String usersKey;
			Object node;
			Integer userCount = 0;

			while (usersItr.hasNext()) {
				try {
					userCount++;
					// Attempt to fetch the next user name.
					node = usersItr.next();
					if (node instanceof Integer)
						usersKey = Integer.toString((Integer) node);
					else
						usersKey = node.toString();

				} catch (Exception ex) {
					throw new IllegalArgumentException("Invalid node type for user entry (" + userCount + ") in file: " + usersFile.getPath(), ex);
				}

				Map<String, Object> thisUserNode = null;
				try {
					thisUserNode = (Map<String, Object>) allUsersNode.get(node);
				} catch (Exception ex) {
					throw new IllegalArgumentException("Bad format found for user: " + usersKey + " in file: " + usersFile.getPath());
				}

				User thisUser = ph.createUser(usersKey);
				if (thisUser == null) {
					throw new IllegalArgumentException("I think this user was declared more than once: " + usersKey + " in file: " + usersFile.getPath());
				}

				// LASTNAME NODES

				Object nodeData = null;
				try {
					
					nodeData = thisUserNode.get("lastname");
					
				} catch (Exception ex) {
					throw new IllegalArgumentException("Bad format found in 'subgroups' for user: " + usersKey + " in file: " + usersFile.getPath());
				}
				
				if ((nodeData != null) && (nodeData instanceof String)) {
					
					thisUser.setLastName((String) nodeData);
					
				}
				
				// USER PERMISSIONS NODES

				nodeData = null;
				try {
					nodeData = thisUserNode.get("permissions");
				} catch (Exception ex) {
					throw new IllegalArgumentException("Bad format found in 'permissions' for user: " + usersKey + " in file: " + usersFile.getPath());
				}

				if (nodeData == null) {
					/*
					 * If no permissions node is found, or it's empty do
					 * nothing.
					 */
				} else {
					try {
						if (nodeData instanceof List) {
							for (Object o : ((List) nodeData)) {
								/*
								 * Only add this permission if it's not empty
								 */
								if (!o.toString().isEmpty()) {
									thisUser.addPermission(o.toString());
								}
							}
						} else if (nodeData instanceof String) {

							/*
							 * Only add this permission if it's not empty
							 */
							if (!nodeData.toString().isEmpty()) {
								thisUser.addPermission(nodeData.toString());
							}

						}
					} catch (NullPointerException e) {
						// Ignore this entry as it's null.
					}
					thisUser.sortPermissions();
				}
				

				// SUBGROUPS NODES

				nodeData = null;
				try {
					nodeData = thisUserNode.get("subgroups");
				} catch (Exception ex) {
					throw new IllegalArgumentException("Bad format found in 'subgroups' for user: " + usersKey + " in file: " + usersFile.getPath());
				}

				if (nodeData == null) {
					/*
					 * If no subgroups node is found, or it's empty do nothing.
					 */
				} else if (nodeData instanceof List) {
					for (Object o : ((List) nodeData)) {
						if (o == null) {
							GroupManager.logger.warning("Invalid Subgroup data for user: " + thisUser.getLastName() + ". Ignoring entry in file: " + usersFile.getPath());
						} else {
							Group subGrp = ph.getGroup(o.toString());
							if (subGrp != null) {
								thisUser.addSubGroup(subGrp);
							} else {
								GroupManager.logger.warning("Subgroup '" + o.toString() + "' not found for user: " + thisUser.getLastName() + ". Ignoring entry in file: " + usersFile.getPath());
							}
						}
					}
				} else if (nodeData instanceof String) {
					Group subGrp = ph.getGroup(nodeData.toString());
					if (subGrp != null) {
						thisUser.addSubGroup(subGrp);
					} else {
						GroupManager.logger.warning("Subgroup '" + nodeData.toString() + "' not found for user: " + thisUser.getLastName() + ". Ignoring entry in file: " + usersFile.getPath());
					}
				}

				// USER INFO NODE

				nodeData = null;
				try {
					nodeData = thisUserNode.get("info");
				} catch (Exception ex) {
					throw new IllegalArgumentException("Bad format found in 'info' section for user: " + usersKey + " in file: " + usersFile.getPath());
				}

				if (nodeData == null) {
					/*
					 * If no info node is found, or it's empty do nothing.
					 */
				} else if (nodeData instanceof Map) {
					thisUser.setVariables((Map<String, Object>) nodeData);

				} else
					throw new IllegalArgumentException("Unknown entry found in 'info' section for user: " + thisUser.getLastName() + " in file: " + usersFile.getPath());

				// END INFO NODE

				// PRIMARY GROUP

				nodeData = null;
				try {
					nodeData = thisUserNode.get("group");
				} catch (Exception ex) {
					throw new IllegalArgumentException("Bad format found in 'group' section for user: " + usersKey + " in file: " + usersFile.getPath());
				}

				if (nodeData != null) {
					Group hisGroup = ph.getGroup(nodeData.toString());
					if (hisGroup == null) {
						GroupManager.logger.warning("There is no group " + thisUserNode.get("group").toString() + ", as stated for player " + thisUser.getLastName() + ": Set to '" + ph.getDefaultGroup().getName() + "' for file: " + usersFile.getPath());
						hisGroup = ph.getDefaultGroup();
					}
					thisUser.setGroup(hisGroup);
				} else {
					thisUser.setGroup(ph.getDefaultGroup());
				}
			}
		}

		ph.removeUsersChangedFlag();
		// Update the LastModified time.
		ph.setUsersFile(usersFile);
		ph.setTimeStampUsers(usersFile.lastModified());
	}

	/**
	 * Write a dataHolder in a specified file
	 * 
	 * @param ph
	 * @param groupsFile
	 */
	public static void writeGroups(WorldDataHolder ph, File groupsFile) {

		Map<String, Object> root = new HashMap<String, Object>();

		Map<String, Object> groupsMap = new HashMap<String, Object>();

		root.put("groups", groupsMap);
		synchronized (ph.getGroups()) {
			for (String groupKey : ph.getGroups().keySet()) {
				Group group = ph.getGroups().get(groupKey);

				Map<String, Object> aGroupMap = new HashMap<String, Object>();
				groupsMap.put(group.getName(), aGroupMap);

				if (ph.getDefaultGroup() == null) {
					GroupManager.logger.severe("There is no default group for world: " + ph.getName());
				}
				aGroupMap.put("default", group.equals(ph.getDefaultGroup()));

				Map<String, Object> infoMap = new HashMap<String, Object>();
				aGroupMap.put("info", infoMap);

				for (String infoKey : group.getVariables().getVarKeyList()) {
					infoMap.put(infoKey, group.getVariables().getVarObject(infoKey));
				}

				aGroupMap.put("inheritance", group.getInherits());

				aGroupMap.put("permissions", group.getPermissionList());
			}
		}

		if (!root.isEmpty()) {
			DumperOptions opt = new DumperOptions();
			opt.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
			final Yaml yaml = new Yaml(opt);
			try {
				OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(groupsFile), "UTF-8");

				String newLine = System.getProperty("line.separator");

				out.write("# Group inheritance" + newLine);
				out.write("#" + newLine);
				out.write("# Any inherited groups prefixed with a g: are global groups" + newLine);
				out.write("# and are inherited from the GlobalGroups.yml." + newLine);
				out.write("#" + newLine);
				out.write("# Groups without the g: prefix are groups local to this world" + newLine);
				out.write("# and are defined in the this groups.yml file." + newLine);
				out.write("#" + newLine);
				out.write("# Local group inheritances define your promotion tree when using 'manpromote/mandemote'" + newLine);
				out.write(newLine);

				yaml.dump(root, out);
				out.close();
			} catch (UnsupportedEncodingException ex) {
			} catch (FileNotFoundException ex) {
			} catch (IOException e) {
			}
		}

		// Update the LastModified time.
		ph.setGroupsFile(groupsFile);
		ph.setTimeStampGroups(groupsFile.lastModified());
		ph.removeGroupsChangedFlag();

		if (GroupManager.isLoaded())
			GroupManager.getGMEventHandler().callEvent(GMSystemEvent.Action.SAVED);

		/*
		 * FileWriter tx = null; try { tx = new FileWriter(groupsFile, false);
		 * tx.write(yaml.dump(root)); tx.flush(); } catch (Exception e) { }
		 * finally { try { tx.close(); } catch (IOException ex) { } }
		 */
	}

	/**
	 * Write a dataHolder in a specified file
	 * 
	 * @param ph
	 * @param usersFile
	 */
	public static void writeUsers(WorldDataHolder ph, File usersFile) {

		Map<String, Object> root = new HashMap<String, Object>();
		LinkedHashMap<String, Object> usersMap = new LinkedHashMap<String, Object>();
		
		root.put("users", usersMap);
		synchronized (ph.getUsers()) {
			
			// A sorted list of users.
			for (String userKey : new TreeSet<String>(ph.getUsers().keySet())) {
				User user = ph.getUsers().get(userKey);
				if ((user.getGroup() == null || user.getGroup().equals(ph.getDefaultGroup())) && user.getPermissionList().isEmpty() && user.getVariables().isEmpty() && user.isSubGroupsEmpty()) {
					continue;
				}

				LinkedHashMap<String, Object> aUserMap = new LinkedHashMap<String, Object>();
				usersMap.put(user.getUUID(), aUserMap);

				if (!user.getUUID().equalsIgnoreCase(user.getLastName())) {
					aUserMap.put("lastname", user.getLastName());
				}
				
				// GROUP NODE
				if (user.getGroup() == null) {
					aUserMap.put("group", ph.getDefaultGroup().getName());
				} else {
					aUserMap.put("group", user.getGroup().getName());
				}

				// SUBGROUPS NODE
				aUserMap.put("subgroups", user.subGroupListStringCopy());

				// PERMISSIONS NODE
				aUserMap.put("permissions", user.getPermissionList());

				// USER INFO NODE - BETA
				if (user.getVariables().getSize() > 0) {
					Map<String, Object> infoMap = new HashMap<String, Object>();
					aUserMap.put("info", infoMap);
					for (String infoKey : user.getVariables().getVarKeyList()) {
						infoMap.put(infoKey, user.getVariables().getVarObject(infoKey));
					}
				}
				// END USER INFO NODE - BETA

			}
		}

		if (!root.isEmpty()) {
			DumperOptions opt = new DumperOptions();
			opt.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
			final Yaml yaml = new Yaml(opt);
			try {
				OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(usersFile), "UTF-8");
				yaml.dump(root, out);
				out.close();
			} catch (UnsupportedEncodingException ex) {
			} catch (FileNotFoundException ex) {
			} catch (IOException e) {
			}
		}

		// Update the LastModified time.
		ph.setUsersFile(usersFile);
		ph.setTimeStampUsers(usersFile.lastModified());
		ph.removeUsersChangedFlag();

		if (GroupManager.isLoaded())
			GroupManager.getGMEventHandler().callEvent(GMSystemEvent.Action.SAVED);

		/*
		 * FileWriter tx = null; try { tx = new FileWriter(usersFile, false);
		 * tx.write(yaml.dump(root)); tx.flush(); } catch (Exception e) { }
		 * finally { try { tx.close(); } catch (IOException ex) { } }
		 */
	}

	/**
	 * Don't use this. Unless you want to make this plugin to interact with
	 * original Nijikokun Permissions This method is supposed to make the
	 * original one reload the file, and propagate the changes made here.
	 * 
	 * Prefer to use the AnjoCaido's fake version of Nijikokun's Permission
	 * plugin. The AnjoCaido's Permission can propagate the changes made on this
	 * plugin instantly, without need to save the file.
	 * 
	 * @param server the server that holds the plugin
	 * @deprecated it is not used anymore... unless if you use original
	 *             Permissions
	 */
	@Deprecated
	public static void reloadOldPlugins(Server server) {

		// Only reload permissions
		PluginManager pm = server.getPluginManager();
		Plugin[] plugins = pm.getPlugins();
		for (int i = 0; i < plugins.length; i++) {
			// plugins[i].getConfiguration().load();
			try {
				plugins[i].getClass().getMethod("setupPermissions").invoke(plugins[i]);
			} catch (Exception ex) {
				continue;
			}
		}
	}

	/**
	 * @return the permissionsHandler
	 */
	public AnjoPermissionsHandler getPermissionsHandler() {

		if (permissionsHandler == null) {
			permissionsHandler = new AnjoPermissionsHandler(this);
		}
		return permissionsHandler;
	}

	/**
	 * @param haveUsersChanged the haveUsersChanged to set
	 */
	public void setUsersChanged(boolean haveUsersChanged) {

		users.setUsersChanged(haveUsersChanged);
	}

	/**
	 * 
	 * @return true if any user data has changed
	 */
	public boolean haveUsersChanged() {

		if (users.HaveUsersChanged()) {
			return true;
		}
		synchronized (users.getUsers()) {
			for (User u : users.getUsers().values()) {
				if (u.isChanged()) {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * @param setGroupsChanged the haveGroupsChanged to set
	 */
	public void setGroupsChanged(boolean setGroupsChanged) {

		groups.setGroupsChanged(setGroupsChanged);
	}

	/**
	 * 
	 * @return true if any group data has changed.
	 */
	public boolean haveGroupsChanged() {

		if (groups.HaveGroupsChanged()) {
			return true;
		}
		synchronized (groups.getGroups()) {
			for (Group g : groups.getGroups().values()) {
				if (g.isChanged()) {
					return true;
				}
			}
		}
		return false;
	}

	/**
     *
     */
	public void removeUsersChangedFlag() {

		setUsersChanged(false);
		synchronized (getUsers()) {
			for (User u : getUsers().values()) {
				u.flagAsSaved();
			}
		}
	}

	/**
     *
     */
	public void removeGroupsChangedFlag() {

		setGroupsChanged(false);
		synchronized (getGroups()) {
			for (Group g : getGroups().values()) {
				g.flagAsSaved();
			}
		}
	}

	/**
	 * @return the usersFile
	 */
	public File getUsersFile() {

		return users.getUsersFile();
	}

	/**
	 * @param file the usersFile to set
	 */
	public void setUsersFile(File file) {

		users.setUsersFile(file);
	}

	/**
	 * @return the groupsFile
	 */
	public File getGroupsFile() {

		return groups.getGroupsFile();
	}

	/**
	 * @param file the groupsFile to set
	 */
	public void setGroupsFile(File file) {

		groups.setGroupsFile(file);
	}

	/**
	 * @return the name
	 */
	public String getName() {

		return name;
	}

	/**
	 * Resets Groups.
	 */
	public void resetGroups() {

		// setDefaultGroup(null);
		groups.resetGroups();
	}

	/**
	 * Resets Users
	 */
	public void resetUsers() {

		users.resetUsers();
		this.clearUUIDLookup();
	}

	/**
	 * Note: Iteration over this object has to be synchronized!
	 * 
	 * @return the groups
	 */
	public Map<String, Group> getGroups() {

		return groups.getGroups();
	}

	/**
	 * Note: Iteration over this object has to be synchronized!
	 * 
	 * @return the users
	 */
	public Map<String, User> getUsers() {

		return users.getUsers();
	}

	/**
	 * @return the groups
	 */
	public GroupsDataHolder getGroupsObject() {

		return groups;
	}

	/**
	 * @param groupsDataHolder the GroupsDataHolder to set
	 */
	public void setGroupsObject(GroupsDataHolder groupsDataHolder) {

		groups = groupsDataHolder;
	}

	/**
	 * @return the users
	 */
	public UsersDataHolder getUsersObject() {

		return users;
	}

	/**
	 * @param usersDataHolder the UsersDataHolder to set
	 */
	public void setUsersObject(UsersDataHolder usersDataHolder) {

		users = usersDataHolder;
	}

	/**
	 * @return the timeStampGroups
	 */
	public long getTimeStampGroups() {

		return groups.getTimeStampGroups();
	}

	/**
	 * @return the timeStampUsers
	 */
	public long getTimeStampUsers() {

		return users.getTimeStampUsers();
	}

	/**
	 * @param timeStampGroups the timeStampGroups to set
	 */
	protected void setTimeStampGroups(long timeStampGroups) {

		groups.setTimeStampGroups(timeStampGroups);
	}

	/**
	 * @param timeStampUsers the timeStampUsers to set
	 */
	protected void setTimeStampUsers(long timeStampUsers) {

		users.setTimeStampUsers(timeStampUsers);
	}

	public void setTimeStamps() {

		if (getGroupsFile() != null)
			setTimeStampGroups(getGroupsFile().lastModified());
		if (getUsersFile() != null)
			setTimeStampUsers(getUsersFile().lastModified());
	}
	
	/** Name to UUID lookups **/
	
	/**
	 * Add a new name to UUID lookup.
	 * 
	 * @param name the User name key to index on.
	 * @param UUID the User object UUID (same as name if there is no UUID).
	 */
	public void putUUIDLookup(String name, String UUID) {
		
		Set<String> lookup = getUUIDLookup(name);
		
		if (lookup == null)
			lookup = new TreeSet<String>();
		
		lookup.add(UUID);
		
		nameToUUIDLookup.put(name, lookup);
	}
	
	/**
	 * Delete a name lookup.
	 * Allows for multiple UUID's assigned to a single name (offline/online)
	 * 
	 * @param name
	 * @param UUID 
	 */
	public void removeUUIDLookup(String name, String UUID) {
		
		if (nameToUUIDLookup.containsKey(name)) {
			
			Set<String> lookup = getUUIDLookup(name);
			
			lookup.remove(UUID);
			
			if (lookup.isEmpty()) {
				nameToUUIDLookup.remove(name);
				return;				
			}
				
			nameToUUIDLookup.put(name, lookup);
			
		}
		
	}
	
	/**
	 * 
	 * @param name
	 * @return a Set of strings containing the User objects UUID (or name if they don't have a UUID)
	 */
	public Set<String> getUUIDLookup(String name) {
		
		return nameToUUIDLookup.get(name);
	}
	
	/**
	 * Reset the UUID Lookup cache
	 */
	protected void clearUUIDLookup() {
		
		nameToUUIDLookup.clear();
	}

}