/*
 * Copyright 2017 The Bazel Authors. All rights reserved.
 *
 * 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 com.google.idea.blaze.base.sync.sharding;

import com.google.common.collect.ImmutableList;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.model.primitives.WorkspacePath;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
import javax.annotation.Nullable;

/** A blaze wildcard target pattern. */
public class WildcardTargetPattern {

  private static final String ALL_PACKAGES_RECURSIVE_SUFFIX = "/...";
  private static final ImmutableList<String> ALL_TARGETS_IN_SUFFIXES =
      ImmutableList.of("*", "all-targets");
  private static final String ALL_RULES_IN_SUFFIX = "all";

  /** Returns null if the target is not a valid wildcard target pattern. */
  @Nullable
  public static WildcardTargetPattern fromExpression(TargetExpression target) {
    String pattern = target.toString();
    int colonIndex = pattern.lastIndexOf(':');
    String packagePart = colonIndex < 0 ? pattern : pattern.substring(0, colonIndex);
    String targetPart = colonIndex < 0 ? "" : pattern.substring(colonIndex + 1);

    if (packagePart.startsWith("-")) {
      packagePart = packagePart.substring(1);
    }
    packagePart = StringUtil.trimStart(packagePart, "//");

    if (packagePart.endsWith(ALL_PACKAGES_RECURSIVE_SUFFIX)) {
      WorkspacePath basePackageDir =
          WorkspacePath.createIfValid(
              StringUtil.trimEnd(packagePart, ALL_PACKAGES_RECURSIVE_SUFFIX));
      if (basePackageDir == null) {
        return null;
      }
      if (targetPart.isEmpty() || targetPart.equals(ALL_RULES_IN_SUFFIX)) {
        return new WildcardTargetPattern(target, basePackageDir, true, true);
      }
      if (ALL_TARGETS_IN_SUFFIXES.contains(targetPart)) {
        return new WildcardTargetPattern(target, basePackageDir, true, false);
      }
      return null; // ignore invalid patterns -- blaze will give us a better error later.
    }

    WorkspacePath packageDir = WorkspacePath.createIfValid(packagePart);
    if (packageDir == null) {
      return null;
    }
    if (targetPart.equals(ALL_RULES_IN_SUFFIX)) {
      return new WildcardTargetPattern(target, packageDir, false, true);
    }
    if (ALL_TARGETS_IN_SUFFIXES.contains(targetPart)) {
      return new WildcardTargetPattern(target, packageDir, false, false);
    }
    // not a wildcard target pattern
    return null;
  }

  public final TargetExpression originalPattern;
  private final WorkspacePath packageDir;
  private final boolean recursive;
  private final boolean rulesOnly;

  private WildcardTargetPattern(
      TargetExpression originalPattern,
      WorkspacePath packageDir,
      boolean recursive,
      boolean rulesOnly) {
    this.originalPattern = originalPattern;
    this.packageDir = packageDir;
    this.recursive = recursive;
    this.rulesOnly = rulesOnly;
  }

  /** The base blaze package this target pattern refers to */
  public WorkspacePath getBasePackage() {
    return packageDir;
  }

  /** Whether the target pattern includes all packages below the base package. */
  public boolean isRecursive() {
    return recursive;
  }

  /** Whether the target pattern includes all targets, or only rules */
  public boolean rulesOnly() {
    return rulesOnly;
  }

  public boolean coversPackage(WorkspacePath packagePath) {
    if (!recursive) {
      return packagePath.equals(packageDir);
    }
    return FileUtil.isAncestor(packageDir.relativePath(), packagePath.relativePath(), false);
  }

  /** Is this an excluded target pattern (i.e. starts with '-')? */
  public boolean isExcluded() {
    return originalPattern.isExcluded();
  }

  @Override
  public String toString() {
    return originalPattern.toString();
  }

  @Override
  public boolean equals(Object obj) {
    return obj instanceof WildcardTargetPattern
        && originalPattern.equals(((WildcardTargetPattern) obj).originalPattern);
  }

  @Override
  public int hashCode() {
    return originalPattern.hashCode();
  }
}