#!/usr/bin/env python3
# coding: utf-8

# Copyright 2015 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from __future__ import print_function

import argparse
import os
import re
import shlex
import subprocess
import sys
import tempfile
import textwrap

if sys.version_info[0] < 3:
  input = raw_input


IS_WINDOWS = sys.platform.startswith('win')


def SubprocessCheckCall0Or1(args):
    """Like subprocss.check_call(), but allows a return code of 1.

    Returns True if the subprocess exits with code 0, False if it exits with
    code 1, and re-raises the subprocess.check_call() exception otherwise.
    """
    try:
        subprocess.check_call(args, shell=IS_WINDOWS)
    except subprocess.CalledProcessError as e:
        if e.returncode != 1:
            raise
        return False

    return True


def GitMergeBaseIsAncestor(ancestor, descendant):
    """Determines whether |ancestor| is an ancestor of |descendant|.
    """
    return SubprocessCheckCall0Or1(
        ['git', 'merge-base', '--is-ancestor', ancestor, descendant])


def main(args):
    parser = argparse.ArgumentParser(
        description='Update the in-tree copy of an imported project')
    parser.add_argument(
        '--repository',
        default='https://chromium.googlesource.com/crashpad/crashpad',
        help='The imported project\'s remote fetch URL',
        metavar='URL')
    parser.add_argument(
        '--subtree',
        default='third_party/crashpad/crashpad',
        help='The imported project\'s location in this project\'s tree',
        metavar='PATH')
    parser.add_argument(
        '--update-to',
        default='FETCH_HEAD',
        help='What to update the imported project to',
        metavar='COMMITISH')
    parser.add_argument(
        '--fetch-ref',
        default='HEAD',
        help='The remote ref to fetch',
        metavar='REF')
    parser.add_argument(
        '--readme',
        help='The README.chromium file describing the imported project',
        metavar='FILE',
        dest='readme_path')
    parser.add_argument(
        '--exclude',
        default=['codereview.settings', 'infra'],
        action='append',
        help='Files to exclude from the imported copy',
        metavar='PATH')
    parsed = parser.parse_args(args)

    original_head = (
        subprocess.check_output(['git', 'rev-parse', 'HEAD'],
                                shell=IS_WINDOWS).rstrip())
    original_head = original_head.decode('utf-8')

    # Read the README, because that’s what it’s for. Extract some things from
    # it, and save it to be able to update it later.
    readme_path = (parsed.readme_path or
                   os.path.join(os.path.dirname(__file__ or '.'),
                                'README.chromium'))
    readme_content_old = open(readme_path, 'rb').read().decode('utf-8')

    project_name_match = re.search(
        r'^Name:\s+(.*)$', readme_content_old, flags=re.MULTILINE)
    project_name = project_name_match.group(1)

    # Extract the original commit hash from the README.
    revision_match = re.search(r'^Revision:\s+([0-9a-fA-F]{40})($|\s)',
                               readme_content_old,
                               flags=re.MULTILINE)
    revision_old = revision_match.group(1)

    subprocess.check_call(['git', 'fetch', parsed.repository, parsed.fetch_ref],
                          shell=IS_WINDOWS)

    # Make sure that parsed.update_to is an ancestor of FETCH_HEAD, and
    # revision_old is an ancestor of parsed.update_to. This prevents the use of
    # hashes that are known to git but that don’t make sense in the context of
    # the update operation.
    if not GitMergeBaseIsAncestor(parsed.update_to, 'FETCH_HEAD'):
        raise Exception('update_to is not an ancestor of FETCH_HEAD',
                        parsed.update_to,
                        'FETCH_HEAD')
    if not GitMergeBaseIsAncestor(revision_old, parsed.update_to):
        raise Exception('revision_old is not an ancestor of update_to',
                        revision_old,
                        parsed.update_to)

    # git-filter-branch needs a ref to update. It’s not enough to just tell it
    # to operate on a range of commits ending at parsed.update_to, because
    # parsed.update_to is a commit hash that can’t be updated to point to
    # anything else.
    subprocess.check_call(['git', 'update-ref', 'UPDATE_TO', parsed.update_to],
                          shell=IS_WINDOWS)

    # Filter the range being updated over to exclude files that ought to be
    # missing. This points UPDATE_TO to the rewritten (filtered) version.
    # git-filter-branch insists on running from the top level of the working
    # tree.
    toplevel = subprocess.check_output(['git', 'rev-parse', '--show-toplevel'],
                                       shell=IS_WINDOWS).rstrip()
    subprocess.check_call(
        ['git',
         'filter-branch',
         '--force',
         '--index-filter',
         'git rm -r --cached --ignore-unmatch ' +
             ' '.join(shlex.quote(path) for path in parsed.exclude),
         revision_old + '..UPDATE_TO'],
        cwd=toplevel,
        shell=IS_WINDOWS)

    # git-filter-branch saved a copy of the original UPDATE_TO at
    # original/UPDATE_TO, but this isn’t useful because it refers to the same
    # thing as parsed.update_to, which is already known.
    subprocess.check_call(
        ['git', 'update-ref', '-d', 'refs/original/UPDATE_TO'],
        shell=IS_WINDOWS)

    filtered_update_range = revision_old + '..UPDATE_TO'
    unfiltered_update_range = revision_old + '..' + parsed.update_to

    # This cherry-picks each change in the window from the filtered view of the
    # upstream project into the current branch.
    assisted_cherry_pick = False
    try:
        if not SubprocessCheckCall0Or1(['git',
                                        'cherry-pick',
                                        '--keep-redundant-commits',
                                        '--strategy=subtree',
                                        '-Xsubtree=' + parsed.subtree,
                                        '-x',
                                        filtered_update_range]):
            assisted_cherry_pick = True
            print("""
Please fix the errors above and run "git cherry-pick --continue".
Press Enter when "git cherry-pick" completes.
You may use a new shell for this, or ^Z if job control is available.
Press ^C to abort.
""", file=sys.stderr)
            input()
    except:
        # ^C, signal, or something else.
        print('Aborting...', file=sys.stderr)
        subprocess.call(['git', 'cherry-pick', '--abort'], shell=IS_WINDOWS)
        raise

    # Get an abbreviated hash and subject line for each commit in the window,
    # sorted in chronological order. Use the unfiltered view so that the commit
    # hashes are recognizable.
    log_lines = subprocess.check_output(
        ['git',
         '-c',
         'core.abbrev=12',
         'log',
         '--abbrev-commit',
         '--pretty=oneline',
         '--reverse',
         unfiltered_update_range],
         shell=IS_WINDOWS).decode('utf-8').splitlines(False)

    if assisted_cherry_pick:
        # If the user had to help, count the number of cherry-picked commits,
        # expecting it to match.
        cherry_picked_commits = int(subprocess.check_output(
            ['git', 'rev-list', '--count', original_head + '..HEAD'],
            shell=IS_WINDOWS))
        if cherry_picked_commits != len(log_lines):
            print('Something smells fishy, aborting anyway...', file=sys.stderr)
            subprocess.call(['git', 'cherry-pick', '--abort'], shell=IS_WINDOWS)
            raise Exception('not all commits were cherry-picked',
                            len(log_lines),
                            cherry_picked_commits)

    # Make a nice commit message. Start with the full commit hash.
    revision_new = subprocess.check_output(
        ['git', 'rev-parse', parsed.update_to],
        shell=IS_WINDOWS).decode('utf-8').rstrip()
    new_message = u'Update ' + project_name + ' to ' + revision_new + '\n\n'

    # Wrap everything to 72 characters, with a hanging indent.
    wrapper = textwrap.TextWrapper(width=72, subsequent_indent = ' ' * 13)
    for line in log_lines:
        # Strip trailing periods from subjects.
        if line.endswith('.'):
            line = line[:-1]

        # If any subjects have what look like commit hashes in them, truncate
        # them to 12 characters.
        line = re.sub(r'(\s)([0-9a-fA-F]{12})([0-9a-fA-F]{28})($|\s)',
                      r'\1\2\4',
                      line)

        new_message += '\n'.join(wrapper.wrap(line)) + '\n'

    # Update the README with the new hash.
    readme_content_new = re.sub(
        r'^(Revision:\s+)([0-9a-fA-F]{40})($|\s.*?$)',
        r'\g<1>' + revision_new,
        readme_content_old,
        count=1,
        flags=re.MULTILINE)

    # If the in-tree copy has no changes relative to the upstream, clear the
    # “Local Modifications” section of the README.
    has_local_modifications = True
    if SubprocessCheckCall0Or1(['git',
                                'diff-tree',
                                '--quiet',
                                'UPDATE_TO',
                                'HEAD:' + parsed.subtree]):
        has_local_modifications = False

        if not parsed.exclude:
            modifications = 'None.\n'
        elif len(parsed.exclude) == 1:
            modifications = (
                ' - %s has been excluded.\n' % parsed.exclude[0])
        else:
            modifications = (
                ' - The following files have been excluded:\n')
            for excluded in sorted(parsed.exclude):
                modifications += '    - ' + excluded + '\n'
        readme_content_new = re.sub(r'\nLocal Modifications:\n.*$',
                                    '\nLocal Modifications:\n' + modifications,
                                    readme_content_new,
                                    count=1,
                                    flags=re.DOTALL)

    # The UPDATE_TO ref is no longer useful.
    subprocess.check_call(['git', 'update-ref', '-d', 'UPDATE_TO'],
                          shell=IS_WINDOWS)

    # This soft-reset causes all of the cherry-picks to show up as staged, which
    # will have the effect of squashing them along with the README update when
    # committed below.
    subprocess.check_call(['git', 'reset', '--soft', original_head],
                          shell=IS_WINDOWS)

    # Write the new README.
    open(readme_path, 'wb').write(readme_content_new.encode('utf-8'))

    # Commit everything.
    subprocess.check_call(['git', 'add', readme_path], shell=IS_WINDOWS)

    try:
        commit_message_name = None
        with tempfile.NamedTemporaryFile(mode='wb',
                                         delete=False) as commit_message_f:
            commit_message_name = commit_message_f.name
            commit_message_f.write(new_message.encode('utf-8'))
        subprocess.check_call(['git',
                               'commit', '--file=' + commit_message_name],
                              shell=IS_WINDOWS)
    finally:
        if commit_message_name:
            os.unlink(commit_message_name)

    if has_local_modifications:
        print('Remember to check the Local Modifications section in ' +
              readme_path, file=sys.stderr)

    return 0


if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))