#!/bin/bash

remote_repo=''
sru_cycle=
while :
do
	if [ "$1" = "--remote-repo" ]; then
		remote_repo="$2"
		shift 2

	elif [ "$1" = "--sru-cycle" ]; then
		sru_cycle="$2"
		shift 2

	else
		break
	fi
done
if [ "$#" -ne 0 ]; then
	{
		echo "Usage: $0 [<options>]"
		echo "       --remote-repo <url>"
		echo "       --sru-cycle <cycle>"
	} 1>&2
	exit 1
fi

default_sru_cycle()
{
	local tracking_bug
	local version

	# Pick out the cycle from the tracking bug file.
	if [ -f "$DEBIAN/tracking-bug" ]; then
		read tracking_bug sru_cycle X <"$DEBIAN/tracking-bug"
	fi

	if [ -z "$sru_cycle" ]; then
		echo "$0: sru-cycle not found via debian/tracking-bug; specify --sru-cycle" 1>&2
		exit 1
	fi

	sru_cycle=$(echo "$sru_cycle" | sed -e 's/-[0-9][0-9]*$//' -e 's/^kernel-sru-cycle-//')

	#echo "default_sru_cycle: version<$version> sru_cycle<$sru_cycle>"
}

# Determine where our changelog is.
DEBIAN=debian
[ -f 'debian/debian.env' ] && . 'debian/debian.env'

[ -z "$sru_cycle" ] && default_sru_cycle
if [ -z "$remote_repo" ]; then
	case "$sru_cycle" in
	s[0-9][0-9][0-9][0-9].[0-9][0-9].[0-9][0-9])
		remote_repo='security' ;;
	*)
		remote_repo='main' ;;
	esac
fi
case "$remote_repo" in
security)
	remote_repo='ssh+git://git.launchpad.net/~canonical-kernel-security-team/canonical-kernel-private/+git/kernel-versions'
	remote_name='security'
	;;
main)
	remote_repo='git://git.launchpad.net/~canonical-kernel/+git/kernel-versions'
	remote_name='main'
	;;
*)
	remote_name='adhoc'
	;;
esac

#
# kernel-versoins repository dkms-version mapping see below for details:
#  https://git.launchpad.net/~canonical-kernel/+git/kernel-versions/plain/README
#
kv_repo="$HOME/.cache/kernel-versions-bare"
git_base="$remote_name/$sru_cycle"

# Now we know where our repo is and what it called update it.
# We maintain "persistent" remotes for main and security, but assume
# any manually supplied entries are transient.
(
	[ ! -d "$kv_repo" ] && mkdir -p "$kv_repo"
	cd "$kv_repo" || exit 1
	[ ! -f config ] && git init -q --bare
	current_url=$(git config "remote.$remote_name.url")
	if [ -z "$current_url" ]; then
		git remote add "$remote_name" "$remote_repo"
	elif [ "$current_url" != "$remote_repo" ]; then
		git config "remote.$remote_name.url" "$remote_repo"
	fi
	git fetch -q -p "$remote_name"
) || exit 1

cat_file()
{
	(cd "$kv_repo" && git cat-file "$@") || exit 1
}

# Determine if we have this cycle.
present=$(cat_file -t "$git_base" 2>/dev/null)
if [ "$present" = "" ]; then
	# If we don't have the cycle in the development cycle then
	# fall back to master.
	case "$sru_cycle" in
	d*)	git_base="$remote_name/master" ;;
	*)	echo "$sru_cycle: cycle not found in $remote_repo" 2>&1
		exit 1
		;;
	esac
fi

# Determine our series and mainline version from our own changelog.
our_series=$(LC_ALL=C dpkg-parsechangelog -l"$DEBIAN/changelog" -SDistribution)
if [ "$our_series" = "UNRELEASED" ]; then
	our_series=$(LC_ALL=C dpkg-parsechangelog -l"$DEBIAN/changelog" -o1 -c1 -SDistribution)
fi
our_mainline=$(LC_ALL=C dpkg-parsechangelog -l"$DEBIAN/changelog" -SVersion | sed -e 's/-.*//')

# Update rules are complex.  We update development series kernels to the
# versions in development.  For stable series we update versions against
# the series in which our prime kernel was built.  This is expressed
# via the map/dkms-versions namespace.  Attempt to map via our series
# and then our mainline-version.

# Attempt to map via our series, if that works assume we are development.
versions_path=$(cat_file -p "$git_base:map/dkms-versions/$our_series" 2>/dev/null)

# If we do not yet have a mapping re-map using our mainline version.
if [ -z "$versions_path" ]; then
	versions_path=$(cat_file -p "$git_base:map/dkms-versions/$our_mainline")
fi

echo "git_base<$git_base> versions_path<$versions_path>"
echo "II: grabbing dkms-versions from $sru_cycle $versions_path"

cat_file -p "$git_base:$versions_path" >"debian/dkms-versions.new"
rc="$?"
if [ "$rc" -ne 0 ]; then
	echo "$0: unable to download an updated dkms-versions file" 1>&2
	exit 1

elif [ "$rc" -eq 0 ]; then
	mv "debian/dkms-versions.new" "debian/dkms-versions"

else
	rm -f "debian/dkms-versions.new"
fi

thing="debian/dkms-versions"
if ! git diff --exit-code -- "$thing" >/dev/null; then
	git commit -m "UBUNTU: $thing -- update from kernel-versions ($git_base)" \
		-m "BugLink: https://bugs.launchpad.net/bugs/1786013" \
		-s -- "$thing"
else
	echo "$thing: no changes from kernel-versions"
fi

exit "$rc"