/*
    * Licensed 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.basepom.mojo.propertyhelper;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  import static com.google.common.base.Preconditions.checkState;
  
  import org.basepom.mojo.propertyhelper.beans.DateDefinition;
  import org.basepom.mojo.propertyhelper.beans.IgnoreWarnFail;
  import org.basepom.mojo.propertyhelper.beans.MacroDefinition;
  import org.basepom.mojo.propertyhelper.beans.NumberDefinition;
  import org.basepom.mojo.propertyhelper.beans.PropertyGroup;
  import org.basepom.mojo.propertyhelper.beans.StringDefinition;
  import org.basepom.mojo.propertyhelper.beans.UuidDefinition;
  import org.basepom.mojo.propertyhelper.macros.MacroType;
  import org.basepom.mojo.propertyhelper.util.Log;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.AbstractMap.SimpleImmutableEntry;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Optional;
  import java.util.Set;
  import javax.annotation.CheckForNull;
  import javax.inject.Inject;
  
  import com.google.common.collect.ImmutableList;
  import com.google.common.collect.ImmutableList.Builder;
  import com.google.common.collect.ImmutableMap;
  import com.google.common.collect.Maps;
  import com.google.common.collect.Sets;
  import org.apache.maven.plugin.AbstractMojo;
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.plugins.annotations.Parameter;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.settings.Settings;
  
  /**
   * Base code for all the mojos.
   */
  public abstract class AbstractPropertyHelperMojo
          extends AbstractMojo {
  
      protected static final Log LOG = Log.findLog();
      protected final ValueCache valueCache = new ValueCache();
      private final Map<String, String> values = Maps.newHashMap();
  
      /**
       * Defines the action to take if a property is present multiple times.
       */
      @Parameter(defaultValue = "fail")
      public String onDuplicateProperty = "fail";
  
      /**
       * Defines the action to take if a referenced property is missing.
       */
      @Parameter(defaultValue = "fail")
      public String onMissingProperty = "fail";
  
      /**
       * List of the property group ids to activate for a plugin execution.
       */
      @Parameter
      public String[] activeGroups = new String[0];
  
      /**
       * List of available property groups. A property group contains one or more property definitions and must be activated with activeGroups.
       */
      @Parameter
      public PropertyGroup[] propertyGroups = new PropertyGroup[0];
  
      /**
       * Number property definitions.
       */
      @Parameter
      public NumberDefinition[] numbers = new NumberDefinition[0];
  
      /**
       * String property definitions.
       */
      @Parameter
      public StringDefinition[] strings = new StringDefinition[0];
  
      /**
       * Date property definitions.
      */
     @Parameter
     public DateDefinition[] dates = new DateDefinition[0];
 
     /**
      * Macro definitions.
      */
     @Parameter
     public MacroDefinition[] macros = new MacroDefinition[0];
 
     /**
      * Uuid definitions.
      */
     @Parameter
     public UuidDefinition[] uuids = new UuidDefinition[0];
 
     /**
      * The maven project (effective pom).
      */
     @Parameter(defaultValue = "${project}", readonly = true)
     public MavenProject project;
     @Parameter(defaultValue = "${settings}", readonly = true)
     public Settings settings;
 
     @Parameter(required = true, readonly = true, defaultValue = "${project.basedir}")
     public File basedir;
     /**
      * If set to true, goal execution is skipped.
      */
     @Parameter(defaultValue = "false")
     boolean skip;
     public List<NumberField> numberFields = null;
 
     @Inject
     public Map<String, MacroType> macroMap = null;
 
     private boolean isSnapshot;
 
     @Override
     public void execute()
             throws MojoExecutionException {
         isSnapshot = project.getArtifact().isSnapshot();
         LOG.debug("Project is a %s.", isSnapshot ? "snapshot" : "release");
         LOG.trace("%s on duplicate, %s on missing", onDuplicateProperty, onMissingProperty);
 
         try {
             if (skip) {
                 LOG.debug("Skipping execution!");
             } else {
                 doExecute();
             }
         } catch (IOException e) {
             throw new MojoExecutionException("While running mojo: ", e);
         } finally {
             LOG.debug("Ended %s mojo run!", this.getClass().getSimpleName());
         }
     }
 
     public MavenProject getProject() {
         checkNotNull(project, "project is null");
         return project;
     }
 
     public Settings getSettings() {
         checkNotNull(settings, "settings is null");
         return settings;
     }
 
     public File getBasedir() {
         checkNotNull(basedir, "basedir is null");
         return basedir;
     }
 
     public Map<String, MacroType> getMacros() {
         checkNotNull(macroMap, "macroMap is null");
         return macroMap;
     }
 
     @CheckForNull
     public List<NumberField> getNumbers() {
         return numberFields;
     }
 
     /**
      * Subclasses need to implement this method.
      */
     protected abstract void doExecute() throws IOException, MojoExecutionException;
 
     protected void loadPropertyElements() throws MojoExecutionException, IOException {
         final Builder<PropertyElement> propertyElements = ImmutableList.builder();
 
         numberFields = NumberField.createNumbers(valueCache, numbers);
         propertyElements.addAll(numberFields);
         propertyElements.addAll(StringField.createStrings(valueCache, strings));
         propertyElements.addAll(DateField.createDates(valueCache, dates));
         propertyElements.addAll(MacroField.createMacros(valueCache, macros, this));
         propertyElements.addAll(UuidField.createUuids(valueCache, uuids));
 
         for (final PropertyElement pe : propertyElements.build()) {
             final Optional<String> value = pe.getPropertyValue();
             values.put(pe.getPropertyName(), value.orElse(null));
 
             if (pe.isExport()) {
                 final String result = value.orElse("");
                 project.getProperties().setProperty(pe.getPropertyName(), result);
                 LOG.debug("Exporting Property name: %s, value: %s", pe.getPropertyName(), result);
             } else {
                 LOG.debug("Property name: %s, value: %s", pe.getPropertyName(),
                         value.orElse("<null>"));
             }
         }
 
         // Now generate the property groups.
         final ImmutableMap.Builder<String, Entry<PropertyGroup, List<PropertyElement>>> builder = ImmutableMap.builder();
 
         final Set<String> propertyNames = Sets.newHashSet();
 
         if (propertyGroups != null) {
             for (final PropertyGroup propertyGroup : propertyGroups) {
                 final List<PropertyElement> propertyFields = PropertyField.createProperties(project.getModel(), values, propertyGroup);
                 builder.put(propertyGroup.getId(), new SimpleImmutableEntry<>(propertyGroup, propertyFields));
             }
         }
 
         final Map<String, Entry<PropertyGroup, List<PropertyElement>>> propertyPairs = builder.build();
 
         if (activeGroups != null) {
             for (final String activeGroup : activeGroups) {
                 final Entry<PropertyGroup, List<PropertyElement>> propertyElement = propertyPairs.get(activeGroup);
                 checkState(propertyElement != null, "activated group '%s' does not exist", activeGroup);
 
                 final PropertyGroup propertyGroup = propertyElement.getKey();
                 if ((propertyGroup.isActiveOnRelease() && !isSnapshot) || (propertyGroup.isActiveOnSnapshot() && isSnapshot)) {
                     for (final PropertyElement pe : propertyElement.getValue()) {
                         final Optional<String> value = pe.getPropertyValue();
                         final String propertyName = pe.getPropertyName();
                         IgnoreWarnFail.checkState(propertyGroup.getOnDuplicateProperty(), !propertyNames.contains(propertyName),
                                 "property name '" + propertyName + "'");
                         propertyNames.add(propertyName);
 
                         project.getProperties().setProperty(propertyName, value.orElse(""));
                     }
                 } else {
                     LOG.debug("Skipping property group %s: Snapshot: %b, activeOnSnapshot: %b, activeOnRelease: %b", activeGroup, isSnapshot,
                             propertyGroup.isActiveOnSnapshot(), propertyGroup.isActiveOnRelease());
                 }
             }
         }
     }
 }