#!/usr/bin/env python
# Copyright (c) 2011 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""
lastchange.py -- Chromium revision fetching utility.
"""

import re
import optparse
import os
import subprocess
import sys

class VersionInfo(object):
  def __init__(self, url, root, revision):
    self.url = url
    self.root = root
    self.revision = revision


def FetchSVNRevision(directory):
  """
  Fetch the Subversion branch and revision for a given directory.

  Errors are swallowed.

  Returns:
    a VersionInfo object or None on error.
  """
  try:
    proc = subprocess.Popen(['svn', 'info'],
                            stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE,
                            cwd=directory,
                            shell=(sys.platform=='win32'))
  except OSError:
    # command is apparently either not installed or not executable.
    return None
  if not proc:
    return None

  attrs = {}
  for line in proc.stdout:
    line = line.strip()
    if not line:
      continue
    key, val = line.split(': ', 1)
    attrs[key] = val

  try:
    url = attrs['URL']
    root = attrs['Repository Root']
    revision = attrs['Revision']
  except KeyError:
    return None

  return VersionInfo(url, root, revision)


def RunGitCommand(directory, command):
  """
  Launches git subcommand.

  Errors are swallowed.

  Returns:
    process object or None.
  """
  command = ['git'] + command
  # Force shell usage under cygwin & win32. This is a workaround for
  # mysterious loss of cwd while invoking cygwin's git.
  # We can't just pass shell=True to Popen, as under win32 this will
  # cause CMD to be used, while we explicitly want a cygwin shell.
  if sys.platform in ('cygwin', 'win32'):
    command = ['sh', '-c', ' '.join(command)]
  try:
    proc = subprocess.Popen(command,
                            stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE,
                            cwd=directory)
    return proc
  except OSError:
    return None


def FetchGitRevision(directory):
  """
  Fetch the Git hash for a given directory.

  Errors are swallowed.

  Returns:
    a VersionInfo object or None on error.
  """
  proc = RunGitCommand(directory, ['rev-parse', 'HEAD'])
  if proc:
    output = proc.communicate()[0].strip()
    if proc.returncode == 0 and output:
      return VersionInfo('git', 'git', output[:7])
  return None


def IsGitSVN(directory):
  """
  Checks whether git-svn has been set up.

  Errors are swallowed.

  Returns:
    whether git-svn has been set up.
  """
  # To test whether git-svn has been set up, query the config for any
  # svn-related configuration.  This command exits with an error code
  # if there aren't any matches, so ignore its output.
  proc = RunGitCommand(directory, ['config', '--get-regexp', '^svn'])
  if proc:
    return (proc.wait() == 0)
  return False


def FetchGitSVNURL(directory):
  """
  Fetch URL of SVN repository bound to git.

  Errors are swallowed.

  Returns:
    SVN URL.
  """
  if IsGitSVN(directory):
    proc = RunGitCommand(directory, ['svn', 'info', '--url'])
    if proc:
      output = proc.communicate()[0].strip()
      if proc.returncode == 0:
        match = re.search(r'^\w+://.*$', output, re.M)
        if match:
          return match.group(0)
  return ''


def FetchGitSVNRoot(directory):
  """
  Fetch root of SVN repository bound to git.

  Errors are swallowed.

  Returns:
    SVN root repository.
  """
  if IsGitSVN(directory):
    git_command = ['config', '--get-regexp', '^svn-remote.svn.url$']
    proc = RunGitCommand(directory, git_command)
    if proc:
      output = proc.communicate()[0].strip()
      if proc.returncode == 0:
        # Zero return code implies presence of requested configuration variable.
        # Its value is second (last) field of output.
        match = re.search(r'\S+$', output)
        if match:
          return match.group(0)
  return ''


def LookupGitSVNRevision(directory, depth):
  """
  Fetch the Git-SVN identifier for the local tree.
  Parses first |depth| commit messages.

  Errors are swallowed.
  """
  if not IsGitSVN(directory):
    return None
  git_re = re.compile(r'^\s*git-svn-id:\s+(\S+)@(\d+)')
  proc = RunGitCommand(directory, ['log', '-' + str(depth)])
  if proc:
    for line in proc.stdout:
      match = git_re.match(line)
      if match:
        id = match.group(2)
        if id:
          proc.stdout.close()  # Cut pipe for fast exit.
          return id
  return None


def IsGitSVNDirty(directory):
  """
  Checks whether our git-svn tree contains clean trunk or some branch.

  Errors are swallowed.
  """
  # For git branches the last commit message is either
  # some local commit or a merge.
  return LookupGitSVNRevision(directory, 1) is None


def FetchGitSVNRevision(directory):
  """
  Fetch the Git-SVN identifier for the local tree.

  Errors are swallowed.
  """
  # We assume that at least first 999 commit messages contain svn evidence.
  revision = LookupGitSVNRevision(directory, 999)
  if not revision:
    return None
  if IsGitSVNDirty(directory):
    revision = revision + '-dirty'
  url = FetchGitSVNURL(directory)
  root = FetchGitSVNRoot(directory)
  return VersionInfo(url, root, revision)


def FetchVersionInfo(default_lastchange, directory=None):
  """
  Returns the last change (in the form of a branch, revision tuple),
  from some appropriate revision control system.
  """
  version_info = (FetchSVNRevision(directory) or
      FetchGitSVNRevision(directory) or FetchGitRevision(directory))
  if not version_info:
    if default_lastchange and os.path.exists(default_lastchange):
      revision = open(default_lastchange, 'r').read().strip()
      version_info = VersionInfo(None, None, revision)
    else:
      version_info = VersionInfo('unknown', '', '0')
  return version_info


def WriteIfChanged(file_name, contents):
  """
  Writes the specified contents to the specified file_name
  iff the contents are different than the current contents.
  """
  try:
    old_contents = open(file_name, 'r').read()
  except EnvironmentError:
    pass
  else:
    if contents == old_contents:
      return
    os.unlink(file_name)
  open(file_name, 'w').write(contents)


def main(argv=None):
  if argv is None:
    argv = sys.argv

  parser = optparse.OptionParser(usage="lastchange.py [options]")
  parser.add_option("-d", "--default-lastchange", metavar="FILE",
                    help="default last change input FILE")
  parser.add_option("-o", "--output", metavar="FILE",
                    help="write last change to FILE")
  parser.add_option("--revision-only", action='store_true',
                    help="just print the SVN revision number")
  opts, args = parser.parse_args(argv[1:])

  out_file = opts.output

  while len(args) and out_file is None:
    if out_file is None:
      out_file = args.pop(0)
  if args:
    sys.stderr.write('Unexpected arguments: %r\n\n' % args)
    parser.print_help()
    sys.exit(2)

  version_info = FetchVersionInfo(opts.default_lastchange)

  if opts.revision_only:
    print version_info.revision
  else:
    contents = "LASTCHANGE=%s\n" % version_info.revision
    if out_file:
      WriteIfChanged(out_file, contents)
    else:
      sys.stdout.write(contents)

  return 0


if __name__ == '__main__':
  sys.exit(main())