/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  package org.apache.maven.project;
  
  import java.nio.file.Path;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.apache.maven.api.Language;
  import org.apache.maven.api.ProjectScope;
  import org.apache.maven.api.SourceRoot;
  import org.apache.maven.api.model.Resource;
  import org.apache.maven.api.model.Source;
  import org.apache.maven.api.services.BuilderProblem.Severity;
  import org.apache.maven.api.services.ModelBuilderResult;
  import org.apache.maven.api.services.ModelProblem.Version;
  import org.apache.maven.impl.DefaultSourceRoot;
  import org.apache.maven.impl.model.DefaultModelProblem;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Handles source configuration for Maven projects with unified tracking for all language/scope combinations.
   * This class uses a flexible set-based tracking mechanism that works for any language and scope combination.
   * <p>
   * Key features:
   * <ul>
   *   <li>Tracks declared sources using {@code (language, scope, module, directory)} identity</li>
   *   <li>Only tracks enabled sources - disabled sources are effectively no-ops</li>
   *   <li>Detects duplicate enabled sources and emits warnings</li>
   *   <li>Provides {@link #hasSources(Language, ProjectScope)} to check if sources exist for a combination</li>
   * </ul>
   *
   * @since 4.0.0
   */
  final class SourceHandlingContext {
  
      private static final Logger LOGGER = LoggerFactory.getLogger(SourceHandlingContext.class);
  
      /**
       * Identity key for source tracking. Two sources with the same key are considered duplicates.
       */
      record SourceKey(Language language, ProjectScope scope, String module, Path directory) {}
  
      /**
       * The {@code <source>} elements declared in the {@code <build>} elements.
       */
      final List<Source> sources;
  
      private final MavenProject project;
      private final Set<String> modules;
      private final ModelBuilderResult result;
      private final Set<SourceKey> declaredSources;
  
      SourceHandlingContext(MavenProject project, ModelBuilderResult result) {
          this.project = project;
          this.sources = project.getBuild().getDelegate().getSources();
          this.modules = SourceQueries.getModuleNames(sources);
          this.result = result;
          // Each module typically has main, test, main resources, test resources = 4 sources
          this.declaredSources = new HashSet<>(4 * modules.size());
          if (usesModuleSourceHierarchy()) {
              LOGGER.trace("Found {} module(s) in the \"{}\" project: {}.", project.getId(), modules.size(), modules);
          } else {
              LOGGER.trace("Project \"{}\" is non-modular.", project.getId());
          }
      }
  
      /**
       * Whether the project uses module source hierarchy.
       * Note that this is not synonymous of whether the project is modular,
       * because it is possible to create a single Java module in a classic Maven project
       * (i.e., using package hierarchy).
       */
      boolean usesModuleSourceHierarchy() {
          return !modules.isEmpty();
      }
  
      /**
       * Determines if a source root should be added to the project and tracks it for duplicate detection.
       * <p>
       * Rules:
      * <ul>
      *   <li>Disabled sources are always added (they're filtered by {@code getEnabledSourceRoots()})</li>
      *   <li>First enabled source for an identity is added and tracked</li>
      *   <li>Subsequent enabled sources with same identity trigger a WARNING and are NOT added</li>
      * </ul>
      *
      * @param sourceRoot the source root to evaluate
      * @return true if the source should be added to the project, false if it's a duplicate enabled source
      */
     boolean shouldAddSource(SourceRoot sourceRoot) {
         if (!sourceRoot.enabled()) {
             // Disabled sources are always added - they're filtered out by getEnabledSourceRoots()
             LOGGER.trace(
                     "Adding disabled source (will be filtered by getEnabledSourceRoots): lang={}, scope={}, module={}, dir={}",
                     sourceRoot.language(),
                     sourceRoot.scope(),
                     sourceRoot.module().orElse(null),
                     sourceRoot.directory());
             return true;
         }
 
         // Normalize path for consistent duplicate detection (handles symlinks, relative paths)
         Path normalizedDir = sourceRoot.directory().toAbsolutePath().normalize();
         SourceKey key = new SourceKey(
                 sourceRoot.language(), sourceRoot.scope(), sourceRoot.module().orElse(null), normalizedDir);
 
         if (!declaredSources.add(key)) {
             String message = String.format(
                     "Duplicate enabled source detected: lang=%s, scope=%s, module=%s, directory=%s. "
                             + "First enabled source wins, this duplicate is ignored.",
                     key.language(), key.scope(), key.module() != null ? key.module() : "(none)", key.directory());
             LOGGER.warn(message);
             result.getProblemCollector()
                     .reportProblem(new DefaultModelProblem(
                             message,
                             Severity.WARNING,
                             Version.V41,
                             project.getModel().getDelegate(),
                             -1,
                             -1,
                             null));
             return false; // Don't add duplicate enabled source
         }
 
         LOGGER.debug(
                 "Adding and tracking enabled source: lang={}, scope={}, module={}, dir={}",
                 key.language(),
                 key.scope(),
                 key.module(),
                 key.directory());
         return true; // Add first enabled source with this identity
     }
 
     /**
      * Checks if any enabled sources have been declared for the given language and scope combination.
      *
      * @param language the language to check (e.g., {@link Language#JAVA_FAMILY}, {@link Language#RESOURCES})
      * @param scope the scope to check (e.g., {@link ProjectScope#MAIN}, {@link ProjectScope#TEST})
      * @return true if at least one enabled source exists for this combination
      */
     boolean hasSources(Language language, ProjectScope scope) {
         return declaredSources.stream().anyMatch(key -> language.equals(key.language()) && scope.equals(key.scope()));
     }
 
     /**
      * {@return the source directory as defined by Maven conventions}
      */
     private Path getStandardSourceDirectory() {
         return project.getBaseDirectory().resolve("src");
     }
 
     /**
      * Fails the build if modular and classic (non-modular) sources are mixed within {@code <sources>}.
      * <p>
      * A project must be either fully modular (all sources have a module) or fully classic
      * (no sources have a module). Mixing modular and non-modular sources within the same
      * project is not supported because the compiler plugin cannot handle such configurations.
      * <p>
      * This validation checks each (language, scope) combination and reports an ERROR if
      * both modular and non-modular sources are found.
      */
     void failIfMixedModularAndClassicSources() {
         for (ProjectScope scope : List.of(ProjectScope.MAIN, ProjectScope.TEST)) {
             for (Language language : List.of(Language.JAVA_FAMILY, Language.RESOURCES)) {
                 boolean hasModular = false;
                 boolean hasClassic = false;
                 for (SourceKey key : declaredSources) {
                     if (language.equals(key.language()) && scope.equals(key.scope())) {
                         String module = key.module();
                         hasModular |= (module != null);
                         hasClassic |= (module == null);
                         if (hasModular && hasClassic) {
                             String message = String.format(
                                     "Mixed modular and classic sources detected for lang=%s, scope=%s. "
                                             + "A project must be either fully modular (all sources have a module) "
                                             + "or fully classic (no sources have a module).",
                                     language.id(), scope.id());
                             LOGGER.error(message);
                             result.getProblemCollector()
                                     .reportProblem(new DefaultModelProblem(
                                             message,
                                             Severity.ERROR,
                                             Version.V41,
                                             project.getModel().getDelegate(),
                                             -1,
                                             -1,
                                             null));
                             break;
                         }
                     }
                 }
             }
         }
     }
 
     /**
      * Handles resource configuration for a given scope (main or test).
      * This method applies the resource priority rules:
      * <ol>
      *   <li>Modular project: use resources from {@code <sources>} if present, otherwise inject defaults</li>
      *   <li>Classic project: use resources from {@code <sources>} if present, otherwise use legacy resources</li>
      * </ol>
      * <p>
      * The error behavior for conflicting legacy configuration is consistent with source directory handling.
      *
      * @param scope the project scope (MAIN or TEST)
      */
     void handleResourceConfiguration(ProjectScope scope) {
         boolean hasResourcesInSources = hasSources(Language.RESOURCES, scope);
 
         List<Resource> resources = scope == ProjectScope.MAIN
                 ? project.getBuild().getDelegate().getResources()
                 : project.getBuild().getDelegate().getTestResources();
 
         String scopeId = scope.id();
         String scopeName = scope == ProjectScope.MAIN ? "Main" : "Test";
         String legacyElement = scope == ProjectScope.MAIN ? "<resources>" : "<testResources>";
         String sourcesConfig = scope == ProjectScope.MAIN
                 ? "<source><lang>resources</lang></source>"
                 : "<source><lang>resources</lang><scope>test</scope></source>";
 
         if (usesModuleSourceHierarchy()) {
             if (hasResourcesInSources) {
                 // Modular project with resources configured via <sources> - already added above
                 if (hasExplicitLegacyResources(resources, scopeId)) {
                     String message = String.format(
                             "Legacy %s element cannot be used because %s resources are configured via %s in <sources>.",
                             legacyElement, scopeId, sourcesConfig);
                     LOGGER.error(message);
                     result.getProblemCollector()
                             .reportProblem(new DefaultModelProblem(
                                     message,
                                     Severity.ERROR,
                                     Version.V41,
                                     project.getModel().getDelegate(),
                                     -1,
                                     -1,
                                     null));
                 } else {
                     LOGGER.debug(
                             "{} resources configured via <sources> element, ignoring legacy {} element.",
                             scopeName,
                             legacyElement);
                 }
             } else {
                 // Modular project without resources in <sources> - inject module-aware defaults
                 if (hasExplicitLegacyResources(resources, scopeId)) {
                     String message = "Legacy " + legacyElement
                             + " element cannot be used because modular sources are configured. "
                             + "Use " + sourcesConfig + " in <sources> for custom resource paths.";
                     LOGGER.error(message);
                     result.getProblemCollector()
                             .reportProblem(new DefaultModelProblem(
                                     message,
                                     Severity.ERROR,
                                     Version.V41,
                                     project.getModel().getDelegate(),
                                     -1,
                                     -1,
                                     null));
                 }
                 for (String module : modules) {
                     project.addSourceRoot(createModularResourceRoot(module, scope));
                 }
                 if (!modules.isEmpty()) {
                     LOGGER.debug(
                             "Injected {} module-aware {} resource root(s) for modules: {}.",
                             modules.size(),
                             scopeId,
                             modules);
                 }
             }
         } else {
             // Classic (non-modular) project
             if (hasResourcesInSources) {
                 // Resources configured via <sources> - already added above
                 if (hasExplicitLegacyResources(resources, scopeId)) {
                     String message = String.format(
                             "Legacy %s element cannot be used because %s resources are configured via %s in <sources>.",
                             legacyElement, scopeId, sourcesConfig);
                     LOGGER.error(message);
                     result.getProblemCollector()
                             .reportProblem(new DefaultModelProblem(
                                     message,
                                     Severity.ERROR,
                                     Version.V41,
                                     project.getModel().getDelegate(),
                                     -1,
                                     -1,
                                     null));
                 } else {
                     LOGGER.debug(
                             "{} resources configured via <sources> element, ignoring legacy {} element.",
                             scopeName,
                             legacyElement);
                 }
             } else {
                 // Use legacy resources element
                 LOGGER.debug(
                         "Using explicit or default {} resources ({} resources configured).", scopeId, resources.size());
                 Path baseDir = project.getBaseDirectory();
                 for (Resource resource : resources) {
                     project.addSourceRoot(new DefaultSourceRoot(baseDir, scope, resource));
                 }
             }
         }
     }
 
     /**
      * Creates a DefaultSourceRoot for module-aware resource directories.
      * Generates paths following the pattern: {@code src/<module>/<scope>/resources}
      *
      * @param module module name
      * @param scope project scope (main or test)
      * @return configured DefaultSourceRoot for the module's resources
      */
     private DefaultSourceRoot createModularResourceRoot(String module, ProjectScope scope) {
         Path resourceDir =
                 getStandardSourceDirectory().resolve(module).resolve(scope.id()).resolve("resources");
 
         return new DefaultSourceRoot(
                 scope,
                 Language.RESOURCES,
                 module,
                 null, // targetVersion
                 resourceDir,
                 null, // includes
                 null, // excludes
                 false, // stringFiltering
                 Path.of(module), // targetPath - resources go to target/classes/<module>
                 true // enabled
                 );
     }
 
     /**
      * Checks if the given resource list contains explicit legacy resources that differ
      * from Super POM defaults. Super POM defaults are: src/{scope}/resources and src/{scope}/resources-filtered
      *
      * @param resources list of resources to check
      * @param scope scope (main or test)
      * @return true if explicit legacy resources are present that conflict with modular sources
      */
     private boolean hasExplicitLegacyResources(List<Resource> resources, String scope) {
         if (resources.isEmpty()) {
             return false; // No resources means no explicit legacy resources to warn about
         }
 
         // Super POM default paths
         Path srcDir = getStandardSourceDirectory();
         String defaultPath = srcDir.resolve(scope).resolve("resources").toString();
         String defaultFilteredPath =
                 srcDir.resolve(scope).resolve("resources-filtered").toString();
 
         // Check if any resource differs from Super POM defaults
         for (Resource resource : resources) {
             String resourceDir = resource.getDirectory();
             if (resourceDir != null && !resourceDir.equals(defaultPath) && !resourceDir.equals(defaultFilteredPath)) {
                 // Found an explicit legacy resource
                 return true;
             }
         }
 
         return false;
     }
 }