com.freya02.botcommands.internal.utils.ExecutionUtils.kt Maven / Gradle / Ivy

Go to download
package com.freya02.botcommands.internal.utils

import com.freya02.botcommands.internal.IExecutableInteractionInfo
import com.freya02.botcommands.internal.core.options.Option
import com.freya02.botcommands.internal.parameters.IAggregatedParameter
import com.freya02.botcommands.internal.parameters.MethodParameter
import com.freya02.botcommands.internal.throwInternal
import com.freya02.botcommands.internal.throwUser
import com.freya02.botcommands.internal.utils.ReflectionUtils.function
import net.dv8tion.jda.api.events.Event
import kotlin.reflect.KParameter

enum class InsertOptionResult {
    OK,
    SKIP,
    ABORT
}

inline fun List.mapOptions(block: MutableMap.(Option) -> Unit): Map {
    val options = this.flatMap { it.allOptions }
    return buildMap(options.size) {
        options.forEach { block(it) }
    }
}

fun tryInsertNullableOption(value: Any?, option: Option, optionMap: MutableMap): InsertOptionResult {
    if (value != null) {
        optionMap[option] = value
        return InsertOptionResult.OK
    } else if (option.isVararg) {
        //Continue looking at other options
    } else if (option.isOptionalOrNullable) { //Default or nullable
        //Put null/default value if parameter is not a kotlin default value
        if (option.kParameter.isOptional) {
            //Kotlin default value, don't add anything to the parameters map
        } else {
            //Nullable
            optionMap[option] = option.nullValue
        }
    } else {
        //Value is null and is required
        throwUser(option.optionParameter.typeCheckingFunction, "Option #${option.index} (${option.declaredName}) couldn't be resolved, this could be due to a faulty ICustomResolver")
    }

    return InsertOptionResult.SKIP
}

context(IExecutableInteractionInfo)
suspend fun Collection.mapFinalParameters(
    event: Event,
    optionValues: Map
) = buildMap(eventFunction.parametersSize) {
    this[eventFunction.instanceParameter] = instance
    this[eventFunction.eventParameter] = event

    for (parameter in this@mapFinalParameters) {
        insertAggregate(event, this, optionValues, parameter)
    }
}

suspend fun insertAggregate(event: Event, aggregatedObjects: MutableMap, optionValues: Map, parameter: IAggregatedParameter) {
    val aggregator = parameter.aggregator

    if (aggregator.isSingleAggregator) {
        val option = parameter.options.first()
        //This is necessary to distinguish between null mappings and default mappings
        if (option in optionValues) {
            //No need to check nullabilities, it's already handled when computing option values
            aggregatedObjects[parameter] = optionValues[option]
        }
    } else {
        val aggregatorArguments: MutableMap = HashMap(aggregator.parametersSize)
        for (option in parameter.options) {
            //This is necessary to distinguish between null mappings and default mappings
            if (option in optionValues) {
                aggregatorArguments[option] = optionValues[option]
            }
        }

        for (nestedAggregatedParameter in parameter.nestedAggregatedParameters) {
            insertAggregate(event, aggregatorArguments, optionValues, nestedAggregatedParameter)
        }

        val aggregatedObject = aggregator.aggregate(event, aggregatorArguments)
        //Check nullability against parameter
        if (aggregatedObject != null) {
            aggregatedObjects[parameter] = aggregatedObject
        } else {
            if (parameter.isNullableOrOptional) { //Default or nullable
                //Put null/default value if parameter is not a kotlin default value
                return if (parameter.kParameter.isOptional) {
                    //Kotlin default value, don't add anything to the parameters map
                } else {
                    //Nullable
                    aggregatedObjects[parameter] = when {
                        parameter.isPrimitive -> throwInternal("Cannot have user-defined aggregators returning primitives")
                        else -> null
                    }
                }
            } else {
                throwUser(parameter.executableParameter.function, "Aggregated parameter couldn't be resolved at option ${parameter.name}")
            }
        }
    }
}

private operator fun MutableMap.set(parameter: MethodParameter, obj: Any?): Any? = obj.also {
    this[parameter.executableParameter] = obj
}

@Suppress("UNCHECKED_CAST")
private operator fun MutableMap.set(option: Option, obj: Any?): Any? = obj.also {
    if (option.isVararg) {
        (this.getOrPut(option.executableParameter) {
            arrayListOf()
        } as MutableList).add(obj)
    } else {
        this[option.executableParameter] = obj
    }
}