#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright 2023 The ChromiumOS Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Report branches including the provided fix(es)
"""

import argparse
import re
import subprocess
import sys


STABLE_URLS = [
    'git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git',
]

UPSTREAM_URLS = [
    'git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git',
    'https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git',
    'https://kernel.googlesource.com/pub/scm/linux/kernel/git/torvalds/linux.git',
]

STABLE_QUEUE_URLS = [
    'git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git'
]

CHROMEOS_URLS = [
    'https://chromium.googlesource.com/chromiumos/third_party/kernel'
]

BRANCHES = ('6.6', '6.1', '5.15', '5.10', '5.4', '4.19')

MIN_RELEASE = 120

def _git(args, stdin=None, encoding='utf-8'):
    """Calls a git subcommand.

    Similar to subprocess.check_output.

    Args:
        args: subcommand + args passed to 'git'.
        stdin: a string or bytes (depending on encoding) that will be passed
            to the git subcommand.
        encoding: either 'utf-8' (default) or None. Override it to None if
            you want both stdin and stdout to be raw bytes.

    Returns:
        the stdout of the git subcommand, same type as stdin. The output is
        also run through strip to make sure there's no extra whitespace.

    Raises:
        subprocess.CalledProcessError: when return code is not zero.
            The exception has a .returncode attribute.
    """

    try:
        # print(['git'] + args)
        return subprocess.run(
            ['git'] + args,
            encoding=encoding,
            input=stdin,
            stdout=subprocess.PIPE,
            stderr=subprocess.DEVNULL,
            check=True,
        ).stdout.strip()
    except subprocess.CalledProcessError:
        return None


def release_branches(chromeos_remote, baseline):
    """Return existing release branches."""

    command = ['branch', '-r', '--list', '%s/release-R*-chromeos-%s' % (chromeos_remote, baseline)]

    releases = []

    branches = _git(command).splitlines()

    for branch in branches:
        release = re.match(r' *%s/release-(R([0-9]+)-[0-9]+\.B)-.*' % chromeos_remote, branch)
        if release and int(release[2]) >= MIN_RELEASE:
            releases += [release[1]]

    return releases


def _find_remote(urls):
    """Find a remote pointing to a given repository."""

    # https remotes may end with or without '/'. Cover both variants.
    _urls = []
    for url in urls:
        _urls.append(url)
        if url.startswith('https://'):
            if url.endswith('/'):
                _urls.append(url.rstrip('/'))
            else:
                _urls.append(url + '/')

    for remote in _git(['remote']).splitlines():
        try:
            if _git(['remote', 'get-url', remote]) in _urls:
                return remote
        except subprocess.CalledProcessError:
            # Kinda weird, get-url failing on an item that git just gave us.
            continue
    return None


def integrated(sha):
    """Find tag at which a given SHA was integrated"""
    fixed = _git(['describe', '--match', 'v*', '--contains', sha])
    if fixed:
        fixed = fixed.split('~')[0]
    else:
        # This patch may not be upstream.
        upstream = _find_remote(UPSTREAM_URLS)
        gitcommand = ['merge-base', '--is-ancestor', sha, f'{upstream}/master']
        if _git(gitcommand) is not None:
            fixed = "ToT"
        else:
            fixed = None

    return fixed


def compare_releases(r1, r2):
    """Compare two releases.

    Return 0 if equal, <0 if r1 is older than r2, >0 if r1 is newer than r2
    """

    s1 = 0
    s2 = 0

    if r1 == r2:
        return 0
    if r1 == 'ToT':
        return 1
    if r2 == 'ToT':
        return -1

    m = re.match(r'(?:v)(\d+).(\d+)(?:\.(\d+))?.*', r1)
    if m:
        s1 = int(m.group(1)) * 1000000
        s1 += int(m.group(2)) * 1000
        if m.group(3) is not None:
            s1 += int(m.group(3))

    m = re.match(r'(?:v)?(\d+).(\d+)(?:\.(\d+))?.*', r2)
    if m:
        s2 = int(m.group(1)) * 1000000
        s2 += int(m.group(2)) * 1000
        if m.group(3) is not None:
            s2 += int(m.group(3))

    if s1 == s2:
        return 0
    if s1 < s2:
        return -1
    return 1


def getcommit(sha):
    """Get commit message for given SHA"""

    gitcommand = ['show', sha]
    return _git(gitcommand)


def get_patch_id(sha):
    """Get patch ID for given SHA"""

    commit = getcommit(sha)
    if not commit:
        return None

    gitcommand = ['patch-id']
    spid = _git(gitcommand, stdin=commit)
    if not spid:
        return None
    return spid.split(" ", 1)[0]


def get_fixes(sha):

    commit = getcommit(sha)
    if not commit:
        return None

    return re.findall(r'Fixes: (.*)', commit)


def findpatch(remote, branch, baseline, sha, subject):
    """ Return True if a patch is found in a branch, False otherwise"""

    release_branch = f'release-{branch}-chromeos-{baseline}'
    gitcommand = ['merge-base', '--is-ancestor', sha, f'{remote}/{release_branch}']
    result = _git(gitcommand)
    if result:
        return True

    # SHA is not in release branch. Search for it based on subject and patch ID.

    patch_id = get_patch_id(sha)
    if not patch_id:
        return False

    gitcommand = ['log', '--oneline', f'v{baseline}..{remote}/{release_branch}']
    commits = _git(gitcommand)
    if not commits:
        return False

    for commit in commits.splitlines():
        if subject in commit:
            ssha = commit.split(' ')[0]
            match_id = get_patch_id(ssha)
            if match_id == patch_id:
                return True

    return False


def check_release_branches(baseline, sha, subject):
    """Check if a patch is present in a release branch"""

    chromeos_remote = _find_remote(CHROMEOS_URLS)
    if chromeos_remote:
        contained = []
        not_contained = []
        for b in release_branches(chromeos_remote, baseline):
            release = b.split('-', maxsplit=1)[0]
            if findpatch(chromeos_remote, b, baseline, sha, subject):
                contained += [release]
            else:
                not_contained += [release]
        if not_contained:
            print('    Not in ' + ', '.join(not_contained))
        if contained:
            print('    In ' + ', '.join(contained))


def checkbranch(remote, baseline, subject, queued=False):
    """Check if a commit is present in a branch.

    Check if a commit described by its subject line is present
    in the provided remote and branch (identified by its baseline version
    number)
    """

    gitcommand = ['log', '--oneline', f'v{baseline}..{remote}/linux-{baseline}.y']
    commits = _git(gitcommand)

    # If the patch in not in an upstream stable release, try to find it in
    # a ChromeOS branch.
    if subject not in commits:
        chromeos_remote = _find_remote(CHROMEOS_URLS)
        if chromeos_remote:
            gitcommand = ['log', '--oneline', f'v{baseline}..{chromeos_remote}/chromeos-{baseline}']
            commits = _git(gitcommand)

    if not commits:
        return False

    for commit in commits.splitlines():
        if subject in commit:
            ssha = commit.split(' ')[0]
            isha = integrated(ssha)
            if not isha or isha == 'ToT':
                if queued:
                    print((f'  Expected to be fixed in chromeos-{baseline} '
                           f'with next stable release merge (sha {ssha})'))
                else:
                    print(f'  Fixed in chromeos-{baseline} (sha {ssha})')
                    check_release_branches(baseline, ssha, subject)
            elif not queued:
                print(f'  Fixed in chromeos-{baseline} with merge of {isha} (sha {ssha})')
                check_release_branches(baseline, ssha, subject)
            return True

    return False


def main(args):
    """Main entrypoint.

    Args:
        args: sys.argv[1:]

    Returns:
        An int return code.
    """

    parser = argparse.ArgumentParser()

    parser.add_argument('shas', nargs='+',
                        help='A valid SHA')

    args = vars(parser.parse_args(args))

    remote = _find_remote(STABLE_URLS)
    if remote:
        _git(['fetch', remote])
    else:
        print('Stable remote not found, results may be incomplete')

    queue_remote = _find_remote(STABLE_QUEUE_URLS)
    if queue_remote:
        _git(['fetch', queue_remote])
    else:
        print('Stable queue remote not found, results may be incomplete')

    chromeos_remote = _find_remote(CHROMEOS_URLS)
    if chromeos_remote:
        _git(['fetch', chromeos_remote])
    else:
        print('ChromeOS remote not found, results may be incomplete')

    # Try to find and fetch upstream
    upstream = _find_remote(UPSTREAM_URLS)
    if upstream:
        _git(['fetch', upstream])

    for sha in args['shas']:
        subject = _git(['show', '--pretty=format:%s', '-s', sha])
        if not subject:
            print(f'Subject not found for SHA {sha}')
            sys.exit(1)

        full_sha = _git(['show', '--pretty=format:%H', '-s', sha])
        if not full_sha:
            print(f'Failed to extract full SHA for SHA {sha}')
            sys.exit(1)

        ssha = full_sha[0:11]

        integrated_branch = integrated(ssha)
        if integrated_branch:
            print(f'Upstream commit {ssha} ("{subject}")')
            print(f'  Integrated in {integrated_branch}')
            fixes = get_fixes(ssha)
            for fix in fixes:
                print(f'  Fixes: {fix}')
                isha = fix.split(' ')[0]
                if isha:
                    introduced = integrated(isha)
                    if introduced:
                        print(f'    Introduced in {introduced}')
        else:
            # If the patch is not upstream, do not bother trying to find
            # ChromeOS branches.
            # FIXME: We should try to find non-upstream patches as well.
            print(f'Commit {ssha} ("{subject}")')
            print('  Not found in upstream kernel')
            continue

        for branch in BRANCHES:
            if compare_releases(integrated_branch, branch) > 0:
                if (not checkbranch(remote, branch, subject) and
                    (not queue_remote
                     or not checkbranch(queue_remote, branch, subject, queued=True))):
                    print(f'  Not in chromeos-{branch}')


if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))