Untitled

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.Processor;
import javax.lang.model.element.Element;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.DeclaredType;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.ElementKind;
import javax.lang.model.util.Types;
import javax.lang.model.util.Elements;
import com.squareup.javapoet.*;

import javax.annotation.processing.Messager;
import javax.tools.Diagnostic;
import java.util.List;

@SupportedAnnotationTypes("*") // Modify according to your annotation
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class MyAnnotationProcessor extends AbstractProcessor {

    private Messager messager;
    private Types typeUtils;
    private Elements elementUtils;

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        messager = processingEnv.getMessager();
        typeUtils = processingEnv.getTypeUtils();
        elementUtils = processingEnv.getElementUtils();

        for (Element element : roundEnv.getElementsAnnotatedWith(YourAnnotation.class)) {
            if (element.getKind() == ElementKind.METHOD) {
                ExecutableElement methodElement = (ExecutableElement) element;
                
                // Loop through method parameters to find the generic type
                List<? extends VariableElement> parameters = methodElement.getParameters();
                for (VariableElement parameter : parameters) {
                    TypeMirror paramType = parameter.asType();
                    if (paramType instanceof DeclaredType) {
                        DeclaredType declaredType = (DeclaredType) paramType;
                        List<? extends TypeMirror> typeArguments = declaredType.getTypeArguments();

                        if (!typeArguments.isEmpty()) {
                            TypeMirror firstTypeArgument = typeArguments.get(0); // MyWrapper<Long, MyClass> -> Long
                            TypeMirror secondTypeArgument = typeArguments.get(1); // MyWrapper<Long, MyClass> -> MyClass

                            // Print the actual types for debugging
                            messager.printMessage(Diagnostic.Kind.NOTE, "First type argument: " + firstTypeArgument.toString());
                            messager.printMessage(Diagnostic.Kind.NOTE, "Second type argument: " + secondTypeArgument.toString());
                            
                            // Now you can generate the new method with Request<MyWrapper<Long, MyClass>>
                            MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder(methodElement.getSimpleName().toString())
                                    .addModifiers(Modifier.PUBLIC)
                                    .returns(TypeName.VOID)
                                    .addParameter(ParameterSpec.builder(Request.class, "request")
                                            .addParameter(TypeName.get(firstTypeArgument), "first")
                                            .addParameter(TypeName.get(secondTypeArgument), "second")
                                            .build());
                            
                            // Add more logic to build the rest of the method or class
                            TypeSpec generatedClass = TypeSpec.classBuilder("GeneratedClass")
                                    .addMethod(methodBuilder.build())
                                    .build();
                            
                            JavaFile javaFile = JavaFile.builder("com.example.generated", generatedClass)
                                    .build();
                            try {
                                javaFile.writeTo(processingEnv.getFiler());
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
        return true;
    }
}