from collections import defaultdict

from copy import deepcopy

from rbtools.hooks.common import execute, get_review_request_id

def get_branch_name(ref_name):

    """Returns the branch name corresponding to the specified ref name."""

    branch_ref_prefix = 'refs/heads/'

    if ref_name.startswith(branch_ref_prefix):

        return ref_name[len(branch_ref_prefix):]

def get_commit_hashes(old_rev, new_rev):

    """Returns a list of abbreviated commit hashes from old_rev to new_rev."""

    git_command = ('git rev-list --abbrev-commit --reverse %s..%s'

                   % (old_rev, new_rev))

    return execute(git_command).split('\n')

def get_unique_commit_hashes(ref_name):

    """Returns a list of abbreviated commit hashes unique to ref_name."""

    excluded_branches = get_excluded_branches(ref_name)

    git_command = ('git rev-list %s --abbrev-commit --reverse --not %s'

                   % (ref_name, excluded_branches))

    return execute(git_command).strip().split('\n')

def get_excluded_branches(ref_name):

    """Returns a string with all branches, excluding the specified branch."""

    git_command = ('git for-each-ref refs/heads/ --format="%%(refname)" '

                   '| grep -v %s' % ref_name)

    return execute(git_command).replace('\n', ' ')

def get_branches_containing_commit(commit_hash):

    """Returns a list of all branches containing the specified commit."""

    git_command = ('git branch --contains %s' % commit_hash)

    branches = execute(git_command).replace('*', '').split('\n')

    return [branch.strip() for branch in branches]

def get_commit_message(commit):

    """Returns the specified commit's commit message."""

    git_command = ('git show -s --pretty=format:"%%B" %s' % commit)

    return execute(git_command).strip()

def get_review_id_to_commits_map(lines, regex):

    """Returns a dictionary, mapping a review request ID to a list of commits.

    The commits must be in the form: oldrev newrev refname (separated by

    newlines), as given by a Git pre-receive or post-receive hook.

    If a commit's commit message does not contain a review request ID, we append

    the commit to the key '0'.

    """

    review_id_to_commits_map = defaultdict(list)

    # Store a list of new branches (which have an all-zero old_rev value)

    # created in this push to handle them specially.

    new_branches = []

    null_sha1 = '0000000000000000000000000000000000000000'

    for line in lines:

        old_rev, new_rev, ref_name = line.split()

        branch_name = get_branch_name(ref_name)

        if not branch_name or new_rev == null_sha1:

            continue

        if old_rev == null_sha1:

            new_branches.append(branch_name)

            commit_hashes = get_unique_commit_hashes(ref_name)

        else:

            commit_hashes = get_commit_hashes(old_rev, new_rev)

        for commit_hash in commit_hashes:

            if commit_hash:

                commit_message = get_commit_message(commit_hash)

                review_request_id = get_review_request_id(regex, commit_message)

                if not review_request_id:

                    review_request_id = '0'

                commit = '%s (%s)' % (branch_name, commit_hash)

                review_id_to_commits_map[review_request_id].append(commit)

    # If there are new branches, check every commit in the dictionary

    # (corresponding to only old branches) to see if the new branches also

    # contain that commit.

    if new_branches:

        review_id_to_commits_map_copy = deepcopy(review_id_to_commits_map)

        for review_id, commit_list in review_id_to_commits_map_copy.iteritems():

            for commit in commit_list:

                commit_branch = commit[:commit.find('(') - 1]

                if commit_branch in new_branches:

                    continue

                commit_hash = commit[commit.find('(') + 1:-1]

                commit_branches = get_branches_containing_commit(commit_hash)

                for branch in set(new_branches).intersection(commit_branches):

                    new_commit = '%s (%s)' % (branch, commit_hash)

                    review_id_to_commits_map[review_id].append(new_commit)

    return review_id_to_commits_map