package net.aufdemrand.denizen.npc.traits;
import net.aufdemrand.denizen.events.bukkit.ScriptReloadEvent;
import net.aufdemrand.denizen.tags.BukkitTagContext;
import net.aufdemrand.denizen.utilities.DenizenAPI;
import net.aufdemrand.denizen.utilities.debugging.dB;
import net.aufdemrand.denizencore.scripts.ScriptRegistry;
import net.aufdemrand.denizencore.tags.TagManager;
import net.aufdemrand.denizencore.utilities.CoreUtilities;
import net.aufdemrand.denizencore.utilities.text.StringHolder;
import net.citizensnpcs.api.command.exception.CommandException;
import net.citizensnpcs.api.persistence.Persist;
import net.citizensnpcs.api.trait.Trait;
import net.citizensnpcs.api.util.Paginator;
import net.citizensnpcs.util.Messages;
import org.bukkit.command.CommandSender;
import org.bukkit.event.EventHandler;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
public class ConstantsTrait extends Trait {
// Saved to C2 saves.yml
@Persist(value = "", collectionType = ConcurrentHashMap.class)
private Map<String, String> constants = new HashMap<String, String>();
// Used internally
private Map<String, String> assignmentConstants = new HashMap<String, String>();
private String assignment = null;
public ConstantsTrait() {
super("constants");
}
/**
* Returns the value of the specified Constant, unique to this NPC. Note:
* Returns tags filled with the currently assigned NPC. See: Denizen TagManager
*
* @param name name of constant, case in-sensitive
* @return value of the constant
*/
public String getConstant(String name) {
getAssignmentConstants();
if (constants.containsKey(CoreUtilities.toLowerCase(name))) // TODO: shouldDebug
{
return TagManager.tag(constants.get(CoreUtilities.toLowerCase(name)),
new BukkitTagContext(null, DenizenAPI.getDenizenNPC(npc), false, null, true, null));
}
else if (getAssignmentConstants().containsKey(CoreUtilities.toLowerCase(name))) {
return TagManager.tag(assignmentConstants.get(CoreUtilities.toLowerCase(name)),
new BukkitTagContext(null, DenizenAPI.getDenizenNPC(npc), false, null, true, null));
}
return null;
}
/**
* Gets a map of the NPCs constants. Note: Does not include any constants
* inherited by the NPCs Assignment. To grab a comprehensive map of both,
* use {@link #getAllConstants()}.
*
* @return a map of constants, keyed by constant name.
*/
public Map<String, String> getNPCConstants() {
return constants;
}
/**
* Gets a map of the NPCs constants, including those inherited by the Assignment.
* Any constants that are overridden by this NPC are taken into account, so this
* map may differ from the constants found in the Assignment. To get a map of
* constants from an Assignment, use {@link #getAssignmentConstants()}.
*
* @return a map of constants, keyed by constant name.
*/
public Map<String, String> getAllConstants() {
Map<String, String> allConstants = new HashMap<String, String>();
getAssignmentConstants().putAll(allConstants);
getNPCConstants().putAll(allConstants);
return allConstants;
}
/**
* Sets the value of a constant, as identified by the name. This will
* override any constants inherited from the NPCs Assignment.
*
* @param name name of the constant, case in-sensitive
* @param value value of the constant
*/
public void setConstant(String name, String value) {
constants.put(CoreUtilities.toLowerCase(name), value);
}
/**
* Removes an NPC-specific constant, as identified by the name. This will
* not remove any values inherited from an NPCs Assignment, only constants
* unique to this NPC.
*
* @param name name of the constant, case in-sensitive
*/
public void removeConstant(String name) {
if (constants.containsKey(CoreUtilities.toLowerCase(name))) {
constants.remove(CoreUtilities.toLowerCase(name));
}
}
/**
* Checks if this NPC has any unique constants, beyond what is inherited from
* the NPCs Assignment.
*
* @return true if NPC constants are present
*/
public boolean hasNPCConstants() {
return !constants.isEmpty();
}
public Map<String, String> getAssignmentConstants() {
// Check to make sure NPC has an assignment
if (npc.hasTrait(AssignmentTrait.class) && npc.getTrait(AssignmentTrait.class).hasAssignment()) {
// Check to make sure assignment hasn't changed.. if it has, the assignmentConstants map will be rebuilt
if (assignment != null && assignment.equalsIgnoreCase(npc.getTrait(AssignmentTrait.class).getAssignment().getName())) {
return assignmentConstants;
}
else {
return rebuildAssignmentConstants();
}
}
return assignmentConstants;
}
public Map<String, String> rebuildAssignmentConstants() {
// Builds a map of constants inherited from the NPCs current Assignment
if (!npc.hasTrait(AssignmentTrait.class) || !npc.getTrait(AssignmentTrait.class).hasAssignment()) {
assignmentConstants.clear();
return assignmentConstants;
}
if (npc.getTrait(AssignmentTrait.class).getAssignment() != null) {
assignment = npc.getTrait(AssignmentTrait.class).getAssignment().getName();
assignmentConstants.clear();
}
else {
return assignmentConstants;
}
try {
if (ScriptRegistry.getScriptContainer(assignment).contains("DEFAULT CONSTANTS")) {
for (StringHolder constant : ScriptRegistry.getScriptContainer(assignment)
.getConfigurationSection("DEFAULT CONSTANTS").getKeys(false)) {
assignmentConstants.put(CoreUtilities.toLowerCase(constant.str),
ScriptRegistry.getScriptContainer(assignment)
.getString("DEFAULT CONSTANTS." + constant.str.toUpperCase(), ""));
}
}
}
catch (NullPointerException e) {
dB.echoError("Constants in assignment script '" + npc.getTrait(AssignmentTrait.class)
.getAssignment().getName() + "' improperly defined, no constants will be set.");
}
return assignmentConstants;
}
/**
* Rebuilds assignment constants on a script reload
*/
@EventHandler
public void onScriptsReload(ScriptReloadEvent event) {
rebuildAssignmentConstants();
}
public void describe(CommandSender sender, int page) throws CommandException {
Paginator paginator = new Paginator().header("Constants for " + npc.getName());
paginator.addLine("<e>NPC-specific constants: " + (hasNPCConstants() ? "" : "None.") + "");
if (hasNPCConstants()) {
paginator.addLine("<e>Key: <a>Name <b>Value");
}
for (Entry<String, String> constant : constants.entrySet()) {
paginator.addLine("<a> " + String.valueOf(constant.getKey().charAt(0)).toUpperCase() + constant.getKey().substring(1) + "<b> " + constant.getValue());
}
paginator.addLine("");
if (npc.hasTrait(AssignmentTrait.class) && npc.getTrait(AssignmentTrait.class).hasAssignment()) {
getAssignmentConstants();
// List constants inherited from an Assignment.
paginator.addLine("<e>Constants for assignment '" + assignment.toUpperCase() + "':");
paginator.addLine("<e>Key: <a>Name <b>Value");
for (Entry<String, String> constant : getAssignmentConstants().entrySet()) {
// If a constant from the Assignment has been overridden by a NPC constant,
// change formatting to indicate so.
if (constants.containsKey(constant.getKey())) {
paginator.addLine("<m>" + String.valueOf(constant.getKey().charAt(0)).toUpperCase() + constant.getKey().substring(1) + "<r> <m>" + constant.getValue());
}
else {
paginator.addLine("<a>" + String.valueOf(constant.getKey().charAt(0)).toUpperCase() + constant.getKey().substring(1) + "<b> " + constant.getValue());
}
}
paginator.addLine("");
}
if (!paginator.sendPage(sender, page)) {
throw new CommandException(Messages.COMMAND_PAGE_MISSING, page);
}
}
}