/*
    * SPDX-FileCopyrightText: Copyright (c) 2011-2026 Yegor Bugayenko
    * SPDX-License-Identifier: MIT
    */
   package com.qulice.maven;
   
   import com.jcabi.log.Logger;
   import java.util.ArrayList;
   import java.util.Collection;
  import javax.inject.Inject;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MavenPluginManager;
  import org.apache.maven.plugin.MojoFailureException;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.context.Context;
  import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;
  import org.slf4j.impl.StaticLoggerBinder;
  
  /**
   * Abstract mojo.
   *
   * @since 0.3
   */
  public abstract class AbstractQuliceMojo extends AbstractMojo
      implements Contextualizable {
  
      /**
       * Name of the parameter that carries the extra ErrorProne flags of the
       * project down to {@code ErrorProneValidator}.
       */
      private static final String ERRORPRONE = "qulice.errorprone";
  
      /**
       * Environment to pass to validators.
       */
      private final DefaultMavenEnvironment environment;
  
      /**
       * Maven project, to be injected by Maven itself.
       */
      @Parameter(defaultValue = "${project}", readonly = true)
      private MavenProject project;
  
      /**
       * Maven session, to be injected by Maven itself.
       */
      @Parameter(defaultValue = "${session}", readonly = true)
      private MavenSession sess;
  
      /**
       * Maven plugin manager, to be injected by Maven itself.
       */
      @Inject
      private MavenPluginManager manager;
  
      /**
       * Shall we skip execution?
       */
      @Parameter(property = "qulice.skip", defaultValue = "false")
      private boolean skip;
  
      /**
       * List of regular expressions to exclude.
       */
      @Parameter(property = "qulice.excludes")
      private final Collection<String> excludes;
  
      /**
       * List of xpath queries to validate pom.xml.
       */
      @Parameter(
          property = "qulice.asserts",
          required = false
      )
      private final Collection<String> asserts;
  
      /**
       * List of ErrorProne flags to add to the ones Qulice already passes,
       * e.g. {@code -Xep:UnicodeInCode:OFF} to switch a bug pattern off, or
       * {@code -Xep:OperatorPrecedence:ERROR} to switch one back on.
       */
      @Parameter(
          property = AbstractQuliceMojo.ERRORPRONE,
          required = false
      )
      private final Collection<String> errorprone;
  
      /**
       * The source encoding.
       *
       * @parameter expression="${project.build.sourceEncoding}" required="true"
       */
      @Parameter(property = "encoding", defaultValue = "${project.build.sourceEncoding}")
      private String charset;
  
      /**
       * Default constructor.
      */
     protected AbstractQuliceMojo() {
         this.environment = new DefaultMavenEnvironment();
         this.excludes = new ArrayList<>(0);
         this.asserts = new ArrayList<>(0);
         this.errorprone = new ArrayList<>(0);
     }
 
     /**
      * Set Maven Project (used mostly for unit testing).
      *
      * @param proj The project to set
      */
     public final void setProject(final MavenProject proj) {
         this.project = proj;
     }
 
     /**
      * Set skip option (mostly for unit testing).
      *
      * @param skp The "skip" option
      */
     public final void setSkip(final boolean skp) {
         this.skip = skp;
     }
 
     /**
      * Set asserts option.
      *
      * @param val Asserts to use
      */
     public final void setAsserts(final Collection<String> val) {
         this.asserts.clear();
         this.asserts.addAll(val);
     }
 
     /**
      * Set excludes.
      *
      * @param exprs Expressions
      */
     public final void setExcludes(final Collection<String> exprs) {
         this.excludes.clear();
         this.excludes.addAll(exprs);
     }
 
     /**
      * Set extra ErrorProne flags.
      *
      * @param flags Flags, e.g. {@code -Xep:UnicodeInCode:OFF}
      */
     public final void setErrorprone(final Collection<String> flags) {
         this.errorprone.clear();
         this.errorprone.addAll(flags);
     }
 
     /**
      * Set source code encoding.
      *
      * @param encoding Source code encoding
      */
     public void setEncoding(final String encoding) {
         this.charset = encoding;
     }
 
     @Override
     public final void contextualize(final Context ctx) {
         this.environment.setContext(ctx);
     }
 
     @Override
     public final void execute() throws MojoFailureException {
         final long start = System.currentTimeMillis();
         StaticLoggerBinder.getSingleton().setMavenLog(this.getLog());
         if (this.skip) {
             this.getLog().info("Execution skipped");
             return;
         }
         this.environment.setProject(this.project);
         this.environment.setMojoExecutor(
             new MojoExecutor(this.manager, this.sess)
         );
         this.environment.setExcludes(this.excludes);
         this.environment.setAssertion(this.asserts);
         this.environment.setEncoding(this.charset);
         if (!this.errorprone.isEmpty()) {
             this.environment.setProperty(
                 AbstractQuliceMojo.ERRORPRONE,
                 String.join(" ", this.errorprone)
             );
         }
         Logger.info(
             this,
             "Qulice %s in %[ms]s",
             this.doExecute(),
             System.currentTimeMillis() - start
         );
     }
 
     /**
      * Current maven session.
      *
      * @return Current maven session
      */
     public final MavenSession session() {
         return this.sess;
     }
 
     /**
      * Do the real execution.
      *
      * @return What was done, as the middle of the final log line, e.g.
      *  {@code "checked 42 .java files against 385 rules"}
      * @throws MojoFailureException If some failure inside
      */
     protected abstract String doExecute() throws MojoFailureException;
 
     /**
      * Get the environment.
      *
      * @return The environment
      */
     protected final MavenEnvironment env() {
         return this.environment;
     }
 }