#!/usr/bin/env python
COPYRIGHT = """\
Copyright (C) 2011 OpenStack LLC.

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."""

import commands
import optparse
import urllib
import json

from distutils.version import StrictVersion
from urlparse import urlparse
import ConfigParser

import os
import sys
import time
import re

version = "1.6"

VERBOSE = False
UPDATE = False
CONFIGDIR = os.path.expanduser("~/.config/git-review")
PYPI_URL = "http://pypi.python.org/pypi/git-review/json"
PYPI_CACHE_TIME = 60 * 60 * 24  # 24 hours


def run_command(cmd, status=False):
    if VERBOSE:
        print "Running:", cmd
    stat, out = commands.getstatusoutput(cmd)
    if status:
        return (stat, out)
    return out


def run_command_status(cmd):
    return run_command(cmd, True)


def update_latest_version(version_file_path):
    """ Cache the latest version of git-review for the upgrade check. """

    if not os.path.exists(CONFIGDIR):
        os.makedirs(CONFIGDIR)

    if os.path.exists(version_file_path) and not UPDATE:
        if (time.time() - os.path.getmtime(version_file_path)) < 28800:
            return

    latest_version = version
    try:
        latest_version = json.load(urllib.urlopen(PYPI_URL))['info']['version']
    except:
        pass

    with open(version_file_path, "w") as version_file:
        version_file.write(latest_version)


def latest_is_newer():
    """ Check if there is a new version of git-review. """

    version_file_path = os.path.join(CONFIGDIR, "latest-version")
    update_latest_version(version_file_path)

    latest_version = None
    with open(version_file_path, "r") as version_file:
        latest_version = StrictVersion(version_file.read())
    if latest_version > StrictVersion(version):
        return True
    return False


def set_hooks_commit_msg():
    """ Install the commit message hook if needed. """

    top_dir = run_command('git rev-parse --show-toplevel')
    target_file = os.path.join(top_dir, ".git/hooks/commit-msg")

    if os.path.exists(target_file) and os.access(target_file, os.X_OK):
        return

    (hostname, team, username, port, project_name) = \
        parse_git_show("gerrit", "Push")
    source_location = "https://%s/tools/hooks/commit-msg" % hostname

    if not os.path.exists(target_file) or UPDATE:
        if VERBOSE:
            print "Fetching source_location: ", source_location
        commit_msg = urllib.urlretrieve(source_location, target_file)

    if not os.access(target_file, os.X_OK):
        os.chmod(target_file, os.path.stat.S_IREAD | os.path.stat.S_IEXEC)

    run_command("GIT_EDITOR=true git commit --amend")


def add_remote(username, hostname, port, project):
    """ Adds a gerrit remote. """

    if username is None:
        username = os.getenv("USERNAME")
    if username is None:
        username = os.getenv("USER")
    if username is None:
        username = raw_input("Enter your gerrit username: ")
    if port is None:
        port = 29418

    remote_url = "ssh://%s@%s:%s/%s" % (username, hostname, port, project)
    if VERBOSE:
        print "No remote set, testing %s" % remote_url

    ssh_cmd = "ssh -p%s -o StrictHostKeyChecking=no %s@%s gerrit ls-projects"
    cmd = ssh_cmd % (port, username, hostname)
    (status, ssh_outout) = run_command_status(cmd)
    if status == 0:
        if VERBOSE:
            print "%s@%s:%s worked." % (username, hostname, port)
        print "Creating a git remote called gerrit that maps to:"
        print "\t%s" % remote_url
        cmd = "git remote add -f gerrit %s" % remote_url
        (status, remote_output) = run_command_status(cmd)

    if status != 0:
        raise Exception("Error running %s" % cmd)


def split_hostname(fetch_url):

    parsed_url = urlparse(fetch_url)
    username = None
    hostname = parsed_url.netloc
    port = 22

    if "@" in hostname:
        (username, hostname) = hostname.split("@")
    if ":" in hostname:
        (hostname, port) = hostname.split(":")

    # Is origin an ssh location? Let's pull more info
    if parsed_url.scheme == "ssh":
        return (username, hostname, port)
    else:
        return (None, hostname, None)


def parse_git_show(remote, verb):
    fetch_url = ""
    for line in run_command("git remote show -n %s" % remote).split("\n"):
        if line.strip().startswith("%s" % verb):
            fetch_url = ":".join(line.split(":")[1:]).strip()

    project_name = fetch_url.split("/")[-1]
    if project_name.endswith(".git"):
        project_name = project_name[:-4]

    hostname = None
    team = None
    username = None
    port = None

    if VERBOSE:
        print "Found origin %s URL:" % verb, fetch_url

    # Special-case git@github urls - the rest can be parsed with urlparse
    if fetch_url.startswith("git@github.com"):
        hostname = "github.com"
    else:
        (username, hostname, port) = split_hostname(fetch_url)

    if hostname == "github.com":
        team = fetch_url.split("/")[-2]
        if team.startswith("git@github.com"):
            team = team.split(':')[1]

    return (hostname, team, username, port, project_name)


def check_remote(remote):
    """Check that a Gerrit Git remote repo exists, if not, set one."""

    if remote in run_command("git remote").split("\n"):

        for current_remote in run_command("git branch -a").split("\n"):
            if current_remote.strip() == "remotes/%s/master" % (remote) \
                and not UPDATE:
                return
        # We have the remote, but aren't set up to fetch. Fix it
        if VERBOSE:
            print "Setting up gerrit branch tracking for better rebasing"
        output = run_command("git remote update %s" % remote)
        if VERBOSE:
            print output
        return

    # Check for a .gitreview at the top of the repo with the gerrit location
    top_dir = run_command('git rev-parse --show-toplevel')
    target_file = os.path.join(top_dir, ".gitreview")

    if os.path.exists(target_file):
        config = ConfigParser.ConfigParser(dict(port='29418'))
        config.read(target_file)
        hostname = config.get("gerrit", "host")
        port = config.get("gerrit", "port")
        project = config.get("gerrit", "project")
        username = None
    else:
        print "No '.gitreview' file found in this repository."
        print "We don't know where your gerrit is. Please manually create "
        print "a remote named gerrit and try again."
        sys.exit(1)

    # Gerrit remote not present, try to add it
    try:
        add_remote(username, hostname, port, project)
    except:
        print sys.exc_info()[2]
        print "We don't know where your gerrit is. Please manually create "
        print "a remote named gerrit and try again."
        raise


def rebase_changes(branch, remote):

    remote_branch = "remotes/%s/%s" % (remote, branch)

    cmd = "git remote update %s" % remote
    (status, output) = run_command_status(cmd)
    if VERBOSE:
        print output
    if status != 0:
        print "Problem running '%s'" % cmd
        if not VERBOSE:
            print output
        return False

    cmd = "GIT_EDITOR=true git rebase -i %s" % remote_branch
    (status, output) = run_command_status(cmd)
    if status != 0:
        print "Errors running %s" % cmd
        print output
        return False
    return True


def assert_diverge(branch, remote):

    cmd = "git diff %s/%s..HEAD" % (remote, branch)
    (status, output) = run_command_status(cmd)
    if len(output) == 0:
        print "No changes between HEAD and %s/%s." % (remote, branch)
        print "Submitting for review would be pointless."
        sys.exit(1)
    if status != 0:
        print "Had trouble running %s" % cmd
        sys.exit(1)


def get_topic():

    branch_name = None
    for branch in run_command("git branch").split("\n"):
        if branch.startswith('*'):
            branch_name = branch.split()[1].strip()

    branch_parts = branch_name.split("/")
    if len(branch_parts) >= 3 and branch_parts[0] == "review":
        return "/".join(branch_parts[2:])

    log_output = run_command("git show --format='%s %b'")
    bug_re = r'\b([Bb]ug|[Ll][Pp])\s*[#:]?\s*(\d+)'

    match = re.search(bug_re, log_output)
    if match is not None:
        return "bug/%s" % match.group(2)

    bp_re = r'\b([Bb]lue[Pp]rint|[Bb][Pp])\s*[#:]?\s*([0-9a-zA-Z-_]+)'
    match = re.search(bp_re, log_output)
    if match is not None:
        return "bp/%s" % match.group(2)

    return branch_name


def download_review(review):

    (hostname, team, username, port, project_name) = \
        parse_git_show("gerrit", "Push")

    ssh_cmds = ["ssh"]
    if port is not None:
        ssh_cmds.extend(["-p", port])
    if username is not None:
        ssh_cmds.extend(["-l", username])
    ssh_cmd = " ".join(ssh_cmds)

    query_string = "--format=JSON --current-patch-set change:%s" % review
    review_info = None
    (status, output) = run_command_status("%s %s gerrit query %s"
                                           % (ssh_cmd, hostname, query_string))

    if status != 0:
        print "Could not fetch review information from gerrit"
        print output
        return status
    try:
        review_info = json.loads(output.split("\n")[0])
    except:
        if VERBOSE:
            print output
        print "Could not find a gerrit review with id: %s" % review
        return 1

    topic = review_info['topic']
    if topic == "master":
        topic = review
    author = re.sub('\W+', '_', review_info['owner']['name']).lower()
    branch_name = "review/%s/%s" % (author, topic)
    revision = review_info['currentPatchSet']['revision']
    refspec = review_info['currentPatchSet']['ref']

    print "Downloading %s from gerrit into %s" % (refspec, branch_name)
    checkout_cmd = "git checkout -b %s remotes/gerrit/master" % branch_name
    (status, output) = run_command_status(checkout_cmd)
    if status != 0:
        if output.endswith("already exists"):
            print "Branch already exists - reusing"
            checkout_cmd = "git checkout %s" % branch_name
            (status, output) = run_command_status(checkout_cmd)
            if status != 0:
                print output
                return status
        else:
            print output
            return status

    (status, output) = run_command_status("git pull gerrit %s" % refspec)
    if status != 0:
        print output
        return status

    (status, output) = run_command_status("git reset --hard %s" % revision)
    if status != 0:
        print output
        return status
    return 0


def print_exit_message(status, needs_update):

    if needs_update:
        print """
***********************************************************
A new version of git-review is availble on PyPI. Please
update your copy with:

  pip install -U git-review

to ensure proper behavior with gerrit. Thanks!
***********************************************************
"""
    sys.exit(status)


def main():

    usage = "git review [OPTIONS] ... [BRANCH]"
    parser = optparse.OptionParser(usage=usage)
    parser.add_option("-t", "--topic", dest="topic",
                      help="Topic to submit branch to")
    parser.add_option("-n", "--dry-run", dest="dry", action="store_true",
                      help="Don't actually submit the branch for review")
    parser.add_option("-r", "--remote", dest="remote",
                      help="git remote to use for gerrit")
    parser.add_option("-R", "--no-rebase", dest="rebase",
                      action="store_false",
                      help="Don't rebase changes before submitting.")
    parser.add_option("-v", "--verbose", dest="verbose", action="store_true",
                      help="Output more information about what's going on")
    parser.add_option("-d", "--download", dest="download",
                      help="Download the contents of an existing gerrit "
                           "review into a branch")
    parser.add_option("-u", "--update", dest="update", action="store_true",
                      help="Force updates from remote locations")
    parser.add_option("-s", "--setup", dest="setup", action="store_true",
                      help="Just run the repo setup commands but don't "
                           "submit anything")
    parser.add_option("--version", dest="version", action="store_true",
                      help="Print version number and exit")
    parser.set_defaults(dry=False, rebase=True, verbose=False, update=False,
                        setup=False, version=False, remote="gerrit")

    branch = "master"
    (options, args) = parser.parse_args()
    if len(args) > 0:
        branch = args[0]
    global VERBOSE
    global UPDATE
    VERBOSE = options.verbose
    UPDATE = options.update
    remote = options.remote
    status = 0

    if options.version:
        print '%s, version %s' % (os.path.split(sys.argv[0])[-1], version)
        print COPYRIGHT
        sys.exit(0)

    needs_update = latest_is_newer()
    check_remote(remote)

    if options.download is not None:
        print_exit_message(download_review(options.download), needs_update)
    else:
        topic = options.topic
        if topic is None:
            topic = get_topic()
        if VERBOSE:
            print "Found topic '%s' from parsing changes." % topic

        set_hooks_commit_msg()

        if not options.setup:
            if options.rebase:
                if not rebase_changes(branch, remote):
                    print_exit_message(1, needs_update)
            assert_diverge(branch, remote)

            cmd = "git push %s HEAD:refs/for/%s/%s" % (remote, branch, topic)
            if options.dry:
                print "Please use the following command " \
                      "to send your commits to review:\n"
                print "\t%s\n" % cmd
            else:
                (status, output) = run_command_status(cmd)
                print output

    print_exit_message(status, needs_update)


if __name__ == "__main__":
    main()