/*
 * SonarQube Java
 * Copyright (C) 2012-2016 SonarSource SA
 * mailto:contact AT sonarsource DOT com
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
package org.sonar.java.checks.xml.maven.helpers;

import com.google.common.base.Preconditions;
import org.sonar.maven.model.LocatedAttribute;

import javax.annotation.CheckForNull;
import javax.annotation.Nullable;

public class RangedVersionMatcher implements LocatedAttributeMatcher {
  @Nullable
  private final ArtifactVersion lowerBound;
  @Nullable
  private final ArtifactVersion upperBound;

  public RangedVersionMatcher(String lowerBound, String upperBound) {
    this.lowerBound = isWildCard(lowerBound) ? null : getVersion(lowerBound);
    this.upperBound = isWildCard(upperBound) ? null : getVersion(upperBound);
    // check that we are not bypassing both bounds
    Preconditions.checkArgument(!(this.lowerBound == null && this.upperBound == null));
  }

  private static boolean isWildCard(String pattern) {
    return "*".equals(pattern);
  }

  /**
   * Build a {@link ArtifactVersion} from a String, throwing an {@link IllegalArgumentException} if failed to parse value.
   * @param version the raw version as string
   * @param callingCheckKey the check requiring the matcher
   * @return the {@link ArtifactVersion} corresponding to the provided version as string
   */
  private static ArtifactVersion getVersion(String version) {
    try {
      return ArtifactVersion.parseString(version);
    } catch (NumberFormatException e) {
      throw new IllegalArgumentException("Provided version does not match expected pattern:"
        + " <major version>.<minor version>.<incremental version> (recieved: " + version + ")", e);
    }
  }

  @Override
  public boolean test(@Nullable LocatedAttribute attribute) {
    if (attribute == null) {
      return false;
    }
    ArtifactVersion dependencyVersion = getVersionSilently(attribute.getValue());
    if (dependencyVersion == null) {
      // unable to parse version, ignore this dependency
      return false;
    }
    boolean matchesLowerBound = lowerBound == null || dependencyVersion.isAfterOrEqual(lowerBound);
    boolean matchesUpperBound = upperBound == null || upperBound.isAfterOrEqual(dependencyVersion);
    return matchesLowerBound && matchesUpperBound;
  }

  /**
   * Build a {@link ArtifactVersion} from a String, without failing in case of exception while parsing.
   * @param version the raw version as string
   * @return the {@link ArtifactVersion} corresponding to the provided version as string
   */
  @CheckForNull
  private static ArtifactVersion getVersionSilently(String version) {
    try {
      return ArtifactVersion.parseString(version);
    } catch (NumberFormatException e) {
      // do nothing, version will be ignored
    }
    return null;
  }

  /**
   * Expected format: <code>[major version].[minor version].[incremental version]-[qualifier]</code>
   *
   * <br />
   *
   * Handled formats such as:
   * <ul>
   *   <li><code>1</code></li>
   *   <li><code>2.4</code></li>
   *   <li><code>0.5-alpha</code></li>
   *   <li><code>1.0.1-SNAPSHOT</code></li>
   * </ul>
   */
  private static class ArtifactVersion {
    private static final int HANDLED_VERSIONS = 3;
    private final Integer[] versions = new Integer[HANDLED_VERSIONS];

    private static ArtifactVersion parseString(String version) {
      String[] split = version.split("\\.");
      if (version.contains("-")) {
        // ignore qualifier
        split = version.split("-")[0].split("\\.");
      }
      ArtifactVersion result = new ArtifactVersion();
      for (int i = 0; i < Math.min(HANDLED_VERSIONS, split.length); i++) {
        result.versions[i] = Integer.parseInt(split[i]);
      }
      return result;
    }

    public boolean isAfterOrEqual(ArtifactVersion v) {
      return isAfterOrEqual(v, 0);
    }

    public boolean isAfterOrEqual(ArtifactVersion v, int i) {
      if (i >= HANDLED_VERSIONS) {
        return true;
      }
      Integer local = versions[i];
      Integer target = v.versions[i];

      if (target == null) {
        return true;
      } else if (local == null) {
        return false;
      }

      int compare = local.compareTo(target);
      return (compare > 0) || (compare == 0 && isAfterOrEqual(v, i + 1));
    }
  }
}