/*
    * SPDX-FileCopyrightText: none
    * SPDX-License-Identifier: CC0-1.0
    */
   
   package gov.nist.secauto.metaschema.maven.plugin;
   
   import gov.nist.secauto.metaschema.core.model.IConstraintLoader;
   import gov.nist.secauto.metaschema.core.model.MetaschemaException;
  import gov.nist.secauto.metaschema.core.model.constraint.IConstraintSet;
  import gov.nist.secauto.metaschema.core.model.xml.ExternalConstraintsModulePostProcessor;
  import gov.nist.secauto.metaschema.core.util.CollectionUtil;
  import gov.nist.secauto.metaschema.core.util.ObjectUtils;
  import gov.nist.secauto.metaschema.databind.IBindingContext;
  import gov.nist.secauto.metaschema.databind.model.metaschema.BindingConstraintLoader;
  import gov.nist.secauto.metaschema.databind.model.metaschema.BindingModuleLoader;
  
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecution;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugins.annotations.Component;
  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 java.io.File;
  import java.io.IOException;
  import java.net.URI;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Objects;
  import java.util.stream.Collectors;
  import java.util.stream.Stream;
  
  import edu.umd.cs.findbugs.annotations.NonNull;
  import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
  
  public abstract class AbstractMetaschemaMojo
      extends AbstractMojo {
    private static final String SYSTEM_FILE_ENCODING_PROPERTY = "file.encoding";
    private static final String[] DEFAULT_INCLUDES = { "**/*.xml" };
  
    /**
     * The Maven project context.
     *
     * @parameter default-value="${project}"
     * @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;
  
    @Component
    private BuildContext buildContext;
  
    /**
     * <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>
     * <li>If the Maven property <code>project.build.sourceEncoding</code> is
     * defined, use its value.</li>
     * <li>Otherwise use the value from the system property
     * <code>file.encoding</code>.</li>
     * </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)
   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 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>
    * <li>If the Maven property <code>project.build.sourceEncoding</code> is
    * defined, use its value.</li>
    * <li>Otherwise use the value from the system property
    * <code>file.encoding</code>.</li>
    * </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 = System.getProperty(SYSTEM_FILE_ENCODING_PROPERTY);
       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();
   }
 
   /**
    * Get the configured collection of constraints.
    *
    * @param bindingContext
    *          the Metaschema binding context to use when loading the constraints
    * @return the loaded constraints
    * @throws MetaschemaException
    *           if a binding exception occurred while loading the constraints
    * @throws IOException
    *           if an error occurred while reading the constraints
    */
   protected List<IConstraintSet> getConstraints(@NonNull IBindingContext bindingContext)
       throws MetaschemaException, IOException {
     IConstraintLoader loader = new BindingConstraintLoader(bindingContext);
     List<IConstraintSet> constraintSets = new ArrayList<>(constraints.length);
     for (File constraint : this.constraints) {
       constraintSets.addAll(loader.load(ObjectUtils.notNull(constraint)));
     }
     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;
   }
 
   /**
    * Construct a new module loader based on the provided mojo configuration.
    *
    * @return the module loader
    * @throws MojoExecutionException
    *           if an error occurred while loading the configured constraints
    */
   @NonNull
   protected BindingModuleLoader newModuleLoader() throws MojoExecutionException {
     IBindingContext bindingContext = IBindingContext.instance();
 
     List<IConstraintSet> constraints;
     try {
       constraints = getConstraints(bindingContext);
     } catch (MetaschemaException | IOException ex) {
       throw new MojoExecutionException("Unable to load external constraints.", ex);
     }
 
     // generate Java sources based on provided metaschema sources
     BindingModuleLoader loader = constraints.isEmpty()
         ? new BindingModuleLoader(bindingContext)
         : new BindingModuleLoader(
             bindingContext,
             CollectionUtil.singletonList(new ExternalConstraintsModulePostProcessor(constraints)));
     loader.allowEntityResolution();
     return loader;
   }
 }