/*
    * SPDX-FileCopyrightText: Copyright (c) 2011-2026 Yegor Bugayenko
    * SPDX-License-Identifier: MIT
    */
   package com.qulice.spi;
   
   import java.io.File;
   import java.io.IOException;
   import java.nio.charset.Charset;
  import java.nio.charset.StandardCharsets;
  import java.nio.file.Files;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Map;
  import java.util.Set;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.filefilter.DirectoryFileFilter;
  import org.apache.commons.io.filefilter.IOFileFilter;
  import org.apache.commons.io.filefilter.WildcardFileFilter;
  
  /**
   * Environment.
   *
   * @since 0.3
   */
  @SuppressWarnings("PMD.TooManyMethods")
  public interface Environment {
  
      /**
       * Get project's basedir.
       *
       * @return The directory
       */
      File basedir();
  
      /**
       * Get directory to keep temporary files in.
       *
       * @return The directory
       */
      File tempdir();
  
      /**
       * Get directory where {@code .class} files are stored.
       *
       * @return The directory
       */
      File outdir();
  
      /**
       * Get the directories the project keeps its test sources in.
       *
       * <p>Maven allows a project to register any number of test source
       * roots, either through {@code <testSourceDirectory>} or through a
       * plugin such as {@code build-helper-maven-plugin:add-test-source},
       * which the jcabi parent POM uses for {@code src/mock/java}. A file
       * therefore cannot be told from a main one by its path alone, and
       * whoever needs to know has to ask for these roots.</p>
       *
       * @return Test source roots, absolute, possibly empty
       */
      Collection<File> testdirs();
  
      /**
       * Get parameter by name, and return default if it's not set.
       *
       * @param name The name of parameter
       * @param value Default value to return as default
       * @return The value
       */
      String param(String name, String value);
  
      /**
       * Get classloader for this project.
       *
       * @return The classloader
       */
      ClassLoader classloader();
  
      /**
       * Get list of paths in classpath.
       *
       * @return The collection of paths
       */
      Collection<String> classpath();
  
      /**
       * Returns the files matching the specified pattern.
       *
       * <p>The pattern matching scheme used is wildcard matching. The characters
       * '?' and '*' represents single or multiple wildcard characters,
       * respectively. Pattern matching is case sensitive.</p>
       *
       * @param pattern File name pattern
       * @return Collection of files, matching the specified pattern
      */
     Collection<File> files(String pattern);
 
     /**
      * Shall this item be excluded from report?
      *
      * @param check Name of the check that is asking
      * @param name File or any other item, which is subject of validation
      * @return TRUE if it should be ignored
      */
     boolean exclude(String check, String name);
 
     /**
      * List of exclude patterns for given checker.
      * Each list element will contain exactly one exclude pattern which,
      * depending on the plugin that uses the excludes might be either wildcard
      * (CodeNarc) pattern or regex pattern (FindBugs).
      *
      * @param checker Name of the checker that is asking (pmd, codenarc ...)
      * @return Exclude patterns
      */
     Collection<String> excludes(String checker);
 
     /**
      * Encoding for the files.
      *
      * @return Source files charset
      */
     Charset encoding();
 
     /**
      * Mock of {@link Environment}.
      *
      * @since 0.1
      */
     final class Mock implements Environment {
 
         /**
          * The basedir.
          */
         private final File origin;
 
         /**
          * Files for classpath.
          */
         private final Set<String> paths;
 
         /**
          * Map of params.
          */
         private final Map<String, String> params;
 
         /**
          * Test source roots, on top of the default {@code src/test}.
          */
         private final Collection<File> tests;
 
         /**
          * Exclude patterns.
          */
         private String excl;
 
         /**
          * Default constructor.
          */
         public Mock() {
             this(Environment.Mock.temporary());
         }
 
         /**
          * Constructor with a ready basedir.
          *
          * @param base The basedir
          */
         private Mock(final File base) {
             this(base, Environment.Mock.outputs(base));
         }
 
         /**
          * Primary constructor.
          *
          * @param base The basedir
          * @param dirs Directories to put on the classpath
          */
         private Mock(final File base, final Set<String> dirs) {
             this.origin = base;
             this.paths = dirs;
             this.params = new HashMap<>();
             this.tests = new ArrayList<>(0);
         }
 
         /**
          * With this extra test source root, the way
          * {@code build-helper-maven-plugin} would add one.
          *
          * @param path Directory name, related to basedir
          * @return This object
          */
         public Environment.Mock withTestdir(final String path) {
             this.tests.add(new File(this.origin, path));
             return this;
         }
 
         /**
          * With this param and its value.
          *
          * @param name Param name
          * @param value Param value
          * @return This object
          */
         public Environment.Mock withParam(final String name,
             final String value) {
             this.params.put(name, value);
             return this;
         }
 
         /**
          * With this file on board.
          *
          * @param name File name related to basedir
          * @param content File content to write
          * @return This object
          * @throws IOException If some IO problem
          */
         public Environment.Mock withFile(final String name,
             final String content) throws IOException {
             FileUtils.writeStringToFile(
                 new File(this.origin, name),
                 content,
                 StandardCharsets.UTF_8
             );
             return this;
         }
 
         /**
          * With this file on board.
          *
          * @param name File name related to basedir
          * @param bytes File content to write
          * @return This object
          * @throws IOException If some IO problem
          */
         public Environment.Mock withFile(final String name,
             final byte[] bytes) throws IOException {
             FileUtils.writeByteArrayToFile(new File(this.origin, name), bytes);
             return this;
         }
 
         /**
          * With exclude patterns.
          *
          * @param excludes Exclude patterns
          * @return This object
          */
         public Environment.Mock withExcludes(final String excludes) {
             this.excl = excludes;
             return this;
         }
 
         /**
          * With default classpath.
          *
          * @return This object
          */
         public Environment.Mock withDefaultClasspath() {
             Collections.addAll(
                 this.paths,
                 System.getProperty("java.class.path")
                     .split(System.getProperty("path.separator"))
             );
             return this;
         }
 
         @Override
         public File basedir() {
             return this.origin;
         }
 
         @Override
         public File tempdir() {
             final File file = new File(this.origin, "target/tempdir");
             if (!file.mkdirs() && !file.isDirectory()) {
                 throw new IllegalStateException(
                     String.format("cannot create tempdir at %s", file)
                 );
             }
             return file;
         }
 
         @Override
         public File outdir() {
             final File file = new File(this.origin, "target/classes");
             if (!file.mkdirs() && !file.isDirectory()) {
                 throw new IllegalStateException(
                     String.format("cannot create outdir at %s", file)
                 );
             }
             return file;
         }
 
         @Override
         public Collection<File> testdirs() {
             final Collection<File> dirs = new ArrayList<>(this.tests);
             dirs.add(new File(this.origin, "src/test"));
             return dirs;
         }
 
         @Override
         public String param(final String name, final String value) {
             String val = this.params.get(name);
             if (val == null) {
                 val = value;
             }
             return val;
         }
 
         @Override
         public ClassLoader classloader() {
             return Thread.currentThread().getContextClassLoader();
         }
 
         @Override
         public Collection<String> classpath() {
             return Collections.unmodifiableCollection(this.paths);
         }
 
         @Override
         public Collection<File> files(final String pattern) {
             final Collection<File> files = new ArrayList<>(0);
             final IOFileFilter filter = WildcardFileFilter.builder().setWildcards(pattern).get();
             if (this.basedir().exists()) {
                 for (final File found : FileUtils.listFiles(
                     this.basedir(),
                     filter,
                     DirectoryFileFilter.INSTANCE
                 )) {
                     if (!new Binary(found).yes()) {
                         files.add(found);
                     }
                 }
             }
             return files;
         }
 
         @Override
         public boolean exclude(final String check, final String name) {
             return false;
         }
 
         @Override
         public Collection<String> excludes(final String checker) {
             final Collection<String> exc;
             if (this.excl == null) {
                 exc = Collections.emptyList();
             } else {
                 exc = Arrays.asList(this.excl.split(","));
             }
             return exc;
         }
 
         @Override
         public Charset encoding() {
             return StandardCharsets.UTF_8;
         }
 
         private static File temporary() {
             try {
                 final File temp = Files.createTempDirectory("mock-qulice").toFile();
                 FileUtils.forceDeleteOnExit(temp);
                 final File base = new File(temp, "basedir");
                 if (!base.mkdirs()) {
                     throw new IllegalStateException(
                         String.format("cannot create basedir at %s", base)
                     );
                 }
                 return base;
             } catch (final IOException ex) {
                 throw new IllegalStateException("cannot create basedir", ex);
             }
         }
 
         private static Set<String> outputs(final File base) {
             final File out = new File(base, "target/classes");
             if (!out.mkdirs() && !out.isDirectory()) {
                 throw new IllegalStateException(
                     String.format("cannot create classes dir at %s", out)
                 );
             }
             return new HashSet<>(
                 Collections.singleton(
                     out.getAbsolutePath().replace(File.separatorChar, '/')
                 )
             );
         }
     }
 }