/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package dev.metaschema.maven.plugin;
   
   import org.apache.maven.artifact.Artifact;
   import org.apache.maven.artifact.DependencyResolutionRequiredException;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecution;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugin.logging.Log;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.util.DirectoryScanner;
  import org.sonatype.plexus.build.incremental.BuildContext;
  import org.xml.sax.SAXParseException;
  
  import java.io.File;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.net.URI;
  import java.nio.charset.Charset;
  import java.nio.file.Files;
  import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.nio.file.StandardOpenOption;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Objects;
  import java.util.Set;
  import java.util.function.Function;
  import java.util.stream.Collectors;
  import java.util.stream.Stream;
  
  import javax.inject.Inject;
  import javax.tools.DiagnosticCollector;
  
  import dev.metaschema.core.model.IConstraintLoader;
  import dev.metaschema.core.model.IModule;
  import dev.metaschema.core.model.IModuleLoader;
  import dev.metaschema.core.model.IResourceLocation;
  import dev.metaschema.core.model.MetaschemaException;
  import dev.metaschema.core.model.constraint.ConstraintValidationException;
  import dev.metaschema.core.model.constraint.ConstraintValidationFinding;
  import dev.metaschema.core.model.constraint.ExternalConstraintsModulePostProcessor;
  import dev.metaschema.core.model.constraint.IConstraintSet;
  import dev.metaschema.core.model.validation.AbstractValidationResultProcessor;
  import dev.metaschema.core.model.validation.IValidationFinding;
  import dev.metaschema.core.model.validation.IValidationResult;
  import dev.metaschema.core.model.validation.JsonSchemaContentValidator.JsonValidationFinding;
  import dev.metaschema.core.model.validation.XmlSchemaContentValidator.XmlValidationFinding;
  import dev.metaschema.core.util.CollectionUtil;
  import dev.metaschema.core.util.ObjectUtils;
  import dev.metaschema.databind.DefaultBindingContext;
  import dev.metaschema.databind.IBindingContext;
  import dev.metaschema.databind.PostProcessingModuleLoaderStrategy;
  import dev.metaschema.databind.SimpleModuleLoaderStrategy;
  import dev.metaschema.databind.codegen.IGeneratedClass;
  import dev.metaschema.databind.codegen.IGeneratedModuleClass;
  import dev.metaschema.databind.codegen.IModuleBindingGenerator;
  import dev.metaschema.databind.codegen.IProduction;
  import dev.metaschema.databind.codegen.JavaCompilerSupport;
  import dev.metaschema.databind.codegen.JavaGenerator;
  import dev.metaschema.databind.codegen.ModuleCompilerHelper;
  import dev.metaschema.databind.codegen.config.DefaultBindingConfiguration;
  import dev.metaschema.databind.codegen.config.IBindingConfiguration;
  import dev.metaschema.databind.model.IBoundModule;
  import dev.metaschema.databind.model.metaschema.BindingModuleLoader;
  import dev.metaschema.databind.model.metaschema.IBindingMetaschemaModule;
  import dev.metaschema.databind.model.metaschema.IBindingModuleLoader;
  import dev.metaschema.databind.model.metaschema.binding.MetaschemaModelModule;
  import edu.umd.cs.findbugs.annotations.NonNull;
  import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  
  /**
   * Abstract base class for Metaschema Maven plugin goals.
   * <p>
   * This class provides common functionality for loading Metaschema modules,
   * managing constraint sets, handling incremental builds, and performing
   * code/schema generation. Concrete implementations should override the
   * {@link #generate(Set)} method to provide specific generation behavior.
   * <p>
   * The plugin supports:
   * <ul>
   * <li>Loading multiple Metaschema modules from a configured directory</li>
   * <li>Applying external constraint sets to modules</li>
   * <li>Incremental build support through stale file tracking</li>
   * <li>Configurable file encoding for generated sources</li>
   * </ul>
   *
   * @see GenerateSourcesMojo
   * @see GenerateSchemaMojo
   */
  public abstract class AbstractMetaschemaMojo
     extends AbstractMojo {
   private static final String[] DEFAULT_INCLUDES = { "**/*.xml" };
 
   /**
    * The Maven project context.
    *
    * @required
    * @readonly
    */
   @Parameter(defaultValue = "${project}", required = true, readonly = true)
   MavenProject mavenProject;
 
   /**
    * This will be injected if this plugin is executed as part of the standard
    * Maven lifecycle. If the mojo is directly invoked, this parameter will not be
    * injected.
    */
   @Parameter(defaultValue = "${mojoExecution}", readonly = true)
   private MojoExecution mojoExecution;
 
   @Inject
   private BuildContext buildContext;
 
   @Parameter(defaultValue = "${plugin.artifacts}", readonly = true, required = true)
   private List<Artifact> pluginArtifacts;
 
   /**
    * <p>
    * The directory where the staleFile is found. The staleFile is used to
    * determine if re-generation of generated Java classes is needed, by recording
    * when the last build occurred.
    * </p>
    * <p>
    * This directory is expected to be located within the
    * <code>${project.build.directory}</code>, to ensure that code (re)generation
    * occurs after cleaning the project.
    * </p>
    */
   @Parameter(defaultValue = "${project.build.directory}/metaschema", readonly = true, required = true)
   protected File staleFileDirectory;
 
   /**
    * <p>
    * Defines the encoding used for generating Java Source files.
    * </p>
    * <p>
    * The algorithm for finding the encoding to use is as follows (where the first
    * non-null value found is used for encoding):
    * <ol>
    * <li>If the configuration property is explicitly given within the plugin's
    * configuration, use that value.
    * <li>If the Maven property <code>project.build.sourceEncoding</code> is
    * defined, use its value.
    * <li>Otherwise use the value from the system property
    * <code>file.encoding</code>.
    * </ol>
    * </p>
    *
    * @see #getEncoding()
    * @since 2.0
    */
   @Parameter(defaultValue = "${project.build.sourceEncoding}")
   private String encoding;
 
   /**
    * Location to generate Java source files in.
    */
   @Parameter(
       defaultValue = "${project.build.directory}/generated-sources/metaschema",
       required = true,
       property = "outputDirectory")
   private File outputDirectory;
 
   /**
    * The directory to read source metaschema from.
    */
   @Parameter(defaultValue = "${basedir}/src/main/metaschema")
   private File metaschemaDir;
 
   /**
    * A list of <code>files</code> containing Metaschema module constraints files.
    */
   @Parameter(property = "constraints")
   private File[] constraints;
 
   /**
    * A set of inclusion patterns used to select which Metaschema modules are to be
    * processed. By default, all files are processed.
    */
   @Parameter
   protected String[] includes;
 
   /**
    * A set of exclusion patterns used to prevent certain files from being
    * processed. By default, this set is empty such that no files are excluded.
    */
   @Parameter
   protected String[] excludes;
 
   /**
    * Indicate if the execution should be skipped.
    */
   @Parameter(property = "metaschema.skip", defaultValue = "false")
   private boolean skip;
 
   /**
    * The BuildContext is used to identify which files or directories were modified
    * since last build. This is used to determine if Module-based generation must
    * be performed again.
    *
    * @return the active Plexus BuildContext.
    */
   protected final BuildContext getBuildContext() {
     return buildContext;
   }
 
   /**
    * Retrieve the Maven project context.
    *
    * @return The active MavenProject.
    */
   protected final MavenProject getMavenProject() {
     return mavenProject;
   }
 
   /**
    * Retrieve the plugin artifacts available to this mojo.
    *
    * @return the list of plugin artifacts
    */
   protected final List<Artifact> getPluginArtifacts() {
     return pluginArtifacts;
   }
 
   /**
    * Retrieve the mojo execution context.
    *
    * @return The active MojoExecution.
    */
   @SuppressFBWarnings(value = "EI_EXPOSE_REP", justification = "this is a data holder")
   public MojoExecution getMojoExecution() {
     return mojoExecution;
   }
 
   /**
    * Retrieve the directory where generated classes will be stored.
    *
    * @return the directory
    */
   protected File getOutputDirectory() {
     return outputDirectory;
   }
 
   /**
    * Set the directory where generated classes will be stored.
    *
    * @param outputDirectory
    *          the directory to use
    */
   protected void setOutputDirectory(File outputDirectory) {
     Objects.requireNonNull(outputDirectory, "outputDirectory");
     this.outputDirectory = outputDirectory;
   }
 
   /**
    * Gets the file encoding to use for generated classes.
    * <p>
    * The algorithm for finding the encoding to use is as follows (where the first
    * non-null value found is used for encoding):
    * </p>
    * <ol>
    * <li>If the configuration property is explicitly given within the plugin's
    * configuration, use that value.
    * <li>If the Maven property <code>project.build.sourceEncoding</code> is
    * defined, use its value.
    * <li>Otherwise use the value from the system property
    * <code>file.encoding</code>.
    * </ol>
    *
    * @return The encoding to be used by this AbstractJaxbMojo and its tools.
    */
   protected final String getEncoding() {
     String encoding;
     if (this.encoding != null) {
       // first try to use the provided encoding
       encoding = this.encoding;
       if (getLog().isDebugEnabled()) {
         getLog().debug(String.format("Using configured encoding [%s].", encoding));
       }
     } else {
       encoding = Charset.defaultCharset().displayName();
       if (getLog().isWarnEnabled()) {
         getLog().warn(String.format("Using system encoding [%s]. This build is platform dependent!", encoding));
       }
     }
     return encoding;
   }
 
   /**
    * Retrieve a stream of Module file sources.
    *
    * @return the stream
    */
   protected Stream<File> getModuleSources() {
     DirectoryScanner ds = new DirectoryScanner();
     ds.setBasedir(metaschemaDir);
     ds.setIncludes(includes != null && includes.length > 0 ? includes : DEFAULT_INCLUDES);
     ds.setExcludes(excludes != null && excludes.length > 0 ? excludes : null);
     ds.addDefaultExcludes();
     ds.setCaseSensitive(true);
     ds.setFollowSymlinks(false);
     ds.scan();
     return Stream.of(ds.getIncludedFiles()).map(filename -> new File(metaschemaDir, filename)).distinct();
   }
 
   /**
    * Create a new binding context configured with the specified module post
    * processor.
    *
    * @param modulePostProcessor
    *          the post processor to apply to loaded modules
    * @return the configured binding context
    * @throws IOException
    *           if an I/O error occurs during context creation
    * @throws MetaschemaException
    *           if an error occurs while processing the Metaschema module
    */
   @NonNull
   protected IBindingContext newBindingContext(
       @NonNull IModuleLoader.IModulePostProcessor modulePostProcessor) throws IOException, MetaschemaException {
     // generate Java sources based on provided metaschema sources
     return new DefaultBindingContext(
         new PostProcessingModuleLoaderStrategy(
             // ensure that the external constraints do not apply to the built in module
             CollectionUtil.singletonList(modulePostProcessor),
             new SimpleModuleLoaderStrategy(
                 // this is used instead of the default generator to ensure that plugin classpath
                 // entries are used for compilation
                 new ModuleBindingGenerator(
                     ObjectUtils.notNull(Files.createDirectories(Paths.get("target/metaschema-codegen-modules"))),
                     new DefaultBindingConfiguration()))));
   }
 
   /**
    * Get the configured collection of constraints.
    *
    * @return the loaded constraints
    * @throws MojoExecutionException
    *           if an error occurred while loading the constraints
    */
   @NonNull
   protected List<IConstraintSet> getConstraints() throws MojoExecutionException {
     IConstraintLoader loader = IBindingContext.getConstraintLoader();
     List<IConstraintSet> constraintSets = new ArrayList<>(constraints.length);
     for (File constraint : this.constraints) {
       try {
         constraintSets.addAll(loader.load(ObjectUtils.notNull(constraint)));
       } catch (IOException | MetaschemaException ex) {
         throw new MojoExecutionException("Loading of external constraints failed", ex);
       }
     }
     return CollectionUtil.unmodifiableList(constraintSets);
   }
 
   /**
    * Determine if the execution of this mojo should be skipped.
    *
    * @return {@code true} if the mojo execution should be skipped, or
    *         {@code false} otherwise
    */
   protected boolean shouldExecutionBeSkipped() {
     return skip;
   }
 
   /**
    * Get the name of the file that is used to detect staleness.
    *
    * @return the name
    */
   protected abstract String getStaleFileName();
 
   /**
    * Gets the staleFile for this execution.
    *
    * @return the staleFile
    */
   protected final File getStaleFile() {
     StringBuilder builder = new StringBuilder();
     if (getMojoExecution() != null) {
       builder.append(getMojoExecution().getExecutionId()).append('-');
     }
     builder.append(getStaleFileName());
     return new File(staleFileDirectory, builder.toString());
   }
 
   /**
    * Determine if code generation is required. This is done by comparing the last
    * modified time of each Module source file against the stale file managed by
    * this plugin.
    *
    * @return {@code true} if the code generation is needed, or {@code false}
    *         otherwise
    */
   protected boolean isGenerationRequired() {
     final File staleFile = getStaleFile();
     boolean generate = !staleFile.exists();
     if (generate) {
       if (getLog().isInfoEnabled()) {
         getLog().info(String.format("Stale file '%s' doesn't exist! Generating source files.", staleFile.getPath()));
       }
       generate = true;
     } else {
       generate = false;
       // check for staleness
       long staleLastModified = staleFile.lastModified();
 
       BuildContext buildContext = getBuildContext();
       URI metaschemaDirRelative = getMavenProject().getBasedir().toURI().relativize(metaschemaDir.toURI());
 
       if (buildContext.isIncremental() && buildContext.hasDelta(metaschemaDirRelative.toString())) {
         if (getLog().isInfoEnabled()) {
           getLog().info("metaschemaDirRelative: " + metaschemaDirRelative.toString());
         }
         generate = true;
       }
 
       if (!generate) {
         for (File sourceFile : getModuleSources().collect(Collectors.toList())) {
           if (getLog().isInfoEnabled()) {
             getLog().info("Source file: " + sourceFile.getPath());
           }
           if (sourceFile.lastModified() > staleLastModified) {
             generate = true;
           }
         }
       }
     }
     return generate;
   }
 
   /**
    * Retrieve the combined classpath containing both project dependencies and
    * plugin artifacts.
    *
    * @return a set of classpath elements as absolute paths
    * @throws DependencyResolutionRequiredException
    *           if the project dependencies cannot be resolved
    */
   protected Set<String> getClassPath() throws DependencyResolutionRequiredException {
     Set<String> pathElements;
     try {
       pathElements = new LinkedHashSet<>(getMavenProject().getCompileClasspathElements());
     } catch (DependencyResolutionRequiredException ex) {
       getLog().warn("exception calling getCompileClasspathElements", ex);
       throw ex;
     }
 
     if (pluginArtifacts != null) {
       for (Artifact a : getPluginArtifacts()) {
         if (a.getFile() != null) {
           pathElements.add(a.getFile().getAbsolutePath());
         }
       }
     }
     return pathElements;
   }
 
   /**
    * Load and validate the Metaschema modules to generate sources or schemas for.
    *
    * @param bindingContext
    *          the binding context to use for module loading and validation
    * @param modulePostProcessor
    *          the post processor to apply to each loaded module
    * @return the set of loaded and validated modules
    * @throws MetaschemaException
    *           if an error occurs while processing the Metaschema module
    * @throws IOException
    *           if an I/O error occurs while loading a module
    * @throws ConstraintValidationException
    *           if constraint validation fails on a loaded module
    */
   @NonNull
   protected Set<IModule> getModulesToGenerateFor(
       @NonNull IBindingContext bindingContext,
       @NonNull IModuleLoader.IModulePostProcessor modulePostProcessor)
       throws MetaschemaException, IOException, ConstraintValidationException {
 
     // Don't use the normal loader, since it attempts to register and compile the
     // module.
     // We only care about the module content for generating sources and schemas
     IBindingModuleLoader loader = new BindingModuleLoader(bindingContext, (module, ctx) -> {
       modulePostProcessor.processModule(module);
     });
     loader.allowEntityResolution();
 
     LoggingValidationHandler validationHandler = new LoggingValidationHandler();
 
     Set<IModule> modules = new HashSet<>();
     for (File source : getModuleSources().collect(Collectors.toList())) {
       assert source != null;
       if (getLog().isInfoEnabled()) {
         getLog().info("Using metaschema source: " + source.getPath());
       }
       IBindingMetaschemaModule module = loader.load(source);
 
       IValidationResult result = bindingContext.validate(
           module.getSourceNodeItem(),
           loader.getBindingContext().newBoundLoader(),
           null);
 
       validationHandler.handleResults(result);
 
       modules.add(module);
     }
     return modules;
   }
 
   /**
    * Create or update the stale file to record the current build time.
    *
    * @param staleFile
    *          the stale file to create or update
    * @throws MojoExecutionException
    *           if the stale file cannot be created
    */
   protected void createStaleFile(@NonNull File staleFile) throws MojoExecutionException {
     // create the stale file
     if (!staleFileDirectory.exists() && !staleFileDirectory.mkdirs()) {
       throw new MojoExecutionException("Unable to create output directory: " + staleFileDirectory);
     }
     try (OutputStream os
         = Files.newOutputStream(staleFile.toPath(), StandardOpenOption.CREATE, StandardOpenOption.WRITE,
             StandardOpenOption.TRUNCATE_EXISTING)) {
       os.close();
       if (getLog().isInfoEnabled()) {
         getLog().info("Created stale file: " + staleFile);
       }
     } catch (IOException ex) {
       throw new MojoExecutionException("Failed to write stale file: " + staleFile.getPath(), ex);
     }
   }
 
   @Override
   public void execute() throws MojoExecutionException {
     File staleFile = getStaleFile();
     try {
       staleFile = ObjectUtils.notNull(staleFile.getCanonicalFile());
     } catch (IOException ex) {
       if (getLog().isWarnEnabled()) {
         getLog().warn("Unable to resolve canonical path to stale file. Treating it as not existing.", ex);
       }
     }
 
     boolean generate;
     if (shouldExecutionBeSkipped()) {
       if (getLog().isDebugEnabled()) {
         getLog().debug(String.format("Generation is configured to be skipped. Skipping."));
       }
       generate = false;
     } else if (staleFile.exists()) {
       generate = isGenerationRequired();
     } else {
       if (getLog().isInfoEnabled()) {
         getLog().info(String.format("Stale file '%s' doesn't exist! Generation is required.", staleFile.getPath()));
       }
       generate = true;
     }
 
     if (generate) {
       List<IConstraintSet> constraints = getConstraints();
       IModuleLoader.IModulePostProcessor modulePostProcessor
           = new LimitedExternalConstraintsModulePostProcessor(constraints);
 
       List<File> generatedFiles;
       try {
         generatedFiles = performGeneration(modulePostProcessor);
       } finally {
         // ensure the stale file is created to ensure that regeneration is only
         // performed when a
         // change is made
         createStaleFile(staleFile);
       }
 
       if (getLog().isInfoEnabled()) {
         getLog().info(String.format("Generated %d files.", generatedFiles.size()));
       }
 
       // for m2e
       for (File file : generatedFiles) {
         getBuildContext().refresh(file);
       }
     }
   }
 
   @NonNull
   private List<File> performGeneration(
       @NonNull IModuleLoader.IModulePostProcessor modulePostProcessor) throws MojoExecutionException {
     File outputDir = getOutputDirectory();
     if (getLog().isDebugEnabled()) {
       getLog().debug(String.format("Using outputDirectory: %s", outputDir.getPath()));
     }
 
     if (!outputDir.exists() && !outputDir.mkdirs()) {
       throw new MojoExecutionException("Unable to create output directory: " + outputDir);
     }
 
     IBindingContext bindingContext;
     try {
       bindingContext = newBindingContext(modulePostProcessor);
     } catch (MetaschemaException | IOException ex) {
       throw new MojoExecutionException("Failed to create the binding context", ex);
     }
 
     // generate Java sources based on provided metaschema sources
     Set<IModule> modules;
     try {
       modules = getModulesToGenerateFor(bindingContext, modulePostProcessor);
     } catch (Exception ex) {
       throw new MojoExecutionException("Loading of metaschema modules failed", ex);
     }
 
     return generate(modules);
   }
 
   /**
    * Perform the generation operation.
    *
    * @param modules
    *          the modules to generate resources/sources for
    *
    * @return the files generated during the operation
    * @throws MojoExecutionException
    *           if an error occurred while performing the generation operation
    */
   @NonNull
   protected abstract List<File> generate(@NonNull Set<IModule> modules) throws MojoExecutionException;
 
   /**
    * A validation result handler that logs validation findings using the Maven
    * plugin logger.
    * <p>
    * Findings are logged at different levels based on their severity:
    * <ul>
    * <li>CRITICAL and ERROR - logged at error level</li>
    * <li>WARNING - logged at warn level</li>
    * <li>INFORMATIONAL - logged at info level</li>
    * <li>All other severities - logged at debug level</li>
    * </ul>
    */
   protected final class LoggingValidationHandler
       extends AbstractValidationResultProcessor {
 
     private <T extends IValidationFinding> void handleFinding(
         @NonNull T finding,
         @NonNull Function<T, CharSequence> formatter) {
 
       Log log = getLog();
 
       switch (finding.getSeverity()) {
       case CRITICAL:
       case ERROR:
         if (log.isErrorEnabled()) {
           log.error(formatter.apply(finding), finding.getCause());
         }
         break;
       case WARNING:
         if (log.isWarnEnabled()) {
           getLog().warn(formatter.apply(finding), finding.getCause());
         }
         break;
       case INFORMATIONAL:
         if (log.isInfoEnabled()) {
           getLog().info(formatter.apply(finding), finding.getCause());
         }
         break;
       default:
         if (log.isDebugEnabled()) {
           getLog().debug(formatter.apply(finding), finding.getCause());
         }
         break;
       }
     }
 
     @Override
     protected void handleJsonValidationFinding(JsonValidationFinding finding) {
       handleFinding(finding, this::getMessage);
     }
 
     @Override
     protected void handleXmlValidationFinding(XmlValidationFinding finding) {
       handleFinding(finding, this::getMessage);
     }
 
     @Override
     protected void handleConstraintValidationFinding(ConstraintValidationFinding finding) {
       handleFinding(finding, this::getMessage);
     }
 
     @NonNull
     private CharSequence getMessage(JsonValidationFinding finding) {
       StringBuilder builder = new StringBuilder();
       builder.append('[')
           .append(finding.getCause().getPointerToViolation())
           .append("] ")
           .append(finding.getMessage());
 
       URI documentUri = finding.getDocumentUri();
       if (documentUri != null) {
         builder.append(" [")
             .append(documentUri.toString())
             .append(']');
       }
       return builder;
     }
 
     @NonNull
     private CharSequence getMessage(XmlValidationFinding finding) {
       StringBuilder builder = new StringBuilder();
 
       builder.append(finding.getMessage())
           .append(" [");
 
       URI documentUri = finding.getDocumentUri();
       if (documentUri != null) {
         builder.append(documentUri.toString());
       }
 
       SAXParseException ex = finding.getCause();
       builder.append(finding.getMessage())
           .append('{')
           .append(ex.getLineNumber())
           .append(',')
           .append(ex.getColumnNumber())
           .append("}]");
       return builder;
     }
 
     @NonNull
     private CharSequence getMessage(@NonNull ConstraintValidationFinding finding) {
       StringBuilder builder = new StringBuilder();
       builder.append('[')
           .append(finding.getTarget().getMetapath())
           .append(']');
 
       String id = finding.getIdentifier();
       if (id != null) {
         builder.append(' ')
             .append(id);
       }
 
       builder.append(' ')
           .append(finding.getMessage());
 
       URI documentUri = finding.getTarget().getBaseUri();
       IResourceLocation location = finding.getLocation();
       if (documentUri != null || location != null) {
         builder.append(" [");
       }
 
       if (documentUri != null) {
         builder.append(documentUri.toString());
       }
 
       if (location != null) {
         builder.append('{')
             .append(location.getLine())
             .append(',')
             .append(location.getColumn())
             .append('}');
       }
       if (documentUri != null || location != null) {
         builder.append(']');
       }
       return builder;
     }
   }
 
   /**
    * A module binding generator that generates and compiles Java classes for
    * Metaschema modules during plugin execution.
    * <p>
    * This generator uses the plugin's classpath for compilation, ensuring that all
    * necessary dependencies are available during the code generation process.
    */
   public class ModuleBindingGenerator implements IModuleBindingGenerator {
     @NonNull
     private final Path compilePath;
     @NonNull
     private final ClassLoader classLoader;
     @NonNull
     private final IBindingConfiguration bindingConfiguration;
 
     /**
      * Construct a new module binding generator.
      *
      * @param compilePath
      *          the directory path where generated classes will be compiled to
      * @param bindingConfiguration
      *          the binding configuration to use for code generation
      */
     public ModuleBindingGenerator(
         @NonNull Path compilePath,
         @NonNull IBindingConfiguration bindingConfiguration) {
       this.compilePath = compilePath;
       this.classLoader = ModuleCompilerHelper.newClassLoader(
           compilePath,
           ObjectUtils.notNull(Thread.currentThread().getContextClassLoader()));
       this.bindingConfiguration = bindingConfiguration;
     }
 
     /**
      * Generate Java source files for the specified module.
      *
      * @param module
      *          the Metaschema module to generate classes for
      * @return the production containing the generated class information
      * @throws MetaschemaException
      *           if an error occurs during class generation
      */
     @NonNull
     public IProduction generateClasses(@NonNull IModule module) throws MetaschemaException {
       IProduction production;
       try {
         production = JavaGenerator.generate(module, compilePath, bindingConfiguration);
       } catch (IOException ex) {
         throw new MetaschemaException(
             String.format("Unable to generate and compile classes for module '%s'.", module.getLocation()),
             ex);
       }
       return production;
     }
 
     private void compileClasses(@NonNull IProduction production, @NonNull Path classDir)
         throws IOException, DependencyResolutionRequiredException {
       List<IGeneratedClass> classesToCompile = production.getGeneratedClasses().collect(Collectors.toList());
 
       List<Path> classes = ObjectUtils.notNull(classesToCompile.stream()
           .map(IGeneratedClass::getClassFile)
           .collect(Collectors.toUnmodifiableList()));
 
       JavaCompilerSupport compiler = new JavaCompilerSupport(classDir);
       compiler.setLogger(new JavaCompilerSupport.Logger() {
 
         @Override
         public boolean isDebugEnabled() {
           return getLog().isDebugEnabled();
         }
 
         @Override
         public boolean isInfoEnabled() {
           return getLog().isInfoEnabled();
         }
 
         @Override
         public void debug(String msg) {
           getLog().debug(msg);
         }
 
         @Override
         public void info(String msg) {
           getLog().info(msg);
         }
       });
 
       getClassPath().forEach(compiler::addToClassPath);
 
       JavaCompilerSupport.CompilationResult result = compiler.compile(classes);
 
       if (!result.isSuccessful()) {
         DiagnosticCollector<?> diagnostics = new DiagnosticCollector<>();
         if (getLog().isErrorEnabled()) {
           getLog().error("diagnostics: " + diagnostics.getDiagnostics().toString());
         }
         throw new IllegalStateException(String.format("failed to compile classes: %s",
             classesToCompile.stream()
                 .map(clazz -> clazz.getClassName().canonicalName())
                 .collect(Collectors.joining(","))));
       }
     }
 
     @Override
     public Class<? extends IBoundModule> generate(IModule module) throws MetaschemaException {
       IProduction production = generateClasses(module);
       try {
         compileClasses(production, compilePath);
       } catch (IOException | DependencyResolutionRequiredException ex) {
         throw new IllegalStateException("failed to compile classes", ex);
       }
       IGeneratedModuleClass moduleClass = ObjectUtils.requireNonNull(production.getModuleProduction(module));
 
       try {
         return moduleClass.load(classLoader);
       } catch (ClassNotFoundException ex) {
         throw new IllegalStateException(ex);
       }
     }
   }
 
   /**
    * A module post processor that applies external constraints to modules,
    * excluding the built-in Metaschema module to avoid duplicate constraint
    * application.
    */
   private static class LimitedExternalConstraintsModulePostProcessor
       extends ExternalConstraintsModulePostProcessor {
 
     /**
      * Construct a new post processor with the specified constraint sets.
      *
      * @param additionalConstraintSets
      *          the constraint sets to apply to modules
      */
     public LimitedExternalConstraintsModulePostProcessor(
         @NonNull Collection<IConstraintSet> additionalConstraintSets) {
       super(additionalConstraintSets);
     }
 
     /**
      * This method ensures that constraints are not applied to the built-in
      * Metaschema module module twice, when this module is selected as the source
      * for generation.
      */
     @Override
     public void processModule(IModule module) {
       if (!(module instanceof MetaschemaModelModule)) {
         super.processModule(module);
       }
     }
   }
 }