/*
    * SPDX-FileCopyrightText: Copyright (c) 2011-2026 Yegor Bugayenko
    * SPDX-License-Identifier: MIT
    */
   package com.qulice.maven;
   
   import com.google.common.base.Predicates;
   import com.google.common.collect.Collections2;
   import com.google.common.collect.Iterables;
  import com.jcabi.log.Logger;
  import com.qulice.spi.Binary;
  import java.io.File;
  import java.net.MalformedURLException;
  import java.net.URI;
  import java.net.URL;
  import java.net.URLClassLoader;
  import java.nio.charset.Charset;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  import java.util.Properties;
  import javax.annotation.Nullable;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.FilenameUtils;
  import org.apache.commons.io.filefilter.DirectoryFileFilter;
  import org.apache.commons.io.filefilter.IOFileFilter;
  import org.apache.commons.io.filefilter.WildcardFileFilter;
  import org.apache.maven.artifact.DependencyResolutionRequiredException;
  import org.apache.maven.model.Build;
  import org.apache.maven.model.Resource;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.context.Context;
  
  /**
   * Environment, passed from MOJO to validators.
   * @since 0.3
   */
  @SuppressWarnings("PMD.GodClass")
  public final class DefaultMavenEnvironment implements MavenEnvironment {
  
      /**
       * Maven project.
       */
      private MavenProject iproject;
  
      /**
       * Plexus context.
       */
      private Context icontext;
  
      /**
       * Plugin configuration.
       */
      private final Properties iproperties;
  
      /**
       * MOJO executor.
       */
      private MojoExecutor exectr;
  
      /**
       * Excludes, regular expressions.
       */
      private final Collection<String> exc;
  
      /**
       * Xpath queries for pom.xml validation.
       */
      private final Collection<String> assertion;
  
      /**
       * Source code encoding charset.
       */
      private String charset;
  
      /**
       * Default constructor.
       */
      public DefaultMavenEnvironment() {
          this.iproperties = new Properties();
          this.exc = new ArrayList<>(0);
          this.assertion = new ArrayList<>(0);
          this.charset = "UTF-8";
      }
  
      @Override
      public String param(final String name, final String value) {
          String ret = this.iproperties.getProperty(name);
          if (ret == null && this.iproject != null) {
              ret = this.iproject.getProperties().getProperty(name);
          }
          if (ret == null) {
              ret = value;
          }
          return ret;
      }
  
      @Override
      public File basedir() {
         return this.iproject.getBasedir();
     }
 
     @Override
     public File tempdir() {
         final File dir = new File(
             this.iproject.getBuild().getDirectory(), "tempdir"
         );
         if (!dir.mkdirs() && !dir.isDirectory()) {
             throw new IllegalStateException(
                 String.format("Cannot create tempdir at %s", dir)
             );
         }
         return dir;
     }
 
     @Override
     public File outdir() {
         return new File(this.iproject.getBuild().getOutputDirectory());
     }
 
     @Override
     public Collection<File> testdirs() {
         final Collection<File> dirs = new ArrayList<>(0);
         final List<String> roots = this.iproject.getTestCompileSourceRoots();
         if (roots != null) {
             for (final String root : roots) {
                 dirs.add(this.resolve(root));
             }
         }
         return dirs;
     }
 
     @Override
     public Collection<String> classpath() {
         final Collection<String> paths = new ArrayList<>(0);
         final String blank = "%20";
         final String whitespace = " ";
         try {
             for (final String name
                 : this.iproject.getTestClasspathElements()) {
                 paths.add(
                     name.replace(
                         File.separatorChar, '/'
                     ).replaceAll(whitespace, blank)
                 );
             }
         } catch (final DependencyResolutionRequiredException ex) {
             throw new IllegalStateException("Failed to read classpath", ex);
         }
         return paths;
     }
 
     @Override
     public ClassLoader classloader() {
         final List<URL> urls = new ArrayList<>(0);
         for (final String path : this.classpath()) {
             try {
                 urls.add(
                     URI.create(String.format("file:///%s", path)).toURL()
                 );
             } catch (final MalformedURLException ex) {
                 throw new IllegalStateException("Failed to build URL", ex);
             }
         }
         final URLClassLoader loader = new PrivilegedClassLoader(urls).run();
         for (final URL url : loader.getURLs()) {
             Logger.debug(this, "Classpath: %s", url);
         }
         return loader;
     }
 
     @Override
     public MavenProject project() {
         return this.iproject;
     }
 
     @Override
     public Properties properties() {
         return this.iproperties;
     }
 
     @Override
     public Context context() {
         return this.icontext;
     }
 
     @Override
     public Properties config() {
         return this.iproperties;
     }
 
     @Override
     public MojoExecutor executor() {
         return this.exectr;
     }
 
     @Override
     public Collection<String> asserts() {
         return this.assertion;
     }
 
     @Override
     public Collection<File> files(final String pattern) {
         final Collection<File> files = new ArrayList<>(0);
         final IOFileFilter filter = WildcardFileFilter.builder().setWildcards(pattern).get();
         for (final File sources : this.sources()) {
             if (sources.exists()) {
                 for (final File found : FileUtils.listFiles(
                     sources,
                     filter,
                     DirectoryFileFilter.INSTANCE
                 )) {
                     if (new Binary(found).yes()) {
                         Logger.debug(
                             this,
                             "Skipping binary file %s",
                             found
                         );
                     } else {
                         files.add(found);
                     }
                 }
             }
         }
         return files;
     }
 
     @Override
     public boolean exclude(final String check, final String name) {
         return Iterables.any(
             this.excludes(check),
             new PathPredicate(name)
         );
     }
 
     @Override
     public Collection<String> excludes(final String checker) {
         return Collections2.filter(
             Collections2.transform(
                 this.exc,
                 new CheckerExcludes(checker)
             ),
             Predicates.notNull()
         );
     }
 
     /**
      * Set Maven Project (used mostly for unit testing).
      * @param proj The project to set
      */
     public void setProject(final MavenProject proj) {
         this.iproject = proj;
     }
 
     /**
      * Set context.
      * @param ctx The context to set
      */
     public void setContext(final Context ctx) {
         this.icontext = ctx;
     }
 
     /**
      * Set executor.
      * @param exec The executor
      */
     public void setMojoExecutor(final MojoExecutor exec) {
         this.exectr = exec;
     }
 
     /**
      * Set property.
      * @param name Its name
      * @param value Its value
      */
     public void setProperty(final String name, final String value) {
         this.iproperties.setProperty(name, value);
     }
 
     /**
      * Set list of regular expressions to exclude.
      * @param exprs Expressions
      */
     public void setExcludes(final Collection<String> exprs) {
         this.exc.clear();
         this.exc.addAll(exprs);
     }
 
     /**
      * Set list of Xpath queries for pom.xml validation.
      * @param ass Xpath queries
      */
     public void setAssertion(final Collection<String> ass) {
         this.assertion.clear();
         this.assertion.addAll(ass);
     }
 
     /**
      * Set the encoding of source files.
      * @param encoding The encoding to use
      */
     public void setEncoding(final String encoding) {
         this.charset = encoding;
     }
 
     @Override
     public Charset encoding() {
         if (this.charset == null || this.charset.isEmpty()) {
             this.charset = "UTF-8";
         }
         return Charset.forName(this.charset);
     }
 
     private Collection<File> sources() {
         final Collection<File> dirs = new ArrayList<>(0);
         final Build build = this.iproject.getBuild();
         final File output = this.buildDirectory(build);
         this.addRoots(dirs, this.iproject.getCompileSourceRoots(), output);
         this.addRoots(dirs, this.iproject.getTestCompileSourceRoots(), output);
         if (build != null) {
             this.addResources(dirs, build.getResources(), output);
             this.addResources(dirs, build.getTestResources(), output);
         }
         if (dirs.isEmpty()) {
             dirs.add(new File(this.basedir(), "src"));
         }
         return dirs;
     }
 
     @Nullable
     private File buildDirectory(@Nullable final Build build) {
         File dir = null;
         if (build != null && build.getDirectory() != null) {
             dir = this.resolve(build.getDirectory());
         }
         return dir;
     }
 
     private void addRoots(final Collection<File> dirs,
         final List<String> roots, @Nullable final File output) {
         if (roots != null) {
             for (final String root : roots) {
                 final File resolved = this.resolve(root);
                 if (DefaultMavenEnvironment.outside(resolved, output)) {
                     dirs.add(resolved);
                 } else {
                     Logger.debug(
                         this,
                         "Skipping generated source root %s under %s",
                         resolved, output
                     );
                 }
             }
         }
     }
 
     private void addResources(final Collection<File> dirs,
         final List<Resource> resources, @Nullable final File output) {
         if (resources != null) {
             for (final Resource res : resources) {
                 final File resolved = this.resolve(res.getDirectory());
                 if (DefaultMavenEnvironment.outside(resolved, output)) {
                     dirs.add(resolved);
                 } else {
                     Logger.debug(
                         this,
                         "Skipping generated resource directory %s under %s",
                         resolved, output
                     );
                 }
             }
         }
     }
 
     private static boolean outside(final File file,
         @Nullable final File parent) {
         boolean answer = true;
         if (parent != null) {
             final String head = FilenameUtils.normalize(
                 parent.getAbsolutePath(), true
             );
             final String tail = FilenameUtils.normalize(
                 file.getAbsolutePath(), true
             );
             if (head != null && tail != null
                 && (tail.equals(head) || tail.startsWith(head.concat("/")))) {
                 answer = false;
             }
         }
         return answer;
     }
 
     private File resolve(final String path) {
         final File file = new File(path);
         final File resolved;
         if (file.isAbsolute()) {
             resolved = file;
         } else {
             resolved = new File(this.basedir(), path);
         }
         return resolved;
     }
 }