/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package gov.nist.secauto.metaschema.databind.codegen;
   
   import gov.nist.secauto.metaschema.core.util.CollectionUtil;
   
  import java.io.IOException;
  import java.io.StringWriter;
  import java.nio.file.Path;
  import java.util.LinkedHashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  import java.util.stream.Collectors;
  
  import javax.tools.DiagnosticCollector;
  import javax.tools.JavaCompiler;
  import javax.tools.JavaFileObject;
  import javax.tools.StandardJavaFileManager;
  import javax.tools.ToolProvider;
  
  import edu.umd.cs.findbugs.annotations.NonNull;
  import edu.umd.cs.findbugs.annotations.Nullable;
  
  public class JavaCompilerSupport {
    @Nullable
    private Logger logger;
    @NonNull
    private final Path classDir;
    @NonNull
    private final Set<String> classPath = new LinkedHashSet<>();
    @NonNull
    private final Set<String> modulePath = new LinkedHashSet<>();
    @NonNull
    private final Set<String> rootModuleNames = new LinkedHashSet<>();
  
    public JavaCompilerSupport(@NonNull Path classDir) {
      this.classDir = classDir;
    }
  
    public Set<String> getClassPath() {
      return classPath;
    }
  
    public Set<String> getModulePath() {
      return modulePath;
    }
  
    public Set<String> getRootModuleNames() {
      return rootModuleNames;
    }
  
    public void addToClassPath(@NonNull String entry) {
      classPath.add(entry);
    }
  
    public void addToModulePath(@NonNull String entry) {
      modulePath.add(entry);
    }
  
    public void addRootModule(@NonNull String entry) {
      rootModuleNames.add(entry);
    }
  
    public void setLogger(@NonNull Logger logger) {
      this.logger = logger;
    }
  
    @NonNull
    protected List<String> generateCompilerOptions() {
      List<String> options = new LinkedList<>();
      // options.add("-verbose");
      // options.add("-g");
      options.add("-d");
      options.add(classDir.toString());
  
      if (!classPath.isEmpty()) {
        options.add("-classpath");
        options.add(classPath.stream()
            .collect(Collectors.joining(":")));
      }
  
      if (!modulePath.isEmpty()) {
        options.add("-p");
        options.add(modulePath.stream()
            .collect(Collectors.joining(":")));
      }
  
      return options;
    }
  
    /**
     * Generate and compile Java classes.
     *
     * @param classFiles
     *          the files to compile
    * @return information about the generated classes
    * @throws IOException
    *           if an error occurred while compiling the classes
    * @throws IllegalArgumentException
    *           if any of the options are invalid, or if any of the given
    *           compilation units are of other kind than
    *           {@link javax.tools.JavaFileObject.Kind#SOURCE}
    */
 
   public CompilationResult compile(@NonNull List<Path> classFiles) throws IOException {
     DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
 
     JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
 
     List<JavaFileObject> compilationUnits;
     try (StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, null)) {
 
       compilationUnits = classFiles.stream()
           .map(fileManager::getJavaFileObjects)
           .map(CollectionUtil::toList)
           .flatMap(List::stream)
           .collect(Collectors.toUnmodifiableList());
 
       List<String> options = generateCompilerOptions();
 
       Logger logger = this.logger;
       if (logger != null && logger.isDebugEnabled()) {
         logger.debug(String.format("Using options: %s", options));
       }
 
       boolean result;
       try (StringWriter writer = new StringWriter()) {
         JavaCompiler.CompilationTask task = compiler.getTask(
             writer,
             fileManager,
             diagnostics,
             options,
             null,
             compilationUnits);
         task.addModules(rootModuleNames);
 
         result = task.call();
         writer.flush();
         String output = writer.toString();
         if (!output.isBlank() && logger != null && logger.isInfoEnabled()) {
           logger.info(String.format("compiler output: %s", writer.toString()));
         }
       }
       return new CompilationResult(result, diagnostics);
     }
   }
 
   public static final class CompilationResult {
     private final boolean successful;
     @NonNull
     private final DiagnosticCollector<JavaFileObject> diagnostics;
 
     private CompilationResult(boolean successful, @NonNull DiagnosticCollector<JavaFileObject> diagnostics) {
       this.successful = successful;
       this.diagnostics = diagnostics;
     }
 
     public boolean isSuccessful() {
       return successful;
     }
 
     public DiagnosticCollector<?> getDiagnostics() {
       return diagnostics;
     }
   }
 
   public interface Logger {
     boolean isDebugEnabled();
 
     boolean isInfoEnabled();
 
     void debug(String msg);
 
     void info(String msg);
   }
 }