LWCPlayer.java

/*
 * Copyright 2011 Tyler Blair. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 *    1. Redistributions of source code must retain the above copyright notice, this list of
 *       conditions and the following disclaimer.
 *
 *    2. Redistributions in binary form must reproduce the above copyright notice, this list
 *       of conditions and the following disclaimer in the documentation and/or other materials
 *       provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are those of the
 * authors and contributors and should not be interpreted as representing official policies,
 * either expressed or implied, of anybody else.
 */

package com.griefcraft.model;

import com.griefcraft.lwc.LWC;
import com.griefcraft.modules.history.HistoryModule;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.permissions.Permission;
import org.bukkit.permissions.PermissionAttachment;
import org.bukkit.permissions.PermissionAttachmentInfo;
import org.bukkit.plugin.Plugin;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

public class LWCPlayer implements CommandSender {

    /**
     * The LWC instance
     */
    private LWC lwc;

    /**
     * The player instance
     */
    private Player player;

    /**
     * Cache of LWCPlayer objects
     */
    private final static Map<Player, LWCPlayer> playerCache = new HashMap<Player, LWCPlayer>();

    /**
     * The map of actions the player has
     */
    private final Map<String, Action> actions = new HashMap<String, Action>();

    /**
     * The set of modes the player has
     */
    private final Set<Mode> modes = new HashSet<Mode>();

    /**
     * The set of protections the player can access
     */
    private final Set<Protection> accessibleProtections = new HashSet<Protection>();

    public LWCPlayer(LWC lwc, Player player) {
        this.lwc = lwc;
        this.player = player;
    }

    /**
     * Get the LWCPlayer object from a Player object
     *
     * @param player
     * @return
     */
    public static LWCPlayer getPlayer(Player player) {
        if (!playerCache.containsKey(player)) {
            playerCache.put(player, new LWCPlayer(LWC.getInstance(), player));
        }

        return playerCache.get(player);
    }

    /**
     * Remove a player from the player cache
     *
     * @param player
     */
    public static void removePlayer(Player player) {
        getPlayer(player);

        // uncache them
        playerCache.remove(player);
    }

    /**
     * @return the Bukkit Player object
     */
    public Player getBukkitPlayer() {
        return player;
    }

    /**
     * Get the player's UUID
     *
     * @return player's UUID
     */
    public UUID getUniqueId() {
        return player.getUniqueId();
    }

    /**
     * @return the player's name
     */
    public String getName() {
        return player.getName();
    }

    /**
     * Enable a mode on the player
     *
     * @param mode
     * @return
     */
    public boolean enableMode(Mode mode) {
        return modes.add(mode);
    }

    /**
     * Disable a mode on the player
     *
     * @param mode
     * @return
     */
    public boolean disableMode(Mode mode) {
        return modes.remove(mode);
    }

    /**
     * Disable all modes enabled by the player
     *
     * @return
     */
    public void disableAllModes() {
        modes.clear();
    }

    /**
     * Check if the player has an action
     *
     * @param name
     * @return
     */
    public boolean hasAction(String name) {
        return actions.containsKey(name);
    }

    /**
     * Get the action represented by the name
     *
     * @param name
     * @return
     */
    public Action getAction(String name) {
        return actions.get(name);
    }

    /**
     * Add an action
     *
     * @param action
     * @return
     */
    public boolean addAction(Action action) {
        actions.put(action.getName(), action);
        return true;
    }

    /**
     * Remove an action
     *
     * @param action
     * @return
     */
    public boolean removeAction(Action action) {
        actions.remove(action.getName());
        return true;
    }

    /**
     * Remove all actions
     */
    public void removeAllActions() {
        actions.clear();
    }

    /**
     * Retrieve a Mode object for a player
     *
     * @param name
     * @return
     */
    public Mode getMode(String name) {
        for (Mode mode : modes) {
            if (mode.getName().equals(name)) {
                return mode;
            }
        }

        return null;
    }

    /**
     * Check if the player has the given mode
     *
     * @param name
     * @return
     */
    public boolean hasMode(String name) {
        return getMode(name) != null;
    }

    /**
     * @return the Set of modes the player has activated
     */
    public Set<Mode> getModes() {
        return new HashSet<Mode>(modes);
    }

    /**
     * @return the Set of actions the player has
     */
    public Map<String, Action> getActions() {
        return new HashMap<String, Action>(actions);
    }

    /**
     * @return a Set containing all of the action names
     */
    public Set<String> getActionNames() {
        return new HashSet<String>(actions.keySet());
    }

    /**
     * @return the set of protections the player can temporarily access
     */
    public Set<Protection> getAccessibleProtections() {
        return new HashSet<Protection>(accessibleProtections);
    }

    /**
     * Add an accessible protection for the player
     *
     * @param protection
     * @return
     */
    public boolean addAccessibleProtection(Protection protection) {
        return accessibleProtections.add(protection);
    }

    /**
     * Remove an accessible protection from the player
     *
     * @param protection
     * @return
     */
    public boolean removeAccessibleProtection(Protection protection) {
        return accessibleProtections.remove(protection);
    }

    /**
     * Remove all accessible protections
     */
    public void removeAllAccessibleProtections() {
        accessibleProtections.clear();
    }

    /**
     * Create a History object that is attached to this protection
     *
     * @return
     */
    public History createHistoryObject() {
        History history = new History();

        history.setPlayer(player.getName());
        history.setStatus(History.Status.INACTIVE);

        return history;
    }

    /**
     * Send a locale to the player
     *
     * @param key
     * @param args
     */
    public void sendLocale(String key, Object... args) {
        lwc.sendLocale(player, key, args);
    }

    /**
     * Get the player's history
     *
     * @return
     */
    public List<History> getRelatedHistory() {
        return lwc.getPhysicalDatabase().loadHistory(player);
    }

    /**
     * Get the player's history for a given page
     *
     * @param page
     * @return
     */
    public List<History> getRelatedHistory(int page) {
        return lwc.getPhysicalDatabase().loadHistory(player, (page - 1) * HistoryModule.ITEMS_PER_PAGE, HistoryModule.ITEMS_PER_PAGE);
    }

    /**
     * Get the player's history pertaining to the type
     *
     * @param type
     * @return
     */
    public List<History> getRelatedHistory(History.Type type) {
        List<History> related = new ArrayList<History>();

        for (History history : getRelatedHistory()) {
            if (history.getType() == type) {
                related.add(history);
            }
        }

        return related;
    }

    public void sendMessage(String s) {
        player.sendMessage(s);
    }

    public void sendMessage(String[] s) {
        for (String _s : s) {
            sendMessage(_s);
        }
    }

    public Server getServer() {
        return player.getServer();
    }

    public boolean isPermissionSet(String s) {
        return player.isPermissionSet(s);
    }

    public boolean isPermissionSet(Permission permission) {
        return player.isPermissionSet(permission);
    }

    public boolean hasPermission(String s) {
        return player.hasPermission(s);
    }

    public boolean hasPermission(Permission permission) {
        return player.hasPermission(permission);
    }

    public PermissionAttachment addAttachment(Plugin plugin, String s, boolean b) {
        return player.addAttachment(plugin, s, b);
    }

    public PermissionAttachment addAttachment(Plugin plugin) {
        return player.addAttachment(plugin);
    }

    public PermissionAttachment addAttachment(Plugin plugin, String s, boolean b, int i) {
        return player.addAttachment(plugin, s, b, i);
    }

    public PermissionAttachment addAttachment(Plugin plugin, int i) {
        return player.addAttachment(plugin, i);
    }

    public void removeAttachment(PermissionAttachment permissionAttachment) {
        player.removeAttachment(permissionAttachment);
    }

    public void recalculatePermissions() {
        player.recalculatePermissions();
    }

    public Set<PermissionAttachmentInfo> getEffectivePermissions() {
        return player.getEffectivePermissions();
    }

    public boolean isOp() {
        return player.isOp();
    }

    public void setOp(boolean b) {
        player.setOp(b);
    }
}