Arakne / Araknemu

public final class Ban extends AbstractCommand<Ban.Arguments> implements SubArgumentsCommandTrait<Ban.Arguments> {

    private final GameAccount account;

    private final BanishmentService<GameAccount> service;

    public Ban(GameAccount account, BanishmentService<GameAccount> service) {

        this.account = account;

        this.service = service;

    }

    @Override

    protected void build(Builder builder) {

        builder

            .description("Ban an account")

            .help(

                formatter -> formatter

                    .synopsis("[context] ban [for|list|unban] ARGUMENTS")

                    .options("for DURATION CAUSE", "Ban the account for the given duration.\nThe duration is in format [days]dT[hours]h[minutes]m[seconds]s\nNote: You cannot ban a game master account.")

                    .options("list", "List all banishment entries for the account")

                    .options("unban", "Remove current banishment for the account")

                    .example("${account:John} ban list", "Display all ban entries of the 'John' account")

                    .example("${account:John} ban for 5d", "Ban 'John' for 5 days")

                    .example("${player:Alan} ban for 10m", "Ban 'Alan' account for 10 minutes")

                    .example("${player:Alan} unban", "Unban 'Alan' account")

            )

            .requires(Permission.MANAGE_ACCOUNT)

        ;

    }

    @Override

    public String name() {

        return "ban";

    }

    /**

     * Unban the account

     */

    private void unban(AdminPerformer performer) {

        service.unban(account);

        performer.success("The account {} has been unbaned", account.pseudo());

    }

    /**

     * List all ban entries

     */

    private void list(AdminPerformer performer) {

        final List<BanEntry<GameAccount>> entries = service.list(account);

        if (entries.isEmpty()) {

            performer.success("No ban entries found");

            return;

        }

        performer.success("List of ban entries for {} :", account.pseudo());

        for (BanEntry<GameAccount> entry : entries) {

            performer.info(

                "{} - {} (by {}) : {}{}",

                entry.start(),

                entry.end(),

                entry.banisher().map(LivingAccount::pseudo).orElse("system"),

                entry.cause(),

                entry.active() ? " <b>active</b>" : ""

            );

        }

    }

    /**

     * Ban the account for a given duration

     */

    private void banFor(AdminPerformer performer, Arguments.ForArguments arguments) throws CommandException {

        checkCanBan(performer);

        final BanEntry<GameAccount> entry = performer.account().isPresent()

            : service.ban(account, arguments.duration, arguments.cause)

        ;

        performer.success("The account {} has been banned until {}", account.pseudo(), entry.end());

    }

    /**

     * Check if the account can be banned

     */

    private void checkCanBan(AdminPerformer performer) throws CommandException {

        if (performer.account().filter(performerAccount -> performerAccount.id() == account.id()).isPresent()) {

            throw new CommandException(name(), "Cannot ban yourself");

        }

        if (account.isMaster()) {

            throw new CommandException(name(), "Cannot ban a game master");

        }

    }

    @Override

    public Arguments createArguments() {

        return new Arguments();

    }

    public static final class Arguments implements SubArguments<Ban> {

        @Argument(required = true)

        @SubCommands({

            @SubCommand(name = "for", impl = ForArguments.class),

            @SubCommand(name = "list", impl = ListArguments.class),

            @SubCommand(name = "unban", impl = UnbanArguments.class),

        })

        private SubArguments<Ban> action;

        @Override

        public void execute(AdminPerformer performer, Ban command) throws AdminException {

            action.execute(performer, command);

        }

        public static final class ForArguments implements SubArguments<Ban> {

            @Argument(index = 0, required = true)

            private Duration duration;

            @Argument(index = 1, required = true, handler = ConcatRestOfArgumentsHandler.class)

            private String cause;

            @Override

            public void execute(AdminPerformer performer, Ban command) throws AdminException {

                command.banFor(performer, this);

            }

        }

        public static final class ListArguments implements SubArguments<Ban> {

            @Override

            public void execute(AdminPerformer performer, Ban command) throws AdminException {

                command.list(performer);

            }

        }

        public static final class UnbanArguments implements SubArguments<Ban> {

            @Override

            public void execute(AdminPerformer performer, Ban command) throws AdminException {

                command.unban(performer);