/*
 * Copyright 2008 Google Inc.
 * 
 * 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.gwt.ant.taskdefs;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Task;

import java.io.File;
import java.io.IOException;
import java.io.LineNumberReader;
import java.io.StringReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * A Svn interface task, because the initial solution of <exec> and
 * <propertyregex> is unhappy in ant 1.6.5, and while that's old, it's not quite
 * "too old" for us to care.
 */
public class SvnInfo extends Task {

  /**
   * Structured svn info.
   */
  static class Info {
    /**
     * The relative path of this svn working copy within the root of the remote
     * repository. That is, if the root is "http://example.com/svn" and the
     * working copy URL is "http://example.com/svn/tags/w00t", this will be set
     * to "tags/w00t".
     */
    public final String branch;

    /**
     * The revision of this working copy. Initially set to the value parsed from
     * "svn info" given a more detailed value via "svnversion".
     */
    public String revision;

    public Info(String branch, String revision) {
      this.branch = branch;
      this.revision = revision;
    }
  }

  /**
   * A regex that matches a URL.
   */
  static final String URL_REGEX = "\\w+://\\S*";

  /**
   * A pattern that matches the URL line in svn info output.  Note that it
   * <i>also</i> matches Repository Root; to support i18n subversion clients,
   * we're positionally dependent that URL will be the first match, and
   * Repository Root the second.
   */
  private static final Pattern BRANCH_PATTERN = Pattern.compile("[^:]*:\\s*("
      + URL_REGEX + ")\\s*");

  /**
   * A pattern that matches the Revision line in svn info output.  <i>Also</i>
   * matches Last Changed Rev; we're positionally dependent (revision is
   * earlier) to support internationalized svn client output.
   */
  private static final Pattern REVISION_PATTERN = Pattern.compile("[^:]*:\\s*(\\d+)\\s*");

  /**
   * A pattern that matches the Repository Root line in svn info output.
   */
  private static final Pattern ROOT_PATTERN = Pattern.compile("[^:]*:\\s*("
      + URL_REGEX + "/svn)\\s*");

  /**
   * Returns true if this git working copy matches the specified svn revision,
   * and also has no local modifications.
   */
  static boolean doesGitWorkingCopyMatchSvnRevision(File dir, String svnRevision) {
    String workingRev = getGitWorkingRev(dir);
    String targetRev = getGitRevForSvnRev(dir, svnRevision);
    if (!workingRev.equals(targetRev)) {
      return false;
    }
    String status = getGitStatus(dir);
    return status.contains("nothing to commit (working directory clean)");
  }

  /**
   * Returns the git commit number matching the specified svn revision.
   */
  static String getGitRevForSvnRev(File dir, String svnRevision) {
    String output = CommandRunner.getCommandOutput(dir, "git", "svn",
        "find-rev", "r" + svnRevision);
    output = output.trim();
    if (output.length() == 0) {
      throw new BuildException("git svn find-rev didn't give any answer");
    }
    return output;
  }

  /**
   * Runs "git status" and returns the result.
   */
  static String getGitStatus(File dir) {
    // git status returns 1 for a status code, so just don't check it.
    String output = CommandRunner.getCommandOutput(false, dir, "git", "status");
    if (output.length() == 0) {
      throw new BuildException("git status didn't give any answer");
    }
    return output;
  }

  /**
   * Runs "git svn info", returning the output as a string.
   */
  static String getGitSvnInfo(File dir) {
    String output = CommandRunner.getCommandOutput(dir, "git", "svn", "info");
    if (output.length() == 0) {
      throw new BuildException("git svn info didn't give any answer");
    }
    return output;
  }

  /**
   * Returns the current git commit number of the working copy.
   */
  static String getGitWorkingRev(File dir) {
    String output = CommandRunner.getCommandOutput(dir, "git", "rev-list",
        "--max-count=1", "HEAD");
    output = output.trim();
    if (output.length() == 0) {
      throw new BuildException("git rev-list didn't give any answer");
    }
    return output;
  }

  /**
   * Runs "svn info", returning the output as a string.
   */
  static String getSvnInfo(File dir) {
    String output = CommandRunner.getCommandOutput(dir, "svn", "info");
    if (output.length() == 0) {
      throw new BuildException("svn info didn't give any answer");
    }
    return output;
  }

  /**
   * Runs "svnversion", returning the output as a string.
   */
  static String getSvnVersion(File dir) {
    String output = CommandRunner.getCommandOutput(dir, "svnversion", ".");
    output = output.trim();
    if (output.length() == 0) {
      throw new BuildException("svnversion didn't give any answer");
    }
    return output;
  }

  /**
   * Determine if this directory is a part of a .git repository.
   * 
   * @param dir working directory to start looking for the repository.
   * @return <code>true</code> if a .git repo is found. Returns
   *         <code>false</false> if a .git repo cannot be found, or if 
   *         this directory is part of a subversion repository.
   */
  static boolean looksLikeGit(File dir) {
    if (looksLikeSvn(dir)) {
      return false;
    }
    File gitDir = findGitDir(dir);

    if (gitDir != null && gitDir.isDirectory()) {
      return new File(gitDir, "svn").isDirectory();
    }
    return false;
  }

  /**
   * Returns <code>true</code> if the specified directory looks like an svn
   * working copy.
   */
  static boolean looksLikeSvn(File dir) {
    return new File(dir, ".svn").isDirectory();
  }

  /**
   * Parses the output of running "svn info".
   */
  static Info parseInfo(String svnInfo) {
    String rootUrl = null;
    String branchUrl = null;
    String revision = null;
    LineNumberReader lnr = new LineNumberReader(new StringReader(svnInfo));
    try {
      for (String line = lnr.readLine(); line != null; line = lnr.readLine()) {
        Matcher m;
        if ((m = ROOT_PATTERN.matcher(line)) != null && m.matches()) {
          rootUrl = m.group(1);
        } else if ((m = BRANCH_PATTERN.matcher(line)) != null && m.matches()) {
          if (branchUrl == null) {
            branchUrl = m.group(1);
          } // else skip the 2nd and later matches
        } else if ((m = REVISION_PATTERN.matcher(line)) != null && m.matches()) {
          if (revision == null) {
            revision = m.group(1);
          } // else skip the 2nd and later matches
        }
      }
    } catch (IOException e) {
      throw new BuildException("Should never happen", e);
    }

    if (rootUrl == null) {
      throw new BuildException("svn info didn't get root URL: " + svnInfo);
    }
    if (branchUrl == null) {
      throw new BuildException("svn info didn't get branch URL: " + svnInfo);
    }
    if (revision == null) {
      throw new BuildException("svn info didn't get revision: " + svnInfo);
    }
    rootUrl = removeTrailingSlash(rootUrl);
    branchUrl = removeTrailingSlash(branchUrl);
    if (!branchUrl.startsWith(rootUrl)) {
      throw new BuildException("branch URL (" + branchUrl + ") and root URL ("
          + rootUrl + ") did not match");
    }

    String branch;
    if (branchUrl.length() == rootUrl.length()) {
      branch = "";
    } else {
      branch = branchUrl.substring(rootUrl.length() + 1);
    }
    return new Info(branch, revision);
  }

  static String removeTrailingSlash(String url) {
    if (url.endsWith("/")) {
      return url.substring(0, url.length() - 1);
    }
    return url;
  }

  /**
   * Find the GIT working directory.
   * 
   * First checks for the presence of the env variable GIT_DIR, then, looks up
   * the tree for a directory named '.git'.
   * 
   * @param dir Current working directory
   * @return An object representing the .git directory. Returns
   *         <code>null</code> if none can be found.
   */
  private static File findGitDir(File dir) {
    String gitDirPath = System.getenv("GIT_DIR");
    if (gitDirPath != null) {
      File gitDir = new File(gitDirPath).getAbsoluteFile();
      if (gitDir.isDirectory()) {
        return gitDir;
      }
    }

    dir = dir.getAbsoluteFile();
    while (dir != null) {
      File gitDir = new File(dir, ".git"); 
      if (gitDir.isDirectory()) {
        return gitDir;
      }
      dir = dir.getParentFile();
    }
    return null;
  }

  private String fileprop;

  private String outprop;

  private String workdir;

  public SvnInfo() {
    super();
  }

  @Override
  public void execute() throws BuildException {
    if (outprop == null) {
      throw new BuildException(
          "<svninfo> task requires an outputproperty attribute");
    }
    if (workdir == null) {
      workdir = getProject().getProperty("basedir");
    }
    File workDirFile = new File(workdir);
    if (!workDirFile.isDirectory()) {
      throw new BuildException(workdir + " is not a directory");
    }

    if (getProject().getProperty(outprop) == null) {
      Info info;
      if (looksLikeSvn(workDirFile)) {
        info = parseInfo(getSvnInfo(workDirFile));
  
        // Use svnversion to get a more exact revision string.
        info.revision = getSvnVersion(workDirFile);
      } else if (looksLikeGit(workDirFile)) {
        info = parseInfo(getGitSvnInfo(workDirFile));
  
        // Add a 'M' tag if this working copy is not pristine.
        if (!doesGitWorkingCopyMatchSvnRevision(workDirFile, info.revision)) {
          info.revision += "M";
        }
      } else {
        info = new Info("unknown", "unknown");
      }
      getProject().setNewProperty(outprop, info.branch + "@" + info.revision);
    } else {
      String propval = getProject().getProperty(outprop);
      if (!propval.matches("[^@]+@[0-9]+")) {
        throw new BuildException(
          "predefined " + outprop +
              "should look like branch-spec@revison-number");
      }
    }
    if (fileprop != null) {
      String outpropval = getProject().getProperty(outprop);
      int atIndex = outpropval.indexOf('@');
      String branch = outpropval.substring(0, atIndex);
      String revision = outpropval.substring(atIndex + 1);
      
      getProject().setNewProperty(fileprop,
          branch.replace('/', '-') + "-" + revision.replace(':', '-'));
    }
  }

  /**
   * Establishes the directory used as the SVN workspace to fetch version
   * information.
   * 
   * @param srcdir workspace directory name
   */
  public void setDirectory(String srcdir) {
    workdir = srcdir;
  }

  /**
   * Establishes the property containing the SVN output string, branch@rev.
   * 
   * @param propname Name of a property
   */
  public void setOutputFileProperty(String propname) {
    fileprop = propname;
  }

  /**
   * Establishes the property containing the SVN output string, branch@rev.
   * 
   * @param propname Name of a property
   */
  public void setOutputProperty(String propname) {
    outprop = propname;
  }
}