#!/usr/bin/python

# Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.

import optparse
import os
import platform
import subprocess
import sys

"""A script used to revert one or a sequence of consecutive CLs, for svn and
git-svn users.
"""

def parse_args():
  parser = optparse.OptionParser()
  parser.add_option('--revisions', '-r', dest='rev_range', action='store',
                    default=None, help='The revision number(s) of the commits '
                    'you wish to undo. An individual number, or a range (8-10, '
                    '8..10, or 8:10).')
  args, _ = parser.parse_args()
  revision_range = args.rev_range
  if revision_range is None:
    maybe_fail('You must specify at least one revision number to revert.')
  if revision_range.find('-') > -1 or revision_range.find(':') > -1 or \
      revision_range.find('..') > -1:
    # We have a range of commits to revert.
    split = revision_range.split('-')
    if len(split) == 1:
      split = revision_range.split(':')
    if len(split) == 1:
      split = revision_range.split('..')
    start = int(split[0])
    end = int(split[1])
    if start > end:
      temp = start
      start = end
      end = temp
    if start != end:
      maybe_fail('Warning: Are you sure you want to revert a range of '
                 'revisions? If you just want to revert one CL, only specify '
                 'one revision number.', user_input=True)
  else:
    start = end = int(revision_range)
  return start, end

def maybe_fail(msg, user_input=False):
  """Determine if we have encountered a condition upon which our script cannot
  continue, and abort if so.
  Args:
    - msg: The error or user prompt message to print.
    - user_input: True if we require user confirmation to continue. We assume
                  that the user must enter y to proceed.
  """
  if user_input:
    force = raw_input(msg + ' (y/N) ')
    if force != 'y':
      sys.exit(0)
  else:
    print msg
    sys.exit(1)

def has_new_code(is_git):
  """Tests if there are any newer versions of files on the server.
  Args:
    - is_git: True if we are working in a git repository.
  """
  os.chdir(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
  if not is_git:
    results, _ = run_cmd(['svn', 'st'])
  else:
    results, _ = run_cmd(['git', 'status'])
  for line in results.split('\n'):
    if not is_git and (not line.strip().startswith('?') and line != ''):
      return True
    elif is_git and ('Changes to be committed' in line or 
        'Changes not staged for commit:' in line):
      return True
  if is_git:
    p = subprocess.Popen(['git', 'log', '-1'], stdout=subprocess.PIPE,
                         shell=(platform.system()=='Windows'))
    output, _ = p.communicate()
    if find_git_info(output) is None:
      return True
  return False

def run_cmd(cmd_list, suppress_output=False, std_in=''):
  """Run the specified command and print out any output to stdout."""
  print ' '.join(cmd_list)
  p = subprocess.Popen(cmd_list, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                       stdin=subprocess.PIPE,
                       shell=(platform.system()=='Windows'))
  output, stderr = p.communicate(std_in)
  if output and not suppress_output:
    print output
  if stderr and not suppress_output:
    print stderr
  return output, stderr

def runs_git():
  """Returns True if we're standing in an svn-git repository."""
  p = subprocess.Popen(['svn', 'info'], stdout=subprocess.PIPE,
                       stderr=subprocess.PIPE,
                       shell=(platform.system()=='Windows'))
  output, err = p.communicate()
  if err is not None and 'is not a working copy' in err:
    p = subprocess.Popen(['git', 'status'], stdout=subprocess.PIPE,
                         shell=(platform.system()=='Windows'))
    output, _ = p.communicate()
    if 'fatal: Not a git repository' in output:
      maybe_fail('Error: not running git or svn.')
    else:
      return True
  return False

def find_git_info(git_log, rev_num=None):
  """Determine the latest svn revision number if rev_num = None, or find the 
  git commit_id that corresponds to a particular svn revision number.
  """
  for line in git_log.split('\n'):
    tokens = line.split()
    if len(tokens) == 2 and tokens[0] == 'commit':
      current_commit_id = tokens[1]
    elif len(tokens) > 0 and tokens[0] == 'git-svn-id:':
      revision_number = int(tokens[1].split('@')[1])
      if revision_number == rev_num:
        return current_commit_id
      if rev_num is None:
        return revision_number

def revert(start, end, is_git):
  """Revert the sequence of CLs.
  Args:
    - start: The first CL to revert.
    - end: The last CL to revert.
    - is_git: True if we are in a git-svn checkout.
  """
  if not is_git:
    _, err = run_cmd(['svn', 'merge', '-r', '%d:%d' % (end, start-1), '.'],
                     std_in='p')
    if 'Conflict discovered' in err:
      maybe_fail('Please fix the above conflicts before submitting. Then create'
             ' a CL and submit your changes to complete the revert.')

  else:
    # If we're running git, we have to use the log feature to find the commit
    # id(s) that correspond to the particular revision number(s).
    output, _ = run_cmd(['git', 'log', '-1'], suppress_output=True)
    current_revision = find_git_info(output)
    distance = (current_revision-start) + 1
    output, _ = run_cmd(['git', 'log', '-%d' % distance], suppress_output=True)
    reverts = [start]
    commit_msg = '"Reverting %d"' % start
    if end != start:
      reverts = range(start, end + 1)
      reverts.reverse()
      commit_msg = '%s-%d"' % (commit_msg[:-1], end)
    for the_revert in reverts:
      git_commit_id = find_git_info(output, the_revert)
      if git_commit_id is None:
        maybe_fail('Error: Revision number not found. Is this earlier than your'
                   ' git checkout history?')
      _, err = run_cmd(['git', 'revert', '-n', git_commit_id])
      if 'error: could not revert' in err or 'unmerged' in err:
        command_sequence = ''
        for a_revert in reverts:
          git_commit_id = find_git_info(output, a_revert)
          command_sequence += 'git revert -n %s\n' % git_commit_id
        maybe_fail('There are conflicts while reverting. Please resolve these '
                   'after manually running:\n' + command_sequence + 'and then '
                   'create a CL and submit to complete the revert.')
    run_cmd(['git', 'commit', '-m', commit_msg])

def main():
  revisions = parse_args()
  git_user = runs_git()
  if has_new_code(git_user):
    maybe_fail('WARNING: This checkout has local modifications!! This could '
         'result in a CL that is not just a revert and/or you could lose your'
         ' local changes! Are you **SURE** you want to continue? ',
       user_input=True)
  if git_user:
    run_cmd(['git', 'cl', 'rebase'])
  run_cmd(['gclient', 'sync'])
  revert(revisions[0], revisions[1], git_user)
  print ('Now, create a CL and submit! The buildbots and your teammates thank '
         'you!')

if __name__ == '__main__':
  main()