#!/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()