#!/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())