71 lines
3.1 KiB
Java
71 lines
3.1 KiB
Java
package net.tomatentum.marinara.wrapper;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
|
|
import org.slf4j.Logger;
|
|
|
|
import net.tomatentum.marinara.interaction.commands.SlashCommandDefinition;
|
|
import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOption;
|
|
import net.tomatentum.marinara.interaction.commands.annotation.SlashCommandOptionChoice;
|
|
import net.tomatentum.marinara.interaction.ident.InteractionIdentifier;
|
|
import net.tomatentum.marinara.interaction.ident.RootCommandIdentifier;
|
|
import net.tomatentum.marinara.interaction.ident.SlashCommandIdentifier;
|
|
import net.tomatentum.marinara.util.LoggerUtil;
|
|
|
|
public class CommandConverter<A extends Object, O extends Object, C extends Object> {
|
|
|
|
public static <A, O, C> CommandConverter<A, O, C> of(Spec<A, O, C> spec) {
|
|
return new CommandConverter<>(spec);
|
|
}
|
|
|
|
private Logger logger = LoggerUtil.getLogger(getClass());
|
|
|
|
private Spec<A, O, C> spec;
|
|
|
|
CommandConverter(Spec<A, O, C> spec) {
|
|
this.spec = spec;
|
|
}
|
|
|
|
public A convert(SlashCommandDefinition def) {
|
|
logger.debug("Converting command {}", def);
|
|
List<O> options = new ArrayList<>();
|
|
if (!def.isRootCommand()) {
|
|
Arrays.stream(def.getSubCommands()).map(this::convertSubCommand).forEach(options::add);
|
|
Arrays.stream(def.getSubCommandGroups()).map(x -> this.convertSubCommandGroup(def, x)).forEach(options::add);
|
|
}else
|
|
Arrays.stream(def.rootIdentifier().options()).map(this::convertOption).forEach(options::add);
|
|
|
|
return spec.convertCommand(def.rootIdentifier(), options);
|
|
}
|
|
|
|
private O convertSubCommandGroup(SlashCommandDefinition def, InteractionIdentifier identifier) {
|
|
logger.debug("Converting subCommandGroup {} of {}", identifier, def);
|
|
SlashCommandIdentifier[] subCommands = def.getSubCommands(identifier.name());
|
|
List<O> convertedSubCommands = Arrays.stream(subCommands).map(this::convertSubCommand).toList();
|
|
return spec.convertSubCommandGroup(identifier, convertedSubCommands);
|
|
}
|
|
|
|
private O convertSubCommand(SlashCommandIdentifier identifier) {
|
|
logger.debug("Converting subCommand {}", identifier);
|
|
List<O> options = Arrays.stream(identifier.options()).map(this::convertOption).toList();
|
|
return spec.convertSubCommand(identifier, options);
|
|
}
|
|
|
|
private O convertOption(SlashCommandOption option) {
|
|
logger.debug("Converting option {}", option);
|
|
List<C> choices = Arrays.stream(SlashCommandDefinition.getActualChoices(option)).map(spec::convertChoice).toList();
|
|
return spec.convertOption(option, choices);
|
|
}
|
|
|
|
public static interface Spec<A extends Object, O extends Object, C extends Object> {
|
|
|
|
public A convertCommand(RootCommandIdentifier rootIdentifier, List<O> options);
|
|
public O convertSubCommandGroup(InteractionIdentifier identifier, List<O> subCommands);
|
|
public O convertSubCommand(InteractionIdentifier identifier, List<O> options);
|
|
public O convertOption(SlashCommandOption option, List<C> choices);
|
|
public C convertChoice(SlashCommandOptionChoice choice);
|
|
}
|
|
}
|