#!/usr/bin/python
# -*- coding: utf-8 -*-

# Copyright (C) 2015 The Qt Company Ltd.
# Contact: http://www.qt.io/licensing/
#
# You may use this file under the terms of the 3-clause BSD license.
# See the file LICENSE from this package for details.
#

from __future__ import print_function

import os
import sys
import logging
import subprocess
import re
import warnings

fnull = open(os.devnull, "w")

class colors:
    HEADER = '\033[95m'
    BLUE = '\033[94m'
    GREEN = '\033[92m'
    WARNING = '\033[93m'
    FAIL = '\033[91m'
    ENDC = '\033[0m'

class BlameParser:
    __begin = ('<' * 7, '=' * 7)
    __end_map = {'merge': '=', 'diff3': '|'}
    # One example line to parse (result from git blame -c --date=short):
    # "ddd8ab31	(Andras Becsi	2014-06-13 18:17:07 +0200	414)bool GLSurface::InitializeOneOffInternal()"
    __matcher = re.compile(r"([0-9a-f]+)\s+\((.*?)\s+\d+\)(.*)").match

    def __init__(self):
        self.__end = (self.__from_git_config('merge.conflictstyle', 'merge', self.__end_map) * 7, '>' * 7)

    def __from_git_config(self, parameter, default, mapping):
        try:
            value = subprocess.check_output(['git', 'config', parameter]).decode('utf-8').strip()
        except subprocess.CalledProcessError:
            # When the value is unset
            value = ''
        try:
            return mapping[value or default]
        except KeyError:
            raise ValueError('Unknown git config', parameter, value)

    def __parse_blame_line(self, codeline):
        # Match a "git blame -c --date=short" output line
        m = self.__matcher(codeline)
        if m:
            return m.group(1, 2, 3)
        raise ValueError("Failed to parse blame line: %s" % (codeline))

    def __get_blame_results(self, conflict):
        cmd_git_blame = ["git", "blame", "-c", "--date=short", conflict]
        blame_output = subprocess.check_output(cmd_git_blame).decode('utf-8')
        return blame_output.split('\n')

    def parse(self, conflict):
        results, scan = {}, False
        for line in self.__get_blame_results(conflict):
            if not line.strip():
                continue
            sha1, info, code = self.__parse_blame_line(line)
            if any(code.startswith(b) for b in self.__begin):
                scan = True
                continue
            if any(code.startswith(e) for e in self.__end):
                scan = False
            if scan:
                results[sha1] = info

        return results.items()

# Try to find related commits for the conflicts
def check_conflicts(module, config, from_ref, conflicts):
    results = ''
    blameparser = BlameParser()
    for conflict in conflicts:
        changes = blameparser.parse(conflict)
        results += conflict + ':\n\t' + '\n\t'.join('%s %s' %c for c in changes) + '\n'
    return results

# Replace all occurrences of searchExp in one file
def replaceInFile(file, searchExp, replaceExp):
    import fileinput
    for line in fileinput.input(file, inplace=1):
        line = re.sub(searchExp, replaceExp, line)
        sys.stdout.write(line)

# Reset module to destination branch
def reset_module(module, config):
    opts = {}
    opts['to'] = config.branch_to
    try:
        git_checkout = "git checkout %(to)s" %opts
        subprocess.check_call(git_checkout.split(), stdout=fnull)
        git_reset = "git reset --hard origin/%(to)s" %opts
        subprocess.check_call(git_reset.split(), stdout=fnull, stderr=fnull)
    except Exception as e:
        logging.error("Git reset failed: %s", str(e))
        return False
    return True

# Run git merge for one module
def do_merge(module, config, from_ref):
    try:
        cmd_git_merge = ["git", "merge", "-m", \
                         "Merge remote-tracking branch \'origin/" + config.branch_from + "\' into " + config.branch_to, \
                         from_ref, "--no-edit", "--no-ff"]
        ret = subprocess.call(cmd_git_merge, stdout=fnull)
        if ret != 0 and config.mergetool:
            print("Starting mergetool")
            ret = subprocess.call(['git', 'mergetool', '-y'])
            if ret == 0:
                ret = subprocess.call(['git', 'commit', '--no-edit'], stdout=fnull)
        if ret != 0:
            print("Module %s failed to merge, manual merge needed." % module)
            return False

        # Make sure we get a change-id as git merge doesn't generate it for us
        git_amend = "git commit --amend --no-edit"
        subprocess.check_call(git_amend.split(), stdout=fnull)

    except Exception as e:
        logging.error("Merge failed: %s", str(e))
        return False

    return True

def wip_merge(module, config, from_ref):
    conflicts = []
    try:
        cmd_git_status = ["git", "status", "--porcelain"]
        status_output = subprocess.check_output(cmd_git_status).decode('utf-8').strip()
        status_count = 0
        if status_output:
            lines = status_output.split('\n')
            status_count = len(lines)

            for line in lines:
                try: mode, file = line.split()
                except (ValueError, TypeError): pass # not exactly two tokens
                else:
                    if 'U' in mode:
                        print("conflict: ", file)
                        conflicts.append(file)

        if not conflicts:
            print("Didn't find any conflict. Need to check carefully.")
            return False

        cmd_git_commit = ["git", "commit", "-a", "-m",
                          "WIP: Merge remote-tracking branch \'origin/" + config.branch_from + "\' into " + config.branch_to + "\n"
                          + '\nConflicts:\n\t' + '\n\t'.join(conflicts) + '\n']
        ret = subprocess.call(cmd_git_commit, stdout=fnull)
        if ret != 0:
            print("Failed to do \"git commit -a\".")
            return False

        # Make sure we get a change-id as git merge doesn't generate it for us
        git_amend = "git commit --amend --no-edit"
        subprocess.check_call(git_amend.split(), stdout=fnull)

        related = check_conflicts(module, config, from_ref, conflicts)
        print("Related: ", related)

    except Exception as e:
        logging.error("Create WIP change failed: %s", str(e))
        return False

    return True

# Change the version number in the .qmake.conf file to a given string
def update_qmake_conf(module, version):
    fileName = ".qmake.conf"
    replaceInFile(fileName, "5\..\..", version)
    cmd_git_status = "git status".split()

    status = subprocess.check_output(cmd_git_status).decode('utf-8')
    print(status)
    if status.find(fileName) < 0:
        return False

    cmd_git_add = "git add .qmake.conf".split()
    subprocess.check_call(cmd_git_add, stdout=fnull)
    cmd_git_commit = ['git', 'commit', '-m', 'Update module version to %s' % version]
    subprocess.check_call(cmd_git_commit, stdout=fnull)
    return True

# Run git push to the destination branch for one module
def push_gerrit(module, config):
    subprocess.call(["git", "show"])
    print('\n"%s" was successfully updated and merged' % module)
    # fix for python 2.x compatibility
    try: input = raw_input
    except NameError: pass
    confirm = input('Push merge? [Y/n] ')
    if not confirm or confirm.startswith(('y', 'Y')):
        output = subprocess.check_output(('git push gerrit HEAD:refs/for/%s' % config.branch_to).split()).decode('utf-8')
        #url = re.search("https.*", output).group(0).strip()
        #print(url)

        #GERRIT_CHANGE_ID=$(echo "$GIT_PUSH" | sed 's/.*https:\/\/codereview.qt-project.org\/\(.*\)/\;tx;d;:x')
        #echo "ChangeId: $GERRIT_CHANGE_ID"
        # if we had gerrit 2.4, we could do this:
        #for reviewer in
        #   sh codereview.qt-project.org gerrit set-reviewers --add jedrzej.nowacki@digia.com 49938

    else:
        print(colors.WARNING + "Merge not pushed." + colors.ENDC)

# Perform merge and push it for one module
def merge(module, config, from_ref):
    push_required = False
    if config.merge or config.wip:
        if not do_merge(module, config, from_ref):
            return False
        push_required = True

    if config.version:
        print('Updating .qmake.conf for', module)
        if update_qmake_conf(module, config.version):
            push_required = True

    if push_required:
        push_gerrit(module, config)
    return True

# Create WIP change when having conflicts
def create_wip(module, config, from_ref):
    if config.wip:
        if not wip_merge(module, config, from_ref):
            return False

        push_gerrit(module, config)

    return True

def get_module_sha_from_super(module, branch):
    result = ""
    cmd_git_lstree = ["git", "ls-tree", "origin/" + branch, module]
    lstree_output = subprocess.check_output(cmd_git_lstree).decode('utf-8').strip()
    lstree_outputs = lstree_output.split()
    if len(lstree_outputs) == 4 and lstree_outputs[3] == module:
        result = lstree_outputs[2].strip()
    return result

# Iterate over all modules (either default or passed with -m option)
def process_modules(config):
    if config.list_modules:
        print("Modules: ", config.modules)
        return

    cmd_git_fetch = ["git", "fetch"]
    subprocess.check_call(cmd_git_fetch, stdout=fnull, stderr=fnull)

    manual_merges = []

    for module in config.modules.split():
        print("\nModule: " + colors.GREEN + module + colors.ENDC)
        if not os.path.isdir(module):
            print("Directory '%s' does not exist. Skipping..." % module)
            continue
        try:
            os.chdir(module)
            try:
                cmd_git_fetch = ["git", "fetch"]
                subprocess.check_call(cmd_git_fetch, stdout=fnull, stderr=fnull)

                to_string = "origin/" + config.branch_to
                from_string = "origin/" + config.branch_from

                if config.super:
                    os.chdir("..")
                    from_sha1 = get_module_sha_from_super(module, config.branch_from)
                    if from_sha1:
                        from_string = from_sha1
                    else:
                        print("Unable to obtain sha1 from super module for module ", module, "\n")
                    os.chdir(module)

                print("Merge from", from_string, "to", to_string, ":")
                cmd_git_cherry = ["git", "cherry", to_string, from_string, "-v"]
                cherry_output = subprocess.check_output(cmd_git_cherry).decode('utf-8').strip()

                change_count = 0
                if cherry_output:
                    change_count = len(cherry_output.split('\n'))

                if config.status:
                    print(cherry_output)
                    print(colors.GREEN, change_count, colors.ENDC, "patches to be merged in", module, "\n")

                if config.reset or config.merge or config.version or config.wip:
                    reset_module(module, config)

                if change_count > 0:
                    if not merge(module, config, from_string):
                        manual_merges.append(module)
                        if config.wip:
                            create_wip(module, config, from_string)

            except Exception as e:
                logging.error("Command execution failed: %s", str(e))
                import traceback
                traceback.print_exc(file=sys.stdout)
            finally:
                os.chdir("..")

        except Exception as e:
            logging.error("Changing current dir failed: %s", str(e))
            import traceback
            traceback.print_exc(file=sys.stdout)

    if manual_merges:
        print("Modules failed to merge: ", manual_merges)

# get a list of submodules and a list of submodules that are not checked out
def get_submodules():
    git_submodule_status = subprocess.check_output('git submodule status'.split(' ')).strip()
    modules = []
    modules_not_checked_out = []
    for line in git_submodule_status.split('\n'):
        module = line.strip().split(' ')[1]
        if line.startswith('-'):
            modules_not_checked_out.append(module)
            print('WARNING:', module, 'is not checked out')
        elif module in ('qtqa', 'qtrepotools'):
            print('skipping', module)
        else:
            modules.append(module)
    return modules, modules_not_checked_out


if __name__== "__main__":
    import argparse
    parser = argparse.ArgumentParser(prog="git-qt-merge-branches",
        description="Merge branches for the Qt Project",
        epilog="""

Run from within a work tree of the qt5 super-module, with all relevant
sub-modules checked out (e.g. using qt5/init-repository).
""")
    group = parser.add_argument_group("Primary action", "Chose one of:")
    group.add_argument('-s', '--status', action="store_true",
                       help='show the status (which patches will be merged)')
    group.add_argument('-d', '--merge', action="store_true",
                       help='do the merge')
    parser.add_argument('-u', '--super', action="store_true",
                        help='obtain sha1s from supermodule instead of using branch tips')
    parser.add_argument('-m', '--modules',
                        help='override the list of modules (eg. -m "qtbase qtdeclarative")')
    group.add_argument('-l', '--list-modules', action="store_true",
                       help='list the modules to be merged and exit')
    group.add_argument('--reset', action="store_true",
                       help='reset to origin/to_branch. this is implicit in the merge command')
    parser.add_argument('-f', '--branch-from', default='stable',
                        help='from which branch to merge')
    parser.add_argument('-t', '--branch-to', default='dev',
                        help='the target branch')
    group.add_argument('-v', '--version', default='',
                       help='set version in .qmake.conf to given version string')
    parser.add_argument('--mergetool', action="store_true",
                        help='run mergetool for conflicts')
    parser.add_argument('-w', '--wip', action="store_true",
                        help='create WIP change when conflicts arise')
    config = parser.parse_args()

    print("Qt Project merge tool\n")
    default_modules, modules_not_checked_out = get_submodules()
    if config.modules is None:
        config.modules = ' '.join(default_modules)
    print("Submodules: ", default_modules)
    print("Ignored submodules: ", modules_not_checked_out)

    logging.basicConfig(format='%(levelname)s: %(message)s')

    if config.status or config.merge or config.reset or config.list_modules or config.version or config.wip:
        process_modules(config)
    else:
        parser.print_help()
    print("Submodules that are not checked out and are ignored:\n",
          ' '.join(modules_not_checked_out))