#!/bin/bash
set -e

function echo_usage {
	echo "usage: mconfigure [options] <package>"
	echo "	-a <arch>"
	echo "	-c : configure"
	echo "	-d : compile"
	echo "	-p : pack default: do all"
	echo "	-o : support old Debian 7 format"
}

function check_unversioned {
	# has to be called in the projects base directory
	# result: "M" in stdout or nothing
	set -e
	
	# check if build is running in a sandbox
	if ! [ -f .cm.ignore ]
	then
		# we create one
		echo ".cm.ignore" > .cm.ignore
		echo "debian.*" >> .cm.ignore
		echo "up.*" >> .cm.ignore
	fi
	
	project=$(pwd)
	project=${project##*/}
	pushd .. >/dev/null
		mCM $project -b -an > /dev/null
		wc=$(wc $project.batch)
		rm $project.batch
		if [ "${wc:0:5}" != "0 0 0" ]
		then
			echo "M"
		fi
	popd >/dev/null
}

function set_build {
	set -e
	if [ -e .svn ]
	then
		version="0.0"
		build=$(svnversion)
		build=${build/:/-}
		build="$build$(check_unversioned)"
	elif [ -e .git ]
	then
		tag=$(git describe --tags --match "${paket}_*" 2>/dev/null) || true
		if test -z "$tag"
		then
			tag="0.0-0TOP"
		fi
		changes=$(check_unversioned)
		tag="$tag$changes"
		version=${tag%-*}
		version=${version##*_}
		build=${tag##*-}
	else
		echo "No configuration system found. Cannot determine version."
		exit 1
	fi
}

function check_version {
	set -e
	
	vline=$(head -1 debian/$paket.changelog)
	vline=${vline%-*}
	clversion=${vline#*(}
	if [ $version = "0.0" ]
	then
		version=$clversion
		return
	fi

	# do no check on a modified git repos
	if [ "${build: -1}" == "M" ]
	then
		return
	fi

	if [ "$clversion" != $version ]
	then
		echo "version mismatch: git: $version, changelog: $clversion"
		exit 1
	fi
}

if [ ! -d debian ]
then
	echo "run mconfigure in the project base directory with a debian directory in it!"
	exit 2
fi

configure=0
compile=0
pack=0
while getopts "a:cdpo" opt; do
	case $opt in
		a) ARCH=$OPTARG
			;;
		c) configure=1
			;;
		d)	compile=1
			;;
		p)	pack=1
			;;
		o)	oldpack="-Zgzip"
			;;
		\?) echo "Invalid option: -$OPTARG"
			echo_usage
			exit 1
			;;
		:) echo "Option -$OPTARG requires an argument."
			echo_usage
			exit 1
			;;
	esac
done
shift $((OPTIND -1))

if [ $# -lt 1 ]
then
	echo_usage
	exit 1
fi

paket=$1

# if nothing is selected, select all
if [ $configure -eq 0 -a $compile -eq 0 -a $pack -eq 0 ]
then
	configure=1
	compile=1
	pack=1
fi

if [ $configure -eq 1 ]
then
	# delete changelog and control
	rm debian/changelog debian/control 2>/dev/null || true
	
	# mconfigure builds 2 environment files: setenv.sh + rules.pre
	
	if [ -n "$ARCH" ]
	then
		arch_opt="-a $ARCH"
	fi
	dpkg-architecture $arch_opt > debian/setenv.sh
	echo "" > debian/rules.pre
	
	echo "paket=$paket" >> debian/setenv.sh
	echo "oldpack=\"$oldpack\"" >> debian/setenv.sh

	set_build
	check_version
	echo "version=$version" >> debian/setenv.sh
	echo "build=$build" >> debian/setenv.sh

	# get repository name
#	tmp=$(pwd)
#	pwd=${tmp##*/}
#	pwd=${pwd,,*}
#	echo "pwd=$pwd" >> debian/rules.pre

	echo "building $paket with build $version-$build"

	pushd debian >/dev/null
	# ./debian -------------------------------------

	ln -sf /usr/share/mbuild/rules .

	if [ -e tmp ]
	then
		rm -rf tmp
	fi

	# check for pre/post installation scripts
	if [ -f $paket.preinst ]
	then
		echo "add_inst_tgt += debian/tmp/DEBIAN/preinst" >> rules.pre
	fi
	if [ -f $paket.postinst ]
	then
		    echo "add_inst_tgt += debian/tmp/DEBIAN/postinst" >> rules.pre
	fi
	if [ -f $paket.prerm ]
	then
		    echo "add_inst_tgt += debian/tmp/DEBIAN/prerm" >> rules.pre
	fi
	if [ -f $paket.postrm ]
	then
		    echo "add_inst_tgt += debian/tmp/DEBIAN/postrm" >> rules.pre
	fi
	
	mkdir -p tmp/DEBIAN

	# add export to setenv.sh
	sed -i "s/^/export /" setenv.sh

	popd >/dev/null
	# ./. ---------------------------------------------

	# copy package control
	if [ -f debian/$paket.control ]
	then
		# proceed
		echo
	else
		echo "warning: control file not found"
		echo "  this file is necessary for any package production."
	fi
	
	# build prepare
	if [ -x debian/$paket.prepare ]
	then
		. debian/setenv.sh
		debian/$paket.prepare
	fi
	if [ -e debian/$paket.build ]
	then
		if [ -e ../build ]
		then
			rm -rf ../build
			mkdir ../build
		fi
		if grep -- "-prepare" debian/$paket.build >/dev/null
		then
			debian/rules sync
			debian/$paket.build -prepare
		fi
		# sync build dir
		. debian/setenv.sh
		debian/rules sync
		
		# executing prebuild
		if [ -x debian/$paket.prebuild ]
		then
			pushd ~/build >/dev/null
			debian/$paket.prebuild
			popd >/dev/null
		fi
	fi
	
	# pack prepare
	if [ -f debian/$paket.cp -a -f debian/$paket.control ]
	then
		echo "PACK=binary" >> debian/rules.pre
		if grep "^Architecture: *all" debian/$paket.control >/dev/null
		then
			echo "arch = all" >> debian/rules.pre
			echo "BINARY_INDEP = copy ../${paket}_$version-${build}_all.deb" >> debian/rules.pre
		else
			echo 'arch = ${DEB_HOST_ARCH}' >> debian/rules.pre
			echo "BINARY_ARCH = copy ../${paket}_$version-${build}_"'$(arch).deb' >> debian/rules.pre
		fi
	elif [ -f debian/$paket.cp ]
	then
		echo "PACK=zip" >> debian/rules.pre
	else
		echo "PACK=version" >> debian/rules.pre
	fi
fi

if [ $compile -eq 1 -a ! -e debian/$paket.build ]
then
	echo "no debian/$paket.build: skipping build step"
	compile=0
fi
if [ $compile -eq 1 ]
then
	# build artefacts
	. debian/setenv.sh
	debian/rules build
fi

if [ $pack -eq 1 ]
then
	# build package
	. debian/setenv.sh
	debian/rules pack
fi