gson-compile/gson-compile-processor/src/main/java/io/gitlab/jfronny/gson/compile/processor/GsonCompileProcessor.java

package io.gitlab.jfronny.gson.compile.processor;

import com.squareup.javapoet.*;
import io.gitlab.jfronny.commons.StringFormatter;
import io.gitlab.jfronny.gson.compile.annotations.GSerializable;
import io.gitlab.jfronny.gson.compile.processor.adapter.Adapter;
import io.gitlab.jfronny.gson.compile.processor.adapter.Adapters;
import io.gitlab.jfronny.gson.compile.processor.util.AbstractProcessor2;
import io.gitlab.jfronny.gson.compile.processor.util.SupportedAnnotationTypes2;
import io.gitlab.jfronny.gson.compile.processor.util.valueprocessor.Properties;
import io.gitlab.jfronny.gson.compile.processor.util.valueprocessor.*;

import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.*;
import javax.lang.model.type.TypeMirror;
import javax.lang.model.util.Elements;
import javax.tools.Diagnostic;
import java.io.*;
import java.nio.file.*;
import java.util.*;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;

@SupportedSourceVersion(SourceVersion.RELEASE_17)
@SupportedAnnotationTypes2({GSerializable.class})
@SupportedOptions({"gsonCompileNoReflect"})
public class GsonCompileProcessor extends AbstractProcessor2 {
    private Messager message;
    private Filer filer;
    private Map<ClassName, TypeSpec.Builder> seen;
    private ValueCreator valueCreator;
    private Elements elements;
    private boolean hasManifold = false;

    @Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        try {
            Class.forName("manifold.ext.Model");
            System.out.println("Detected manifold!");
            hasManifold = true;
        } catch (ClassNotFoundException e) {
            hasManifold = false;
        }
        message = processingEnv.messager;
        filer = processingEnv.filer;
        elements = processingEnv.elementUtils;
        seen = new LinkedHashMap<>();
        valueCreator = new ValueCreator(processingEnv);
        for (Adapter adapter : Adapters.ADAPTERS) {
            adapter.init(processingEnv);
        }
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnvironment) {
        Set<SerializableClass> toGenerate = new LinkedHashSet<>();
        // Gather all serializable types
        for (TypeElement annotation : annotations) {
            for (Element element : roundEnvironment.getElementsAnnotatedWith(annotation)) {
                for (AnnotationMirror mirror : element.annotationMirrors) {
                    try {
                        if (mirror.annotationType.toString().equals(GSerializable.class.getCanonicalName())) {
                            var bld = new Object() {
                                TypeMirror with = null;
                                TypeMirror builder = null;
                                TypeMirror configure = null;
                                Boolean generateAdapter = null;
                            };
                            elements.getElementValuesWithDefaults(mirror).forEach((executableElement, value) -> {
                                String name = executableElement.simpleName.toString();
                                switch (name) {
                                    case "with" -> {
                                        if (bld.with != null) throw new IllegalArgumentException("Duplicate annotation parameter: with");
                                        bld.with = (TypeMirror) value.value;
                                    }
                                    case "builder" -> {
                                        if (bld.builder != null) throw new IllegalArgumentException("Duplicate annotation parameter: builder");
                                        bld.builder = (TypeMirror) value.value;
                                    }
                                    case "configure" -> {
                                        if (bld.configure != null) throw new IllegalArgumentException("Duplicate annotation parameter: configure");
                                        bld.configure = (TypeMirror) value.value;
                                    }
                                    case "generateAdapter" -> {
                                        if (bld.generateAdapter != null) throw new IllegalArgumentException("Duplicate annotation parameter: generateAdapter");
                                        bld.generateAdapter = (Boolean) value.value;
                                    }
                                    default -> throw new IllegalArgumentException("Unexpected annotation parameter: " + name);
                                }
                            });
                            if (bld.with == null) throw new IllegalArgumentException("Missing annotation parameter: with");
                            if (bld.builder == null) throw new IllegalArgumentException("Missing annotation parameter: builder");
                            if (bld.configure == null) throw new IllegalArgumentException("Missing annotation parameter: configure");
                            if (bld.generateAdapter == null) throw new IllegalArgumentException("Missing annotation parameter: generateAdapter");

                            toGenerate.add(SerializableClass.of((TypeElement) element, bld.with, bld.builder, bld.configure, bld.generateAdapter, hasManifold));
                        }
                    } catch (ElementException e) {
                        e.printMessage(message);
                    }
                }
            }
        }
        // Do not allow mutation past this point, especially not from individual process tasks
        toGenerate = Set.copyOf(toGenerate);
        // Generate adapters
        for (SerializableClass toProcess : toGenerate) {
            try {
                process(toProcess, toGenerate);
            } catch (ElementException e) {
                e.printMessage(message);
            }
        }
        for (var entry : seen.keySet().stream().collect(Collectors.groupingBy(ClassName::packageName)).entrySet()) {
            Map<List<String>, TypeSpec.Builder> known = entry.value.stream()
                    .collect(Collectors.toMap(
                            ClassName::simpleNames,
                            seen::get,
                            (u, v) -> u,
                            () -> new TreeMap<>(StringListComparator.INSTANCE.reversed())
                    ));
            // Generate additional parent classes
            for (List<String> klazz : known.keySet().stream().toList()) {
                List<String> current = new LinkedList<>();
                for (String s : klazz) {
                    current.add(s);
                    TypeSpec.Builder builder = find(known, current);
                    if (builder == null) {
                        builder = TypeSpec.classBuilder(s).addModifiers(Modifier.PUBLIC);
                        if (current.size() == 1 && hasManifold) builder.addAnnotation(Cl.MANIFOLD_EXTENSION);
                        known.put(List.copyOf(current), builder);
                    }
                    if (current.size() > 1) builder.addModifiers(Modifier.STATIC);
                }
            }
            // Add to parent class
            for (var entry1 : known.entrySet()) {
                if (entry1.key.size() == 1) continue;
                find(known, entry1.key.subList(0, entry1.key.size() - 1)).addType(entry1.value.build());
            }
            // Print
//            System.out.println("Got " + known.size() + " classes");
//            for (var entry1 : known.entrySet()) {
//                System.out.println("Class " + entry.key + '.' + String.join(".", entry1.key));
//                for (TypeSpec typeSpec : entry1.value.typeSpecs) {
//                    System.out.println("- " + typeSpec.name);
//                }
//            }
            // Write top-level classes
            for (var entry1 : known.entrySet()) {
                if (entry1.key.size() == 1) {
                    JavaFile javaFile = JavaFile.builder(entry.key, entry1.value.build())
                            .skipJavaLangImports(true)
                            .indent("    ")
                            .build();
                    try {
                        javaFile.writeTo(filer);
                    } catch (IOException e) {
                        message.printMessage(Diagnostic.Kind.ERROR, "Could not write source: " + StringFormatter.toString(e));
                    }
                }
            }
        }
        seen.clear();
        return false;
    }

    private <K, V> V find(Map<List<K>, V> map, List<K> key) {
        for (var entry : map.entrySet()) if (entry.key.equals(key)) return entry.value;
        return null;
    }

    private void process(SerializableClass toProcess, Set<SerializableClass> other) throws ElementException {
        if (seen.containsKey(toProcess.generatedClassName)) return; // Don't process the same class more than once

        TypeName classType = toProcess.typeName;
        List<TypeVariableName> typeVariables = new ArrayList<>();
        if (classType instanceof ParameterizedTypeName type) {
            for (TypeName argument : type.typeArguments) {
                typeVariables.add(TypeVariableName.get(argument.toString()));
            }
        }

        TypeSpec.Builder spec = TypeSpec.classBuilder(toProcess.generatedClassName.simpleName())
                .addOriginatingElement(toProcess.classElement)
                .addModifiers(Modifier.PUBLIC)
                .addTypeVariables(typeVariables);

        seen.put(toProcess.generatedClassName, spec);

        if (toProcess.adapter != null) {
            generateDelegateToAdapter(spec, classType, toProcess.adapter);
        } else {
            if (toProcess.generateAdapter) {
                generateDelegatingAdapter(spec, classType, toProcess.generatedClassName);
            }
            generateSerialisation(spec, toProcess, typeVariables, other);
        }

        generateAuxiliary(spec, classType, toProcess.configure());
    }

    private static void generateDelegatingAdapter(TypeSpec.Builder spec, TypeName classType, ClassName generatedClassName) {
        spec.addType(
                TypeSpec.classBuilder("Adapter")
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .superclass(ParameterizedTypeName.get(Cl.TYPE_ADAPTER, classType))
                        .addMethod(MethodSpec.methodBuilder("write")
                                .addAnnotation(Override.class)
                                .addModifiers(Modifier.PUBLIC)
                                .addParameter(Cl.GSON_WRITER, "writer")
                                .addParameter(classType, "value")
                                .addException(IOException.class)
                                .addCode(generatedClassName.simpleName + ".write(value, writer);")
                                .build())
                        .addMethod(MethodSpec.methodBuilder("read")
                                .addAnnotation(Override.class)
                                .addModifiers(Modifier.PUBLIC)
                                .addParameter(Cl.GSON_READER, "reader")
                                .addException(IOException.class)
                                .returns(classType)
                                .addCode("return " + generatedClassName.simpleName + ".read(reader);")
                                .build())
                        .build()
        );
    }

    private void generateDelegateToAdapter(TypeSpec.Builder spec, TypeName classType, TypeMirror adapter) {
        spec.addMethod(
                extension(MethodSpec.methodBuilder("read"))
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addParameter(Cl.GSON_READER, "reader")
                        .addException(IOException.class)
                        .returns(classType)
                        .addCode("return $T.read(reader);", adapter)
                        .build()
        );
        spec.addMethod(
                extension(MethodSpec.methodBuilder("write"), classType)
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addParameter(Cl.GSON_WRITER, "writer")
                        .addException(IOException.class)
                        .addCode("$T.write(writer, value);", adapter)
                        .build()
        );
    }

    private void generateAuxiliary(TypeSpec.Builder spec, TypeName classType, TypeMirror configure) {
        final UnaryOperator<CodeBlock.Builder> configureReader = cb -> {
            if (configure != null) cb.addStatement("$T.configure(reader)", configure);
            return cb;
        };
        final UnaryOperator<CodeBlock.Builder> configureWriter = cb -> {
            if (configure != null) cb.addStatement("$T.configure(writer)", configure);
            return cb;
        };

        final String readStatement = "return read(reader)";
        final String writeStatement = "write(value, writer)";

        spec.addMethod(
                extension(MethodSpec.methodBuilder("read"))
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addParameter(TypeName.get(Reader.class), "in")
                        .addException(IOException.class)
                        .returns(classType)
                        .addCode(configureReader.apply(CodeBlock.builder().beginControlFlow("try ($1T reader = new $1T(in))", Cl.GSON_READER))
                                .addStatement(readStatement)
                                .endControlFlow()
                                .build())
                        .build()
        );

        spec.addMethod(
                extension(MethodSpec.methodBuilder("read"))
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addParameter(TypeName.get(String.class), "json")
                        .addException(IOException.class)
                        .returns(classType)
                        .addCode(CodeBlock.builder().beginControlFlow("try ($1T reader = new $1T(json))", StringReader.class)
                                .addStatement(readStatement)
                                .endControlFlow()
                                .build())
                        .build()
        );

        spec.addMethod(
                extension(MethodSpec.methodBuilder("read"))
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addParameter(Cl.GSON_ELEMENT, "tree")
                        .addException(IOException.class)
                        .returns(classType)
                        .addCode(configureReader.apply(CodeBlock.builder().beginControlFlow("try ($1T reader = new $1T(tree))", Cl.GSON_TREE_READER))
                                .addStatement(readStatement)
                                .endControlFlow()
                                .build())
                        .build()
        );

        spec.addMethod(
                extension(MethodSpec.methodBuilder("read"))
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addParameter(Path.class, "path")
                        .addException(IOException.class)
                        .returns(classType)
                        .addCode(CodeBlock.builder().beginControlFlow("try ($T reader = $T.newBufferedReader(path))", BufferedReader.class, Files.class)
                                .addStatement(readStatement)
                                .endControlFlow()
                                .build())
                        .build()
        );

        spec.addMethod(
                extension(MethodSpec.methodBuilder("write"), classType)
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addParameter(Writer.class, "out")
                        .addException(IOException.class)
                        .addCode(configureWriter.apply(CodeBlock.builder().beginControlFlow("try ($1T writer = new $1T(out))", Cl.GSON_WRITER))
                                .addStatement(writeStatement)
                                .endControlFlow()
                                .build())
                        .build()
        );

        spec.addMethod(
                extension(MethodSpec.methodBuilder("write"), classType)
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addParameter(Path.class, "path")
                        .addException(IOException.class)
                        .addCode(CodeBlock.builder().beginControlFlow("try ($1T writer = $2T.newBufferedWriter(path, $3T.CREATE, $3T.WRITE, $3T.TRUNCATE_EXISTING))", BufferedWriter.class, Files.class, StandardOpenOption.class)
                                .addStatement(writeStatement)
                                .endControlFlow()
                                .build())
                        .build()
        );

        spec.addMethod(
                extension(MethodSpec.methodBuilder("toJson"), classType)
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addException(IOException.class)
                        .returns(String.class)
                        .addCode(CodeBlock.builder().beginControlFlow("try ($1T writer = new $1T())", StringWriter.class)
                                .addStatement(writeStatement)
                                .addStatement("return writer.toString()")
                                .endControlFlow()
                                .build())
                        .build()
        );

        spec.addMethod(
                extension(MethodSpec.methodBuilder("toJsonTree"), classType)
                        .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                        .addException(IOException.class)
                        .returns(Cl.GSON_ELEMENT)
                        .addCode(configureWriter.apply(CodeBlock.builder().beginControlFlow("try ($1T writer = new $1T())", Cl.GSON_TREE_WRITER))
                                .addStatement(writeStatement)
                                .addStatement("return writer.get()")
                                .endControlFlow()
                                .build())
                        .build()
        );
    }

    private void generateSerialisation(TypeSpec.Builder spec, SerializableClass self, List<TypeVariableName> typeVariables, Set<SerializableClass> otherAdapters) throws ElementException {
        Value value = self.builder == null ? valueCreator.from(self.classElement, false) : valueCreator.from(TypeHelper.asDeclaredType(self.builder).asElement(), true);
        ConstructionSource constructionSource = value.constructionSource;
        Properties properties = value.properties;

        // public static void write(JsonWriter writer, T value) throws IOException
        {
            CodeBlock.Builder code = CodeBlock.builder();
            code.beginControlFlow("if (value == null)")
                    .addStatement("writer.nullValue()")
                    .addStatement("return")
                    .endControlFlow();

            code.addStatement("writer.beginObject()");
            for (Property.Field param : properties.fields) {
                if (Properties.containsName(properties.getters, param)) continue;
                Runnable writeGet = () -> code.add("value.$N", param.callableName);
                if (param.type.kind.isPrimitive) {
                    generateComments(param, code);
                    code.addStatement("writer.name($S)", getSerializedName(param));
                    Adapters.generateWrite(param, spec, code, typeVariables, otherAdapters, message, writeGet);
                } else {
                    code.beginControlFlow("if (value.$N != null || writer.getSerializeNulls())", param.callableName);
                    generateComments(param, code);
                    code.addStatement("writer.name($S)", getSerializedName(param));
                    code.addStatement("if (value.$N == null) writer.nullValue()", param.callableName);
                    code.beginControlFlow("else");
                    Adapters.generateWrite(param, spec, code, typeVariables, otherAdapters, message, writeGet);
                    code.endControlFlow();
                    code.endControlFlow();
                }
            }
            for (Property.Getter param : properties.getters) {
                if (param.type.kind.isPrimitive) {
                    generateComments(param, code);
                    code.addStatement("writer.name($S)", getSerializedName(param));
                    Adapters.generateWrite(param, spec, code, typeVariables, otherAdapters, message, () -> code.add("value.$N()", param.callableName));
                } else {
                    code.addStatement("$T $L$N = value.$N()", param.type, "$", param.callableName, param.callableName);
                    code.beginControlFlow("if ($L$N != null || writer.getSerializeNulls())", "$", param.callableName);
                    generateComments(param, code);
                    code.addStatement("writer.name($S)", getSerializedName(param));
                    code.addStatement("if ($L$N == null) writer.nullValue()", "$", param.callableName);
                    code.beginControlFlow("else");
                    Adapters.generateWrite(param, spec, code, typeVariables, otherAdapters, message, () -> code.add("$L$N", "$", param.callableName));
                    code.endControlFlow();
                    code.endControlFlow();
                }
            }
            code.addStatement("writer.endObject()");

            spec.addMethod(extension(MethodSpec.methodBuilder("write"), self.typeName)
                    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                    .addParameter(Cl.GSON_WRITER, "writer")
                    .addException(IOException.class)
                    .addCode(code.build())
                    .build());
        }

        // public static T read(JsonReader reader) throws IOException
        {
            CodeBlock.Builder code = CodeBlock.builder();
            code.beginControlFlow("if (reader.peek() == $T.NULL)", Cl.GSON_TOKEN)
                    .addStatement("reader.nextNull()")
                    .addStatement("return null")
                    .endControlFlow();

            boolean isEmpty = true;
            for (Property<?> param : properties.names) {
                isEmpty = false;
                code.addStatement("$T _$N = $L", param.type, param.name, TypeHelper.getDefaultValue(param.type));
            }
            if (isEmpty) {
                code.addStatement("reader.skipValue()");
            } else {
                code.addStatement("reader.beginObject()")
                        .beginControlFlow("while (reader.hasNext())")
                        .beginControlFlow("switch (reader.nextName())");
                for (Property<?> param : properties.names) {
                    if (param.type.kind.isPrimitive) {
                        code.add("case $S -> _$N = ", getSerializedName(param), param.name);
                        Adapters.generateRead(param, spec, code, typeVariables, otherAdapters, message);
                        code.add(";\n");
                    } else {
                        code.beginControlFlow("case $S ->", getSerializedName(param))
                                .beginControlFlow("if (reader.peek() == $T.NULL)", Cl.GSON_TOKEN)
                                .addStatement("reader.nextNull()")
                                .addStatement("_$N = null", param.name);
                        code.unindent().add("} else _$N = ", param.name);
                        Adapters.generateRead(param, spec, code, typeVariables, otherAdapters, message);
                        code.add(";\n")
                                .endControlFlow();
                    }
                }
                code.add("default -> ")
                        .addStatement("reader.skipValue()");

                code.endControlFlow()
                        .endControlFlow()
                        .addStatement("reader.endObject()");
            }

            code.addStatement("$T result", self.typeName);
            ClassName creatorName = ClassName.get((TypeElement) constructionSource.constructionElement.enclosingElement);
            if (constructionSource instanceof ConstructionSource.Builder builder) {
                StringBuilder args = new StringBuilder();
                for (Property.ConstructorParam param : properties.constructorParams) {
                    args.append(", _").append(param.name);
                }
                code.add("$T builder = ", builder.builderClass);
                if (constructionSource.isConstructor) {
                    code.add("new $T($L)", builder.builderClass, args.length() > 0 ? args.substring(2) : "");
                } else {
                    code.add("$T.$N($L)", creatorName, self.classElement.simpleName, args.length() > 0 ? args.substring(2) : "");
                }
                code.add(";\n");
                for (Property.Setter param : properties.builderParams) {
                    code.addStatement("builder.$N(_$N)", param.callableName, param.name);
                }
                code.addStatement("result = builder.$N()", builder.buildMethod.simpleName);
            } else {
                StringBuilder args = new StringBuilder();
                for (Property.Param param : properties.params) {
                    args.append(", _").append(param.name);
                }
                if (constructionSource.isConstructor) {
                    code.addStatement("result = new $T($L)", self.typeName, args.length() > 0 ? args.substring(2) : "");
                } else {
                    code.addStatement("result = $T.$N($L)", creatorName, constructionSource.constructionElement.simpleName, args.length() > 0 ? args.substring(2) : "");
                }
            }
            for (Property.Setter setter : properties.setters) {
                code.addStatement("result.$N(_$N)", setter.callableName, setter.name);
            }
            for (Property.Field field : properties.fields) {
                if (Properties.containsName(properties.setters, field)) continue;
                if (Properties.containsName(properties.params, field)) continue;
                code.addStatement("result.$N = _$N", field.name, field.callableName);
            }
            code.addStatement("return result");

            spec.addMethod(extension(MethodSpec.methodBuilder("read"))
                    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                    .returns(self.typeName)
                    .addParameter(Cl.GSON_READER, "reader")
                    .addException(IOException.class)
                    .addCode(code.build())
                    .build());
        }
    }

    private void generateComments(Property<?> prop, CodeBlock.Builder code) {
        for (AnnotationMirror annotation : prop.annotations) {
            if (annotation.annotationType.asElement().toString().equals(Cl.GCOMMENT.toString())) {
                String comment = (String) annotation.elementValues.values().iterator().next().value;
                code.addStatement("if (writer.isLenient()) writer.comment($S)", comment);
            }
        }
    }

    private static String getSerializedName(Property<?> property) {
        for (AnnotationMirror annotationMirror : property.annotations) {
            if (annotationMirror.annotationType.asElement().toString().equals(Cl.SERIALIZED_NAME.toString())) {
                return (String) annotationMirror.elementValues.values().iterator().next().value;
            }
        }
        return property.name;
    }

    private MethodSpec.Builder extension(MethodSpec.Builder method) {
        if (hasManifold) method.addAnnotation(Cl.MANIFOLD_EXTENSION);
        return method;
    }

    private MethodSpec.Builder extension(MethodSpec.Builder method, TypeName thizName) {
        if (hasManifold) {
            method.addAnnotation(Cl.MANIFOLD_EXTENSION);
            method.addParameter(ParameterSpec.builder(thizName, "value").addAnnotation(Cl.MANIFOLD_THIS).build());
        }
        else {
            method.addParameter(thizName, "value");
        }
        return method;
    }
}