#!/bin/bash

: ${MAGERC="/etc/mage.rc"}

source /etc/mage.rc.global
source ${MAGERC}
source ${MLIBDIR}/mage4.functions.sh
source ${MLIBDIR}/smage2.functions.sh

#### fixups ####
METADIR=/var/cache/mage/meta
#################

source ${MLIBDIR}/sql_functions.sh

die()
{
	echo -e "Exited ${BASH_SOURCE} at line no ${BASH_LINENO}."
	echo -e "$@"
	exit 1
}

sql()
{
	local sqlcmd="$*"
	[[ -z ${sqlcmd} ]] && die "no sqlcmd given."

	sqlite3 -nullvalue 'NULL' -list -separator '|' ${DBFILE} << EOF || die "error running '$@'"
${sqlcmd};
EOF
}

create_database_layout()
{
	sql "create table categories(id integer primary key, pcat text unique)"
	sql "create table packages(id integer primary key,
					pname text,
					pver text,
					pbuild text,
					pcat_id numeric,
					state text,
					provide text,
					pkgtype text
				)"
	sql "create table depends(id integer primary key, pkg_id numeric, relation text, pcat_id numeric, pname text, pver text, pbuild text)"
	sql "create table sdepends(id integer primary key, pkg_id numeric, relation text, pcat_id numeric, pname text, pver text, pbuild text)"
	sql "create table packages_info(id integer primary key, pkg_id numeric, arch text, md5 text, mtime numeric, homepage text, description text, size numeric)"
	#sql "create table packages_content(id integer primary key, pkginfo_id numeric, char text, dirs text, files text, pipes text, symlinks text)"
	sql "create table packages_content(id integer primary key, pkginfo_id numeric, char blob, dirs blob, files blob, pipes blob, symlinks blob)"
	sql "create table packages_routines(id integer primary key,
					pkg_id numeric,
					mincludes text,
					preinstall numeric,
					postinstall numeric,
					preremove numeric,
					postremove numeric,
					script text)"
}

convert_meta_db()
{
	local i
	local magefile
	local pcat
	local pname
	local pver
	local pbuild
	local pcatid
	local state
	local pkgid
	local dep
	local descriptiom
	local homepage
	local provide
	local pkgtype
	local preinstall
	local postinstall
	local preremove
	local postremove
	local sym
	local depname
	local depver
	local depbuild
	local depcat
	local depcatid
	local md5file
	local md5sum

	# create categories
	cat ${SMAGESCRIPTSDIR}/.known_categories | while read pcat
	do
		case ${pcat} in
			include|profiles) continue;;
		esac

		sql "insert into categories (pcat) values('${pcat}')"
	done

	# create packages
	for pkg in $(find ${METADIR} -mindepth 2 -maxdepth 2 -type d | sort)
	do
		case ${DEBUG} in
			1|true) echo "converting ${pkg}" ;;
		esac
		pcat="$(sed -n '2p' ${pkg}/meta)"
		pname="$(sed -n '1p' ${pkg}/meta)"
		pver="$(sed -n '3p' ${pkg}/meta)"
		pbuild="$(sed -n '4p' ${pkg}/meta)"
		state="$(sed -n '5p' ${pkg}/meta)"
		[[ -f ${pkg}/provides ]] && provide="$(< ${pkg}/provides)"
		pkgtype="$(sed -n '8p' ${pkg}/meta)"

		pcatid=$(sql "select id from categories where pcat='${pcat}'")
		sql "insert into packages(pname, pver, pbuild, pcat_id, state, provide, pkgtype )
				values('${pname}','${pver}','${pbuild}','${pcatid}','${state}','${provide}','${pkgtype}')"

		pkgid=$(sql "select id from packages where pname='${pname}' and pver='${pver}' and pbuild='${pbuild}'")

if [[ -f ${pkg}/depend ]]
then
		# depends
		while read sym dep
		do
			[[ -z ${dep} ]] && continue
			depcat="$(dep2pcat ${dep})"
			depcatid=$(sql "select id from categories where pcat='${depcat}'")
			depname="$(dep2pname ${dep})"
			depver="$(dep2pver ${dep})"
			sql "insert into depends(pkg_id, relation, pcat_id, pname, pver, pbuild)
					values('${pkgid}', '${sym}', '${depcatid}', '${depname}', '${depver}', '${depbuild}')"
		done << EOF
$(<${pkg}/depend)
EOF
fi

if [[ -f ${pkg}/sdepend ]]
then
		# sdepends
		while read sym dep
		do
			[[ -z ${dep} ]] && continue
			depcat="$(dep2pcat ${dep})"
			depcatid=$(sql "select id from categories where pcat='${depcat}'")
			depname="$(dep2pname ${dep})"
			depver="$(dep2pver ${dep})"
			sql "insert into sdepends(pkg_id, relation, pcat_id, pname, pver, pbuild)
					values('${pkgid}', '${sym}', '${depcatid}', '${depname}', '${depver}', '${depbuild}')"
		done << EOF
$(<${pkg}/sdepend)
EOF
fi

		for arch in i686 x86_64
		do
			if [[ -f ${pkg}/${arch}/desc ]]
			then
				md5sum="$(sed -n '1p' ${pkg}/${arch}/desc)"
				mtime="$(sed -n '3p' ${pkg}/${arch}/desc)"
				size="$(sed -n '2p' ${pkg}/${arch}/desc)"
			fi

			# fix descriptions
			description="$(sed -n '6p' ${pkg}/meta | sed s:\':\'\':g)"
			homepage="$(sed -n '7p' ${pkg}/meta)"

			sql "insert into packages_info(pkg_id, arch, md5, description, homepage, mtime, size)
				values('${pkgid}','${arch}','${md5sum}','${description}','${homepage}','${mtime}','${size}')"
		done

	# id, pkg_id, arch, md5, mtime, homepage, description, size


		mincludes="$(sed -n '10p' ${pkg}/meta)"

		#
		# install routines & includes
		#
# 		# needs special magic: the last line of typeset has no ';'
# 		# but to eval the function we must append it
# 		# so this sed deletes the last line of the typeset output
# 		# and replaces it with an ;} and a newline between
# 		#
# 		# but we will not add this fun when no postinstall etc are given
# 		# -> [[ -n $(typeset -f postinstall ]] &&
# 		#
# 		# also the character ' is a problem while importing to sql
# 		# because we use ' as escape char. so we replace it with ''
# 		#
# 		# $([[ -n $(typeset -f postinstall) ]] && echo -e "$(typeset -f postinstall | sed s:\':\'\':g | sed '$d');\n}")
# 		#
# 		sql "insert into packages_routines(pkg_id,
# 					mincludes,
# 					postinstall,
# 					preinstall,
# 					preremove,
# 					postremove)
# 				values('${pkgid}',
# 					'${mincludes}',
# 					'$([[ -n $(typeset -f postinstall) ]] && echo -e "$(typeset -f postinstall | sed s:\':\'\':g | sed '$d');\n}")',
# 					'$([[ -n $(typeset -f preinstall) ]] && echo -e "$(typeset -f preinstall | sed s:\':\'\':g | sed '$d');\n}")',
# 					'$([[ -n $(typeset -f preremove) ]] && echo -e "$(typeset -f preremove | sed s:\':\'\':g | sed '$d');\n}")',
# 					'$([[ -n $(typeset -f postremove) ]] && echo -e "$(typeset -f postremove | sed s:\':\'\':g | sed '$d');\n}")')"

		local do_preinst=0
		local do_postinst=0
		local do_prerm=0
		local do_postrm=0
		local do_script=0
		local script=""

		[[ -f ${pkg}/preinstall ]] && do_preinst=1 && do_script=1
		[[ -f ${pkg}/postinstall ]] && do_postinst=1 && do_script=1
		[[ -f ${pkg}/preremove ]] && do_prerm=1 && do_script=1
		[[ -f ${pkg}/postremove ]] && do_postrm=1 && do_script=1

		if [[ ${do_script} = 1 ]]
		then
			script="$(basename ${DBFILE} .sql).routines/${pkgid}/routines.sh"
			install -d $(dirname ${DBFILE})/$(dirname ${script})
			cat ${pkg}/routines.sh > $(dirname ${DBFILE})/${script}
			chmod 0755 $(dirname ${DBFILE})/${script}
		fi

		sql "insert into packages_routines(pkg_id,
					mincludes,
					postinstall,
					preinstall,
					preremove,
					postremove,
					script)
				values('${pkgid}',
					'${INHERITS}',
					'${do_postinst}',
					'${do_preinst}',
					'${do_prerm}',
					'${do_postrm}',
					'${script}')"

		unset state
		unset pkgtype
		unset md5sum
		unset mtime
		unset size
		unset description
		unset mincludes
		unset pname
		unset pver
		unset pbuild
		unset preinstall
		unset postinstall
		unset preremove
		unset postremove
	done
}


convert_install_db()
{
	local i
	local magefile
	local pcat
	local pname
	local pver
	local pbuild
	local pcatid
	local state
	local preinstall
	local postinstall
	local preremove
	local postremove
	local pkgid
	local dep
	local PKGNAME
	local STATE
	local DESCRIPTION
	local HOMEPAGE
	local DEPEND
	local SDEPEND
	local PROVIDE
	local PKGTYPE
	local preinstall
	local postinstall
	local preremove
	local postremove
	local sym
	local depname
	local depver
	local depbuild
	local depcat
	local depcatid
	local md5file
	local md5sum
	local pkginfoid
	local entrydir

	# create categories
	for i in virtual ${INSTALLDB}/*
	do
		pcat="$(basename ${i})"
		case ${pcat} in
			include|profiles) continue;;
		esac

		sql "insert into categories (pcat) values('${pcat}')"
	done

	# create packages
	for magefile in $(find ${INSTALLDB} -type f -name *.mage| sort)
	do
		case ${DEBUG} in
			1|true) echo "converting ${magefile}" ;;
		esac

		pcat="$(magename2pcat ${magefile})"
		pname="$(magename2pname ${magefile})"
		pver="$(magename2pver ${magefile})"
		pbuild="$(magename2pbuild ${magefile})"
		# substitute r from pbuild
		pbuild="${pbuild/r/}"

		smagesource ${magefile}

		pcatid=$(sql "select id from categories where pcat='${pcat}'")
		sql "insert into packages(
					pname,
					pver,
					pbuild,
					pcat_id,
					state,
					provide,
					pkgtype
					)
				values(
					'${pname}',
					'${pver}',
					'${pbuild}',
					'${pcatid}',
					'${STATE}',
					'${PROVIDE}',
					'${PKGTYPE}'
					)"

		pkgid=$(sql "select id from packages where pname='${pname}' and pver='${pver}' and pbuild='${pbuild}'")
		# depends
		while read sym dep
		do
			[[ -z ${dep} ]] && continue
			depcat="$(dep2pcat ${dep})"
			depcatid=$(sql "select id from categories where pcat='${depcat}'")
			depname="$(dep2pname ${dep})"
			depver="$(dep2pver ${dep})"
			sql "insert into depends(pkg_id,
						relation,
						pcat_id,
						pname,
						pver,
						pbuild)
					values('${pkgid}',
						'${sym}',
						'${depcatid}',
						'${depname}',
						'${depver}',
						'${depbuild}')"
		done << EOF
${DEPEND}
EOF
		# sdepends
		while read sym dep
		do
			[[ -z ${dep} ]] && continue
			depcat="$(dep2pcat ${dep})"
			depcatid=$(sql "select id from categories where pcat='${depcat}'")
			depname="$(dep2pname ${dep})"
			depver="$(dep2pver ${dep})"
			sql "insert into sdepends(pkg_id,
						relation,
						pcat_id,
						pname,
						pver,
						pbuild)
					values('${pkgid}',
						'${sym}',
						'${depcatid}',
						'${depname}',
						'${depver}',
						'${depbuild}')"
		done << EOF
${SDEPEND}
EOF

		DESCRIPTION="$(echo ${DESCRIPTION} | sed s:\':\'\':g)"
		sql "insert into packages_info(pkg_id, arch, md5, description, homepage)
			values('${pkgid}','${ARCH}','${md5sum}','${DESCRIPTION}','${HOMEPAGE}')"


		# install routines & includes
		sql "insert into packages_routines(pkg_id,
					mincludes,
					postinstall,
					preinstall,
					preremove,
					postremove)
				values('${pkgid}',
					'${mincludes}',
					'$(typeset -f postinstall | sed s:\':\'\':g)',
					'$(typeset -f preinstall | sed s:\':\'\':g)',
					'$(typeset -f preremove | sed s:\':\'\':g)',
					'$(typeset -f postremove | sed s:\':\'\':g)')"

		####           ####
		# record contents #
		####           ####
		pkginfoid=$(sql "select id from packages_info where pkg_id='${pkgid}' and arch='${ARCH}'")
		entrydir="$(dirname ${magefile})"
# 		sql "insert into packages_content(pkginfo_id,
# 						char,
# 						dirs,
# 						files,
# 						pipes,
# 						symlinks)
# 					values('${pkginfoid}',
# 						'$(< ${entrydir}/.char)',
# 						'$(< ${entrydir}/.dirs)',
# 						'$(< ${entrydir}/.files)',
# 						'$(< ${entrydir}/.pipes)',
# 						'$(< ${entrydir}/.symlinks)')"
		sql "insert into packages_content(pkginfo_id,
						char,
						dirs,
						files,
						pipes,
						symlinks)
					values('${pkginfoid}',
						'records/${pkginfoid}/char.bz2',
						'records/${pkginfoid}/dirs.bz2',
						'records/${pkginfoid}/files.bz2',
						'records/${pkginfoid}/pipes.bz2',
						'records/${pkginfoid}/symlinks.bz2')"
		# create compressed content files
		local entryfile
		for entryfile in char dirs files pipes symlinks
		do
			install -d $(dirname ${DBFILE})/records/${pkginfoid}
			cat ${entrydir}/.${entryfile} | bzip2 -9 >> $(dirname ${DBFILE})/records/${pkginfoid}/${entryfile}.bz2
		done

		unset PKGNAME
		unset DEPEND
		unset SDEPEND
		unset PROVIDE

		# unset these functions
		unset -f preinstall
		unset -f postinstall
		unset -f preremove
		unset -f postremove
	done
}

convert_virtual_defaults()
{
	local virtual
	local package
	local vcat
	local vname
	local pcat
	local pname

	sql "create table virtual_defaults(id integer primary key, vcat text,vname text, pcat text, pname text)"

	while read virtual package
	do
		vcat="$(dirname ${virtual})"
		vname="$(basename ${virtual})"
		pcat="$(dirname ${package})"
		pname="$(basename ${package})"

		sql "insert into virtual_defaults(vcat,vname,pcat,pname) values('${vcat}','${vname}','${pcat}','${pname}')"
	done < /etc/mage-profile/virtuals.defaults
}


# packages db
#DBFILE=/home/tjoke/DATABASES/mage6.sql
#create_database_layout
#convert_mage_db

# virtual default
#DBFILE=/home/tjoke/DATABASES/virtuals6.sql
#convert_virtual_defaults

# # install db
# DBFILE=/home/tjoke/DATABASES/install6.sql
# create_database_layout
# convert_install_db


METHOD="$1"
DBFILE="$2"

[[ -z ${METHOD} ]] && die "No method given. Use --install, --packages or --virtual for your appropiate task"
[[ -z ${DBFILE} ]] && die "No database given."

case $1 in
	--install|-i)
		create_database_layout
		convert_install_db
		;;
	--packages|-p)
		create_database_layout
		convert_meta_db
		;;
	--virtuals|-v)
		convert_virtual_defaults
		;;
	*) die "Unkown method." ;;
esac