[AB-225] adding parameter handler for messages

reworking parameter handling in command received handler
adding string parameter handler to explicitly parse strings

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/LoveCalc.java

@@ -43,7 +43,7 @@ public class LoveCalc extends AbstractConditionableCommand {
         model.setFirstPart(firstPart);
         model.setSecondPart(secondPart);
         return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(LOVE_CALC_RESPONSE_TEMPLATE_KEY, model, commandContext.getChannel()))
-                .thenApply(unused -> CommandResult.fromIgnored());
+                .thenApply(unused -> CommandResult.fromSuccess());
     }
 
     @Override
@@ -58,7 +58,6 @@ public class LoveCalc extends AbstractConditionableCommand {
                 .module(EntertainmentModuleDefinition.ENTERTAINMENT)
                 .templated(true)
                 .supportsEmbedException(true)
-                .causesReaction(true)
                 .parameters(parameters)
                 .help(helpInfo)
                 .build();

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/command/Mock.java

@@ -0,0 +1,81 @@
+package dev.sheldan.abstracto.entertainment.command;
+
+import dev.sheldan.abstracto.core.command.condition.AbstractConditionableCommand;
+import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.HelpInfo;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.execution.CommandContext;
+import dev.sheldan.abstracto.core.command.execution.CommandResult;
+import dev.sheldan.abstracto.core.command.execution.ContextConverter;
+import dev.sheldan.abstracto.core.command.handler.parameter.CombinedParameter;
+import dev.sheldan.abstracto.core.config.FeatureDefinition;
+import dev.sheldan.abstracto.core.service.ChannelService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentFeatureDefinition;
+import dev.sheldan.abstracto.entertainment.config.EntertainmentModuleDefinition;
+import dev.sheldan.abstracto.entertainment.model.MockResponseModel;
+import dev.sheldan.abstracto.entertainment.service.EntertainmentService;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+
+import static dev.sheldan.abstracto.core.command.config.Parameter.ADDITIONAL_TYPES_KEY;
+
+@Component
+public class Mock extends AbstractConditionableCommand {
+
+    public static final String MOCK_RESPONSE_TEMPLATE_KEY = "mock_response";
+    @Autowired
+    private EntertainmentService entertainmentService;
+
+    @Autowired
+    private ChannelService channelService;
+
+    @Override
+    public CompletableFuture<CommandResult> executeAsync(CommandContext commandContext) {
+        Object givenParameter = commandContext.getParameters().getParameters().get(0);
+        String messageText;
+        Member mockedMember = null;
+        if(givenParameter instanceof Message) {
+            Message originalMessage = (Message) givenParameter;
+            messageText = originalMessage.getContentRaw();
+            mockedMember = originalMessage.getMember();
+        } else {
+            messageText = givenParameter.toString();
+        }
+        String mockingText = entertainmentService.createMockText(messageText, commandContext.getAuthor(), mockedMember);
+        MockResponseModel model = (MockResponseModel) ContextConverter.slimFromCommandContext(commandContext, MockResponseModel.class);
+        model.setOriginalText(messageText);
+        model.setMockingText(mockingText);
+        return FutureUtils.toSingleFutureGeneric(channelService.sendEmbedTemplateInTextChannelList(MOCK_RESPONSE_TEMPLATE_KEY, model, commandContext.getChannel()))
+                .thenApply(unused -> CommandResult.fromSuccess());
+    }
+
+    @Override
+    public CommandConfiguration getConfiguration() {
+        List<Parameter> parameters = new ArrayList<>();
+        Map<String, Object> parameterAlternatives = new HashMap<>();
+        parameterAlternatives.put(ADDITIONAL_TYPES_KEY, Arrays.asList(Message.class, String.class));
+        parameters.add(Parameter.builder().name("message").type(CombinedParameter.class).remainder(true)
+                .additionalInfo(parameterAlternatives).templated(true).build());
+        HelpInfo helpInfo = HelpInfo.builder().templated(true).build();
+        return CommandConfiguration.builder()
+                .name("mock")
+                .module(EntertainmentModuleDefinition.ENTERTAINMENT)
+                .templated(true)
+                .async(true)
+                .supportsEmbedException(true)
+                .parameters(parameters)
+                .help(helpInfo)
+                .build();
+    }
+
+    @Override
+    public FeatureDefinition getFeature() {
+        return EntertainmentFeatureDefinition.ENTERTAINMENT;
+    }
+}

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/java/dev/sheldan/abstracto/entertainment/service/EntertainmentServiceBean.java

@@ -54,4 +54,19 @@ public class EntertainmentServiceBean implements EntertainmentService {
     public String takeChoice(List<String> choices, Member memberExecuting) {
         return choices.get(secureRandom.nextInt(choices.size()));
     }
+
+    @Override
+    public String createMockText(String text, Member memberExecuting, Member mockedUser) {
+        char[] textChars = text.toLowerCase().toCharArray();
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0, textCharsLength = textChars.length; i < textCharsLength; i++) {
+            char character = textChars[i];
+            if(i % 2 == 0) {
+                sb.append(Character.toUpperCase(character));
+            } else {
+                sb.append(character);
+            }
+        }
+        return sb.toString();
+    }
 }

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.2.8-entertainment/collection.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../dbchangelog-3.8.xsd" >
+    <include file="entertainment-seedData/data.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.2.8-entertainment/entertainment-seedData/command.xml

@@ -0,0 +1,20 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
+    <property name="entertainmentModule" value="(SELECT id FROM module WHERE name = 'entertainment')"/>
+    <property name="entertainmentFeature" value="(SELECT id FROM feature WHERE key = 'entertainment')"/>
+
+    <changeSet  author="Sheldan"  id="mock-command">
+        <insert tableName="command">
+            <column name="name" value="mock"/>
+            <column name="module_id" valueComputed="${entertainmentModule}"/>
+            <column name="feature_id" valueComputed="${entertainmentFeature}"/>
+        </insert>
+    </changeSet>
+
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/1.2.8-entertainment/entertainment-seedData/data.xml

@@ -0,0 +1,10 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/dbchangelog-ext ../../dbchangelog-3.8.xsd
+    http://www.liquibase.org/xml/ns/pro ../../dbchangelog-3.8.xsd" >
+    <include file="command.xml" relativeToChangelogFile="true"/>
+</databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-impl/src/main/resources/migrations/entertainment-changeLog.xml

@@ -7,4 +7,5 @@
     http://www.liquibase.org/xml/ns/dbchangelog-ext dbchangelog-3.8.xsd
     http://www.liquibase.org/xml/ns/pro dbchangelog-3.8.xsd" >
     <include file="1.0-entertainment/collection.xml" relativeToChangelogFile="true"/>
+    <include file="1.2.8-entertainment/collection.xml" relativeToChangelogFile="true"/>
 </databaseChangeLog>

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/model/MockResponseModel.java

@@ -0,0 +1,14 @@
+package dev.sheldan.abstracto.entertainment.model;
+
+import dev.sheldan.abstracto.core.models.context.SlimUserInitiatedServerContext;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+
+@Getter
+@Setter
+@SuperBuilder
+public class MockResponseModel extends SlimUserInitiatedServerContext {
+    private String originalText;
+    private String mockingText;
+}

abstracto-application/abstracto-modules/entertainment/entertainment-int/src/main/java/dev/sheldan/abstracto/entertainment/service/EntertainmentService.java

@@ -10,4 +10,5 @@ public interface EntertainmentService {
     Integer calculateRollResult(Integer low, Integer high);
     boolean executeRoulette(Member memberExecuting);
     String takeChoice(List<String> choices, Member memberExecuting);
+    String createMockText(String text, Member memberExecuting, Member mockedUser);
 }

abstracto-application/abstracto-modules/statistic/statistic-impl/src/main/java/dev/sheldan/abstracto/statistic/emote/command/parameter/handler/TrackedEmoteParameterHandler.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.statistic.emote.command.parameter.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.CommandParameterHandler;
 import dev.sheldan.abstracto.core.command.handler.CommandParameterIterators;
 import dev.sheldan.abstracto.core.command.handler.provided.EmoteParameterHandler;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.statistic.emote.model.database.TrackedEmote;
 import dev.sheldan.abstracto.statistic.emote.service.TrackedEmoteService;
 import net.dv8tion.jda.api.entities.Emote;
@@ -24,6 +27,9 @@ public class TrackedEmoteParameterHandler implements CommandParameterHandler {
     @Autowired
     private TrackedEmoteService trackedEmoteService;
 
+    @Autowired
+    private CommandService commandService;
+
     /**
      * This {@link CommandParameterHandler} only handles {@link TrackedEmote}
      * @param clazz The desired {@link Class} of a parameter
@@ -42,14 +48,17 @@ public class TrackedEmoteParameterHandler implements CommandParameterHandler {
      * @param input The {@link String} input at the current position
      * @param iterators The {@link CommandParameterIterators} containing all available iterators to directly retrieve JDA related
      *                  entities from
-     * @param clazz The {@link Class} which this type should handle
+     * @param param The {@link Class} which this type should handle
      * @param context The {@link Message} which caused the command to be executed
+     * @param command
      * @return A faked {@link TrackedEmote} based on the given input or from {@link CommandParameterIterators} directly. This {@link TrackedEmote}
      * does not need to actually exist.
      */
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
-        Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, Emote.class, context);
+        Parameter cloned = commandService.cloneParameter(param);
+        cloned.setType(Emote.class);
+        Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, cloned, context, command);
         if(emote != null) {
             return trackedEmoteService.getFakeTrackedEmote(emote, context.getGuild());
         } else {

abstracto-application/abstracto-modules/statistic/statistic-impl/src/main/java/dev/sheldan/abstracto/statistic/emote/command/parameter/handler/TrackedEmoteParameterParameterHandler.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.statistic.emote.command.parameter.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.CommandParameterHandler;
 import dev.sheldan.abstracto.core.command.handler.CommandParameterIterators;
 import dev.sheldan.abstracto.core.command.handler.provided.EmoteParameterHandler;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.statistic.emote.command.parameter.TrackEmoteParameter;
 import dev.sheldan.abstracto.statistic.emote.model.database.TrackedEmote;
 import dev.sheldan.abstracto.statistic.emote.service.TrackedEmoteService;
@@ -28,6 +31,9 @@ public class TrackedEmoteParameterParameterHandler implements CommandParameterHa
     @Autowired
     private TrackedEmoteService trackedEmoteService;
 
+    @Autowired
+    private CommandService commandService;
+
     /**
      * This {@link CommandParameterHandler} only handles {@link TrackEmoteParameter}
      * @param clazz The desired {@link Class} of a parameter
@@ -45,15 +51,18 @@ public class TrackedEmoteParameterParameterHandler implements CommandParameterHa
      * @param input The {@link String} input at the current position
      * @param iterators The {@link CommandParameterIterators} containing all available iterators to directly retrieve JDA related
      *                  entities from
-     * @param clazz The {@link Class} which this type should handle
+     * @param param The {@link Class} which this type should handle
      * @param context The {@link Message} which caused the command to be executed
+     * @param command
      * @return An instance of {@link TrackEmoteParameter} which contains the available instances. This is an {@link Emote} in case it was
      * used directly. In every successful case, it will contain a faked {@link TrackedEmote}.
      */
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         TrackEmoteParameter parameter = TrackEmoteParameter.builder().build();
-        Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, Emote.class, context);
+        Parameter cloned = commandService.cloneParameter(param);
+        cloned.setType(Emote.class);
+        Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, cloned, context, command);
         if(emote != null) {
             parameter.setEmote(emote);
             parameter.setTrackedEmote(trackedEmoteService.getFakeTrackedEmote(emote, context.getGuild()));

abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emote/command/handler/TrackedEmoteParameterHandlerTest.java

@@ -1,8 +1,11 @@
 package dev.sheldan.abstracto.statistic.emote.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.CommandParameterIterators;
 import dev.sheldan.abstracto.core.command.handler.provided.EmoteParameterHandler;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.statistic.emote.command.parameter.handler.TrackedEmoteParameterHandler;
 import dev.sheldan.abstracto.statistic.emote.model.database.TrackedEmote;
 import dev.sheldan.abstracto.statistic.emote.service.TrackedEmoteService;
@@ -31,6 +34,9 @@ public class TrackedEmoteParameterHandlerTest {
     @Mock
     private TrackedEmoteService trackedEmoteService;
 
+    @Mock
+    private CommandService commandService;
+
     @Mock
     private Message contextMessage;
 
@@ -40,6 +46,15 @@ public class TrackedEmoteParameterHandlerTest {
     @Mock
     private Guild guild;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Parameter parameter2;
+
+    @Mock
+    private Command command;
+
     @Mock
     private TrackedEmote trackedEmote;
 
@@ -60,9 +75,10 @@ public class TrackedEmoteParameterHandlerTest {
         when(contextMessage.getGuild()).thenReturn(guild);
         Emote emote = Mockito.mock(Emote.class);
         UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
-        when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(emote);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
+        when(emoteParameterHandler.handle(input, iterators, parameter2, contextMessage, command)).thenReturn(emote);
         when(trackedEmoteService.getFakeTrackedEmote(emote, guild)).thenReturn(trackedEmote);
-        TrackedEmote parsedEmote = (TrackedEmote) testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
+        TrackedEmote parsedEmote = (TrackedEmote) testUnit.handle(input, iterators, parameter, contextMessage, command);
         Assert.assertEquals(trackedEmote, parsedEmote);
     }
 
@@ -72,9 +88,10 @@ public class TrackedEmoteParameterHandlerTest {
         when(contextMessage.getGuild()).thenReturn(guild);
         UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
         when(input.getValue()).thenReturn(emoteId.toString());
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
         when(trackedEmoteService.getFakeTrackedEmote(emoteId, guild)).thenReturn(trackedEmote);
-        when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(null);
+        when(emoteParameterHandler.handle(input, iterators, parameter2, contextMessage, command)).thenReturn(null);
-        TrackedEmote parsedEmote = (TrackedEmote) testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
+        TrackedEmote parsedEmote = (TrackedEmote) testUnit.handle(input, iterators, parameter, contextMessage, command);
         verify(trackedEmoteService, times(0)).getFakeTrackedEmote(any(Emote.class), eq(guild));
         Assert.assertEquals(trackedEmote, parsedEmote);
     }
@@ -83,7 +100,8 @@ public class TrackedEmoteParameterHandlerTest {
     public void testWithIllegalInput() {
         UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
         when(input.getValue()).thenReturn(WRONG_FORMATTED_INPUT);
-        when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(null);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
-        testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
+        when(emoteParameterHandler.handle(input, iterators, parameter2, contextMessage, command)).thenReturn(null);
+        testUnit.handle(input, iterators, parameter, contextMessage, command);
     }
 }

abstracto-application/abstracto-modules/statistic/statistic-impl/src/test/java/dev/sheldan/abstracto/statistic/emote/command/handler/TrackedEmoteParameterParameterHandlerTest.java

@@ -1,8 +1,11 @@
 package dev.sheldan.abstracto.statistic.emote.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.CommandParameterIterators;
 import dev.sheldan.abstracto.core.command.handler.provided.EmoteParameterHandler;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.statistic.emote.command.parameter.TrackEmoteParameter;
 import dev.sheldan.abstracto.statistic.emote.command.parameter.handler.TrackedEmoteParameterParameterHandler;
 import dev.sheldan.abstracto.statistic.emote.model.database.TrackedEmote;
@@ -34,6 +37,9 @@ public class TrackedEmoteParameterParameterHandlerTest {
     @Mock
     private TrackedEmoteService trackedEmoteService;
 
+    @Mock
+    private CommandService commandService;
+
     @Mock
     private Message contextMessage;
 
@@ -46,6 +52,15 @@ public class TrackedEmoteParameterParameterHandlerTest {
     @Mock
     private TrackedEmote trackedEmote;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Parameter parameter2;
+
+    @Mock
+    private Command command;
+
     private static final String WRONG_FORMATTED_INPUT = "input";
 
     @Test
@@ -63,9 +78,10 @@ public class TrackedEmoteParameterParameterHandlerTest {
         when(contextMessage.getGuild()).thenReturn(guild);
         Emote emote = Mockito.mock(Emote.class);
         UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
-        when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(emote);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
+        when(emoteParameterHandler.handle(input, iterators, parameter2, contextMessage, command)).thenReturn(emote);
         when(trackedEmoteService.getFakeTrackedEmote(emote, guild)).thenReturn(trackedEmote);
-        TrackEmoteParameter parsedEmote = (TrackEmoteParameter) testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
+        TrackEmoteParameter parsedEmote = (TrackEmoteParameter) testUnit.handle(input, iterators, parameter, contextMessage, command);
         Assert.assertEquals(trackedEmote, parsedEmote.getTrackedEmote());
         Assert.assertEquals(emote, parsedEmote.getEmote());
     }
@@ -77,8 +93,9 @@ public class TrackedEmoteParameterParameterHandlerTest {
         UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
         when(input.getValue()).thenReturn(emoteId.toString());
         when(trackedEmoteService.getFakeTrackedEmote(emoteId, guild)).thenReturn(trackedEmote);
-        when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(null);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
-        TrackEmoteParameter parsedEmote = (TrackEmoteParameter) testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
+        when(emoteParameterHandler.handle(input, iterators, parameter2, contextMessage, command)).thenReturn(null);
+        TrackEmoteParameter parsedEmote = (TrackEmoteParameter) testUnit.handle(input, iterators, parameter, contextMessage, command);
         verify(trackedEmoteService, times(0)).getFakeTrackedEmote(any(Emote.class), eq(guild));
         Assert.assertEquals(trackedEmote, parsedEmote.getTrackedEmote());
     }
@@ -87,8 +104,9 @@ public class TrackedEmoteParameterParameterHandlerTest {
     public void testWithIllegalInput() {
         UnparsedCommandParameterPiece input = Mockito.mock(UnparsedCommandParameterPiece.class);
         when(input.getValue()).thenReturn(WRONG_FORMATTED_INPUT);
-        when(emoteParameterHandler.handle(input, iterators, Emote.class, contextMessage)).thenReturn(null);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
-        testUnit.handle(input, iterators, TrackedEmote.class, contextMessage);
+        when(emoteParameterHandler.handle(input, iterators, parameter2, contextMessage, command)).thenReturn(null);
+        testUnit.handle(input, iterators, parameter, contextMessage, command);
     }
 
 }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/CommandReceivedHandler.java

@@ -4,6 +4,7 @@ import dev.sheldan.abstracto.core.command.condition.ConditionResult;
 import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.config.ParameterValidator;
 import dev.sheldan.abstracto.core.command.config.Parameters;
+import dev.sheldan.abstracto.core.command.config.ParseResult;
 import dev.sheldan.abstracto.core.command.exception.CommandParameterValidationException;
 import dev.sheldan.abstracto.core.command.exception.IncorrectParameterException;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
@@ -207,7 +208,7 @@ public class CommandReceivedHandler extends ListenerAdapter {
         // we iterate only over the actually found parameters, that way we dont have to consider the optional parameters
         // the parameters are going from left to right anyway
         for (int i = 0; i < parameters.getParameters().size(); i++) {
-            Parameter parameter = parameterList.get(i);
+            Parameter parameter = parameterList.get(Math.min(i, parameterList.size() - 1));
             for (ParameterValidator parameterValidator : parameter.getValidators()) {
                 boolean validate = parameterValidator.validate(parameters.getParameters().get(i));
                 if(!validate) {
@@ -243,37 +244,36 @@ public class CommandReceivedHandler extends ListenerAdapter {
     }
 
     public CompletableFuture<Parameters> getParsedParameters(UnParsedCommandParameter unParsedCommandParameter, Command command, Message message){
-        List<Object> parsedParameters = new ArrayList<>();
+        List<ParseResult> parsedParameters = new ArrayList<>();
-        if(command.getConfiguration().getParameters() == null || command.getConfiguration().getParameters().isEmpty()) {
+        List<Parameter> parameters = command.getConfiguration().getParameters();
-            return CompletableFuture.completedFuture(Parameters.builder().parameters(parsedParameters).build());
+        if(parameters == null || parameters.isEmpty()) {
+            return CompletableFuture.completedFuture(Parameters.builder().parameters(new ArrayList<>()).build());
         }
         log.debug("Parsing parameters for command {} based on message {}.", command.getConfiguration().getName(), message.getId());
         Iterator<TextChannel> channelIterator = message.getMentionedChannels().iterator();
         Iterator<Emote> emoteIterator = message.getEmotesBag().iterator();
         Iterator<Member> memberIterator = message.getMentionedMembers().iterator();
         Iterator<Role> roleIterator = message.getMentionedRolesBag().iterator();
-        Parameter param = command.getConfiguration().getParameters().get(0);
+        Parameter param = parameters.get(0);
         CommandParameterIterators iterators = new CommandParameterIterators(channelIterator, emoteIterator, memberIterator, roleIterator);
-        boolean reminderActive = false;
         List<CompletableFuture> futures = new ArrayList<>();
         for (int i = 0; i < unParsedCommandParameter.getParameters().size(); i++) {
-            if(i < command.getConfiguration().getParameters().size() && !param.isRemainder()) {
+            if(i < parameters.size() && !param.isRemainder()) {
-                param = command.getConfiguration().getParameters().get(i);
+                param = parameters.get(i);
             } else {
-                reminderActive = true;
+                param = parameters.get(parameters.size() - 1);
             }
             UnparsedCommandParameterPiece value = unParsedCommandParameter.getParameters().get(i);
-            boolean handlerMatched = false;
             for (CommandParameterHandler handler : parameterHandlers) {
                 try {
                     if (handler.handles(param.getType())) {
-                        handlerMatched = true;
                         if (handler.async()) {
-                            CompletableFuture future = handler.handleAsync(value, iterators, param.getType(), message);
+                            CompletableFuture future = handler.handleAsync(value, iterators, param, message, command);
                             futures.add(future);
-                            parsedParameters.add(future);
+                            parsedParameters.add(ParseResult.builder().parameter(param).result(future).build());
                         } else {
-                            parsedParameters.add(handler.handle(value, iterators, param.getType(), message));
+                            Object result = handler.handle(value, iterators, param, message, command);
+                            parsedParameters.add(ParseResult.builder().parameter(param).result(result).build());
                         }
                         break;
                     }
@@ -285,44 +285,30 @@ public class CommandReceivedHandler extends ListenerAdapter {
                     throw new IncorrectParameterException(command, param.getName());
                 }
             }
-            if(!handlerMatched) {
-                Object valueAsString = value.getValue().toString();
-                if(!reminderActive) {
-                    parsedParameters.add(valueAsString);
-                } else {
-                    if(!param.isListParam()) {
-                        if(parsedParameters.isEmpty()) {
-                            parsedParameters.add(valueAsString);
-                        } else {
-                            int lastIndex = parsedParameters.size() - 1;
-                            parsedParameters.set(lastIndex, parsedParameters.get(lastIndex) + " " + valueAsString);
-                        }
-                    } else {
-                        if(parsedParameters.isEmpty()) {
-                            ArrayList<Object> list = new ArrayList<>();
-                            list.add(valueAsString);
-                            parsedParameters.add(list);
-                        } else {
-                            int lastIndex = parsedParameters.size() - 1;
-                            ((List)parsedParameters.get(lastIndex)).add(valueAsString);
-                        }
-                    }
-                }
-            }
         }
 
         if(!futures.isEmpty()) {
             CompletableFuture<Parameters> multipleFuturesFuture = new CompletableFuture<>();
             CompletableFuture<Void> combinedFuture = FutureUtils.toSingleFuture(futures);
             combinedFuture.thenAccept(aVoid -> {
-                List<Object> usableParameters = parsedParameters.stream().map(o -> {
+                List<Object> allParamResults = parsedParameters.stream().map(o -> {
-                    if(o instanceof CompletableFuture) {
+                    if(o.getResult() instanceof CompletableFuture) {
-                        return ((CompletableFuture) o).join();
+                        return ((CompletableFuture) o.getResult()).join();
                     } else {
                         return o;
                     }
                 }).collect(Collectors.toList());
-                multipleFuturesFuture.complete(Parameters.builder().parameters(usableParameters).build());
+                List<ParseResult> parseResults = new ArrayList<>();
+                for (int i = 0; i < allParamResults.size(); i++) {
+                    ParseResult parseResult = ParseResult
+                            .builder()
+                            .result(allParamResults.get(i))
+                            // all parameters beyond the most possible ones are attributed to be from the last parameter
+                            .parameter(parameters.get(Math.min(i, parameters.size() - 1)))
+                            .build();
+                    parseResults.add(parseResult);
+                }
+                multipleFuturesFuture.complete(Parameters.builder().parameters(extractParametersFromParsed(parseResults)).build());
             });
 
             combinedFuture.exceptionally(throwable -> {
@@ -331,11 +317,38 @@ public class CommandReceivedHandler extends ListenerAdapter {
             });
             return multipleFuturesFuture;
         } else {
-            Parameters parameters = Parameters.builder().parameters(parsedParameters).build();
+            Parameters resultParameters = Parameters.builder().parameters(extractParametersFromParsed(parsedParameters)).build();
-            return CompletableFuture.completedFuture(parameters);
+            return CompletableFuture.completedFuture(resultParameters);
         }
     }
 
+    private List<Object> extractParametersFromParsed(List<ParseResult> results) {
+        List<Object> usableParameters = new ArrayList<>();
+        results.forEach(parseResult -> {
+            if(parseResult.getParameter().isRemainder() && !parseResult.getParameter().isListParam() && parseResult.getResult() instanceof String) {
+                if(usableParameters.isEmpty()) {
+                    usableParameters.add(parseResult.getResult());
+                } else {
+                    int lastIndex = usableParameters.size() - 1;
+                    usableParameters.set(lastIndex, usableParameters.get(lastIndex).toString() + " " + parseResult.getResult().toString());
+                }
+            } else if(parseResult.getParameter().isListParam()) {
+                if(usableParameters.isEmpty()) {
+                    ArrayList<Object> list = new ArrayList<>();
+                    list.add(parseResult.getResult().toString());
+                    usableParameters.add(list);
+                } else {
+                    int lastIndex = usableParameters.size() - 1;
+                    ((List)usableParameters.get(lastIndex)).add(parseResult.getResult());
+                }
+            }
+            else {
+                usableParameters.add(parseResult.getResult());
+            }
+        });
+       return usableParameters;
+    }
+
     @PostConstruct
     public void postConstruct() {
         metricService.registerCounter(COMMANDS_PROCESSED_COUNTER, "Commands processed");

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/AChannelParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.AChannelParameterHandler;
 import dev.sheldan.abstracto.core.command.handler.provided.TextChannelParameterHandler;
@@ -30,8 +32,8 @@ public class AChannelParameterHandlerImpl implements AChannelParameterHandler {
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
-        TextChannel textChannel = (TextChannel) textChannelParameterHandler.handle(input, iterators, clazz, context);
+        TextChannel textChannel = (TextChannel) textChannelParameterHandler.handle(input, iterators, param, context, command);
         if(textChannel == null) {
             Long channelId = Long.parseLong((String) input.getValue());
             AChannel actualInstance = channelManagementService.loadChannel(channelId);

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/AEmoteParameterHandlerImpl.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.AEmoteParameterHandler;
 import dev.sheldan.abstracto.core.command.handler.provided.EmoteParameterHandler;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.core.models.database.AEmote;
 import dev.sheldan.abstracto.core.service.EmoteService;
 import net.dv8tion.jda.api.entities.Emote;
@@ -20,14 +23,19 @@ public class AEmoteParameterHandlerImpl implements AEmoteParameterHandler {
     @Autowired
     private EmoteService emoteService;
 
+    @Autowired
+    private CommandService commandService;
+
     @Override
     public boolean handles(Class clazz) {
         return clazz.equals(AEmote.class);
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
-        Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, Emote.class, context);
+        Parameter cloned = commandService.cloneParameter(param);
+        cloned.setType(Emote.class);
+        Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, cloned, context, command);
         if(emote != null) {
             return emoteService.getFakeEmoteFromEmote(emote);
         } else {

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/ARoleParameterHandlerImpl.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.ARoleParameterHandler;
 import dev.sheldan.abstracto.core.command.handler.provided.RoleParameterHandler;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.service.RoleService;
 import net.dv8tion.jda.api.entities.Message;
@@ -20,14 +23,19 @@ public class ARoleParameterHandlerImpl implements ARoleParameterHandler {
     @Autowired
     private RoleService roleService;
 
+    @Autowired
+    private CommandService commandService;
+
     @Override
     public boolean handles(Class clazz) {
         return clazz.equals(ARole.class);
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
-        Role role = (Role) roleParameterHandler.handle(input, iterators, Role.class, context);
+        Parameter cloned = commandService.cloneParameter(param);
+        cloned.setType(Role.class);
+        Role role = (Role) roleParameterHandler.handle(input, iterators, cloned, context, command);
         return roleService.getFakeRoleFromRole(role);
     }
 

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/AUserInAServerParameterHandlerImpl.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.AUserInAServerParameterHandler;
 import dev.sheldan.abstracto.core.command.handler.provided.MemberParameterHandler;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.core.exception.UserInServerNotFoundException;
 import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.management.UserInServerManagementService;
@@ -23,10 +26,15 @@ public class AUserInAServerParameterHandlerImpl implements AUserInAServerParamet
     @Autowired
     private UserInServerManagementService userInServerManagementService;
 
+    @Autowired
+    private CommandService commandService;
+
     @Override
-    public CompletableFuture handleAsync(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public CompletableFuture handleAsync(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         CompletableFuture<AUserInAServer> future = new CompletableFuture<>();
-        memberParameterHandler.handleAsync(input, iterators, Member.class, context).whenComplete((o, throwable) -> {
+        Parameter cloned = commandService.cloneParameter(param);
+        cloned.setType(Member.class);
+        memberParameterHandler.handleAsync(input, iterators, cloned, context, command).whenComplete((o, throwable) -> {
             try {
                 AUserInAServer actualInstance;
                 if (throwable == null) {

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/BooleanParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.BooleanParameterHandler;
 import net.dv8tion.jda.api.entities.Message;
@@ -14,7 +16,7 @@ public class BooleanParameterHandlerImpl implements BooleanParameterHandler {
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         return Boolean.valueOf((String) input.getValue());
     }
 

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/ChannelGroupParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.exception.ChannelGroupNotFoundException;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.ChannelGroupParameterHandler;
@@ -23,7 +25,7 @@ public class ChannelGroupParameterHandlerImpl implements ChannelGroupParameterHa
     private ServerManagementService serverManagementService;
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         AServer server = serverManagementService.loadServer(context.getGuild().getIdLong());
         String inputString = (String) input.getValue();
         AChannelGroup actualInstance = channelGroupManagementService.findByNameAndServerOptional(inputString, server)

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/ChannelGroupTypeParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.ChannelGroupTypeParameterHandler;
 import dev.sheldan.abstracto.core.models.database.ChannelGroupType;
@@ -25,7 +27,7 @@ public class ChannelGroupTypeParameterHandlerImpl implements ChannelGroupTypePar
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         ChannelGroupType actualGroupType = channelGroupTypeManagementService.findChannelGroupTypeByKey((String) input.getValue());
         return ChannelGroupType
                 .builder()

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/CombinedParameterHandlerImpl.java

@@ -0,0 +1,86 @@
+package dev.sheldan.abstracto.core.command.handler;
+
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.exception.IncorrectParameterException;
+import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
+import dev.sheldan.abstracto.core.command.handler.parameter.CombinedParameter;
+import dev.sheldan.abstracto.core.command.handler.provided.CombinedParametersHandler;
+import dev.sheldan.abstracto.core.metric.service.MetricService;
+import dev.sheldan.abstracto.core.utils.FutureUtils;
+import lombok.extern.slf4j.Slf4j;
+import net.dv8tion.jda.api.entities.Message;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+
+@Component
+@Slf4j
+public class CombinedParameterHandlerImpl implements CombinedParametersHandler {
+
+    @Autowired
+    @Lazy
+    private List<CommandParameterHandler> parameterHandlers;
+
+    @Autowired
+    private MetricService metricService;
+
+    @Override
+    public boolean async() {
+        return true;
+    }
+
+    @Override
+    public CompletableFuture<Object> handleAsync(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
+        List<CompletableFuture<Object>> futures = new ArrayList<>();
+        CompletableFuture<Object> returningFuture = new CompletableFuture<>();
+        List<Object> possibleTypes = (List) param.getAdditionalInfo().get(Parameter.ADDITIONAL_TYPES_KEY);
+        for (Object concreteParameter: possibleTypes) {
+            for (CommandParameterHandler handler : parameterHandlers) {
+                try {
+                    if (handler.handles((Class) concreteParameter)) {
+                        if (handler.async()) {
+                            futures.add(handler.handleAsync(input, iterators, param, context, command));
+                        } else {
+                            Object result = handler.handle(input, iterators, param, context, command);
+                            futures.add(CompletableFuture.completedFuture(result));
+                        }
+                    }
+                } catch (Exception e) {
+                    CompletableFuture<Object> exceptionFuture = new CompletableFuture<>();
+                    futures.add(exceptionFuture);
+                    exceptionFuture.completeExceptionally(e);
+                }
+            }
+        }
+        FutureUtils.toSingleFutureGeneric(futures).whenComplete((unused, throwable) -> {
+            for (CompletableFuture<Object> future: futures) {
+                if(!future.isCompletedExceptionally()) {
+                    Object value = future.join();
+                    if(value != null) {
+                        returningFuture.complete(value);
+                        return;
+                    }
+                }
+            }
+            returningFuture.completeExceptionally(new IncorrectParameterException(command, param.getName()));
+        });
+        return returningFuture;
+    }
+
+    @Override
+    public boolean handles(Class clazz) {
+        return clazz.equals(CombinedParameter.class);
+    }
+
+    @Override
+    public Integer getPriority() {
+        return CommandConstants.CORE_HANDLER_PRIORITY;
+    }
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/CommandKeyParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.CommandParameterKey;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.CommandKeyParameterHandler;
@@ -16,8 +18,8 @@ public class CommandKeyParameterHandlerImpl implements CommandKeyParameterHandle
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
-        return CommandParameterKey.getEnumFromKey(clazz, (String) input.getValue());
+        return CommandParameterKey.getEnumFromKey(param.getType(), (String) input.getValue());
     }
 
     @Override

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/DoubleParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.DoubleParameterHandler;
 import net.dv8tion.jda.api.entities.Message;
@@ -14,7 +16,7 @@ public class DoubleParameterHandlerImpl implements DoubleParameterHandler {
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         return Double.parseDouble((String) input.getValue());
     }
 

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/DurationParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.DurationParameterHandler;
 import dev.sheldan.abstracto.core.utils.ParseUtils;
@@ -17,7 +19,7 @@ public class DurationParameterHandlerImpl implements DurationParameterHandler {
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         return ParseUtils.parseDuration((String) input.getValue());
     }
 

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/EmoteParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.EmoteParameterHandler;
 import net.dv8tion.jda.api.entities.Emote;
@@ -19,7 +21,7 @@ public class EmoteParameterHandlerImpl implements EmoteParameterHandler {
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         String inputString = (String) input.getValue();
         Matcher matcher = Message.MentionType.EMOTE.getPattern().matcher(inputString);
         if(matcher.matches()) {

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/FileParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.exception.NoAttachmentFoundException;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.FileParameterHandler;
@@ -25,7 +27,7 @@ public class FileParameterHandlerImpl implements FileParameterHandler {
     }
 
     @Override
-    public CompletableFuture<Object> handleAsync(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public CompletableFuture<Object> handleAsync(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         if(context.getAttachments().isEmpty()) {
             throw new NoAttachmentFoundException();
         }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/FullEmoteParameterHandlerImpl.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.EmoteParameterHandler;
 import dev.sheldan.abstracto.core.command.handler.provided.FullEmoteParameterHandler;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.core.models.FullEmote;
 import dev.sheldan.abstracto.core.models.database.AEmote;
 import dev.sheldan.abstracto.core.service.EmoteService;
@@ -21,14 +24,19 @@ public class FullEmoteParameterHandlerImpl implements FullEmoteParameterHandler
     @Autowired
     private EmoteService emoteService;
 
+    @Autowired
+    private CommandService commandService;
+
     @Override
     public boolean handles(Class clazz) {
         return clazz.equals(FullEmote.class);
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
-        Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, Emote.class, context);
+        Parameter cloned = commandService.cloneParameter(param);
+        cloned.setType(Emote.class);
+        Emote emote = (Emote) emoteParameterHandler.handle(input, iterators, cloned, context, command);
         AEmote aEmote;
         if(emote != null) {
             aEmote = emoteService.getFakeEmoteFromEmote(emote);

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/FullRoleParameterHandlerImpl.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.FullRoleParameterHandler;
 import dev.sheldan.abstracto.core.command.handler.provided.RoleParameterHandler;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.core.models.FullRole;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.service.RoleService;
@@ -21,14 +24,20 @@ public class FullRoleParameterHandlerImpl implements FullRoleParameterHandler {
     @Autowired
     private RoleService roleService;
 
+    @Autowired
+    private CommandService commandService;
+
     @Override
     public boolean handles(Class clazz) {
         return clazz.equals(FullRole.class);
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
-        Role role = (Role) roleParameterHandler.handle(input, iterators, Role.class, context);
+        Parameter cloned = commandService.cloneParameter(param);
+        cloned.setType(Role.class);
+
+        Role role = (Role) roleParameterHandler.handle(input, iterators, cloned, context, command);
         ARole aRole = roleService.getFakeRoleFromRole(role);
         return FullRole.builder().role(aRole).serverRole(role).build();
     }

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/IntegerParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.IntegerParameterHandler;
 import net.dv8tion.jda.api.entities.Message;
@@ -15,7 +17,7 @@ public class IntegerParameterHandlerImpl implements IntegerParameterHandler {
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         return Integer.parseInt((String) input.getValue());
     }
 

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/LongParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.LongParameterHandler;
 import net.dv8tion.jda.api.entities.Message;
@@ -15,7 +17,7 @@ public class LongParameterHandlerImpl implements LongParameterHandler {
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         return Long.parseLong((String) input.getValue());
     }
 

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/MemberParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.exception.AbstractoTemplatedException;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.MemberParameterHandler;
@@ -26,7 +28,7 @@ public class MemberParameterHandlerImpl implements MemberParameterHandler {
     }
 
     @Override
-    public CompletableFuture<Object> handleAsync(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public CompletableFuture<Object> handleAsync(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         String inputString = (String) input.getValue();
         Matcher matcher = Message.MentionType.USER.getPattern().matcher(inputString);
         if(matcher.matches()) {

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/MessageParameterHandlerImpl.java

@@ -0,0 +1,28 @@
+package dev.sheldan.abstracto.core.command.handler;
+
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
+import dev.sheldan.abstracto.core.command.handler.provided.MessageParameterHandler;
+import net.dv8tion.jda.api.entities.Message;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MessageParameterHandlerImpl implements MessageParameterHandler {
+
+    @Override
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
+        return context.getReferencedMessage();
+    }
+
+    @Override
+    public boolean handles(Class clazz) {
+        return clazz.equals(Message.class);
+    }
+
+    @Override
+    public Integer getPriority() {
+        return CommandConstants.CORE_HANDLER_PRIORITY;
+    }
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/RoleParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.exception.AbstractoTemplatedException;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.RoleParameterHandler;
@@ -20,7 +22,7 @@ public class RoleParameterHandlerImpl implements RoleParameterHandler {
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         String inputString = (String) input.getValue();
         Matcher matcher = Message.MentionType.ROLE.getPattern().matcher(inputString);
         if(matcher.matches()) {

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/StringParameterHandlerImpl.java

@@ -0,0 +1,28 @@
+package dev.sheldan.abstracto.core.command.handler;
+
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
+import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
+import dev.sheldan.abstracto.core.command.handler.provided.StringParameterHandler;
+import net.dv8tion.jda.api.entities.Message;
+import org.springframework.stereotype.Component;
+
+@Component
+public class StringParameterHandlerImpl implements StringParameterHandler {
+
+    @Override
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
+        return input.getValue().toString();
+    }
+
+    @Override
+    public boolean handles(Class clazz) {
+        return clazz.equals(String.class);
+    }
+
+    @Override
+    public Integer getPriority() {
+        return CommandConstants.CORE_HANDLER_PRIORITY;
+    }
+}

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/handler/TextChannelParameterHandlerImpl.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.CommandConstants;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.exception.AbstractoTemplatedException;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.command.handler.provided.TextChannelParameterHandler;
@@ -20,7 +22,7 @@ public class TextChannelParameterHandlerImpl implements TextChannelParameterHand
     }
 
     @Override
-    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) {
+    public Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) {
         String inputString = (String) input.getValue();
         Matcher matcher = Message.MentionType.CHANNEL.getPattern().matcher(inputString);
         if(matcher.matches()) {

abstracto-application/core/core-impl/src/main/java/dev/sheldan/abstracto/core/command/service/CommandServiceBean.java

@@ -7,6 +7,7 @@ import dev.sheldan.abstracto.core.command.condition.CommandCondition;
 import dev.sheldan.abstracto.core.command.condition.ConditionResult;
 import dev.sheldan.abstracto.core.command.condition.ConditionalCommand;
 import dev.sheldan.abstracto.core.command.config.CommandConfiguration;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.config.Parameters;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.UnParsedCommandParameter;
@@ -179,6 +180,21 @@ public class CommandServiceBean implements CommandService {
         return commandReceivedHandler.getParsedParameters(unParsedParameter, command, messageContainingContent);
     }
 
+    @Override
+    public Parameter cloneParameter(Parameter parameter) {
+        return Parameter
+                .builder()
+                .optional(parameter.isOptional())
+                .type(parameter.getType())
+                .remainder(parameter.isRemainder())
+                .name(parameter.getName())
+                .templated(parameter.getTemplated())
+                .description(parameter.getDescription())
+                .validators(parameter.getValidators())
+                .isListParam(parameter.isListParam())
+                .build();
+    }
+
     private ConditionResult checkConditions(CommandContext commandContext, Command command, List<CommandCondition> conditions) {
         if(conditions != null) {
             for (CommandCondition condition : conditions) {

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AChannelParameterHandlerImplTest.java

@@ -1,5 +1,7 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import dev.sheldan.abstracto.core.models.database.AChannel;
 import dev.sheldan.abstracto.core.service.ChannelService;
@@ -38,6 +40,12 @@ public class AChannelParameterHandlerImplTest extends AbstractParameterHandlerTe
     @Mock
     private AChannel aChannel;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(AChannel.class));
@@ -51,9 +59,9 @@ public class AChannelParameterHandlerImplTest extends AbstractParameterHandlerTe
     @Test
     public void testProperChannelMention() {
         UnparsedCommandParameterPiece piece = getPiece();
-        when(textChannelParameterHandler.handle(piece, iterators, TextChannel.class, message)).thenReturn(channel);
+        when(textChannelParameterHandler.handle(piece, iterators, parameter, message, command)).thenReturn(channel);
         when(channelService.getFakeChannelFromTextChannel(channel)).thenReturn(aChannel);
-        AChannel parsed = (AChannel) testUnit.handle(piece, iterators, TextChannel.class, message);
+        AChannel parsed = (AChannel) testUnit.handle(piece, iterators, parameter, message, command);
         Assert.assertEquals(aChannel, parsed);
     }
 

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/AEmoteParameterHandlerImplImplTest.java

@@ -1,6 +1,9 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.core.models.database.AEmote;
 import dev.sheldan.abstracto.core.service.EmoteService;
 import net.dv8tion.jda.api.entities.Emote;
@@ -27,6 +30,9 @@ public class AEmoteParameterHandlerImplImplTest extends AbstractParameterHandler
     @Mock
     private EmoteService emoteService;
 
+    @Mock
+    private CommandService commandService;
+
     @Mock
     private CommandParameterIterators iterators;
 
@@ -39,6 +45,15 @@ public class AEmoteParameterHandlerImplImplTest extends AbstractParameterHandler
     @Mock
     private AEmote aEmote;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Parameter parameter2;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(AEmote.class));
@@ -52,18 +67,20 @@ public class AEmoteParameterHandlerImplImplTest extends AbstractParameterHandler
     @Test
     public void testProperEmoteMention() {
         UnparsedCommandParameterPiece piece = getPieceWithValue(INPUT);
-        when(emoteParameterHandler.handle(piece, iterators, Emote.class, message)).thenReturn(emote);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
+        when(emoteParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(emote);
         when(emoteService.getFakeEmoteFromEmote(emote)).thenReturn(aEmote);
-        AEmote parsed = (AEmote) testUnit.handle(piece, iterators, AEmote.class, message);
+        AEmote parsed = (AEmote) testUnit.handle(piece, iterators, parameter, message, command);
         Assert.assertEquals(aEmote, parsed);
     }
 
     @Test
     public void testDefaultEmoteHandling() {
         UnparsedCommandParameterPiece piece = getPieceWithValue(INPUT);
-        when(emoteParameterHandler.handle(piece, iterators, Emote.class, message)).thenReturn(null);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
+        when(emoteParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(null);
         when(emoteService.getFakeEmote(INPUT)).thenReturn(aEmote);
-        AEmote parsed = (AEmote) testUnit.handle(piece, iterators, AEmote.class, message);
+        AEmote parsed = (AEmote) testUnit.handle(piece, iterators, parameter, message, command);
         Assert.assertEquals(aEmote, parsed);
     }
 

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/ARoleParameterHandlerImplImplTest.java

@@ -1,6 +1,9 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.core.models.database.AEmote;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.service.RoleService;
@@ -27,6 +30,9 @@ public class ARoleParameterHandlerImplImplTest extends AbstractParameterHandlerT
     @Mock
     private RoleService roleService;
 
+    @Mock
+    private CommandService commandService;
+
     @Mock
     private CommandParameterIterators iterators;
 
@@ -39,6 +45,15 @@ public class ARoleParameterHandlerImplImplTest extends AbstractParameterHandlerT
     @Mock
     private ARole aRole;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Parameter parameter2;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(ARole.class));
@@ -52,9 +67,10 @@ public class ARoleParameterHandlerImplImplTest extends AbstractParameterHandlerT
     @Test
     public void testProperRoleMention() {
         UnparsedCommandParameterPiece piece = getPiece();
-        when(roleParameterHandler.handle(piece, iterators, Role.class, message)).thenReturn(role);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
+        when(roleParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(role);
         when(roleService.getFakeRoleFromRole(role)).thenReturn(aRole);
-        ARole parsed = (ARole) testUnit.handle(piece, iterators, AEmote.class, message);
+        ARole parsed = (ARole) testUnit.handle(piece, iterators, parameter, message, command);
         Assert.assertEquals(aRole, parsed);
     }
 

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/BooleanParameterHandlerImplTest.java

@@ -1,10 +1,13 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
+import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
@@ -13,6 +16,12 @@ public class BooleanParameterHandlerImplTest extends AbstractParameterHandlerTes
     @InjectMocks
     private BooleanParameterHandlerImpl testUnit;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(Boolean.class));
@@ -26,25 +35,25 @@ public class BooleanParameterHandlerImplTest extends AbstractParameterHandlerTes
     @Test
     public void testTrueParsing() {
         UnparsedCommandParameterPiece piece = getPieceWithValue("true");
-        Assert.assertTrue((Boolean)testUnit.handle(piece, null, null, null));
+        Assert.assertTrue((Boolean)testUnit.handle(piece, null, parameter, null, command));
     }
 
     @Test
     public void testAnyOtherText() {
         UnparsedCommandParameterPiece piece = getPieceWithValue("test");
-        Assert.assertFalse((Boolean)testUnit.handle(piece, null, null, null));
+        Assert.assertFalse((Boolean)testUnit.handle(piece, null, parameter, null, command));
     }
 
     @Test
     public void testNullInput() {
         UnparsedCommandParameterPiece piece = getPieceWithValue(null);
-        Assert.assertFalse((Boolean)testUnit.handle(piece, null, null, null));
+        Assert.assertFalse((Boolean)testUnit.handle(piece, null, parameter, null, command));
     }
 
     @Test
     public void testEmptyStringAsInput() {
         UnparsedCommandParameterPiece piece = getPieceWithValue("");
-        Assert.assertFalse((Boolean)testUnit.handle(piece, null, null, null));
+        Assert.assertFalse((Boolean)testUnit.handle(piece, null, parameter, null, command));
     }
 
 }

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DoubleParameterHandlerImplTest.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
+import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
@@ -12,6 +15,12 @@ public class DoubleParameterHandlerImplTest extends AbstractParameterHandlerTest
     @InjectMocks
     private DoubleParameterHandlerImpl testUnit;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(Double.class));
@@ -24,32 +33,32 @@ public class DoubleParameterHandlerImplTest extends AbstractParameterHandlerTest
 
     @Test
     public void testSuccessfulParse() {
-        Assert.assertEquals(5D, testUnit.handle(getPieceWithValue("5"), null, null, null));
+        Assert.assertEquals(5D, testUnit.handle(getPieceWithValue("5"), null, parameter, null, command));
     }
 
     @Test
     public void testNegativeNumber() {
-        Assert.assertEquals(-5D, testUnit.handle(getPieceWithValue("-5"), null, null, null));
+        Assert.assertEquals(-5D, testUnit.handle(getPieceWithValue("-5"), null, parameter, null, command));
     }
 
 
     public void testDecimal() {
-        Assert.assertEquals(3.14D, testUnit.handle(getPieceWithValue("3.14"), null, null, null));
+        Assert.assertEquals(3.14D, testUnit.handle(getPieceWithValue("3.14"), null, parameter, null, command));
     }
 
     @Test(expected = NumberFormatException.class)
     public void testTextAsInput() {
-        testUnit.handle(getPieceWithValue("someText"), null, null, null);
+        testUnit.handle(getPieceWithValue("someText"), null, parameter, null, command);
     }
 
     @Test(expected = NullPointerException.class)
     public void testNullInput() {
-        testUnit.handle(getPieceWithValue(null), null, null, null);
+        testUnit.handle(getPieceWithValue(null), null, parameter, null, command);
     }
 
     @Test(expected = NumberFormatException.class)
     public void testEmptyStringAsInput() {
-        testUnit.handle(getPieceWithValue(""), null, null, null);
+        testUnit.handle(getPieceWithValue(""), null, parameter, null, command);
     }
 
 }

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/DurationParameterHandlerImplTest.java

@@ -1,10 +1,13 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.exception.DurationFormatException;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
+import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
 import java.time.Duration;
@@ -16,6 +19,12 @@ public class DurationParameterHandlerImplTest extends AbstractParameterHandlerTe
     @InjectMocks
     private DurationParameterHandlerImpl testUnit;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(Duration.class));
@@ -28,23 +37,23 @@ public class DurationParameterHandlerImplTest extends AbstractParameterHandlerTe
 
     @Test
     public void testSimpleParsing() {
-        Assert.assertEquals(Duration.ofMinutes(1), testUnit.handle(getPieceWithValue("1m"), null, null, null));
+        Assert.assertEquals(Duration.ofMinutes(1), testUnit.handle(getPieceWithValue("1m"), null, parameter, null, command));
     }
 
     @Test
     public void testMoreComplicatedParsing() {
         Duration targetDuration = Duration.ofDays(4).plus(5, ChronoUnit.HOURS).plus(5, ChronoUnit.MINUTES);
-        Assert.assertEquals(targetDuration, testUnit.handle(getPieceWithValue("5h5m4d"), null, null, null));
+        Assert.assertEquals(targetDuration, testUnit.handle(getPieceWithValue("5h5m4d"), null, parameter, null, command));
     }
 
     @Test(expected = DurationFormatException.class)
     public void testNullInput() {
-        testUnit.handle(getPieceWithValue(null), null, null, null);
+        testUnit.handle(getPieceWithValue(null), null, parameter, null, command);
     }
 
     @Test(expected = DurationFormatException.class)
     public void testEmptyStringAsInput() {
-        testUnit.handle(getPieceWithValue(""), null, null, null);
+        testUnit.handle(getPieceWithValue(""), null, parameter, null, command);
     }
 
 }

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/EmoteParameterHandlerImplTest.java

@@ -1,5 +1,7 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import net.dv8tion.jda.api.entities.Emote;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Message;
@@ -33,6 +35,12 @@ public class EmoteParameterHandlerImplTest extends AbstractParameterHandlerTest
     @Mock
     private Guild guild;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     private static final Long EMOTE_ID = 111111111111111111L;
     private static final String EMOTE_NAME = "test";
 
@@ -50,7 +58,7 @@ public class EmoteParameterHandlerImplTest extends AbstractParameterHandlerTest
     public void testProperEmoteMention() {
         oneEmoteInIterator();
         String input = getEmoteMention();
-        Emote parsed = (Emote) testUnit.handle(getPieceWithValue(input), iterators, Emote.class, null);
+        Emote parsed = (Emote) testUnit.handle(getPieceWithValue(input), iterators, parameter, null, command);
         Assert.assertEquals(parsed, emote);
     }
 
@@ -58,13 +66,13 @@ public class EmoteParameterHandlerImplTest extends AbstractParameterHandlerTest
     public void testEmoteById() {
         setupMessage();
         String input = EMOTE_ID.toString();
-        Emote parsed = (Emote) testUnit.handle(getPieceWithValue(input), null, Emote.class, message);
+        Emote parsed = (Emote) testUnit.handle(getPieceWithValue(input), null, parameter, message, command);
         Assert.assertEquals(parsed, emote);
     }
 
     @Test
     public void testInvalidEmoteMention() {
-        Assert.assertNull(testUnit.handle(getPieceWithValue("test"), null, Emote.class, null));
+        Assert.assertNull(testUnit.handle(getPieceWithValue("test"), null, parameter, null, command));
     }
 
     private String getEmoteMention() {

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullEmoteParameterHandlerImplImplTest.java

@@ -1,6 +1,9 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.core.models.FullEmote;
 import dev.sheldan.abstracto.core.models.database.AEmote;
 import dev.sheldan.abstracto.core.service.EmoteService;
@@ -27,6 +30,9 @@ public class FullEmoteParameterHandlerImplImplTest extends AbstractParameterHand
     @Mock
     private EmoteService emoteService;
 
+    @Mock
+    private CommandService commandService;
+
     @Mock
     private CommandParameterIterators iterators;
 
@@ -39,6 +45,15 @@ public class FullEmoteParameterHandlerImplImplTest extends AbstractParameterHand
     @Mock
     private AEmote aEmote;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Parameter parameter2;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(FullEmote.class));
@@ -53,9 +68,10 @@ public class FullEmoteParameterHandlerImplImplTest extends AbstractParameterHand
     public void testProperEmoteMention() {
         String input = "test";
         UnparsedCommandParameterPiece piece = getPieceWithValue(input);
-        when(emoteParameterHandler.handle(piece, iterators, Emote.class, message)).thenReturn(emote);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
+        when(emoteParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(emote);
         when(emoteService.getFakeEmoteFromEmote(emote)).thenReturn(aEmote);
-        FullEmote parsed = (FullEmote) testUnit.handle(piece, iterators, FullEmote.class, message);
+        FullEmote parsed = (FullEmote) testUnit.handle(piece, iterators, parameter, message, command);
         Assert.assertEquals(aEmote, parsed.getFakeEmote());
         Assert.assertEquals(emote, parsed.getEmote());
     }
@@ -65,9 +81,10 @@ public class FullEmoteParameterHandlerImplImplTest extends AbstractParameterHand
     public void testDefaultEmoteHandling() {
         String input = "test";
         UnparsedCommandParameterPiece piece = getPieceWithValue(input);
-        when(emoteParameterHandler.handle(piece, iterators, Emote.class, message)).thenReturn(null);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
+        when(emoteParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(null);
         when(emoteService.getFakeEmote(input)).thenReturn(aEmote);
-        FullEmote parsed = (FullEmote) testUnit.handle(piece, iterators, AEmote.class, message);
+        FullEmote parsed = (FullEmote) testUnit.handle(piece, iterators, parameter, message, command);
         Assert.assertNull(parsed.getEmote());
         Assert.assertEquals(aEmote, parsed.getFakeEmote());
     }

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/FullRoleParameterHandlerImplImplTest.java

@@ -1,6 +1,9 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
+import dev.sheldan.abstracto.core.command.service.CommandService;
 import dev.sheldan.abstracto.core.models.FullRole;
 import dev.sheldan.abstracto.core.models.database.ARole;
 import dev.sheldan.abstracto.core.service.RoleService;
@@ -27,6 +30,9 @@ public class FullRoleParameterHandlerImplImplTest extends AbstractParameterHandl
     @Mock
     private RoleService roleService;
 
+    @Mock
+    private CommandService commandService;
+
     @Mock
     private CommandParameterIterators iterators;
 
@@ -39,6 +45,15 @@ public class FullRoleParameterHandlerImplImplTest extends AbstractParameterHandl
     @Mock
     private ARole aRole;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Parameter parameter2;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(FullRole.class));
@@ -52,9 +67,10 @@ public class FullRoleParameterHandlerImplImplTest extends AbstractParameterHandl
     @Test
     public void testProperEmoteMention() {
         UnparsedCommandParameterPiece piece = getPiece();
-        when(roleParameterHandler.handle(piece, iterators, Role.class, message)).thenReturn(role);
+        when(commandService.cloneParameter(parameter)).thenReturn(parameter2);
+        when(roleParameterHandler.handle(piece, iterators, parameter2, message, command)).thenReturn(role);
         when(roleService.getFakeRoleFromRole(role)).thenReturn(aRole);
-        FullRole parsed = (FullRole) testUnit.handle(piece, iterators, FullRole.class, message);
+        FullRole parsed = (FullRole) testUnit.handle(piece, iterators, parameter, message, command);
         Assert.assertEquals(aRole, parsed.getRole());
         Assert.assertEquals(role, parsed.getServerRole());
     }

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/IntegerParameterHandlerImplTest.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
+import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
@@ -12,6 +15,12 @@ public class IntegerParameterHandlerImplTest extends AbstractParameterHandlerTes
     @InjectMocks
     private IntegerParameterHandlerImpl testUnit;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(Integer.class));
@@ -24,33 +33,33 @@ public class IntegerParameterHandlerImplTest extends AbstractParameterHandlerTes
 
     @Test
     public void testSuccessfulParse() {
-        Assert.assertEquals(5, testUnit.handle(getPieceWithValue("5"), null, null, null));
+        Assert.assertEquals(5, testUnit.handle(getPieceWithValue("5"), null, parameter, null, command));
     }
 
     @Test
     public void testNegativeNumber() {
-        Assert.assertEquals(-5, testUnit.handle(getPieceWithValue("-5"), null, null, null));
+        Assert.assertEquals(-5, testUnit.handle(getPieceWithValue("-5"), null, parameter, null, command));
     }
 
 
     @Test(expected = NumberFormatException.class)
     public void testDecimal() {
-        testUnit.handle(getPieceWithValue("3.14"), null, null, null);
+        testUnit.handle(getPieceWithValue("3.14"), null, parameter, null, command);
     }
 
     @Test(expected = NumberFormatException.class)
     public void testTextAsInput() {
-        testUnit.handle(getPieceWithValue("someText"), null, null, null);
+        testUnit.handle(getPieceWithValue("someText"), null, parameter, null, command);
     }
 
     @Test(expected = NumberFormatException.class)
     public void testNullInput() {
-        testUnit.handle(getPieceWithValue(null), null, null, null);
+        testUnit.handle(getPieceWithValue(null), null, parameter, null, command);
     }
 
     @Test(expected = NumberFormatException.class)
     public void testEmptyStringAsInput() {
-        testUnit.handle(getPieceWithValue(""), null, null, null);
+        testUnit.handle(getPieceWithValue(""), null, parameter, null, command);
     }
 
 }

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/LongParameterHandlerImplTest.java

@@ -1,9 +1,12 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
+import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
 @RunWith(MockitoJUnitRunner.class)
@@ -12,6 +15,12 @@ public class LongParameterHandlerImplTest extends AbstractParameterHandlerTest {
     @InjectMocks
     private LongParameterHandlerImpl testUnit;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     @Test
     public void testSuccessfulCondition() {
         Assert.assertTrue(testUnit.handles(Long.class));
@@ -24,32 +33,32 @@ public class LongParameterHandlerImplTest extends AbstractParameterHandlerTest {
 
     @Test
     public void testSuccessfulParse() {
-        Assert.assertEquals(5L, testUnit.handle(getPieceWithValue("5"), null, null, null));
+        Assert.assertEquals(5L, testUnit.handle(getPieceWithValue("5"), null, parameter, null, command));
     }
 
     @Test
     public void testNegativeNumber() {
-        Assert.assertEquals(-5L, testUnit.handle(getPieceWithValue("-5"), null, null, null));
+        Assert.assertEquals(-5L, testUnit.handle(getPieceWithValue("-5"), null, parameter, null, command));
     }
 
     @Test(expected = NumberFormatException.class)
     public void testDecimal() {
-        testUnit.handle(getPieceWithValue("3.14"), null, null, null);
+        testUnit.handle(getPieceWithValue("3.14"), null, parameter, null, command);
     }
 
     @Test(expected = NumberFormatException.class)
     public void testTextAsInput() {
-        testUnit.handle(getPieceWithValue("someText"), null, null, null);
+        testUnit.handle(getPieceWithValue("someText"), null, parameter, null, command);
     }
 
     @Test(expected = NumberFormatException.class)
     public void testNullInput() {
-        testUnit.handle(getPieceWithValue(null), null, null, null);
+        testUnit.handle(getPieceWithValue(null), null, parameter, null, command);
     }
 
     @Test(expected = NumberFormatException.class)
     public void testEmptyStringAsInput() {
-        testUnit.handle(getPieceWithValue(""), null, null, null);
+        testUnit.handle(getPieceWithValue(""), null, parameter, null, command);
     }
 
 }

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/MemberParameterHandlerImplTest.java

@@ -1,5 +1,7 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.exception.AbstractoTemplatedException;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Member;
@@ -38,6 +40,12 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest
     @Mock
     private Guild guild;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     private static final Long USER_ID = 111111111111111111L;
 
     @Test
@@ -55,7 +63,7 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest
     public void testProperMemberMention() {
         oneMemberInIterator();
         String input = getUserMention();
-        CompletableFuture<Member> parsed = (CompletableFuture) testUnit.handleAsync(getPieceWithValue(input), iterators, Member.class, null);
+        CompletableFuture<Member> parsed = (CompletableFuture) testUnit.handleAsync(getPieceWithValue(input), iterators, parameter, null, command);
         Assert.assertEquals(member, parsed.join());
     }
 
@@ -64,7 +72,7 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest
     public void testMemberById() {
         setupMessage();
         String input = USER_ID.toString();
-        CompletableFuture<Member> parsed = (CompletableFuture) testUnit.handleAsync(getPieceWithValue(input), null, Member.class, message);
+        CompletableFuture<Member> parsed = (CompletableFuture) testUnit.handleAsync(getPieceWithValue(input), null, parameter, message, command);
         Assert.assertEquals(member, parsed.join());
     }
 
@@ -73,7 +81,7 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest
         String input = "test";
         when(message.getGuild()).thenReturn(guild);
         when(guild.getMembersByName(input, true)).thenReturn(new ArrayList<>());
-        testUnit.handleAsync(getPieceWithValue(input), null, Member.class, message);
+        testUnit.handleAsync(getPieceWithValue(input), null, parameter, message, command);
     }
 
     @Test(expected = AbstractoTemplatedException.class)
@@ -82,7 +90,7 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest
         Member secondMember = Mockito.mock(Member.class);
         when(message.getGuild()).thenReturn(guild);
         when(guild.getMembersByName(input, true)).thenReturn(Arrays.asList(member, secondMember));
-        testUnit.handleAsync(getPieceWithValue(input), null, Member.class, message);
+        testUnit.handleAsync(getPieceWithValue(input), null, parameter, message, command);
     }
 
     @Test
@@ -90,7 +98,7 @@ public class MemberParameterHandlerImplTest extends AbstractParameterHandlerTest
         String input = "test";
         when(message.getGuild()).thenReturn(guild);
         when(guild.getMembersByName(input, true)).thenReturn(Arrays.asList(member));
-        CompletableFuture<Object> future = testUnit.handleAsync(getPieceWithValue(input), null, Member.class, message);
+        CompletableFuture<Object> future = testUnit.handleAsync(getPieceWithValue(input), null, parameter, message, command);
         Member returnedMember = (Member) future.join();
         Assert.assertFalse(future.isCompletedExceptionally());
         Assert.assertEquals(member, returnedMember);

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/RoleParameterHandlerImplTest.java

@@ -1,5 +1,7 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.exception.AbstractoTemplatedException;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Message;
@@ -36,6 +38,12 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest {
     @Mock
     private Guild guild;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     private static final Long ROLE_ID = 111111111111111111L;
 
     @Test
@@ -52,7 +60,7 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest {
     public void testProperRoleMention() {
         oneRoleIterator();
         String input = getRoleMention();
-        Role parsed = (Role) testUnit.handle(getPieceWithValue(input), iterators, Role.class, null);
+        Role parsed = (Role) testUnit.handle(getPieceWithValue(input), iterators, parameter, null, command);
         Assert.assertEquals(role, parsed);
     }
 
@@ -60,7 +68,7 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest {
     public void testRoleById() {
         setupMessage();
         String input = ROLE_ID.toString();
-        Role parsed = (Role) testUnit.handle(getPieceWithValue(input), null, Role.class, message);
+        Role parsed = (Role) testUnit.handle(getPieceWithValue(input), null, parameter, message, command);
         Assert.assertEquals(role, parsed);
     }
 
@@ -69,7 +77,7 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest {
         String input = "test";
         when(message.getGuild()).thenReturn(guild);
         when(guild.getRolesByName(input, true)).thenReturn(new ArrayList<>());
-        testUnit.handle(getPieceWithValue(input), null, Role.class, message);
+        testUnit.handle(getPieceWithValue(input), null, parameter, message, command);
     }
 
     @Test(expected = AbstractoTemplatedException.class)
@@ -78,7 +86,7 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest {
         Role secondRole = Mockito.mock(Role.class);
         when(message.getGuild()).thenReturn(guild);
         when(guild.getRolesByName(input, true)).thenReturn(Arrays.asList(role, secondRole));
-        testUnit.handle(getPieceWithValue(input), null, Role.class, message);
+        testUnit.handle(getPieceWithValue(input), null, parameter, message, command);
     }
 
     @Test
@@ -86,7 +94,7 @@ public class RoleParameterHandlerImplTest extends AbstractParameterHandlerTest {
         String input = "test";
         when(message.getGuild()).thenReturn(guild);
         when(guild.getRolesByName(input, true)).thenReturn(Arrays.asList(role));
-        Role returnedRole =  (Role) testUnit.handle(getPieceWithValue(input), null, Role.class, message);
+        Role returnedRole =  (Role) testUnit.handle(getPieceWithValue(input), null, parameter, message, command);
         Assert.assertEquals(role, returnedRole);
     }
 

abstracto-application/core/core-impl/src/test/java/dev/sheldan/abstracto/core/command/handler/TextChannelParameterHandlerImplTest.java

@@ -1,5 +1,7 @@
 package dev.sheldan.abstracto.core.command.handler;
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.exception.AbstractoTemplatedException;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Message;
@@ -36,6 +38,12 @@ public class TextChannelParameterHandlerImplTest extends AbstractParameterHandle
     @Mock
     private Guild guild;
 
+    @Mock
+    private Parameter parameter;
+
+    @Mock
+    private Command command;
+
     private static final Long CHANNEL_ID = 111111111111111111L;
 
     @Test
@@ -52,7 +60,7 @@ public class TextChannelParameterHandlerImplTest extends AbstractParameterHandle
     public void testProperChannelMention() {
         oneChannelInIterator();
         String input = getChannelMention();
-        TextChannel parsed = (TextChannel) testUnit.handle(getPieceWithValue(input), iterators, TextChannel.class, null);
+        TextChannel parsed = (TextChannel) testUnit.handle(getPieceWithValue(input), iterators, parameter, null, command);
         Assert.assertEquals(channel, parsed);
     }
 
@@ -60,7 +68,7 @@ public class TextChannelParameterHandlerImplTest extends AbstractParameterHandle
     public void testChannelMentionById() {
         setupMessage();
         String input = CHANNEL_ID.toString();
-        TextChannel parsed = (TextChannel) testUnit.handle(getPieceWithValue(input), null, TextChannel.class, message);
+        TextChannel parsed = (TextChannel) testUnit.handle(getPieceWithValue(input), null, parameter, message, command);
         Assert.assertEquals(channel, parsed);
     }
 
@@ -69,7 +77,7 @@ public class TextChannelParameterHandlerImplTest extends AbstractParameterHandle
         String input = "test";
         when(message.getGuild()).thenReturn(guild);
         when(guild.getTextChannelsByName(input, true)).thenReturn(new ArrayList<>());
-        testUnit.handle(getPieceWithValue(input), null, TextChannel.class, message);
+        testUnit.handle(getPieceWithValue(input), null, parameter, message, command);
     }
 
     @Test(expected = AbstractoTemplatedException.class)
@@ -78,7 +86,7 @@ public class TextChannelParameterHandlerImplTest extends AbstractParameterHandle
         TextChannel secondChannel = Mockito.mock(TextChannel.class);
         when(message.getGuild()).thenReturn(guild);
         when(guild.getTextChannelsByName(input, true)).thenReturn(Arrays.asList(channel, secondChannel));
-        testUnit.handle(getPieceWithValue(input), null, TextChannel.class, message);
+        testUnit.handle(getPieceWithValue(input), null, parameter, message, command);
     }
 
     @Test
@@ -86,7 +94,7 @@ public class TextChannelParameterHandlerImplTest extends AbstractParameterHandle
         String input = "test";
         when(message.getGuild()).thenReturn(guild);
         when(guild.getTextChannelsByName(input, true)).thenReturn(Arrays.asList(channel));
-        TextChannel returnedChannel =  (TextChannel) testUnit.handle(getPieceWithValue(input), null, TextChannel.class, message);
+        TextChannel returnedChannel =  (TextChannel) testUnit.handle(getPieceWithValue(input), null, parameter, message, command);
         Assert.assertEquals(channel, returnedChannel);
     }
 

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/config/Parameter.java

@@ -6,7 +6,9 @@ import lombok.Setter;
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 @Getter
 @Setter
@@ -25,4 +27,8 @@ public class Parameter implements Serializable {
     private Boolean templated = false;
     @Builder.Default
     private List<ParameterValidator> validators = new ArrayList<>();
+    @Builder.Default
+    private Map<String, Object> additionalInfo = new HashMap<>();
+
+    public static final String ADDITIONAL_TYPES_KEY = "ADDITIONAL_TYPES";
 }

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/config/ParseResult.java

@@ -0,0 +1,13 @@
+package dev.sheldan.abstracto.core.command.config;
+
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@Builder
+public class ParseResult {
+    private Parameter parameter;
+    private Object result;
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/execution/ParameterPieceType.java

@@ -1,5 +1,5 @@
 package dev.sheldan.abstracto.core.command.execution;
 
 public enum ParameterPieceType {
-    STRING, ATTACHMENT
+    STRING, ATTACHMENT, REFERENCED_MESSAGE
 }

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/execution/UnParsedCommandParameter.java

@@ -17,6 +17,13 @@ public class UnParsedCommandParameter {
         this.parameters = new ArrayList<>();
         Matcher m = SPLIT_REGEX.matcher(parameters);
         boolean skippedCommand = false;
+        if(message.getReferencedMessage() != null) {
+            this.parameters.add(UnparsedCommandParameterPiece
+                    .builder()
+                    .value(message.getReferencedMessage())
+                    .type(ParameterPieceType.REFERENCED_MESSAGE)
+                    .build());
+        }
         while (m.find()) {
             if(!skippedCommand) {
                 skippedCommand = true;
@@ -35,7 +42,11 @@ public class UnParsedCommandParameter {
             }
         }
         message.getAttachments().forEach(attachment ->
-                this.parameters.add(UnparsedCommandParameterPiece.builder().value(attachment).type(ParameterPieceType.ATTACHMENT).build()));
+                this.parameters.add(UnparsedCommandParameterPiece
+                        .builder()
+                        .value(attachment)
+                        .type(ParameterPieceType.ATTACHMENT)
+                        .build()));
     }
     private List<UnparsedCommandParameterPiece> parameters;
 }

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/handler/CommandParameterHandler.java

@@ -1,6 +1,8 @@
 package dev.sheldan.abstracto.core.command.handler;
 
 
+import dev.sheldan.abstracto.core.command.Command;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.execution.UnparsedCommandParameterPiece;
 import net.dv8tion.jda.api.entities.Message;
 
@@ -9,7 +11,7 @@ import java.util.concurrent.CompletableFuture;
 public interface CommandParameterHandler {
     boolean handles(Class clazz);
     default boolean async() { return false; }
-    default Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) { return new Object();}
+    default Object handle(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) { return new Object();}
-    default CompletableFuture<Object> handleAsync(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Class clazz, Message context) { return CompletableFuture.completedFuture(null); }
+    default CompletableFuture<Object> handleAsync(UnparsedCommandParameterPiece input, CommandParameterIterators iterators, Parameter param, Message context, Command command) { return CompletableFuture.completedFuture(null); }
     Integer getPriority();
 }

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/handler/parameter/CombinedParameter.java

@@ -0,0 +1,10 @@
+package dev.sheldan.abstracto.core.command.handler.parameter;
+
+import lombok.Builder;
+import lombok.Getter;
+
+
+@Getter
+@Builder
+public class CombinedParameter {
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/handler/provided/CombinedParametersHandler.java

@@ -0,0 +1,6 @@
+package dev.sheldan.abstracto.core.command.handler.provided;
+
+import dev.sheldan.abstracto.core.command.handler.CommandParameterHandler;
+
+public interface CombinedParametersHandler extends CommandParameterHandler {
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/handler/provided/MessageParameterHandler.java

@@ -0,0 +1,6 @@
+package dev.sheldan.abstracto.core.command.handler.provided;
+
+import dev.sheldan.abstracto.core.command.handler.CommandParameterHandler;
+
+public interface MessageParameterHandler extends CommandParameterHandler {
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/handler/provided/StringParameterHandler.java

@@ -0,0 +1,6 @@
+package dev.sheldan.abstracto.core.command.handler.provided;
+
+import dev.sheldan.abstracto.core.command.handler.CommandParameterHandler;
+
+public interface StringParameterHandler extends CommandParameterHandler {
+}

abstracto-application/core/core-int/src/main/java/dev/sheldan/abstracto/core/command/service/CommandService.java

@@ -2,6 +2,7 @@ package dev.sheldan.abstracto.core.command.service;
 
 import dev.sheldan.abstracto.core.command.Command;
 import dev.sheldan.abstracto.core.command.condition.ConditionResult;
+import dev.sheldan.abstracto.core.command.config.Parameter;
 import dev.sheldan.abstracto.core.command.config.Parameters;
 import dev.sheldan.abstracto.core.command.execution.CommandContext;
 import dev.sheldan.abstracto.core.command.execution.UnParsedCommandParameter;
@@ -28,4 +29,5 @@ public interface CommandService {
     ConditionResult isCommandExecutable(Command command, CommandContext commandContext);
     UnParsedCommandParameter getUnParsedCommandParameter(String messageContent, Message message);
     CompletableFuture<Parameters> getParametersForCommand(String commandName, Message messageContainingContent);
+    Parameter cloneParameter(Parameter parameter);
 }

abstracto-application/documentation/src/main/docs/asciidoc/modules/utility.adoc

@@ -191,3 +191,7 @@ Ask a magic 8-ball a question::
 Roll a virtual die::
 * Usage: `role [max] [min]`
 * Description: Rolls a virtual die. Per default this is a six sided die. If `max` is provided, it changes the amount of sides possible and if `min` is provided, no value below this is possible. If `min` is larger than `max`, it is taken as `max` and vice-versa.
+
+Mock the message of another user::
+* Usage: `mock <text/message>`
+* Description: Takes the `text` and prints the text with the characters with alternating upper and lower case. If no text is provided, this command requires that the command has been executed in a message which replies to another message. In this case the text to be mocked will be the content of the message which has been replied to.