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

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.anjocaido.groupmanager.GroupManager;
import org.anjocaido.groupmanager.data.Group;
import org.anjocaido.groupmanager.data.User;
import org.anjocaido.groupmanager.dataholder.WorldDataHolder;
import org.anjocaido.groupmanager.utils.PermissionCheckResult;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;

/**
 * Everything here maintains the model created by Nijikokun
 *
 * But implemented to use GroupManager system. Which provides instant changes,
 * without file access.
 *
 * It holds permissions only for one single world.
 *
 * @author gabrielcouto, ElgarL
 */
public class AnjoPermissionsHandler extends PermissionsReaderInterface {

    WorldDataHolder ph = null;

    /**
     * It needs a WorldDataHolder to work with.
     *
     * @param holder
     */
    public AnjoPermissionsHandler(final WorldDataHolder holder) {

        ph = holder;
    }

    @Override
    public void addGroupInfo(final String name, final String path, final Object data) {

        ph.getGroup(name).getVariables().addVar(path, data);
    }

    @Override
    public void addUserInfo(final String name, final String path, final Object data) {

        ph.getUser(name).getVariables().addVar(path, data);
    }

    /**
     * Checks the specified group for the Info Build node. Does NOT check
     * inheritance
     *
     * @param groupName
     * @return true if can build
     */
    @Override
    public boolean canGroupBuild(final String groupName) {

        final Group g = ph.getGroup(groupName);
        if (g == null) {
            return false;
        }
        return g.getVariables().getVarBoolean("build");
    }

    /**
     * Check if user can build. Checks inheritance and subgroups.
     *
     * @param userName
     *            Player's name
     * @return true if the user can build
     */
    public boolean canUserBuild(final String userName) {

        return getPermissionBoolean(userName, "build");

    }

    /**
     * Wrapper for offline server checks.
     * Looks for the 'groupmanager.noofflineperms' permissions and reports no permissions on servers set to offline.
     *
     * Check user and groups with inheritance and Bukkit if bukkit = true return
     * a PermissionCheckResult.
     *
     * @param user
     * @param targetPermission
     * @param checkBukkit
     * @return PermissionCheckResult
     */
    public PermissionCheckResult checkFullGMPermission(final User user, final String targetPermission, final Boolean checkBukkit) {

        /*
         * Report no permissions under the following conditions.
         *
         * We are in offline mode
         * and the player has the 'groupmanager.noofflineperms' permission.
         */
        if (user == null || targetPermission == null || targetPermission.isEmpty()
                || (!Bukkit.getServer().getOnlineMode() && (checkPermission(user, "groupmanager.noofflineperms", false).resultType == PermissionCheckResult.Type.FOUND))) {

            final PermissionCheckResult result = new PermissionCheckResult();
            result.accessLevel = targetPermission;
            result.resultType = PermissionCheckResult.Type.NOTFOUND;

            return result;
        }

        return checkPermission(user, targetPermission, checkBukkit);
    }

    /**
     * Do what checkUserPermission did before. But now returning a
     * PermissionCheckResult.
     *
     * @param user
     * @param targetPermission
     * @return PermissionCheckResult
     */
    public PermissionCheckResult checkFullUserPermission(final User user, final String targetPermission) {

        return checkFullGMPermission(user, targetPermission, true);
    }

    /**
     * Returns the node responsible for that permission. Does not include User's
     * group permission.
     *
     * @param group
     * @param permission
     * @return the node if permission is found. if not found, return null
     */
    public PermissionCheckResult checkGroupOnlyPermission(final Group group, final String permission) {

        group.sortPermissions();
        final PermissionCheckResult result = new PermissionCheckResult();
        result.owner = group;
        result.askedPermission = permission;
        for (final String access : group.getPermissionList()) {
            result.resultType = comparePermissionString(access, permission);
            if (result.resultType != PermissionCheckResult.Type.NOTFOUND) {
                result.accessLevel = access;
                return result;
            }
        }
        result.resultType = PermissionCheckResult.Type.NOTFOUND;
        return result;
    }

    /**
     * Returns the result of permission check. Including inheritance. If found
     * anything, the PermissionCheckResult that retuns will include the Group
     * name, and the result type. Result types will be EXCEPTION, NEGATION,
     * FOUND.
     *
     * If returned type NOTFOUND, the owner will be null, and ownerType too.
     *
     * It does Breadth-first search
     *
     * @param start
     * @param targetPermission
     * @return PermissionCheckResult
     */
    public PermissionCheckResult checkGroupPermissionWithInheritance(final Group start, final String targetPermission) {

        if (start == null || targetPermission == null) {
            return null;
        }

        final LinkedList<Group> stack = new LinkedList<Group>();
        final List<Group> alreadyVisited = new ArrayList<Group>();
        PermissionCheckResult result = new PermissionCheckResult();

        stack.push(start);
        alreadyVisited.add(start);

        // Set defaults.
        result.askedPermission = targetPermission;
        result.resultType = PermissionCheckResult.Type.NOTFOUND;

        while (!stack.isEmpty()) {
            final Group now = stack.pop();
            final PermissionCheckResult resultNow = checkGroupOnlyPermission(now, targetPermission);

            if (!resultNow.resultType.equals(PermissionCheckResult.Type.NOTFOUND)) {

                if (resultNow.resultType.equals(PermissionCheckResult.Type.EXCEPTION)) {
                    resultNow.accessLevel = targetPermission;
                    return resultNow;
                }

                // Negation found so store for later
                // as we need to continue looking for an Exception.
                result = resultNow;
            }

            for (final String sonName : now.getInherits()) {
                final Group son = ph.getGroup(sonName);
                if (son != null && !alreadyVisited.contains(son)) {
                    // Add rather than push to retain inheritance order.
                    stack.add(son);
                    alreadyVisited.add(son);
                }
            }
        }

        return result;
    }

    /**
     * Does not include User's group permission
     *
     * @param user
     * @param permission
     * @return PermissionCheckResult
     */
    public PermissionCheckResult checkUserOnlyPermission(final User user, final String permission) {

        user.sortPermissions();
        final PermissionCheckResult result = new PermissionCheckResult();
        result.askedPermission = permission;
        result.owner = user;
        for (final String access : user.getPermissionList()) {
            result.resultType = comparePermissionString(access, permission);
            if (result.resultType != PermissionCheckResult.Type.NOTFOUND) {
                result.accessLevel = access;
                return result;
            }
        }
        result.resultType = PermissionCheckResult.Type.NOTFOUND;
        return result;
    }

    /**
     * Check permissions, including it's group and inheritance.
     *
     * @param user
     * @param permission
     * @return true if permission was found. false if not, or was negated.
     */
    public boolean checkUserPermission(final User user, final String permission) {

        final PermissionCheckResult result = checkFullGMPermission(user, permission, true);
        if (result.resultType == PermissionCheckResult.Type.EXCEPTION || result.resultType == PermissionCheckResult.Type.FOUND) {
            return true;
        }

        return false;
    }

    /**
     * Compare a user permission like 'myplugin.*' against a full plugin
     * permission name, like 'myplugin.dosomething'. As the example above, will
     * return true.
     *
     * Please sort permissions before sending them here. So negative tokens get
     * priority.
     *
     * You must test if it start with negative outside this method. It will only
     * tell if the nodes are matching or not.
     *
     * Every '-' or '+' in the beginning is ignored. It will match only node
     * names.
     *
     * @param userAccessLevel
     * @param fullPermissionName
     * @return PermissionCheckResult.Type
     */
    public PermissionCheckResult.Type comparePermissionString(final String userAccessLevel, final String fullPermissionName) {

        int userAccessLevelLength;
        if (userAccessLevel == null || fullPermissionName == null || fullPermissionName.length() == 0 || (userAccessLevelLength = userAccessLevel.length()) == 0) {
            return PermissionCheckResult.Type.NOTFOUND;
        }

        PermissionCheckResult.Type result = PermissionCheckResult.Type.FOUND;
        int userAccessLevelOffset = 0;
        if (userAccessLevel.charAt(0) == '+') {
            userAccessLevelOffset = 1;
            result = PermissionCheckResult.Type.EXCEPTION;
        } else if (userAccessLevel.charAt(0) == '-') {
            userAccessLevelOffset = 1;
            result = PermissionCheckResult.Type.NEGATION;
        }

        if (fullPermissionName.equals(userAccessLevel)) {
            return result;
        }

        if ("groupmanager.noofflineperms".equals(fullPermissionName)) {
            result = PermissionCheckResult.Type.NOTFOUND;
        }

        if ("*".regionMatches(0, userAccessLevel, userAccessLevelOffset, userAccessLevelLength - userAccessLevelOffset)) {
            return result;
        }
        int fullPermissionNameOffset;
        if (fullPermissionName.charAt(0) == '+' || fullPermissionName.charAt(0) == '-') {
            fullPermissionNameOffset = 1;
        } else {
            fullPermissionNameOffset = 0;
        }

        if (userAccessLevel.charAt(userAccessLevel.length() - 1) == '*') {
            return userAccessLevel.regionMatches(true, userAccessLevelOffset, fullPermissionName, fullPermissionNameOffset, userAccessLevelLength - userAccessLevelOffset - 1) ? result : PermissionCheckResult.Type.NOTFOUND;
        }
        return userAccessLevel.regionMatches(true,
                userAccessLevelOffset,
                fullPermissionName,
                fullPermissionNameOffset,
                Math.max(userAccessLevelLength - userAccessLevelOffset, fullPermissionName.length() - fullPermissionNameOffset)) ? result : PermissionCheckResult.Type.NOTFOUND;
    }

    /**
     * Returns All permissions (including inheritance and sub groups) for the
     * player, including child nodes from Bukkit.
     *
     * @param userName
     * @return List<String> of all players permissions.
     */
    @Override
    public List<String> getAllPlayersPermissions(final String userName) {

        final List<String> perms = new ArrayList<String>();

        perms.addAll(getAllPlayersPermissions(userName, true));

        return perms;
    }

    /**
     * Returns All permissions (including inheritance and sub groups) for the
     * player. With or without Bukkit child nodes.
     *
     * @param userName
     * @return Set<String> of all players permissions.
     */
    @Override
    public Set<String> getAllPlayersPermissions(final String userName, final Boolean includeChildren) {

        final Set<String> playerPermArray = new LinkedHashSet<String>();
        final Set<String> overrides = new LinkedHashSet<String>();

        // Add the players own permissions.
        playerPermArray.addAll(populatePerms(ph.getUser(userName).getPermissionList(), includeChildren));

        final ArrayList<String> alreadyProcessed = new ArrayList<String>();

        // fetch all group permissions
        for (final String group : getGroups(userName)) {
            // Don't process a group more than once.
            if (!alreadyProcessed.contains(group)) {
                alreadyProcessed.add(group);

                Set<String> groupPermArray = new LinkedHashSet<String>();

                if (group.startsWith("g:") && GroupManager.getGlobalGroups().hasGroup(group)) {
                    // GlobalGroups
                    groupPermArray = populatePerms(GroupManager.getGlobalGroups().getGroupsPermissions(group), includeChildren);

                } else {
                    // World Groups
                    groupPermArray = populatePerms(ph.getGroup(group).getPermissionList(), includeChildren);
                }

                // Add all group permissions, unless negated by earlier permissions.
                for (final String perm : groupPermArray) {
                    final boolean negated = (perm.startsWith("-"));

                    // Overridden (Exception) permission defeats negation.
                    if (perm.startsWith("+")) {
                        overrides.add(perm.substring(1));
                        continue;
                    }

                    // Perm doesn't already exists and there is no negation for it
                    // or It's a negated perm where a normal perm doesn't exists (don't allow inheritance to negate higher perms)
                    if ((!negated && !playerPermArray.contains(perm) && !wildcardNegation(playerPermArray, perm))
                            || (negated && !playerPermArray.contains(perm.substring(1)) && !wildcardNegation(playerPermArray, perm.substring(1))))
                        playerPermArray.add(perm);

                }
            }

        }

        // Process overridden permissions

        final Iterator<String> itr = overrides.iterator();

        while (itr.hasNext()) {

            final String node = itr.next();

            if (playerPermArray.contains("-" + node)) {
                playerPermArray.remove("-" + node);
            }

            playerPermArray.add(node);

        }

        // Collections.sort(playerPermArray, StringPermissionComparator.getInstance());

        return playerPermArray;
    }

    @Override
    public Group getDefaultGroup() {

        return ph.getDefaultGroup();
    }

    /**
     * Returns the name of the group of that player name.
     *
     * @param userName
     * @return String of players group name.
     */
    @Override
    public String getGroup(final String userName) {

        return ph.getUser(userName).getGroup().getName();
    }

    /**
     * Returns a boolean for given variable in INFO node. It will harvest
     * inheritance for value.
     *
     * @param group
     * @param variable
     * @return false if not found/not parseable.
     */
    @Override
    public boolean getGroupPermissionBoolean(final String group, final String variable) {

        final Group start = ph.getGroup(group);
        if (start == null) {
            return false;
        }
        final Group result = nextGroupWithVariable(start, variable);
        if (result == null) {
            return false;
        }
        return result.getVariables().getVarBoolean(variable);
    }

    /**
     * Returns a double value for the given variable name in INFO node. It will
     * harvest inheritance for value.
     *
     * @param group
     * @param variable
     * @return -1 if not found / not parseable.
     */
    @Override
    public double getGroupPermissionDouble(final String group, final String variable) {

        final Group start = ph.getGroup(group);
        if (start == null) {
            return -1;
        }
        final Group result = nextGroupWithVariable(start, variable);
        if (result == null) {
            return -1;
        }
        return result.getVariables().getVarDouble(variable);
    }

    /**
     * It returns a Integer variable value It will harvest inheritance for
     * value.
     *
     * @param groupName
     * @param variable
     * @return -1 if none found or not parseable.
     */
    @Override
    public int getGroupPermissionInteger(final String groupName, final String variable) {

        final Group start = ph.getGroup(groupName);
        if (start == null) {
            return -1;
        }
        final Group result = nextGroupWithVariable(start, variable);
        if (result == null) {
            return -1;
        }
        return result.getVariables().getVarInteger(variable);
    }

    /**
     * It returns a string variable value, set in the INFO node of the group. It
     * will harvest inheritance for value.
     *
     * @param groupName
     * @param variable
     * @return null if no group with that variable is found.
     */
    @Override
    public String getGroupPermissionString(final String groupName, final String variable) {

        final Group start = ph.getGroup(groupName);
        if (start == null) {
            return null;
        }
        final Group result = nextGroupWithVariable(start, variable);
        if (result == null) {
            return null;
        }
        return result.getVariables().getVarString(variable);
    }

    /**
     * Returns the String prefix for the given group
     *
     * @param groupName
     * @return empty string if found none.
     */
    @Override
    public String getGroupPrefix(final String groupName) {

        final Group g = ph.getGroup(groupName);
        if (g == null) {
            return "";
        }
        return g.getVariables().getVarString("prefix");
    }

    /**
     * Returns a list of all groups.
     *
     * Including subgroups.
     *
     * @param userName
     * @return String[] of all group names.
     */
    @Override
    public String[] getGroups(final String userName) {

        final ArrayList<String> allGroups = listAllGroupsInherited(ph.getUser(userName).getGroup());
        for (final Group subg : ph.getUser(userName).subGroupListCopy()) {
            allGroups.addAll(listAllGroupsInherited(subg));
        }

        final String[] arr = new String[allGroups.size()];
        return allGroups.toArray(arr);
    }

    /**
     * Return the suffix for the given group name
     *
     * @param groupName
     * @return empty string if not found.
     */
    @Override
    public String getGroupSuffix(final String groupName) {

        final Group g = ph.getGroup(groupName);
        if (g == null) {
            return "";
        }
        return g.getVariables().getVarString("suffix");
    }

    @Override
    public boolean getInfoBoolean(final String entryName, final String path, final boolean isGroup) {
        if (isGroup) {
            final Group data = ph.getGroup(entryName);
            if (data == null) {
                return false;
            }
            return data.getVariables().getVarBoolean(path);
        }
        final User data = ph.getUser(entryName);
        if (data == null) {
            return false;
        }
        return data.getVariables().getVarBoolean(path);
    }

    @Override
    public double getInfoDouble(final String entryName, final String path, final boolean isGroup) {
        if (isGroup) {
            final Group data = ph.getGroup(entryName);
            if (data == null) {
                return -1;
            }
            return data.getVariables().getVarDouble(path);
        }
        final User data = ph.getUser(entryName);
        if (data == null) {
            return -1;
        }
        return data.getVariables().getVarDouble(path);

    }

    @Override
    public int getInfoInteger(final String entryName, final String path, final boolean isGroup) {

        if (isGroup) {
            final Group data = ph.getGroup(entryName);
            if (data == null) {
                return -1;
            }
            return data.getVariables().getVarInteger(path);
        }
        final User data = ph.getUser(entryName);
        if (data == null) {
            return -1;
        }
        return data.getVariables().getVarInteger(path);
    }

    @Override
    public String getInfoString(final String entryName, final String path, final boolean isGroup) {

        if (isGroup) {
            final Group data = ph.getGroup(entryName);
            if (data == null) {
                return null;
            }
            return data.getVariables().getVarString(path);
        }
        final User data = ph.getUser(entryName);
        if (data == null) {
            return null;
        }
        return data.getVariables().getVarString(path);
    }

    /**
     * Returns the variable value of the user, in INFO node. If not found, it
     * will search for his Group variables. It will harvest the inheritance and
     * subgroups.
     *
     * @param user
     * @param variable
     * @return false if not found or not parseable to true.
     */
    @Override
    public boolean getPermissionBoolean(final String user, final String variable) {

        final User auser = ph.getUser(user);
        if (auser == null) {
            return false;
        }
        if (auser.getVariables().hasVar(variable)) {
            return auser.getVariables().getVarBoolean(variable);
        }
        final Group start = auser.getGroup();
        if (start == null) {
            return false;
        }
        Group result = nextGroupWithVariable(start, variable);
        if (result == null) {
            // Check sub groups
            if (!auser.isSubGroupsEmpty())
                for (final Group subGroup : auser.subGroupListCopy()) {
                    result = nextGroupWithVariable(subGroup, variable);
                    // Found value?
                    if (result != null)
                        continue;
                }
            if (result == null)
                return false;
        }
        return result.getVariables().getVarBoolean(variable);
        // return getUserPermissionBoolean(user, string1);
    }

    /**
     * Returns the variable value of the user, in INFO node. If not found, it
     * will search for his Group variables. It will harvest the inheritance and
     * subgroups.
     *
     * @param user
     * @param variable
     * @return -1 if not found.
     */
    @Override
    public double getPermissionDouble(final String user, final String variable) {

        final User auser = ph.getUser(user);
        if (auser == null) {
            return -1.0D;
        }
        if (auser.getVariables().hasVar(variable)) {
            return auser.getVariables().getVarDouble(variable);
        }
        final Group start = auser.getGroup();
        if (start == null) {
            return -1.0D;
        }
        Group result = nextGroupWithVariable(start, variable);
        if (result == null) {
            // Check sub groups
            if (!auser.isSubGroupsEmpty())
                for (final Group subGroup : auser.subGroupListCopy()) {
                    result = nextGroupWithVariable(subGroup, variable);
                    // Found value?
                    if (result != null)
                        continue;
                }
            if (result == null)
                return -1.0D;
        }
        return result.getVariables().getVarDouble(variable);
        // return getUserPermissionDouble(string, string1);
    }

    /**
     * Returns the variable value of the user, in INFO node. If not found, it
     * will search for his Group variables. It will harvest the inheritance and
     * subgroups.
     *
     * @param user
     * @param variable
     * @return -1 if not found
     */
    @Override
    public int getPermissionInteger(final String user, final String variable) {

        final User auser = ph.getUser(user);
        if (auser == null) {
            return -1;
        }
        if (auser.getVariables().hasVar(variable)) {
            return auser.getVariables().getVarInteger(variable);
        }
        final Group start = auser.getGroup();
        if (start == null) {
            return -1;
        }
        Group result = nextGroupWithVariable(start, variable);
        if (result == null) {
            // Check sub groups
            if (!auser.isSubGroupsEmpty())
                for (final Group subGroup : auser.subGroupListCopy()) {
                    result = nextGroupWithVariable(subGroup, variable);
                    // Found value?
                    if (result != null)
                        continue;
                }
            if (result == null)
                return -1;
        }
        return result.getVariables().getVarInteger(variable);
        // return getUserPermissionInteger(string, string1);
    }

    /**
     * Returns the variable value of the user, in INFO node. If not found, it
     * will search for his Group variables. It will harvest the inheritance and
     * subgroups.
     *
     * @param user
     * @param variable
     * @return empty string if not found
     */
    @Override
    public String getPermissionString(final String user, final String variable) {

        final User auser = ph.getUser(user);
        if (auser == null) {
            return "";
        }
        if (auser.getVariables().hasVar(variable)) {
            return auser.getVariables().getVarString(variable);
        }
        final Group start = auser.getGroup();
        if (start == null) {
            return "";
        }
        Group result = nextGroupWithVariable(start, variable);
        if (result == null) {
            // Check sub groups
            if (!auser.isSubGroupsEmpty())
                for (final Group subGroup : auser.subGroupListCopy()) {
                    result = nextGroupWithVariable(subGroup, variable);
                    // Found value?
                    if (result != null)
                        continue;
                }
            if (result == null)
                return "";
        }
        return result.getVariables().getVarString(variable);
        // return getUserPermissionString(user, variable);
    }

    /**
     * Gets name of the primary group of the user. Returns the name of the
     * default group if user has no parent groups, or "Default" if there is no
     * default group for that world.
     *
     * @param user
     *            Player's name
     * @return Name of player's primary group
     */
    public String getPrimaryGroup(final String user) {

        return getGroup(user);

    }

    /**
     * Returns the variable value of the user, in INFO node.
     *
     * @param user
     * @param variable
     * @return boolean value
     */
    @Override
    public boolean getUserPermissionBoolean(final String user, final String variable) {

        final User auser = ph.getUser(user);
        if (auser == null) {
            return false;
        }
        return auser.getVariables().getVarBoolean(variable);
    }

    /**
     * Returns the variable value of the user, in INFO node.
     *
     * @param user
     * @param variable
     * @return -1 if not found
     */
    @Override
    public double getUserPermissionDouble(final String user, final String variable) {

        final User auser = ph.getUser(user);
        if (auser == null) {
            return -1;
        }
        return auser.getVariables().getVarDouble(variable);
    }

    /**
     * Returns the variable value of the user, in INFO node.
     *
     * @param user
     * @param variable
     * @return -1 if not found
     */
    @Override
    public int getUserPermissionInteger(final String user, final String variable) {

        final User auser = ph.getUser(user);
        if (auser == null) {
            return -1;
        }
        return auser.getVariables().getVarInteger(variable);
    }

    /**
     * Returns the variable value of the user, in INFO node.
     *
     * @param user
     * @param variable
     * @return empty string if not found
     */
    @Override
    public String getUserPermissionString(final String user, final String variable) {

        final User auser = ph.getUser(user);
        if (auser == null) {
            return "";
        }
        return auser.getVariables().getVarString(variable);
    }

    /**
     * Gets the appropriate prefix for the user. This method is a utility method
     * for chat plugins to get the user's prefix without having to look at every
     * one of the user's ancestors. Returns an empty string if user has no
     * parent groups.
     *
     * @param user
     *            Player's name
     * @return Player's prefix
     */
    @Override
    public String getUserPrefix(final String user) {

        final String prefix = ph.getUser(user).getVariables().getVarString("prefix");
        if (prefix.length() != 0) {
            return prefix;
        }

        return getGroupPrefix(getGroup(user));
    }

    /**
     * Gets the appropriate prefix for the user. This method is a utility method
     * for chat plugins to get the user's prefix without having to look at every
     * one of the user's ancestors. Returns an empty string if user has no
     * parent groups.
     *
     * @param user
     *            Player's name
     * @return Player's prefix
     */
    @Override
    public String getUserSuffix(final String user) {

        final String suffix = ph.getUser(user).getVariables().getVarString("suffix");
        if (suffix.length() != 0) {
            return suffix;
        }

        return getGroupSuffix(getGroup(user));

    }

    /**
     * A short name method, for permission method.
     *
     * @param player
     * @param permission
     * @return true if the player has the permission
     */
    @Override
    public boolean has(final Player player, final String permission) {

        return permission(player, permission);
    }

    /**
     * Check if given group inherits another group.
     *
     * It does Breadth-first search
     *
     * @param start
     *            The group to start the search.
     * @param askedGroup
     *            Name of the group you're looking for
     * @return true if it inherits the group.
     */
    public boolean hasGroupInInheritance(final Group start, final String askedGroup) {

        if (start == null || askedGroup == null) {
            return false;
        }
        final LinkedList<Group> stack = new LinkedList<Group>();
        final ArrayList<Group> alreadyVisited = new ArrayList<Group>();
        stack.push(start);
        alreadyVisited.add(start);
        while (!stack.isEmpty()) {
            final Group now = stack.pop();
            if (now.getName().equalsIgnoreCase(askedGroup)) {
                return true;
            }
            for (final String sonName : now.getInherits()) {
                final Group son = ph.getGroup(sonName);
                if (son != null && !alreadyVisited.contains(son)) {
                    stack.push(son);
                    alreadyVisited.add(son);
                }
            }
        }
        return false;
    }

    /**
     * Verify if player is in such group. It will check it's groups inheritance.
     *
     * So if you have a group Admin > Moderator
     *
     * And verify the player 'MyAdmin', which is Admin, it will return true for
     * both Admin or Moderator groups.
     *
     * If you have a player 'MyModerator', which is Moderator, it will give
     * false if you pass Admin in group parameter.
     *
     * @param name
     * @param group
     * @return true if in group (with inheritance)
     */
    @Override
    public boolean inGroup(final String name, final String group) {

        if (hasGroupInInheritance(ph.getUser(name).getGroup(), group)) {
            return true;
        }
        for (final Group subGroup : ph.getUser(name).subGroupListCopy()) {
            if (hasGroupInInheritance(subGroup, group)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Return whole list of names of groups in a inheritance chain. Including a
     * starting group.
     *
     * It does Breadth-first search. So closer groups will appear first in list.
     *
     * @param start
     * @return the group that passed on test. null if no group passed.
     */
    public ArrayList<String> listAllGroupsInherited(final Group start) {

        if (start == null) {
            return null;
        }
        final LinkedList<Group> stack = new LinkedList<Group>();
        final ArrayList<String> alreadyVisited = new ArrayList<String>();
        stack.push(start);
        alreadyVisited.add(start.getName());
        while (!stack.isEmpty()) {
            final Group now = stack.pop();
            for (final String sonName : now.getInherits()) {
                final Group son = ph.getGroup(sonName);
                if (son != null && !alreadyVisited.contains(son.getName())) {
                    stack.push(son);
                    alreadyVisited.add(son.getName());
                }
            }
        }
        return alreadyVisited;
    }

    /**
     * Returns the next group, including inheritance, which contains that
     * variable name.
     *
     * It does Breadth-first search
     *
     * @param start
     *            the starting group to look for
     * @param targetVariable
     *            the variable name
     * @return The group if found. Null if not.
     */
    public Group nextGroupWithVariable(final Group start, final String targetVariable) {

        if (start == null || targetVariable == null) {
            return null;
        }
        final LinkedList<Group> stack = new LinkedList<Group>();
        final ArrayList<Group> alreadyVisited = new ArrayList<Group>();
        stack.push(start);
        alreadyVisited.add(start);
        while (!stack.isEmpty()) {
            final Group now = stack.pop();
            if (now.getVariables().hasVar(targetVariable)) {
                return now;
            }
            for (final String sonName : now.getInherits()) {
                final Group son = ph.getGroup(sonName);
                if (son != null && !alreadyVisited.contains(son)) {
                    stack.push(son);
                    alreadyVisited.add(son);
                }
            }
        }
        return null;
    }

    /**
     * Checks if a player can use that permission node.
     *
     * @param player
     * @param permission
     * @return true if the player has the permission
     */
    @Override
    public boolean permission(final Player player, final String permission) {

        return checkUserPermission(ph.getUser(player.getName()).updatePlayer(player), permission);
    }

    /**
     * Checks if a player can use that permission node.
     *
     * @param playerName
     * @param permission
     * @return true if the player has the permission
     */
    public boolean permission(final String playerName, final String permission) {

        return checkUserPermission(ph.getUser(playerName), permission);
    }

    @Override
    public void removeGroupInfo(final String name, final String path) {

        ph.getGroup(name).getVariables().removeVar(path);
    }

    @Override
    public void removeUserInfo(final String name, final String path) {

        ph.getUser(name).getVariables().removeVar(path);
    }

    /**
     * A Breadth-first search thru inheritance model.
     *
     * Just a model to copy and paste. This will guarantee the closer groups
     * will be checked first.
     *
     * @param start
     * @param targerPermission
     * @return
     */
    @SuppressWarnings("unused")
    private Group breadthFirstSearch(final Group start, final String targerPermission) {

        if (start == null || targerPermission == null) {
            return null;
        }
        final LinkedList<Group> stack = new LinkedList<Group>();
        final ArrayList<Group> alreadyVisited = new ArrayList<Group>();
        stack.push(start);
        alreadyVisited.add(start);
        while (!stack.isEmpty()) {
            final Group now = stack.pop();
            final PermissionCheckResult resultNow = checkGroupOnlyPermission(now, targerPermission);
            if (resultNow.resultType.equals(PermissionCheckResult.Type.EXCEPTION) || resultNow.resultType.equals(PermissionCheckResult.Type.FOUND)) {
                return now;
            }
            if (resultNow.resultType.equals(PermissionCheckResult.Type.NEGATION)) {
                return null;
            }
            for (final String sonName : now.getInherits()) {
                final Group son = ph.getGroup(sonName);
                if (son != null && !alreadyVisited.contains(son)) {
                    stack.push(son);
                    alreadyVisited.add(son);
                }
            }
        }
        return null;
    }

    /**
     *
     * Check user and groups with inheritance and Bukkit if bukkit = true return
     * a PermissionCheckResult.
     *
     * @param user
     * @param targetPermission
     * @param checkBukkit
     * @return PermissionCheckResult
     */
    private PermissionCheckResult checkPermission(final User user, final String targetPermission, final Boolean checkBukkit) {

        PermissionCheckResult result = new PermissionCheckResult();
        result.accessLevel = targetPermission;
        result.resultType = PermissionCheckResult.Type.NOTFOUND;

        if (checkBukkit) {
            // Check Bukkit perms to support plugins which add perms via code
            // (Heroes).
            final Player player = user.getBukkitPlayer();
            // final Permission bukkitPerm = Bukkit.getPluginManager().getPermission(targetPermission);
            if ((player != null) && player.hasPermission(targetPermission)) {
                result.resultType = PermissionCheckResult.Type.FOUND;
                result.owner = user;
                return result;
            }
        }

        final PermissionCheckResult resultUser = checkUserOnlyPermission(user, targetPermission);
        if (resultUser.resultType != PermissionCheckResult.Type.NOTFOUND) {

            resultUser.accessLevel = targetPermission;

            if (resultUser.resultType == PermissionCheckResult.Type.EXCEPTION) {
                return resultUser;
            }

            result = resultUser;

        }

        // IT ONLY CHECKS GROUPS PERMISSIONS IF RESULT FOR USER IS NOT AN EXCEPTION
        final PermissionCheckResult resultGroup = checkGroupPermissionWithInheritance(user.getGroup(), targetPermission);
        if (resultGroup.resultType != PermissionCheckResult.Type.NOTFOUND) {

            resultGroup.accessLevel = targetPermission;

            if (resultGroup.resultType == PermissionCheckResult.Type.EXCEPTION) {
                return resultGroup;
            }

            // Do not override higher level permissions with negations.
            if (result.resultType == PermissionCheckResult.Type.NOTFOUND) {
                result = resultGroup;
            }

        }

        // Do we have a high level negation?
        final boolean negated = (result.resultType == PermissionCheckResult.Type.NEGATION);

        // SUBGROUPS CHECK
        for (final Group subGroup : user.subGroupListCopy()) {

            final PermissionCheckResult resultSubGroup = checkGroupPermissionWithInheritance(subGroup, targetPermission);
            if (resultSubGroup.resultType != PermissionCheckResult.Type.NOTFOUND) {

                resultSubGroup.accessLevel = targetPermission;

                // Allow exceptions to override higher level negations
                // but low level negations can not remove higher level permissions.
                if (resultSubGroup.resultType == PermissionCheckResult.Type.EXCEPTION) {

                    return resultSubGroup;

                } else if ((resultSubGroup.resultType == PermissionCheckResult.Type.FOUND) && (result.resultType != PermissionCheckResult.Type.NEGATION) && !negated) {

                    result = resultSubGroup;

                } else if ((resultSubGroup.resultType == PermissionCheckResult.Type.NEGATION) && !negated) {

                    result = resultSubGroup;
                }

            }
        }

        // THEN IT RETURNS A NOT FOUND
        // OR THE RESULT OF THE SUBGROUP SEARCH.
        return result;
    }

    private Set<String> populatePerms(final List<String> permsList, final boolean includeChildren) {

        // Create a new array so it's modifiable.
        final List<String> perms = new ArrayList<String>(permsList);
        final Set<String> permArray = new LinkedHashSet<String>();
        Boolean allPerms = false;

        // Allow * node to populate ALL permissions to Bukkit.
        if (perms.contains("*")) {
            permArray.addAll(GroupManager.BukkitPermissions.getAllRegisteredPermissions(includeChildren));
            allPerms = true;
            perms.remove("*");
            // Remove the no offline perms node as this should not be given.
            perms.remove("groupmanager.noofflineperms");
        }

        for (final String perm : perms) {
            /**
             * all permission sets are passed here pre-sorted, alphabetically.
             * This means negated nodes will be processed before all permissions
             * other than *.
             */
            final boolean negated = perm.startsWith("-");

            if (!permArray.contains(perm)) {
                permArray.add(perm);

                if ((negated) && (permArray.contains(perm.substring(1))))
                    permArray.remove(perm.substring(1));

                /**
                 * Process child nodes if required,
                 * or this is a negated node AND we used * to include all
                 * permissions,
                 * in which case we need to remove all children of that node.
                 */
                if ((includeChildren) || (negated && allPerms)) {

                    final Map<String, Boolean> children = GroupManager.BukkitPermissions.getAllChildren((negated ? perm.substring(1) : perm), new LinkedHashSet<String>());

                    if (children != null) {
                        if (negated)
                            if (allPerms) {

                                // Remove children of negated nodes
                                for (final String child : children.keySet())
                                    if (children.get(child))
                                        if (permArray.contains(child))
                                            permArray.remove(child);

                            } else {

                                // Add child nodes
                                for (final String child : children.keySet())
                                    if (children.get(child))
                                        if ((!permArray.contains(child)) && (!permArray.contains("-" + child)))
                                            permArray.add(child);
                            }
                    }
                }
            }
        }

        return permArray;
    }

    /**
     * Is there a direct or wildcard negation in the list which covers this permission node.
     *
     * @param playerPermArray
     * @param node
     * @return
     */
    private boolean wildcardNegation(final Set<String> playerPermArray, final String node) {

        /*
         * Check for a negated parent with a wildcard or negated permission
         */

        if (playerPermArray.contains("-" + node))
            return true;

        final String[] parts = node.split("\\.");
        final StringBuilder builder = new StringBuilder(node.length());
        for (final String part : parts) {
            builder.append('*');
            if (playerPermArray.contains("-" + builder.toString())) {
                GroupManager.logger.fine("Wildcard Negation found for " + node);
                return true;
            }

            builder.deleteCharAt(builder.length() - 1);
            builder.append(part).append('.');
        }

        /*
         * No negated parent found so return false.
         */
        GroupManager.logger.fine("No Negation found for " + node);
        return false;

    }
}