# slackware-specific packaging functions

# tiny_make_package
tiny_make_package() {
	PACKAGE_NAME=$1
	TARGET_NAME=$(dirname "$PACKAGE_NAME")
	PACKAGE_NAME=$(basename "$PACKAGE_NAME")
	SHORT_NAME=$(basename "$PACKAGE_NAME" ".$PKG_FORMAT")
	umask 022
	echo ""
	
	if [[ "$EUID" = "0" ]] ; then
		${TAR} cvf "$SHORT_NAME".tar .
	else
		${TAR} --owner=root --group=root -cvf "$SHORT_NAME".tar .
	fi
	echo ""
	
	if [[ "$PKG_FORMAT" = "tgz" ]] ; then
		LONG_NAME=$SHORT_NAME.tar.gz
		echo "Compressing $SHORT_NAME.tar using gzip..."
		gzip -9 $SHORT_NAME.tar
	elif [[ "$PKG_FORMAT" = "tbz" ]] ; then
		LONG_NAME=$SHORT_NAME.tar.bz2
		echo "Compressing $SHORT_NAME.tar using bzip2..."
		bzip2 $SHORT_NAME.tar
	elif [[ "$PKG_FORMAT" = "tlz" ]] ; then
		LONG_NAME=$SHORT_NAME.tar.lzma
		echo "Compressing $SHORT_NAME.tar using lzma..."
		lzma $SHORT_NAME.tar
	elif [[ "$PKG_FORMAT" = "txz" ]] ; then
		LONG_NAME=$SHORT_NAME.tar.xz
		echo "Compressing $SHORT_NAME.tar using xz(lzma-2)..."
		xz $SHORT_NAME.tar
	fi
	
	echo "Renaming $LONG_NAME to $PACKAGE_NAME..."
	mv "$LONG_NAME" "$PACKAGE_NAME"
	
	if [[ ! "$TARGET_NAME" = "." ]]; then
		echo "Moving $PACKAGE_NAME to $TARGET_NAME"
		mv "$PACKAGE_NAME" "$TARGET_NAME"
	fi
}

# Internal Routines
mini_installpkg_slack() {
THIS_PACKAGE="$1"
THIS_PACKAGE_BASENAME="${THIS_PACKAGE##*/}"
THIS_PACKAGE_SHORT_NAME="${THIS_PACKAGE_BASENAME%.*}"
echo $BLUE"Installing package "$NORMAL"${THIS_PACKAGE_BASENAME}"
case "$PKG_FORMAT" in
	tgz) PKG_COMPRESSOR=gzip ;;
	tbz) PKG_COMPRESSOR=bzip2 ;;
	tlz) PKG_COMPRESSOR=lzma ;;
	txz) PKG_COMPRESSOR=xz ;;
esac
# ( cd  ; ${TAR} -xzlUpvf - ) < $PACKAGE 2> /dev/null
# ( cd  ; ${TAR} -xlUpv --use-compress-program $PKG_COMPRESSOR -f - ) < $PACKAGE 2> /dev/null
${TAR} -xlUpv -C / --use-compress-program $PKG_COMPRESSOR -f "$THIS_PACKAGE" 2> /dev/null

DATABASE_FILE=$ADM_DIR_NAME/packages/"$THIS_PACKAGE_SHORT_NAME"
make_database
if [[ -f install/$PKG_POSTINST ]] ; then
	echo "Executing install script for $SHORT_NAME..."
	( cd / ; sh install/$PKG_POSTINST -install; )
fi

if [[ -x /sbin/ldconfig ]] && [[ $ROOT = "" ]] ; then
    /sbin/ldconfig
fi

if [[ -d install ]] ; then
	if [[ -f /etc/kiss-version ]] ; then
		if [[ -r install/$PKG_POSTINST ]] ; then
			cp install/$PKG_POSTINST $ADM_DIR_NAME/postinst/"$THIS_PACKAGE_SHORT_NAME"
			chmod 644 $ADM_DIR_NAME/postinst/"$THIS_PACKAGE_SHORT_NAME"
		fi
		if [[ -r install/$PKG_PREINST ]] ; then
			cp install/$PKG_PREINST $ADM_DIR_NAME/preinst/"$THIS_PACKAGE_SHORT_NAME"
			chmod 644 $ADM_DIR_NAME/preinst/"$THIS_PACKAGE_SHORT_NAME"
		fi
		if [[ -r install/$PKG_POSTRM ]] ; then
			cp install/$PKG_POSTRM $ADM_DIR_NAME/postrm/"$THIS_PACKAGE_SHORT_NAME"
			chmod 644 $ADM_DIR_NAME/postrm/"$THIS_PACKAGE_SHORT_NAME"
		fi
		if [[ -r install/$PKG_PRERM ]] ; then
			cp install/$PKG_PRERM $ADM_DIR_NAME/prerm/"$THIS_PACKAGE_SHORT_NAME"
			chmod 644 $ADM_DIR_NAME/prerm/"$THIS_PACKAGE_SHORT_NAME"
		fi
		if [[ -r install/$PKG_REQUIRED ]] ; then
			cp install/$PKG_REQUIRED $ADM_DIR_NAME/required/"$THIS_PACKAGE_SHORT_NAME"
			chmod 644 $ADM_DIR_NAME/required/"$THIS_PACKAGE_SHORT_NAME"
		fi
		if [[ -r install/$PKG_PROVIDES ]] ; then
			cp install/$PKG_PROVIDES $ADM_DIR_NAME/provides/"$THIS_PACKAGE_SHORT_NAME"
			chmod 644 $ADM_DIR_NAME/provides/"$THIS_PACKAGE_SHORT_NAME"
		fi
	else
		if [[ -r install/$PKG_POSTINST ]]; then
			cp install/$PKG_POSTINST $ADM_DIR_NAME/scripts/"$THIS_PACKAGE_SHORT_NAME"
			chmod 755 $ADM_DIR_NAME/scripts/"$THIS_PACKAGE_SHORT_NAME"
		fi
    fi
    ( cd install ; rm -f $PKG_POSTINST slack-* pkg-* *desc *required *provides *suggests *conflicts 1> /dev/null 2>&1 )
    rmdir install 1> /dev/null 2>&1
fi
}

make_slack_pkg() {
# package segregated packages if they exist
	if [[ -d "$PKG_BUILDS_DIR"/$DEVEL_PKG_NAME ]] ; then
		rm -f "$DEVEL_PACKAGE"
		( cd "$PKG_BUILDS_DIR"/$DEVEL_PKG_NAME
			echo -n $BLUE"Creating package: "$NORMAL"${DEVEL_PACKAGE##*/} - "
			mkdir -p install
			if [[ ! -f install/$PKG_POSTINST ]] ; then
				# check for needed links
				duplicate_pkg_dir_links
				( make_doinst_links "$PKG_BUILDS_DIR"/$I18N_PKG_NAME ) &> /dev/null
				if [[ -e "$CWD"/doinst.links ]] ; then
					cat "$CWD"/doinst.links >> install/$PKG_POSTINST
					rm -f "$CWD"/doinst.links
					find * -type l -exec rm -f {} \;
				fi
			fi
			if [[ -f $PATCHES_DIR/$NAME-patches/$PKG_DESC.$NAME-devel ]] ; then
				cp $PATCHES_DIR/$NAME-patches/$PKG_DESC.$NAME-devel install/$PKG_DESC
			elif [[ -f $CWD/$PKG_DESC.$NAME-devel ]] ; then
				cp $CWD/$PKG_DESC.$NAME-devel install/$PKG_DESC
			else
				echo "$NAME-devel: $NAME-devel Development headers and Libraries from $NAME" > install/$PKG_DESC
				echo "$NAME-devel:" >> install/$PKG_DESC
				echo "$NAME-devel: This package contains the development headers and libraries from $NAME" >> install/$PKG_DESC
				for i in {1..7} ; do
					echo "$NAME-devel:" >> install/$PKG_DESC
				done
				echo "$NAME-devel: $SIGNATURE" >> install/$PKG_DESC
			fi
			# create the child package
			tiny_make_package "$DEVEL_PACKAGE" &> /dev/null
			if [[ -f "$DEVEL_PACKAGE" ]] ; then
				echo $GREEN"Done"$NORMAL
				[[ $REALLY_INSTALL = "YES" ]] && really_install "$DEVEL_PACKAGE"
			else
				echo $RED"Failed!"$NORMAL
			fi
		)
		! [[ $DEBUG ]] && (cd "$PKG_BUILDS_DIR" && rm -rf $DEVEL_PKG_NAME)
	fi
	if [[ -d "$PKG_BUILDS_DIR"/$I18N_PKG_NAME ]] ; then
		rm -f "$I18N_PACKAGE"
		( cd "$PKG_BUILDS_DIR"/$I18N_PKG_NAME
			echo -n $BLUE"Creating package: "$NORMAL"${I18N_PACKAGE##*/} - "
			mkdir -p install
			if [[ ! -f install/$PKG_POSTINST ]] ; then
				# check for needed links
				duplicate_pkg_dir_links
				( make_doinst_links "$PKG_BUILDS_DIR"/$I18N_PKG_NAME ) &> /dev/null
				if [[ -e "$CWD"/doinst.links ]] ; then
					cat "$CWD"/doinst.links >> install/$PKG_POSTINST
					rm -f "$CWD"/doinst.links
					find * -type l -exec rm -f {} \;
				fi
			fi
			if [[ -f $PATCHES_DIR/$NAME-patches/$PKG_DESC.$NAME-i18n ]] ; then
				cp $PATCHES_DIR/$NAME-patches/$PKG_DESC.$NAME-i18n install/$PKG_DESC
			elif [[ -f $CWD/$PKG_DESC.$NAME-i18n ]] ; then
				cp $CWD/$PKG_DESC.$NAME-i18n install/$PKG_DESC
			else
				echo "$NAME-i18n: $NAME-i18n Language files for $NAME" > install/$PKG_DESC
				echo "$NAME-i18n:" >> install/$PKG_DESC
				echo "$NAME-i18n: This package contains the language files for: $NAME" >> install/$PKG_DESC
				for i in {1..7} ; do
					echo "$NAME-i18n:" >> install/$PKG_DESC
				done
				echo "$NAME-i18n: $SIGNATURE" >> install/$PKG_DESC
			fi
			# create the child package
			tiny_make_package "$I18N_PACKAGE" &> /dev/null
			if [[ -f "$I18N_PACKAGE" ]] ; then
				echo $GREEN"Done"$NORMAL
				[[ $REALLY_INSTALL = "YES" ]] && really_install "$I18N_PACKAGE"
			else
				echo $RED"Failed!"$NORMAL
			fi
		)
		! [[ $DEBUG ]] && (cd "$PKG_BUILDS_DIR" && rm -rf $I18N_PKG_NAME)
	fi
	if [[ -d "$PKG_BUILDS_DIR"/$SOLIBS_PKG_NAME ]] ; then
		rm -f "$SOLIBS_PACKAGE"
		( cd "$PKG_BUILDS_DIR"/$SOLIBS_PKG_NAME
			echo -n $BLUE"Creating package: "$NORMAL"${SOLIBS_PACKAGE##*/} - "
			mkdir -p install
			if [[ ! -f install/$PKG_POSTINST ]] ; then
				# check for needed links
				duplicate_pkg_dir_links
				( make_doinst_links "$PKG_BUILDS_DIR"/$SOLIBS_PKG_NAME ) 1> /dev/null
				if [[ -e "$CWD"/doinst.links ]] ; then
					cat "$CWD"/doinst.links >> install/$PKG_POSTINST
					rm -f "$CWD"/doinst.links
					find * -type l -exec rm -f {} \;
				fi
			fi
			if [[ -f $PATCHES_DIR/$NAME-patches/$PKG_DESC.$NAME-solibs ]] ; then
				cp $PATCHES_DIR/$NAME-patches/$PKG_DESC.$NAME-solibs install/$PKG_DESC
			elif [[ -f $CWD/$PKG_DESC.$NAME-solibs ]] ; then
				cp $CWD/$PKG_DESC.$NAME-solibs install/$PKG_DESC
			else
				echo "$NAME-solibs: $NAME-solibs Runtime libraries from $NAME" > install/$PKG_DESC
				echo "$NAME-solibs:" >> install/$PKG_DESC
				echo "$NAME-solibs: This package contains the runtime libraries from: $NAME" >> install/$PKG_DESC
				for i in {1..7} ; do
					echo "$NAME-solibs:" >> install/$PKG_DESC
				done
				echo "$NAME-solibs: $SIGNATURE" >> install/$PKG_DESC
			fi
			# create the child package
			tiny_make_package "$SOLIBS_PACKAGE" &> /dev/null
			if [[ -f "$SOLIBS_PACKAGE" ]] ; then
				echo $GREEN"Done"$NORMAL
				[[ $REALLY_INSTALL = "YES" ]] && really_install "$SOLIBS_PACKAGE"
			else
				echo $RED"Failed!"$NORMAL
			fi
		)
		! [[ $DEBUG ]] && (cd "$PKG_BUILDS_DIR" && rm -rf $SOLIBS_PKG_NAME)
	fi
	
	
	if [[ -d "$PKG_BUILDS_DIR"/$DOCS_PKG_NAME ]] ; then
		rm -f "$DOCS_PACKAGE"
		( cd "$PKG_BUILDS_DIR"/$DOCS_PKG_NAME
			echo -n $BLUE"Creating package: "$NORMAL"${DOCS_PACKAGE##*/} - "
			mkdir -p install
			if [[ ! -f install/$PKG_POSTINST ]] ; then
				# check for needed links
				duplicate_pkg_dir_links
				( make_doinst_links "$PKG_BUILDS_DIR"/$DOCS_PKG_NAME ) 1> /dev/null
				if [[ -e "$CWD"/doinst.links ]] ; then
					cat "$CWD"/doinst.links >> install/$PKG_POSTINST
					rm -f "$CWD"/doinst.links
					find * -type l -exec rm -f {} \;
				fi
			fi
			if [[ -f $PATCHES_DIR/$NAME-patches/$PKG_DESC.$NAME-docs ]] ; then
				cp $PATCHES_DIR/$NAME-patches/$PKG_DESC.$NAME-docs install/$PKG_DESC
			elif [[ -f $CWD/$PKG_DESC.$NAME-docs ]] ; then
				cp $CWD/$PKG_DESC.$NAME-docs install/$PKG_DESC
			else
				echo "$NAME-docs: Document files for $NAME" > install/$PKG_DESC
				echo "$NAME-docs:" >> install/$PKG_DESC
				echo "$NAME-docs: This package contains the documentation for: $NAME" >> install/$PKG_DESC
				for i in {1..7} ; do
					echo "$NAME-docs:" >> install/$PKG_DESC
				done
				echo "$NAME-docs: $SIGNATURE" >> install/$PKG_DESC
			fi
			# create the child package
			tiny_make_package "$DOCS_PACKAGE" &> /dev/null
			if [[ -f "$DOCS_PACKAGE" ]] ; then
				echo $GREEN"Done"$NORMAL
				[[ $REALLY_INSTALL = "YES" ]] && really_install "$DOCS_PACKAGE"
			else
				echo $RED"Failed!"$NORMAL
			fi
		)
		! [[ $DEBUG ]] && (cd "$PKG_BUILDS_DIR" && rm -rf $DOCS_PKG_NAME)
	fi
	
	# create the main package
	rm -f "$PACKAGE"
	echo -n $BLUE"Creating package: "$NORMAL"${PACKAGE##*/} - "
	if [[ $QUIET = "YES" ]] ; then
		cd "$PKG_DIR" ;
		tiny_make_package "$PACKAGE" &> /dev/null
	else
		cd "$PKG_DIR" ;
		echo ""
		tiny_make_package "$PACKAGE"
	fi
	if [[ -f "$PACKAGE" ]] ; then
		echo $GREEN"Done"$NORMAL
		if [[ "$CREATE_MD5_CHECKSUM" = "YES" ]]; then
			echo $BLUE"Creating md5 checksum - "$NORMAL"$(basename $PACKAGE).md5"
			cd "$PKG_DEST_DIR"
			md5sum $(basename "$PACKAGE") > "$PACKAGE".md5
		fi
		echo $BLUE"Package Creation - "$GREEN"Successful! "$NORMAL"Package Location:"
		echo "$PACKAGE"
	else
		echo $RED"FAILED! "$NORMAL
		echo "Creation of ${PACKAGE##*/} has failed."
		FAILED="PACKAGE CREATION in: $FUNCNAME"
	fi
	[[ $REALLY_INSTALL = "YES" ]] && really_install "$PACKAGE"
	if [[ $PAUSE = "AFTER" ]] || [[ $PAUSE = $FUNCNAME ]] ; then
		echo $MAGENTA"Notice - "$BLUE"Pausing after: "$NORMAL" '$FUNCNAME'  Press ENTER to continue"
		read
	fi
}