#!/bin/bash

# Simple script to make use of the data produced by "audit" script
# (which determines parents of stable commits and tags of parents)
# You *have* to run the audit script on release X before you can
# use this script to analyse the audit data for release X.
#
# Audit data is used to analyse whether the commit should be considered
# for placement on the tree of interest, or whether it can be ruled
# out immediately by nature of being already present.
#
# Also determine if the parent happens to be already cherry picked into
# the stable release of interest, or in a queue of commits already
# selected, but not yet tagged and released.
#
# You start by running this once against your own stable tree and store
# that away in MYSTABLE_AUDIT -- this creates a baseline list of existing
# stable commits in your tree and what ".x" that they appeared in (this
# may seem pointless but will be used when you start auditing other
# stable trees to compare to what is in your tree.)
#
# The idea is that you run this once, and then manually update the
# output for 1 or 2 kooky commits that don't have clear parentage.
#
# If another dot/extraversion is released since this was run, you
# should specify a start extraversion and then just append the new
# data to your existing data for all the previous extraversions.
#

# My working tree version, i.e. where I want to add commits
MYSTABLE=34

# Where to find the output of this script for $MYSTABLE itself
# We use this data to rule out parent commits that are already cherry
# picked onto a tagged $MYSTABLE.x release.  (This can be an empty
# file to avoid a chicken and egg when 1st auditing your own stable tree).
MYSTABLE_AUDIT=../00-audit_$MYSTABLE/analyse.txt

# Where to find a list of parent commit IDs that have already been poached
# and queued, that we should skip over when running this audit. (i.e. if
# auditing v2.6.35, we want to skip what we've already stolen from v2.6.32)
MYQUEUE=../00-audit_32/stolen-from-32-stable

# Another stable tree that I want to look at for candidate commits
VER=v2.6.$1

if [ -z "$1" ];then
	echo "Usage: analyse <VERSION> [<EXTRAVERSION>]"
	echo -e \\t example: \"analyse 32 26\"
	echo -e \\t will examine v2.6.32 commits added after v2.6.32.26
	echo -e \\t Starts at EXTRAVERSION=0 if not specified.
	echo -e \\t Current destination tree is v2.6.$MYSTABLE - edit script to change.
	exit 1
fi

git rev-parse --verify --quiet $VER > /dev/null
if [ $? != 0 ]; then
	echo $ver does not appear to be a valid tag.
	exit 1
fi

if [ -n "$2" ];then
        START=$2
else
        START=0
fi

# How many dot releases are there?
DOTS=`git tag |grep $VER'\.[0-9]\+'|wc -l`

if [ $DOTS -eq 0 ];then
	echo there doesnt appear to be stable EXTRAVERSION tags for $VER here
	exit 1
fi

if [ -n "$2" ];then
	START=$2
else
	START=0
fi

i=$START
while [ $i -lt $DOTS ] ; do
	if [ $i -eq 0 ]; then
		LAST=$VER
	else
		LAST=$VER.$i
	fi
	i=$[$i+1]
	THIS=$VER.$i
	# Note the commit ID for the version change in the Makefile
	MAKEFILE=`git rev-list ^$THIS^ $THIS|sed 's/\(^.\{8\}\).*/\1/'`
	echo ---- $VER.$i ----
	echo -e Commit\\t\\tParent\\t\\tParent in\\tIn $MYSTABLE.x\\t\\tNotes
	echo ========================================================================
	for j in `git rev-list  $LAST..$THIS | sed 's/\(^.\{8\}\).*/\1/'` ; do
		FOUND=0
		DOT=""
		DOT_COMMIT=""
		STABLE=""
		PARENT=`cat $THIS/$j/parent | sed 's/\(^.\{8\}\).*/\1/'`
		LEN=`cat $THIS/$j/parent|wc -c`
		TAG=`cat $THIS/$j/tag-contains | grep -v v2\.6\.[123][0-9][\.-]| grep -v v3\.[0-9]*[\.-] | head -n1`
		# this will round up a X-rcN release to a yet unreleased "X"
		if [ -z "$TAG" ]; then
			TAG=`cat $THIS/$j/tag-contains | head -n1`
			TAG=`echo $TAG|sed 's/-rc[0-9]*//'`
		fi

		# imagine we are in dev cycle and there is no "tag --contains" yet.
		if [ -f $THIS/$j/tag-contains ] && [ ! -s $THIS/$j/tag-contains ]; then
			L=`git tag|grep -v -- -rc |tail -n1 `
			MINOR=`echo $L|sed 's/.*\.\([0-9]*\)$/\1/'`
			NMINOR=$[$MINOR+1]
			TAG=`echo $L |sed s/$MINOR$/$NMINOR/`
		fi

		echo -ne $j \\t

		if [ "$j" = "$MAKEFILE" ]; then
			echo -e xxxxxxxx\\t-- \? -- \\tn/a\\tMakefile ver. change
			continue
		fi

		grep -q unknown $THIS/$j/parent
		if [ $? = 0 ]; then
			echo -e xxxxxxxx\\t-- \? -- \\t\?
			continue
		fi

		# Check for garbage strings that arent SHA.
		if [ "$LEN" != "41" ]; then
			echo -e xxxxxxxx\\t-- \? -- \\t\?
			continue
		fi

		echo -ne $PARENT\\t

		if [ "$TAG" != "" ]; then
			echo -ne $TAG\\t\\t
		else
			echo -ne ???????\\t\\t
		fi

		grep -q v2.6.$MYSTABLE $THIS/$j/tag-contains
		if [ $? = 0 ] ; then
			FOUND=1
		fi

		# Check the already tagged commits on our own stable tree.
		if [ $FOUND = 0 ] ; then
			DOT=`grep $PARENT $MYSTABLE_AUDIT|awk '{print $5}'`
			DOT_COMMIT=`grep $PARENT $MYSTABLE_AUDIT|awk '{print $1}'`
			if [ "$DOT" != "" ]; then
				STABLE="\\t$DOT $DOT_COMMIT"
				FOUND=1
			fi
		fi
		# Check things already stolen and queued from other stable
		if [ $FOUND = 0 ] ; then
			grep -q $PARENT $MYQUEUE
			if [ $? = 0 ]; then
				STABLE="\\tin queue already"
				FOUND=1
			fi
		fi

		# Check to see if we are just auditing ourself for a baseline
		if [ "$MYSTABLE" = "$1" ] ; then
			STABLE="\\t$MYSTABLE.$i"
			FOUND=1
		fi

		if [ $FOUND = 1 ] ; then
			echo -e y$STABLE
		else
			echo n
		fi
	done
done