/**
 * Set the value of a key to the specified value.
 *
 * @param key   The key to set the value of
 * @param value The value to set the value to
 * @param <C>   The type of value the key holds
 * @return Whether the value was accepted
 */
public <C> boolean offer(Key.User<C> key, C value) {
    if (!isCompatible(key)) {
        return false;
    }
    Cause cause = getPlayer().isPresent() ? Cause.builder().append(UltimateCore.getContainer()).append(getPlayer().get()).build(EventContext.builder().build()) : Cause.builder().append
            (UltimateCore.get()).append(getUser()).build(EventContext.builder().build());
    DataOfferEvent<C> event = new DataOfferEvent<>(key, (C) this.datas.get(key.getIdentifier()), value, cause);
    Sponge.getEventManager().post(event);
    if (event.isCancelled()) {
        return false;
    }
    value = event.getValue().orElse(null);
    //Save to config if needed
    if (key.getProvider().isPresent()) {
        key.getProvider().get().save(this, value);
    }
    //Save to map
    if (value == null) {
        this.datas.remove(key.getIdentifier());
    } else {
        this.datas.put(key.getIdentifier(), value);
    }

    return UltimateCore.get().getUserService().addToCache(this);
}
 

@GET
@Path("/mail/{player}")
@Permission({ "mail", "list" })
@ApiOperation(value = "List mail", notes = "Get a list of all mail messages of a player.")
public Collection<CachedMailMessage> listMail(
        @PathParam("player") @ApiParam("The uuid of the player") CachedPlayer player)
        throws NotFoundException {

    Optional<NucleusMailService> optSrv = NucleusAPI.getMailService();
    if (!optSrv.isPresent()) {
        throw new InternalServerErrorException("Nuclues mail service not available");
    }

    NucleusMailService srv = optSrv.get();

    Optional<User> optUser = player.getUser();
    if (!optUser.isPresent()) {
        throw new InternalServerErrorException("Could not get user");
    }

    return WebAPI.runOnMain(
            () -> srv.getMail(optUser.get(), mailMessage -> { return true; }).stream()
                    .map(CachedMailMessage::new)
                    .collect(Collectors.toList())
    );
}
 

public static User getOrCreateUser(UUID uuid) {
    if (uuid == null) {
        return null;
    }

    if (uuid == WORLD_USER_UUID) {
        return WORLD_USER;
    }

    // check the cache
    Optional<User> player = Sponge.getGame().getServiceManager().provide(UserStorageService.class).get().get(uuid);
    if (player.isPresent()) {
        return player.get();
    } else {
        try {
            GameProfile gameProfile = Sponge.getServer().getGameProfileManager().get(uuid).get();
            return Sponge.getGame().getServiceManager().provide(UserStorageService.class).get().getOrCreate(gameProfile);
        } catch (Exception e) {
            return null;
        }
    }
}
 

@Listener
@Exclude({ClickInventoryEvent.Close.class, ClickInventoryEvent.Open.class})
public void onInteract(ClickInventoryEvent event, @Root Player p) {
    try {
        //Get target inventory owner
        Inventory inv = event.getTargetInventory();
        if (!(inv instanceof CarriedInventory)) return;
        CarriedInventory cinv = (CarriedInventory) inv;
        if (!cinv.getCarrier().isPresent() || !(cinv.getCarrier().get() instanceof User)) return;
        User t = (User) cinv.getCarrier().get();

        //Check if player is in invsee & Cancel event if player doesn't have permission
        UltimateUser up = UltimateCore.get().getUserService().getUser(p);
        if (up.get(InventoryKeys.INVSEE_TARGET).isPresent() && up.get(InventoryKeys.INVSEE_TARGET).get().equals(t.getUniqueId())) {
            if (!p.hasPermission("uc.inventory.invsee.modify")) {
                event.getCursorTransaction().setValid(false);
                event.setCancelled(true);
            }
        }
    } catch (Exception ignore) {
    }
}
 

@Override
public CommandResult execute(CommandSource src, CommandContext args) {
    Player player;
    try {
        player = GriefPreventionPlugin.checkPlayer(src);
    } catch (CommandException e) {
        src.sendMessage(e.getText());
        return CommandResult.success();
    }

    final User targetPlayer = args.<User>getOne("player1").get();
    final User targetPlayer2 = args.<User>getOne("player2").get();
    GriefPreventionPlugin.instance.setIgnoreStatus(player.getWorld(), targetPlayer, targetPlayer2, IgnoreMode.None);
    GriefPreventionPlugin.instance.setIgnoreStatus(player.getWorld(), targetPlayer2, targetPlayer, IgnoreMode.None);
    GriefPreventionPlugin.sendMessage(player, GriefPreventionPlugin.instance.messageData.playerUnseparate.toText());
    return CommandResult.success();
}
 

public static Optional<User> getOwnerOfEntity(net.minecraft.entity.Entity entity) {
    NBTTagCompound nbt = new NBTTagCompound();
    entity.writeToNBT(nbt);
    if (nbt.hasKey(FORGE_DATA)) {
        NBTTagCompound forgeNBT = nbt.getCompoundTag(FORGE_DATA);
        if (forgeNBT.hasKey(SPONGE_DATA) && forgeNBT.getCompoundTag(SPONGE_DATA).hasKey(SPONGE_ENTITY_CREATOR)) {
            NBTTagCompound creatorNBT = forgeNBT.getCompoundTag(SPONGE_DATA).getCompoundTag(SPONGE_ENTITY_CREATOR);
            UUID uuid = new UUID(creatorNBT.getLong("uuid_most"), creatorNBT.getLong("uuid_least"));
            // get player if online
            EntityPlayer player = entity.world.getPlayerEntityByUUID(uuid);
            if (player != null) {
                return Optional.of((User) player);
            }
            // player is not online, get user from storage if one exists
            return Sponge.getGame().getServiceManager().provide(UserStorageService.class).get().get(uuid);
        }
    }
    return Optional.empty();
}
 

@Override
public void run(CommandSource src, CommandContext args) {
    if (args.getOne("player").isPresent() && args.getOne("amount").isPresent()) {
        User target = args.<User>getOne("player").get();
        String targetName = target.getName();
        BigDecimal toRemove = BigDecimal.valueOf(args.<Double>getOne("amount").get());
        Optional<UniqueAccount> uOpt = EconomyLite.getEconomyService().getOrCreateAccount(target.getUniqueId());
        if (uOpt.isPresent()) {
            UniqueAccount targetAccount = uOpt.get();
            if (targetAccount.withdraw(EconomyLite.getCurrencyService().getCurrentCurrency(), toRemove,
                    Cause.of(EventContext.empty(),(EconomyLite.getInstance()))).getResult().equals(ResultType.SUCCESS)) {
                src.sendMessage(messageStorage.getMessage("command.econ.removesuccess", "name", targetName));
                attemptNotify(target);
            } else {
                src.sendMessage(messageStorage.getMessage("command.econ.removefail", "name", targetName));
            }
        } else {
            src.sendMessage(messageStorage.getMessage("command.error"));
        }
    } else {
        src.sendMessage(messageStorage.getMessage("command.error"));
    }
}
 

@Override
public void run(Player src, CommandContext args) {
    if (args.getOne("player").isPresent() && args.getOne("amount").isPresent()) {
        BigDecimal amount = BigDecimal.valueOf(args.<Double>getOne("amount").get());
        if (amount.doubleValue() <= 0) {
            src.sendMessage(messageStorage.getMessage("command.pay.invalid"));
        } else {
            User target = args.<User>getOne("player").get();
            if (!EconomyLite.getConfigManager().getValue(Boolean.class, false, "confirm-offline-payments") || target.isOnline()) {
                // Complete the payment
                pay(target, amount, src);
            } else {
                src.sendMessage(messageStorage.getMessage("command.pay.confirm", "player", target.getName()));
                // Check if they want to still pay
                src.sendMessage(TextUtils.yesOrNo(c -> {
                    pay(target, amount, src);
                }, c -> {
                    src.sendMessage(messageStorage.getMessage("command.pay.confirmno", "player", target.getName()));
                }));
            }

        }
    } else {
        src.sendMessage(messageStorage.getMessage("command.error"));
    }
}
 

@CommandCompletion("@gdplayers @gdflags @gdmcids @gdtristates @gdcontexts @gddummy")
@CommandAlias("cfp")
@Description("Gets/Sets flag permission for a player in claim you are standing in.")
@Syntax("<player> <flag> <target> <value> [context[key=value]]")
@Subcommand("flag player")
public void execute(Player player, User user, @Optional String[] args) throws InvalidCommandArgument {
    this.subject = PermissionHolderCache.getInstance().getOrCreateUser(user);
    this.friendlySubjectName = user.getName();

    if (user.hasPermission(GDPermissions.COMMAND_ADMIN_CLAIMS) && !player.hasPermission(GDPermissions.SET_ADMIN_FLAGS)) {
        GriefDefenderPlugin.sendMessage(player, MessageCache.getInstance().PERMISSION_PLAYER_ADMIN_FLAGS);
        return;
    }

    super.execute(player, args);
}
 

@Override
public String getRaw(CommandSource receiver, String key, Object... vars) {
    String raw;
    if (custom.containsKey(key)) {
        raw = custom.get(key);
    } else if (english.containsKey(key)) {
        raw = english.get(key);
    } else {
        Messages.log(Text.of(TextColors.RED, "ERROR: Failed to get message for key " + key));
        return null;
    }
    String first = null;
    for (Object var : vars) {
        if (first == null) {
            first = var.toString();
        } else {
            if (var instanceof Text || var instanceof CommandSource || var instanceof User) {
                //Will replaced later if needed
            } else {
                raw = raw.replace(first, var.toString());
            }
            first = null;
        }
    }
    return raw;
}
 

private int getClaimLimit(User user) {
    int limit = RedProtect.get().config.configRoot().region_settings.claim.amount_per_player;
    List<Integer> limits = new ArrayList<>();
    if (limit > 0) {
        if (!user.hasPermission("redprotect.limits.claim.unlimited")) {
            for (String perm : RedProtect.get().config.configRoot().permissions_limits.claims) {
                RedProtect.get().logger.debug(LogLevel.DEFAULT, "Perm: " + perm);
                if (user.hasPermission(perm)) {
                    RedProtect.get().logger.debug(LogLevel.DEFAULT, "Has claim perm: " + perm);
                    String pStr = perm.replaceAll("[^-?0-9]+", "");
                    if (!pStr.isEmpty()) {
                        limits.add(Integer.parseInt(pStr));
                    }
                }
            }
        } else {
            return -1;
        }
    }
    if (limits.size() > 0) {
        limit = Collections.max(limits);
    }
    return limit;
}
 

@Override
public void run(CommandSource src, CommandContext args) {
    if (args.getOne("player").isPresent() && args.getOne("amount").isPresent()) {
        User target = args.<User>getOne("player").get();
        String targetName = target.getName();
        BigDecimal toAdd = BigDecimal.valueOf(args.<Double>getOne("amount").get());
        Optional<UniqueAccount> uOpt = EconomyLite.getEconomyService().getOrCreateAccount(target.getUniqueId());
        if (uOpt.isPresent()) {
            UniqueAccount targetAccount = uOpt.get();
            if (targetAccount.deposit(EconomyLite.getCurrencyService().getCurrentCurrency(), toAdd,
                    Cause.of(EventContext.empty(),(EconomyLite.getInstance()))).getResult().equals(ResultType.SUCCESS)) {
                src.sendMessage(messageStorage.getMessage("command.econ.addsuccess", "name", targetName));
                attemptNotify(target);
            } else {
                src.sendMessage(messageStorage.getMessage("command.econ.addfail", "name", targetName));
            }
        } else {
            src.sendMessage(messageStorage.getMessage("command.error"));
        }
    } else {
        src.sendMessage(messageStorage.getMessage("command.error"));
    }
}
 

@Override
public CommandResult execute(CommandSource src, CommandContext ctx) {
    User user = ctx.<User>getOne("user").orElse(null);
    String group = null;
    if (user == null) {
        group = ctx.<String>getOne("group").orElse(null);
        if (group.equalsIgnoreCase("public") || group.equalsIgnoreCase("all")) {
            user = GriefPreventionPlugin.PUBLIC_USER;
            group = null;
        }
    }
    try {
        if (user != null) {
            CommandHelper.handleUserTrustCommand(GriefPreventionPlugin.checkPlayer(src), TrustType.MANAGER, user);
        } else {
            CommandHelper.handleGroupTrustCommand(GriefPreventionPlugin.checkPlayer(src), TrustType.MANAGER, group);
        }
    } catch (CommandException e) {
        src.sendMessage(e.getText());
    }
    return CommandResult.success();
}
 

@Override
public CommandResult execute(CommandSource src, CommandContext ctx) {
    User user = ctx.<User>getOne("user").orElse(null);
    String group = null;
    if (user == null) {
        group = ctx.<String>getOne("group").orElse(null);
        if (group.equalsIgnoreCase("public") || group.equalsIgnoreCase("all")) {
            user = GriefPreventionPlugin.PUBLIC_USER;
            group = null;
        }
    }
    try {
        if (user != null) {
            CommandHelper.handleUserTrustCommand(GriefPreventionPlugin.checkPlayer(src), TrustType.CONTAINER, user);
        } else {
            CommandHelper.handleGroupTrustCommand(GriefPreventionPlugin.checkPlayer(src), TrustType.CONTAINER, group);
        }
    } catch (CommandException e) {
        src.sendMessage(e.getText());
    }
    return CommandResult.success();
}
 

public GPDebugData(CommandSource source, User target, boolean verbose) {
    this.source = source;
    this.target = target;
    this.verbose = verbose;
    this.records = new ArrayList<>();
    this.header = new ArrayList<>();
    this.header.add("# GriefPrevention Debug Log");
    this.header.add("#### This file was automatically generated by [GriefPrevention](https://github.com/MinecraftPortCentral/GriefPrevention) ");
    this.header.add("");
    this.header.add("### Metadata");
    this.header.add("| Key | Value |");
    this.header.add("|-----|-------|");
    this.header.add("| GP Version | " + GriefPreventionPlugin.IMPLEMENTATION_VERSION + "|");
    this.header.add("| Sponge Version | " + GriefPreventionPlugin.SPONGE_VERSION + "|");
    final PluginContainer lpContainer = Sponge.getPluginManager().getPlugin("luckperms").orElse(null);
    if (lpContainer != null) {
        final String version = lpContainer.getVersion().orElse(null);
        if (version != null) {
            this.header.add("| LuckPerms Version | " + version);
        }
    }
    this.header.add("| User | " + (this.target == null ? "ALL" : this.target.getName()) + "|");
    this.header.add("| Record start | " + DATE_FORMAT.format(new Date(this.startTime)) + "|");
}
 

public <T> T getInternalOptionValue(TypeToken<T> type, User player, Option<T> option, Claim claim) {
    final GDPermissionHolder holder = PermissionHolderCache.getInstance().getOrCreateHolder(player.getUniqueId().toString());
    if (claim != null) {
        return this.getInternalOptionValue(type, holder, option, claim, claim.getType(), new HashSet<>());
    }
    return this.getInternalOptionValue(type, holder, option, (ClaimType) null);
}
 

public Subject getPlayerSubject() {
    this.playerSubject = null;
    if (this.playerSubject == null || this.playerSubject.get() == null) {
        User user = GriefPreventionPlugin.getOrCreateUser(this.playerID);
        if (user.isOnline()) {
            user = user.getPlayer().get();
        }
        this.playerSubject = new WeakReference<>(user);
    }

    return this.playerSubject.get();
}
 

private MimeMessage buildMessage(User player, String email, String newPassword, MailConfig emailConfig,
                                 Session session) throws MessagingException, UnsupportedEncodingException {
    String serverName = Sponge.getServer().getBoundAddress()
            .map(sa -> sa.getAddress().getHostAddress())
            .orElse("Minecraft Server");
    ImmutableMap<String, String> variables = ImmutableMap.of("player", player.getName(),
            "server", serverName,
            "password", newPassword);

    MimeMessage message = new MimeMessage(session);
    String senderEmail = emailConfig.getAccount();

    //sender email with an alias
    message.setFrom(new InternetAddress(senderEmail, emailConfig.getSenderName()));
    message.setRecipient(RecipientType.TO, new InternetAddress(email, player.getName()));
    message.setSubject(emailConfig.getSubject(serverName, player.getName()).toPlain());

    //current time
    message.setSentDate(Calendar.getInstance().getTime());
    String textContent = emailConfig.getText(serverName, player.getName(), newPassword).toPlain();

    //html part
    BodyPart htmlPart = new MimeBodyPart();
    htmlPart.setContent(textContent, "text/html; charset=UTF-8");

    //plain text
    BodyPart textPart = new MimeBodyPart();
    textPart.setContent(textContent.replaceAll("(?s)<[^>]*>(\\s*<[^>]*>)*", " "), "text/plain; charset=UTF-8");

    Multipart alternative = new MimeMultipart("alternative");
    alternative.addBodyPart(htmlPart);
    alternative.addBodyPart(textPart);
    message.setContent(alternative);
    return message;
}
 

public static Optional<User> resolvePlayerByName(String name) {
    // try online players first
    Optional<Player> targetPlayer = Sponge.getGame().getServer().getPlayer(name);
    if (targetPlayer.isPresent()) {
        return Optional.of((User) targetPlayer.get());
    }

    Optional<User> user = Sponge.getGame().getServiceManager().provide(UserStorageService.class).get().get(name);
    if (user.isPresent()) {
        return user;
    }

    return Optional.empty();
}
 

@Listener(order = Order.FIRST, beforeModifications = true)
public void onProjectileImpactBlock(CollideBlockEvent.Impact event) {
    if (!GDFlags.PROJECTILE_IMPACT_BLOCK || !(event.getSource() instanceof Entity)) {
        return;
    }

    final Entity source = (Entity) event.getSource();
    if (GriefDefenderPlugin.isSourceIdBlacklisted(Flags.PROJECTILE_IMPACT_BLOCK.getName(), source.getType().getId(), source.getWorld().getProperties())) {
        return;
    }

    final User user = CauseContextHelper.getEventUser(event);
    if (user == null) {
        return;
    }

    if (!GriefDefenderPlugin.getInstance().claimsEnabledForWorld(event.getImpactPoint().getExtent().getUniqueId())) {
        return;
    }

    GDTimings.PROJECTILE_IMPACT_BLOCK_EVENT.startTimingIfSync();
    Location<World> impactPoint = event.getImpactPoint();
    GDClaim targetClaim = null;
    GDPlayerData playerData = null;
    if (user instanceof Player) {
        playerData = GriefDefenderPlugin.getInstance().dataStore.getOrCreatePlayerData(event.getTargetLocation().getExtent(), user.getUniqueId());
        targetClaim = this.dataStore.getClaimAtPlayer(playerData, impactPoint);
    } else {
        targetClaim = this.dataStore.getClaimAt(impactPoint);
    }

    Tristate result = GDPermissionManager.getInstance().getFinalPermission(event, impactPoint, targetClaim, Flags.PROJECTILE_IMPACT_BLOCK, source, event.getTargetBlock(), user, TrustTypes.ACCESSOR, true);
    if (result == Tristate.FALSE) {
        event.setCancelled(true);
        GDTimings.PROJECTILE_IMPACT_BLOCK_EVENT.stopTimingIfSync();
        return;
    }

    GDTimings.PROJECTILE_IMPACT_BLOCK_EVENT.stopTimingIfSync();
}
 

@Nullable
public static UUID getUUIDByName(String name) {
    // try online players first
    Player targetPlayer = Sponge.getGame().getServer().getPlayer(name).orElse(null);
    if (targetPlayer != null) {
        return targetPlayer.getUniqueId();
    }

    User user = Sponge.getGame().getServiceManager().provide(UserStorageService.class).get().get(name).orElse(null);
    if (user != null) {
        return user.getUniqueId();
    }

    return null;
}
 

public GDPermissionUser getOrCreateUser(User user) {
    if (user == null) {
        return null;
    }

    return this.getOrCreateUser(user.getUniqueId());
}
 

@Listener(order = Order.FIRST, beforeModifications = true)
public void onEntityExplosionDetonate(ExplosionEvent.Detonate event) {
    if (!GPFlags.EXPLOSION || !GriefPreventionPlugin.instance.claimsEnabledForWorld(event.getTargetWorld().getProperties())) {
        return;
    }
    if (GriefPreventionPlugin.isSourceIdBlacklisted(ClaimFlag.EXPLOSION.toString(), event.getSource(), event.getTargetWorld().getProperties())) {
        return;
    }

    GPTimings.ENTITY_EXPLOSION_DETONATE_EVENT.startTimingIfSync();
    final User user = CauseContextHelper.getEventUser(event);
    Iterator<Entity> iterator = event.getEntities().iterator();
    GPClaim targetClaim = null;
    Object source = event.getSource();
    if (source instanceof Explosion) {
        final Explosion explosion = (Explosion) source;
        if (explosion.getSourceExplosive().isPresent()) {
            source = explosion.getSourceExplosive().get();
        } else {
            Entity exploder = event.getCause().first(Entity.class).orElse(null);
            if (exploder != null) {
                source = exploder;
            }
        }
    }

    while (iterator.hasNext()) {
        Entity entity = iterator.next();
        targetClaim =  GriefPreventionPlugin.instance.dataStore.getClaimAt(entity.getLocation(), targetClaim);
        if (GPPermissionHandler.getClaimPermission(event, entity.getLocation(), targetClaim, GPPermissions.ENTITY_DAMAGE, source, entity, user) == Tristate.FALSE) {
            iterator.remove();
        }
    }
    GPTimings.ENTITY_EXPLOSION_DETONATE_EVENT.stopTimingIfSync();
}
 

private boolean isAllowed(User player) {
    if (settings.getGeneral().isBypassed(player)) {
        return true;
    }

    if (settings.getGeneral().isCommandOnlyProtection()) {
        //check if the user is already registered
        return plugin.getDatabase().getAccount(player).isPresent()
                || !player.hasPermission(PomData.ARTIFACT_ID + ".registerRequired");
    }

    return plugin.getDatabase().isLoggedIn(player);
}
 

@CommandCompletion("@gdplayers @gdworlds @gddummy")
@CommandAlias("claimlist|claimslist")
@Syntax("[<player>|<player> <world>]")
@Description("List information about a player's claim blocks and claims.")
@Subcommand("claim list")
public void execute(Player src, @Optional User targetPlayer, @Optional World world) {
    GDPermissionUser user = null;
    // check target player
    if (targetPlayer != null) {
        user = PermissionHolderCache.getInstance().getOrCreateUser(targetPlayer);
        if (user != null && user.getOnlinePlayer() != src && !src.hasPermission(GDPermissions.COMMAND_CLAIM_LIST_OTHERS)) {
            TextAdapter.sendComponent(src, MessageCache.getInstance().PERMISSION_PLAYER_VIEW_OTHERS);
            return;
        }
    } else {
        user = PermissionHolderCache.getInstance().getOrCreateUser(src);
    }

    if (user == null) {
        GriefDefenderPlugin.sendMessage(src, MessageStorage.MESSAGE_DATA.getMessage(MessageStorage.COMMAND_INVALID_PLAYER,
                ImmutableMap.of(
                "player", targetPlayer)));
        return;
    }
    if (world == null) {
        world = src.getWorld();
    }

    showClaimList(src, user, this.forcedType, world.getUniqueId());
}
 

@CommandCompletion("@gdplayers @gddummy")
@CommandAlias("givepet")
@Description("Transfers a pet to a new owner.")
@Syntax("<player>")
@Subcommand("givepet")
public void execute(Player player, User newOwner) {
    final GDPlayerData playerData = GriefDefenderPlugin.getInstance().dataStore.getOrCreatePlayerData(player.getWorld(), player.getUniqueId());
    playerData.petRecipientUniqueId = newOwner.getUniqueId();
    GriefDefenderPlugin.sendMessage(player, MessageCache.getInstance().COMMAND_PET_TRANSFER_READY);
}
 

private void showPlayerInfo(CommandSource source, FactionPlayer factionPlayer)
{
    List<Text> playerInfo = new ArrayList<>();
    String playerFactionName = "";
    if (factionPlayer.getFactionName().isPresent())
        playerFactionName = factionPlayer.getFactionName().get();

    LocalDateTime lastPlayed = LocalDateTime.now();

    final Optional<User> optionalUser = factionPlayer.getUser();
    if (optionalUser.isPresent())
    {
        final Optional<JoinData> joinData = optionalUser.get().get(JoinData.class);
        if (joinData.isPresent())
        {
            final JoinData data = joinData.get();
            final Instant instant = data.lastPlayed().get();
            lastPlayed = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        }
    }

    String formattedDate = DATE_TIME_FORMATTER.format(lastPlayed);
    final boolean isOnline = optionalUser.isPresent() && optionalUser.get().isOnline();
    final Text online = isOnline ? Text.of(TextColors.GREEN, "ONLINE") : Text.of(TextColors.RED, "OFFLINE");
    Text info = Text.builder()
            .append(Text.of(TextColors.AQUA, Messages.NAME + ": ", TextColors.GOLD, factionPlayer.getName() + "\n"))
            .append(Text.of(TextColors.AQUA, Messages.PLAYER_STATUS + ": ")).append(online).append(Text.of("\n"))
            .append(Text.of(TextColors.AQUA, Messages.FACTION + ": ", TextColors.GOLD, playerFactionName + "\n"))
            .append(Text.of(TextColors.AQUA, Messages.POWER + ": ", TextColors.GOLD, factionPlayer.getPower() + "/" + factionPlayer.getMaxPower() + "\n"))
            .append(Text.of(TextColors.AQUA, Messages.LAST_PLAYED + ": ", TextColors.GOLD, formattedDate))
            .build();

    playerInfo.add(info);

    PaginationList.Builder paginationBuilder = PaginationList.builder().title(Text.of(TextColors.GREEN, Messages.PLAYER_INFO)).padding(Text.of("=")).contents(playerInfo);
    paginationBuilder.sendTo(source);
}
 

private boolean isHoldingEagleFeather(final User user)
{
    return user.getItemInHand(HandTypes.MAIN_HAND).isPresent()
            && user.getItemInHand(HandTypes.MAIN_HAND).get().getType() == ItemTypes.FEATHER
            && user.getItemInHand(HandTypes.MAIN_HAND).get().get(Keys.DISPLAY_NAME).isPresent()
            && user.getItemInHand(HandTypes.MAIN_HAND).get().get(Keys.DISPLAY_NAME).get().equals(EagleFeather.getDisplayName());
}
 

private void notifyPlayer(final User user)
{
    if (this.chatConfig.shouldDisplayProtectionSystemMessages())
    {
        user.getPlayer().ifPresent(x->x.sendMessage(Text.of(PluginInfo.ERROR_PREFIX, TextColors.RED, Messages.YOU_DONT_HAVE_ACCESS_TO_DO_THIS)));
    }
}
 

/**
 * Retrieve an {@link UltimateUser} by the user's User instance.
 *
 * @param user The User instance of the user to get
 * @return The UltimateUser, or Optional.empty() if not found
 */
@Override
public UltimateUser getUser(User user) {
    for (UltimateUser use : users) {
        if (use.getIdentifier().equals(user.getUniqueId())) {
            return use;
        }
    }
    UltimateUser ucuser = new UltimateUser(user);
    users.add(ucuser);
    return ucuser;
}