#!/usr/bin/env python3
#
# Copyright (C) 2019 The Android Open Source Project
#
# 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.
#
# pylint: disable=not-callable, relative-import, line-too-long, no-else-return

import argparse
import fileinput
import os.path as path
import re
import subprocess
import xml.etree.ElementTree as ET


def green_print(to_print):
    print("\033[92m" + to_print + "\033[0m")


def is_clang_project(element):
    return element.tag == "project" and \
           element.get("path") == "prebuilts-master/clang/host/linux-x86"


class KernelToolchainUpdater():

    def __init__(self):
        self.parse_args()
        if self.clang_version_arg:
            self.clang_revision, self.clang_version = self.clang_version_arg.split(':')
        else:
            self.get_clang_versions()

        self.kernel_dir = path.normpath(path.join(self.repo_checkout, self.kernel_relpath))
        self.repo_dir = path.join(self.repo_checkout, ".repo", "manifests")
        self.topic = path.basename(self.repo_checkout) + "_" + self.clang_revision

        if path.basename(self.kernel_dir) != 'common':
            self.resync_tree()
            self.get_clang_sha()
            self.update_sha()
            self.commit_sha()
            self.push_manifest_change()

        self.resync_tree()
        self.update_kernel_toolchain()
        self.commit_kernel_toolchain()
        self.push_kernel_change()

    def parse_args(self):
        parser = argparse.ArgumentParser()
        # TODO: some validation of the command line args would be nice.
        parser.add_argument(
            "repo_checkout",
            help="Source directory of the repo checkout of the kernel.")
        parser.add_argument(
            "kernel_relpath",
            help="Path relative to repo checkout containing kernel source tree.")
        parser.add_argument(
            "clang_bin", help="Path to the new clang binary in AOSP.")
        parser.add_argument(
            "bug_number",
            help="The bug number to be included in the commit message.")
        parser.add_argument(
            "-d", action="store_true", help="Dry run and debug.")
        parser.add_argument(
            "-n", action="store_true", help="No push (but do local changes)")
        parser.add_argument(
            "--no_topic",
            action="store_true",
            help="Do not set topic on uploaded changes.")
        parser.add_argument(
            "--wip",
            action="store_true",
            help="Mark change as WIP.")
        parser.add_argument(
            "--hashtag",
            metavar="HASHTAG",
            help="Hashtags (comma-separated) to apply to pushed changes.")
        parser.add_argument(
            "--clang_version",
            metavar="REVISION:VERSION",
            help="REVISION (e.g. r1234) and VERSION (e.g. 10.0.0) to use " +\
                 "instead of fetching this from clang_bin.")
        args = parser.parse_args()
        self.bug_number = args.bug_number
        self.clang_bin = args.clang_bin
        self.repo_checkout = args.repo_checkout
        self.kernel_relpath = args.kernel_relpath
        self.dry_run = args.d
        self.no_push = args.n
        self.no_topic = args.no_topic
        self.wip = args.wip
        self.hashtag = args.hashtag
        self.clang_version_arg = args.clang_version

    def get_clang_versions(self):
        output = subprocess.check_output([self.clang_bin, "--version"]).decode("utf-8")
        self.clang_revision = re.search("based on (r[0-9]+[a-z]?)",
                                        output).groups()[0]
        self.clang_version = re.search("clang version ([0-9\.]+)",
                                       output).groups()[0]

    def get_clang_sha(self):
        clang_dir = path.dirname(self.clang_bin)
        output = subprocess.check_output(
            ["git", "--no-pager", "log", "-n", "1"], cwd=clang_dir).decode("utf-8")
        self.clang_sha = re.search("commit ([0-9a-z]+)", output).groups()[0]

    def update_sha(self):
        green_print("Updating SHA")
        xml_path = path.join(self.repo_dir, "default.xml")
        if self.dry_run:
            print("Updating %s to use\n%s." % (xml_path, self.clang_sha))
            return
        # It would be great to just use the builtin XML serializer/deserializer
        # in a sane way; unfortunately this will end up reformatting
        # indentation and reordering element attributes.
        for line in fileinput.input(xml_path, inplace=True):
            try:
                element = ET.fromstring(line)
                if is_clang_project(element):
                    line = re.sub("revision=\"[0-9a-z]+\"",
                                  "revision=\"%s\"" % self.clang_sha, line)
            except ET.ParseError:
                pass
            finally:
                print(line, end="")

    def commit_sha(self):
        green_print("Committing SHA")
        message = """
Update Clang to %s based on %s

Bug: %s
""".strip() % (self.clang_version, self.clang_revision, self.bug_number)
        command = "git commit -asm"
        if self.dry_run:
            print(command + " \"" + message + "\"")
            return
        subprocess.check_output(
            command.split(" ") + [message], cwd=self.repo_dir)

    def push_manifest_change(self):
        green_print("Pushing manifest change")
        output = subprocess.check_output(["repo", "--no-pager", "info"],
                                         cwd=self.repo_dir).decode("utf-8")
        repo_branch = output.split("\n")[1].split(" ")[3].split("/")[2]
        command = "git push origin HEAD:refs/for/" + repo_branch

        if self.wip:
            command += '%wip' # note: no preceding space needed here.
        if not self.no_topic:
            command += " -o topic=" + self.topic
        if self.hashtag:
            command += " -o hashtag=" + self.hashtag
        if self.dry_run or self.no_push:
            print(command)
            return
        subprocess.check_output(command.split(" "), cwd=self.repo_dir)

    def resync_tree(self):
        green_print("Syncing kernel tree")
        command = "repo sync -c --no-tags -q -n -j 71"
        if self.dry_run:
            print(command)
            return
        subprocess.check_output(command.split(" "), cwd=self.repo_dir)

    def update_kernel_toolchain(self):
        green_print("Updating kernel toolchain")
        config_path = path.join(self.kernel_dir, "build.config.constants")
        if self.dry_run:
            print("Updating %s to use %s." % (config_path, self.clang_revision))
            return
        for line in fileinput.input(config_path, inplace=True):
            line = re.sub("CLANG_VERSION=r[0-9a-z]+",
                          "CLANG_VERSION=" + self.clang_revision, line)
            print(line, end="")

    def commit_kernel_toolchain(self):
        green_print("Committing kernel toolchain")
        message = """
ANDROID: clang: update to %s

Bug: %s
""".strip() % (self.clang_version, self.bug_number)
        command = "git commit -asm"
        if self.dry_run:
            print(command + " \"" + message + "\"")
            return
        # TODO: it might be nice to `git checkout -b <topic>` before committing.
        subprocess.check_output(
            command.split(" ") + [message], cwd=self.kernel_dir)

    def push_kernel_change(self):
        green_print("Pushing kernel change")
        xml_path = path.join(self.repo_dir, "default.xml")
        remote = subprocess.check_output(["git", "--no-pager", "remote"],
                                         cwd=self.kernel_dir).decode("utf-8").strip()
        for project in ET.parse(xml_path).iter("project"):
            if (project.get("path") == self.kernel_relpath):
                command = "git push %s HEAD:refs/for/%s" % (
                        remote, project.get("revision"))
                if self.wip:
                    command += '%wip' # note: no preceding space needed here.
                if not self.no_topic:
                    command += " -o topic=" + self.topic
                if self.hashtag:
                    command += " -o hashtag=" + self.hashtag
                if self.dry_run or self.no_push:
                    print(command)
                    return
                subprocess.check_output(command.split(" "), cwd=self.kernel_dir)
                break


if __name__ == "__main__":
    KernelToolchainUpdater()