#!/usr/bin/python

##
# Copyright c 2016 IBM Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
##

###############################################################################
# @file commit-tracker
# @brief Prints out all commits on the master branch of the specified
#        repository, as well as all commits on linked submodule
#        repositories
###############################################################################

import argparse
import logging
import os
import re
import sys
import time
import git

###############################################################################
# @class CommitReport
# @brief A class representing information about a commit and all commits in
#        relevant subrepos
###############################################################################
class CommitReport:
    def __init__(self, i_repo_uri, i_repo_name,  i_sha, i_nice_name,
                 i_summary, i_insertions, i_deletions):
        self.repo_uri = i_repo_uri
        self.repo_name = i_repo_name
        self.sha = i_sha
        self.nice_name = i_nice_name
        self.summary = i_summary
        self.insertions = i_insertions
        self.deletions = i_deletions
        self.subreports = []

    def to_cl_string(self, i_level=0):
        # Define colors for the console
        RED = '\033[31m'
        BLUE = '\033[94m'
        ENDC = '\033[0m'
        # Put the string together
        l_cl_string = ('  ' * i_level) + RED + self.repo_name + ENDC  + ' ' \
            + BLUE + self.nice_name + ENDC + ' ' \
            + re.sub('\s+', ' ', self.summary)
        # Do the same for every subreport
        for l_report in self.subreports:
            l_cl_string += '\n' + l_report.to_cl_string(i_level + 1)
        return l_cl_string

    def get_total_insertions(self):
        l_insertions = self.insertions
        for l_commit in self.subreports:
            l_insertions += l_commit.get_total_insertions()
        return l_insertions

    def get_total_deletions(self):
        l_deletions = self.deletions
        for l_commit in self.subreports:
            l_deletions += l_commit.get_total_deletions()
        return l_deletions

###############################################################################
# @brief Main function for the script
#
# @param i_args : Command line arguments
###############################################################################
def main(i_args):
    # Parse the arguments
    l_args_obj = parse_arguments(i_args)

    # Print every commit
    print 'Getting report for ' + l_args_obj.repo_dir
    l_reports = generate_commit_reports(
        l_args_obj.repo_uri,
        l_args_obj.repo_dir,
        l_args_obj.latest_commit,
        l_args_obj.earliest_commit)

    # Compile issues, insertions, and deletions
    l_total_deletions = 0
    l_total_insertions = 0
    for l_report in l_reports:
        l_total_deletions += l_report.get_total_deletions()
        l_total_insertions += l_report.get_total_insertions()

    # Print commit information to the console
    print 'Commits'
    for l_report in l_reports:
        print l_report.to_cl_string()
    print 'Insertions and Deletions'
    print str(l_total_insertions) + ' insertions'
    print str(l_total_deletions) + ' deletions'

###############################################################################
# @brief Parses the arguments from the command line
#
# @param i_args : The list of arguments from the command line, excluding the
#                 name of the script
#
# @return An object representin the parsed arguments
###############################################################################
def parse_arguments(i_args):
    l_parser = argparse.ArgumentParser(
        description='Prints commit information from the given repo and all ' \
                    +'sub-repos specified with SRC_REV, starting from the ' \
                    +'most recent commit specified going back to the ' \
                    +'earliest commit specified.')
    l_parser.add_argument(
        'repo_uri',
        help='The URI of the repo to get commit information for')
    l_parser.add_argument(
        'repo_dir',
        help='The directory of the repo to get commit information for')
    l_parser.add_argument(
        'latest_commit',
        help='A reference (branch name, HEAD, SHA, etc.) to the most ' \
             +'recent commit to get information for')
    l_parser.add_argument(
        'earliest_commit',
        help='A reference to the earliest commit to get information for')
    return l_parser.parse_args(i_args)

###############################################################################
# @brief Generates a list of CommitReport objects, each one
#        representing a commit in the given repo URI and path,
#        starting at the beginning commit inclusive, ending at the
#        end commit exclusive
#
# @param i_repo_uri     : The URI to the repo to get reports for
# @param i_repo_path    : The path to the repo to get reports for
# @param i_begin_commit : A reference to the most recent commit. The
#                         most recent commit to get a report for
# @param i_end_commit   : A reference to the commit farthest in the
#                         past. The next youngest commit will be
#                         the last one to get a report for
#
# @return A list of CommitReport objects in order from newest to
#         oldest commit
###############################################################################
def generate_commit_reports(i_repo_uri, i_repo_path, i_begin_commit,
                            i_end_commit):
    # Get the repo that the user requested
    clone_or_update(i_repo_uri, i_repo_path)
    try:
        l_repo = git.Repo(i_repo_path)
    except git.exc.InvalidGitRepositoryError:
        logging.error(str(i_repo_path) + ' is not a valid git repository')
        return

    # Get commits between the beginning and end references
    try:
        l_commits = l_repo.iter_commits(rev=(i_begin_commit + '...'
                                             + i_end_commit))
        # Go through each commit, generating a report
        l_reports = []
        for l_commit in l_commits:
            # Get the insertion and deletion line counts
            l_insertions, l_deletions = get_line_count(
                    l_repo,str(l_commit.hexsha),
                    str(l_commit.hexsha) + '~1')
            # Construct a new commit report
            l_report = CommitReport(
                i_repo_uri,
                i_repo_path.split('/')[-1].replace('.git', ''),
                str(l_commit.hexsha),
                to_prefix_name_rev(l_commit.name_rev),
                l_commit.summary,
                l_insertions,
                l_deletions)

            # Search the diffs for any bumps of submodule versions
            l_diffs = l_commit.diff(str(l_commit.hexsha) + '~1')
            for l_diff in l_diffs:
                # If we have two files to compare with diff...
                if l_diff.a_path and l_diff.b_path:
                    # ... get info about the change, log it...
                    l_subrepo_uri, l_subrepo_new_hash, l_subrepo_old_hash \
                        = get_bump_info(l_repo, str(l_commit.hexsha),
                                          i_repo_path, l_diff.b_path)
                    logging.debug('Found diff...')
                    logging.debug('  Subrepo URI: ' + str(l_subrepo_uri))
                    logging.debug('  Subrepo new hash: '
                                  + str(l_subrepo_new_hash))
                    logging.debug('  Subrepo old hash: '
                                  + str(l_subrepo_old_hash))
                    logging.debug('  Found in: ' + str(l_diff.b_path))
                    # ... and print the commits for the subrepo if this was a
                    #     version bump
                    if (l_subrepo_new_hash
                            and l_subrepo_old_hash
                            and l_subrepo_uri
                            and l_subrepo_uri.startswith('git')):
                        logging.debug('  Bumped')
                        l_subrepo_path = l_subrepo_uri.split('/')[-1]
                        l_subreports = generate_commit_reports(
                            l_subrepo_uri,
                            l_subrepo_path,
                            l_subrepo_new_hash,
                            l_subrepo_old_hash)
                        l_report.subreports.extend(l_subreports)

            # Put the report on the end of the list
            l_reports.append(l_report)

    except git.exc.GitCommandError as e:
        logging.error(e)
        logging.error(str(i_begin_commit) + ' and ' + str(i_end_commit)
                      + ' are invalid revisions')
    return l_reports

###############################################################################
# @brief Gets the repo URI, the updated SHA, and the old SHA from a
#        given repo, commit SHA and file
#
# @param i_repo      : The Repo object to get version bump information
#                      from
# @param i_hexsha    : The hex hash for the commit to search for
#                      version bumps
# @param i_repo_path : The path to the repo containing the file to
#                      get bump information from
# @param i_file      : The path, starting at the base of the repo,
#                      to the file to get bump information from
#
# @return Returns the repo URI, the updated SHA, and the old SHA in
#         a tuple in that order
###############################################################################
def get_bump_info(i_repo, i_hexsha, i_repo_path, i_file):
    # Checkout the old repo
    i_repo.git.checkout(i_hexsha)
    # Get the diff text
    l_diff_text = i_repo.git.diff(i_hexsha, i_hexsha + '~1', '--', i_file)
    logging.debug('Hash: ' + i_hexsha)
    logging.debug('File: ' + i_repo_path + '/' + i_file)
    logging.debug('Diff Text: ' + l_diff_text)

    # SRCREV sets the SHA for the version of the other repo to use when
    # building openbmc. SHAs should be stored in the file in a format
    # like  SRCRV =? "<SHA>". Find both the new '+' and old '-' ones
    l_old_hash = None
    l_new_hash = None
    l_old_hash_match = re.search('-[A-Z_]*SRCREV[+=? ]+"([a-f0-9]+)"',
                                 l_diff_text)
    l_new_hash_match = re.search('\+[A-Z_]*SRCREV[+=? ]+"([a-f0-9]+)"',
                                 l_diff_text)
    if l_old_hash_match:
        l_old_hash = l_old_hash_match.group(1)
    if l_new_hash_match:
        l_new_hash = l_new_hash_match.group(1)

    # Get the URI of the subrepo
    l_uri = None
    if os.path.isfile(i_repo_path + '/' + i_file):
        l_changed_file = open(i_repo_path + '/' + i_file, 'r')
        for l_line in l_changed_file:
            # URIs should be stored in a format similar to
            # SRC_URI ?= "git://github.com/<path to repo>"
            l_uri_match = re.search('_URI[+=? ]+"([-a-zA-Z0-9/:\.]+)"', l_line)
            if l_uri_match:
                l_uri = l_uri_match.group(1)
                break
    else:
        logging.debug(i_repo_path + '/' + i_file)

    # Go back to master
    i_repo.git.checkout('master')
    return l_uri, l_new_hash, l_old_hash

###############################################################################
# @brief Updates the repo under the given path or clones it from the
#        uri if it doesn't yet exist
#
# @param i_uri  : The URI to the remote repo to clone
# @param i_path : The file path to where the repo currently exists or
#                 where it will be created
###############################################################################
def clone_or_update(i_uri, i_path):
    # If the repo exists, just update it
    if os.path.isdir(i_path):
        l_repo = git.Repo(i_path)
        l_repo.remotes[0].pull()

    # If it doesn't exist, clone it
    else:
        os.mkdir(i_path)
        l_repo = git.Repo.init(i_path)
        origin = l_repo.create_remote('origin', i_uri)
        origin.fetch()
        l_repo.create_head('master', origin.refs.master) \
            .set_tracking_branch(origin.refs.master)
        origin.pull()

###############################################################################
# @brief Gets the number of changed lines between two commits
#
# @param i_repo         : The Repo object these commits are in
# @param i_begin_commit : A git reference to the beginning commit
# @param i_end_commit   : A git reference to the end commit
#
# @return A two-tuple containing the number of insertions and the number of
#         deletions between the begin and end commit
###############################################################################
def get_line_count(i_repo, i_begin_commit, i_end_commit):
    diff_output = i_repo.git.diff(i_end_commit, i_begin_commit, shortstat=True)
    insertions = 0
    deletions = 0
    insertion_match = re.search('([0-9]+) insertion', diff_output)
    deletion_match = re.search('([0-9]+) deletion', diff_output)
    if insertion_match:
        insertions = int(insertion_match.group(1))
    if deletion_match:
        deletions = int(deletion_match.group(1))
    return insertions, deletions

##############################################################################
# @brief Cuts the hash in commit revision names down to its 7 digit prefix
#
# @param i_name_rev : The name of the revision to change
#
# @return The same revision name but with the hash its 7 digit prefix instead
###############################################################################
def to_prefix_name_rev(i_name_rev):
    l_name_rev = i_name_rev
    l_hash, l_name = l_name_rev.split()
    l_name_rev = l_hash[0:7] + ' ' + l_name
    return l_name_rev

# Only run main if run as a script
if __name__ == '__main__':
    main(sys.argv[1:])