#!/usr/bin/env python3
# Copyright (c) 2023, the R8 project authors. Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.

import subprocess
import sys
import re
import r8_release


class Branch:

    def __init__(self, name, first, last=None):
        self.name = name
        self.first = first
        self.last = last  # optional last for testing purposes.

    def origin(self):
        return "origin/%s" % self.name

    def last_or_origin(self):
        return self.last if self.last else self.origin()

    def __str__(self):
        return self.name


# The initial commit is the furthest back we need to search on main.
# Currently, it is the merge point of main onto 4.0.23-dev
MAIN = Branch('main', 'a2e203580aa00a36f85cd68d3d584b97aef34d59')
OLDEST_BRANCH_VERSION = (4, 0)
DEV_BRANCH_VERSION = [int(s) for s in r8_release.R8_DEV_BRANCH.split('.')]

# List of change ids that should not be reported.
IGNORED = ['I92d7bf3afbf609fdea21683941cfd15c90305cf2']

VERBOSE = False


# Helper to call and decode a shell command.
def run_cmd(cmd):
    if VERBOSE:
        print(' '.join(cmd))
    return subprocess.check_output(cmd).decode('UTF-8')


# Comparator on major and minor branch versions.
def branch_version_less_than(b1, b2):
    if b1[0] < b2[0]:
        return True
    if b1[0] == b2[0] and b1[1] < b2[1]:
        return True
    return False


# Find all release branches between OLDEST_BRANCH and DEV_BRANCH
def get_release_branches():
    # Release branches are assumed to be of the form 'origin/X.Y'
    out = run_cmd(['git', 'branch', '-r', '-l'])
    pattern = re.compile('origin/(\d+).(\d+)')
    releases = []
    for line in out.split('\n'):
        m = pattern.search(line.strip())
        if m:
            major = m.group(1)
            minor = m.group(2)
            if major and minor:
                candidate = (int(major), int(minor))
                if branch_version_less_than(candidate, OLDEST_BRANCH_VERSION):
                    continue
                if branch_version_less_than(candidate, DEV_BRANCH_VERSION):
                    releases.extend(find_dev_cutoff(candidate))
    return releases


# Find the most recent commit hash that is for a -dev version.
# This is the starting point for the map of commits after cutoff from main.
def find_dev_cutoff(branch_version):
    out = run_cmd([
        'git',
        'log',
        'origin/%d.%d' % branch_version,
        '--grep',
        'Version .*-dev',
        '--pretty=oneline',
    ])
    # Format of output is: <hash> Version <version>-dev
    try:
        hash = out[0:out.index(' ')]
        return [Branch('%d.%d' % branch_version, hash)]
    except ValueError:
        throw_error("Failed to find dev cutoff for branch %d.%d" %
                    branch_version)


# Build a map from each "Change-Id" hash to the hash of its commit.
def get_change_id_map(branch):
    out = run_cmd(
        ['git', 'log',
         '%s..%s' % (branch.first, branch.last_or_origin())])
    map = {}
    current_commit = None
    for line in out.split('\n'):
        if line.startswith('commit '):
            current_commit = line[len('commit '):]
            assert len(current_commit) == 40
        elif line.strip().startswith('Change-Id: '):
            change_id = line.strip()[len('Change-Id: '):]
            assert len(change_id) == 41
            map[change_id] = current_commit
    return map


# Check if a specific commit is present on a specific branch.
def is_commit_in(commit, branch):
    out = run_cmd(
        ['git', 'branch', '-r',
         branch.origin(), '--contains', commit])
    return out.strip() == branch.origin()


def main():
    found_errors = False
    # The main map is all commits back to the "init" point.
    main_map = get_change_id_map(MAIN)
    # Compute the release branches.
    release_branches = get_release_branches()
    # Populate the release maps with all commits after the last -dev point.
    release_maps = {}
    for branch in release_branches:
        release_maps[branch.name] = get_change_id_map(branch)
    # Each branch is then compared forwards with each subsequent branch.
    for i in range(len(release_branches)):
        branch = release_branches[i]
        newer_branches = release_branches[i + 1:]
        if (len(newer_branches) == 0):
            print('Last non-dev release branch is %s, nothing to check.' %
                  branch)
            continue
        print('Checking branch %s.' % branch)
        changes = release_maps[branch.name]
        cherry_picks_count = 0
        for change in changes.keys():
            is_cherry_pick = False
            missing_from = None
            commit_on_main = main_map.get(change)
            for newer_branch in newer_branches:
                if change in release_maps[newer_branch.name]:
                    is_cherry_pick = True
                    # If the change is in the release mappings check for holes.
                    if missing_from:
                        found_errors |= change_error(
                            change, 'Error: missing Change-Id %s on branch %s. '
                            'Is present on %s and again on %s.' % (
                                change,
                                missing_from,
                                branch,
                                newer_branch,
                            ))
                elif commit_on_main:
                    is_cherry_pick = True
                    # The change is not in the non-dev part of the branch, so we need to
                    # check that the fork from main included the change.
                    if not is_commit_in(commit_on_main, newer_branch):
                        found_errors |= change_error(
                            change, 'Error: missing Change-Id %s on branch %s. '
                            'Is present on %s and on main as commit %s.' %
                            (change, newer_branch, branch, commit_on_main))
                else:
                    # The change is not on "main" so we just record for holes on releases.
                    missing_from = newer_branch
            if is_cherry_pick:
                cherry_picks_count += 1
        print('Found %d cherry-picks (out of %d commits).' %
              (cherry_picks_count, len(changes)))

    if found_errors:
        return 1
    return 0


def change_error(change, msg):
    if change in IGNORED:
        return False
    error(msg)
    return True


def throw_error(msg):
    raise ValueError(msg)


def error(msg):
    print(msg, file=sys.stderr)


if __name__ == '__main__':
    sys.exit(main())