/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package dev.metaschema.databind.codegen;
   
   import org.apache.logging.log4j.LogManager;
   import org.apache.logging.log4j.Logger;
  import org.eclipse.jdt.annotation.Owning;
  
  import java.io.IOException;
  import java.lang.module.ModuleDescriptor;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLClassLoader;
  import java.nio.file.Path;
  import java.security.AccessController;
  import java.security.PrivilegedAction;
  import java.util.Arrays;
  import java.util.List;
  import java.util.stream.Collectors;
  
  import javax.tools.DiagnosticCollector;
  
  import dev.metaschema.core.model.IModule;
  import dev.metaschema.core.util.ObjectUtils;
  import dev.metaschema.databind.IBindingContext;
  import dev.metaschema.databind.codegen.config.DefaultBindingConfiguration;
  import dev.metaschema.databind.codegen.config.IBindingConfiguration;
  import edu.umd.cs.findbugs.annotations.NonNull;
  
  /**
   * This class provides methods to generate and dynamically compile Java code
   * based on a Module. The {@link #newClassLoader(Path, ClassLoader)} method can
   * be used to get a {@link ClassLoader} for Java code previously generated by
   * this class.
   */
  public final class ModuleCompilerHelper {
    private static final Logger LOGGER = LogManager.getLogger(ModuleCompilerHelper.class);
  
    private ModuleCompilerHelper() {
      // disable construction
    }
  
    /**
     * Create a new classloader capable of loading Java classes generated in the
     * provided {@code classDir}.
     * <p>
     * The caller owns the returned class loader and is responsible for closing it.
     *
     * @param classDir
     *          the directory where generated Java classes have been compiled
     * @param parent
     *          the classloader to delegate to when the created class loader cannot
     *          load a class
     * @return the new class loader
     */
    @SuppressWarnings("resource")
    @Owning
    @NonNull
    public static ClassLoader newClassLoader(
        @NonNull final Path classDir,
        @NonNull final ClassLoader parent) {
      return ObjectUtils.notNull(AccessController.doPrivileged(
          (PrivilegedAction<ClassLoader>) () -> {
            try {
              return new URLClassLoader(new URL[] { classDir.toUri().toURL() }, parent);
            } catch (MalformedURLException ex) {
              throw new IllegalStateException("unable to configure class loader", ex);
            }
          }));
    }
  
    /**
     * Generate and compile Java class, representing the provided Module
     * {@code module} and its related definitions, using the default binding
     * configuration.
     *
     * @param module
     *          the Module module to generate Java classes for
     * @param classDir
     *          the directory to generate the classes in
     * @return information about the generated classes
     * @throws IOException
     *           if an error occurred while generating or compiling the classes
     */
    @NonNull
    public static IProduction compileMetaschema(
        @NonNull IModule module,
        @NonNull Path classDir)
        throws IOException {
      return compileModule(module, classDir, new DefaultBindingConfiguration());
    }
  
    /**
     * Generate and compile Java class, representing the provided Module
     * {@code module} and its related definitions, using the provided custom
     * {@code bindingConfiguration}.
    *
    * @param module
    *          the Module module to generate Java classes for
    * @param classDir
    *          the directory to generate the classes in
    * @param bindingConfiguration
    *          configuration settings with directives that tailor the class
    *          generation
    * @return information about the generated classes
    * @throws IOException
    *           if an error occurred while generating or compiling the classes
    */
   @NonNull
   public static IProduction compileModule(
       @NonNull IModule module,
       @NonNull Path classDir,
       @NonNull IBindingConfiguration bindingConfiguration) throws IOException {
     IProduction production = JavaGenerator.generate(module, classDir, bindingConfiguration);
     List<IGeneratedClass> classesToCompile = production.getGeneratedClasses().collect(Collectors.toList());
 
     List<Path> classes = ObjectUtils.notNull(classesToCompile.stream()
         .map(IGeneratedClass::getClassFile)
         .collect(Collectors.toUnmodifiableList()));
 
     // configure the compiler
     JavaCompilerSupport compiler = new JavaCompilerSupport(classDir);
     compiler.setLogger(new JavaCompilerSupport.Logger() {
 
       @Override
       public boolean isInfoEnabled() {
         return LOGGER.isInfoEnabled();
       }
 
       @Override
       public boolean isDebugEnabled() {
         return LOGGER.isDebugEnabled();
       }
 
       @Override
       public void info(String msg) {
         LOGGER.atInfo().log(msg);
       }
 
       @Override
       public void debug(String msg) {
         LOGGER.atDebug().log(msg);
       }
     });
 
     // determine if we need to use the module path
     boolean useModulePath = false;
     Module databindModule = IBindingContext.class.getModule();
     if (databindModule != null) {
       ModuleDescriptor descriptor = databindModule.getDescriptor();
       if (descriptor != null) {
         // add the databind module to the task
         compiler.addRootModule(ObjectUtils.notNull(descriptor.name()));
         useModulePath = true;
       }
     }
 
     handleClassAndModulePath(compiler, useModulePath);
 
     // perform compilation
     JavaCompilerSupport.CompilationResult result = compiler.compile(classes);
 
     if (!result.isSuccessful()) {
       // log compilation diagnostics
       DiagnosticCollector<?> diagnostics = new DiagnosticCollector<>();
       if (LOGGER.isErrorEnabled()) {
         LOGGER.error(diagnostics.getDiagnostics().toString());
       }
       throw new IllegalStateException(String.format("failed to compile classes: %s%nClasspath: %s%nModule Path: %s%n%s",
           classesToCompile.stream()
               .map(clazz -> clazz.getClassName().canonicalName())
               .collect(Collectors.joining(",")),
           diagnostics.getDiagnostics().toString(),
           compiler.getClassPath().stream()
               .collect(Collectors.joining(":")),
           compiler.getModulePath().stream()
               .collect(Collectors.joining(":"))));
     }
     return production;
   }
 
   private static void handleClassAndModulePath(JavaCompilerSupport compiler, boolean useModulePath) {
     String classPath = System.getProperty("java.class.path");
     String modulePath = System.getProperty("jdk.module.path");
     if (useModulePath) {
       // use classpath and modulepath from the JDK
       if (classPath != null) {
         Arrays.stream(classPath.split(":")).forEachOrdered(compiler::addToClassPath);
       }
 
       if (modulePath != null) {
         Arrays.stream(modulePath.split(":")).forEachOrdered(compiler::addToModulePath);
       }
     } else {
       // use classpath only
       if (classPath != null) {
         Arrays.stream(classPath.split(":")).forEachOrdered(compiler::addToClassPath);
       }
 
       if (modulePath != null) {
         Arrays.stream(modulePath.split(":")).forEachOrdered(compiler::addToClassPath);
       }
     }
 
   }
 }