# Internal function called by make_description

# Internal function called by make_description
make_default_desc() {
if [[ "$FAILED" = "" ]] ; then
   echo $BLUE"Creating $PKG_DESC - "$NORMAL"Creating a new $PKG_DESC file for the package."

   cat /dev/null > $PKG_DIR/install/$PKG_DESC

   # Align the text formatting guide starting at ':' (plus one space)
   namelen=${#NAME}
   offset=$(( $namelen + 2 ))
   spaces=0
   while [[ $spaces -lt $offset ]] ; do
	echo -n ' ' >> $PKG_DIR/install/$PKG_DESC
		(( spaces++ ))
   done
   echo "|-------------Use this guide to format your text with--------------|" >> $PKG_DIR/install/$PKG_DESC

   #if [[ $AUTO_SCRIPT ]] ; then
	SPECFILE=""
	if [[ -e $SRC_DIR/$NAME.spec ]] ; then
		SPECFILE=$SRC_DIR/$NAME.spec
	elif [[ -e $SRC_DIR/$NAME.spec.in ]] ; then
		SPECFILE=$SRC_DIR/$NAME.spec.in
	fi
	if [[ -f $SPECFILE ]] ; then
		echo "$NAME: $BLURB_1" >> $PKG_DIR/install/$PKG_DESC
		echo "$NAME: $BLURB_2" >> $PKG_DIR/install/$PKG_DESC
		cat $SPECFILE | read_rpm_desc | text_wrapper
		#echo "$NAME: $BLURB_11" >> $PKG_DIR/install/$PKG_DESC
	elif [[ -e $SRC_DIR/debian/control ]] ; then
		echo "$NAME: $BLURB_1" >> $PKG_DIR/install/$PKG_DESC
		echo "$NAME: $BLURB_2" >> $PKG_DIR/install/$PKG_DESC
		cat $SRC_DIR/debian/control | read_deb_desc | text_wrapper
		#echo "$NAME: $BLURB_11" >> $PKG_DIR/install/$PKG_DESC
	elif [[ -e $SRC_DIR/PKG-INFO ]] ; then
		echo "$NAME: $BLURB_1" >> $PKG_DIR/install/$PKG_DESC
		echo "$NAME: $BLURB_2" >> $PKG_DIR/install/$PKG_DESC
		cat $SRC_DIR/PKG-INFO | read_pkg-info_desc | text_wrapper
		#echo "$NAME: $BLURB_11" >> $PKG_DIR/install/$PKG_DESC
	else
		echo "$NAME: $BLURB_1" >> $PKG_DIR/install/$PKG_DESC
		echo "$NAME: $BLURB_2" >> $PKG_DIR/install/$PKG_DESC
		cat /dev/null | text_wrapper
	fi
	
	#elif [[ "$QUERY_FOR_PKG_DESC" = "YES" ]] ; then
	if [[ ! -f $PKG_DIR/install/$PKG_DESC ]] ; then
		if [[ "$QUERY_FOR_PKG_DESC" = "YES" ]] ; then
			echo $BLUE"Interactive mode: "$NORMAL
			echo "  Here you can give a description of this package for the $PKG_DESC file."
			echo "  Type in the text as one long line and press ENTER when finished."
			echo "  The text will automatically be formatted for you. Or just press ENTER "
			echo "  to accept the default text: $BLURB_3"
			echo ""
			echo -n "> "
			read BLURB_3
			echo "$NAME: $BLURB_1" >> $PKG_DIR/install/$PKG_DESC
			echo "$NAME: $BLURB_2" >> $PKG_DIR/install/$PKG_DESC
			if [[ "$BLURB_3" = "" ]] ; then 
				BLURB_3="No description was given for this package."
				echo "$NAME: $BLURB_3" >> $PKG_DIR/install/$PKG_DESC
				cat /dev/null | text_wrapper
			else
				echo $BLURB_3 | text_wrapper
			fi

		else
		cat >> $PKG_DIR/install/$PKG_DESC << END 
$NAME: $BLURB_1
$NAME: $BLURB_2
$NAME: $BLURB_3
$NAME: $BLURB_4
$NAME: $BLURB_5
$NAME: $BLURB_6
$NAME: $BLURB_7
$NAME: $BLURB_8
$NAME: $BLURB_9
$NAME: $BLURB_10
END

		fi
	fi

	cd $PKG_DIR ;
	if [[ "$(find . |xargs file |grep ELF |grep -v 'relocatable'| grep -v "shared object")" != "" ]] ; then
	find . |xargs file |grep ELF |grep -v 'relocatable'| grep -v "shared object" |cut -f 1 -d : |xargs ldd > ${CWD}/deps_list.tmp
		if [[ $(cat ${CWD}/deps_list.tmp) != "" ]] ; then
		  cat ${CWD}/deps_list.tmp | white_out |cut -f1 -d' '|grep -v "./" > ${CWD}/deps_list
		  rm -f ${CWD}/deps_list.tmp
		  for PKG_DEP in $(cat ${CWD}/deps_list); do
			THIS_DEP="$(grep -n ${PKG_DEP} $ADM_DIR_NAME/packages/* |head --lines 1 |cut -f1 -d: |cut -f 5 -d/)"
			THIS_DEP=${THIS_DEP%-*} ; THIS_DEP=${THIS_DEP%-*} ; THIS_DEP=${THIS_DEP%-*}
			if  [ ! "$THIS_DEP" == "glibc" ] && \
				[ "$THIS_DEP" != "aaa_elflibs" ] && \
				[ "$THIS_DEP" != "$NAME" ] ; then
			echo $THIS_DEP >> $CWD/deps_list.tmp
			fi
		  done
		  rm -f ${CWD}/deps_list
		  if [[ $(cat ${CWD}/deps_list.tmp) != "" ]] ; then
			# add the blurb with package deps
			echo "$NAME: $BLURB_11 - This package depends on:" >> $PKG_DIR/install/$PKG_DESC
			for DEP in $(cat $CWD/deps_list.tmp) ; do
				echo $DEP >> $CWD/deps_list
			done
			rm -f ${CWD}/deps_list.tmp
			cat $CWD/deps_list |sort -u |uniq -u >> $CWD/deps_list.tmp
			rm -f $CWD/deps_list
			for dep in $(cat $CWD/deps_list.tmp) ; do
				echo $dep |rev |cut -f3- -d'-' |rev >> $CWD/deps_list
			done
			rm -f $CWD/deps_list.tmp
			cat $CWD/deps_list > $PKG_DIR/install/$PKG_REQUIRED
			cat $CWD/deps_list |wrap_deps
		  else
			echo "$NAME: $BLURB_11" >> $PKG_DIR/install/$PKG_DESC
		  fi
		else
		  echo "$NAME: $BLURB_11" >> $PKG_DIR/install/$PKG_DESC
		fi
	else
	  echo "$NAME: $BLURB_11" >> $PKG_DIR/install/$PKG_DESC
	fi
	rm -f $CWD/deps_list
	rm -f $CWD/deps_list.tmp
	
	if [ "$EXEC_NAME" = "trackinstall" ] && [[ ! $AUTO_SCRIPT ]] ; then
		# skip this if we are using trackinstall or src2pkg without AUTO_SCRIPT
		true
	else
		echo "  A copy named new.$PKG_DESC will be placed in the current directory."
		echo "  Edit, if needed, and change the name to simply $PKG_DESC."
		echo "  Then rebuild the package to have the changes included"
		cat $PKG_DIR/install/$PKG_DESC > $CWD/new.$PKG_DESC
	fi
fi
}	

reject_desc() {
echo $YELLOW"WARNING! "$NORMAL"The supplied $PKG_DESC file is not valid."
echo "You need 9-13 lines that begin with '$NAME:' for this package."
if ! [[ -e $CWD/rej.$PKG_DESC ]] ; then
	echo "It will be renamed to rej.$PKG_DESC and a new one created."
	mv $CWD/$PKG_DESC $CWD/rej.$PKG_DESC
else
	rm -f $CWD/$PKG_DESC
fi
}

make_description() {
if [[ "$FAILED" = "" ]] ; then
	cd $CWD;
	mkdir -p $PKG_DIR/install
	if [[ -e $CWD/$PKG_DESC ]] ; then
		nol=$( cat $CWD/$PKG_DESC | grep $NAME: | wc -l )
		if [[ $nol -lt 9 ]] || [[ $nol -gt 13 ]] ; then
			reject_desc
			make_default_desc 
		else
			cat $CWD/$PKG_DESC > $PKG_DIR/install/$PKG_DESC
			chmod 644 $PKG_DIR/install/$PKG_DESC
			echo $BLUE"Verified $PKG_DESC found - "$NORMAL"Inserting in the package tree "
		fi
	elif [[ -e $CWD/$NAME.txt ]] ; then
		nol=$( cat $CWD/$NAME.txt | grep $NAME: | wc -l )
		if [[ $nol -lt 9 ]] || [[ $nol -gt 13 ]] ; then
			make_default_desc 
		else
			cat $CWD/$NAME.txt > $PKG_DIR/install/$PKG_DESC
			chmod 644 $PKG_DIR/install/$PKG_DESC
			echo $BLUE"Created $PKG_DESC from $NAME.txt - "$NORMAL"Inserting in the package tree "
		fi
	else
		make_default_desc 
	fi
fi
}

# make_link_script
make_install_script() {
  COUNT=1
  LINE="$(sed -n "$COUNT p" $1)"
  while [ ! "$LINE" = "" ]; do
   LINKGOESIN="$(echo "$LINE" | cut -f 1 -d " ")" 
   LINKGOESIN="$(dirname $LINKGOESIN)" 
   LINKNAMEIS="$(echo "$LINE" | cut -f 1 -d ' ')"
   LINKNAMEIS="$(basename "$LINKNAMEIS")"
   LINKPOINTSTO="$(echo "$LINE" | cut -f 3 -d ' ')"
   echo "( cd $LINKGOESIN ; rm -rf $LINKNAMEIS )"
   echo "( cd $LINKGOESIN ; ln -sf $LINKPOINTSTO $LINKNAMEIS )"
   COUNT=$(expr $COUNT + 1)
   LINE="$(sed -n "$COUNT p" $1)"
  done
}

#search for links and make link creation script if necessary
make_doinst_links() {
cd $PKG_DIR ;
TMP=/tmp
echo -n $BLUE"Searching for links in the PKG_DIR - "$NORMAL
INST=$(mktemp $TMP/src2pkg.XXXXXX)
# This requires the ls from coreutils-5.0 (or newer):
find . -type l -exec ls -l --time-style=long-iso {} \; | white_out | cut -f 8- -d ' ' | cut -b3- | tee $INST 1> /dev/null
if [ ! "$(cat $INST)" = "" ]; then
  echo $GREEN"Done"$NORMAL
  make_install_script $INST | tee $CWD/doinst.links 1> /dev/null
else
 echo "None found"
fi
rm -f $INST
}

# 
make_doinst() {
if [[ "$FAILED" = "" ]] ; then
	# If a doinst.sh is present, assume that it is final and copy as-is into the PKG_DIR
	if [[ -e $CWD/doinst.sh ]] ; then
	 echo $BLUE"Found doinst.sh - "$NORMAL"Inserting in the package directory"
	 cat $CWD/doinst.sh > $PKG_DIR/install/doinst.sh
	else
		if ! [[ $MAKE_LINKS = "NO" ]] ; then
		 make_doinst_links
		fi
		if [[ -e $CWD/doinst.prepend ]] ; then
		 echo $BLUE"Found doinst.prepend - "$NORMAL"Starting a new doinst.sh with its' contents"
		 cat $CWD/doinst.prepend > $PKG_DIR/install/doinst.sh
		 echo "" >> $PKG_DIR/install/doinst.sh
		fi
		if [[ -e $CWD/doinst.links ]] ; then
		 echo $BLUE"Adding links to doinst.sh - "$NORMAL"Adding links-creation to the doinst.sh"
		 cat $CWD/doinst.links >> $PKG_DIR/install/doinst.sh
		 rm -f $CWD/doinst.links
		fi
		if [ -e $CWD/doinst.append ] ; then
		 echo $BLUE"Found doinst.append - "$NORMAL"Adding its' contents to doinst.sh"
		 cat $CWD/doinst.append >> $PKG_DIR/install/doinst.sh
		 echo "" >> $PKG_DIR/install/doinst.sh
		fi
		 if [[ "$EXEC_NAME" = "trackinstall" ]] && [[ ! $AUTO_SCRIPT ]] ; then
		 true
		elif [ -e $PKG_DIR/install/doinst.sh ] ; then
		 echo $BLUE"Copying new doinst.sh - "$NORMAL"Copying as new.doinst.sh into the current directory"
		 echo "Be sure to check it. For permanent use, edit and/or rename to doinst.sh"
		 cat $PKG_DIR/install/doinst.sh > $CWD/new.doinst.sh
		fi
	fi
	# Remove symbolic links
	if ! [[ $REMOVE_LINKS = "NO" ]] ; then
		cd $PKG_DIR ;
		if [[ $(find . -type l) != "" ]] ; then
		 echo $BLUE"Deleting symbolic links - "$NORMAL"Removing links from the package directory"
		 find . -type l -exec rm -f {} \;
		fi
	fi
	# I dont't even know if this is right. 
	if [[ -f $CWD/slack-required ]] ; then
	 cp $CWD/slack-required > $PKG_DIR/install/
	fi
	if [[ $SHOW_DEPS ]] ; then
	 cd $PKG_DIR ;
	 if [[ "$(find . | xargs file | grep ELF | cut -f 1 -d : | xargs ldd | white_out | cut -f1 -d' ')" != "" ]] ; then
	  echo $BLUE"Package dependencies:"$NORMAL
	  find . | xargs file | grep ELF | cut -f 1 -d : | xargs ldd | white_out | cut -f1 -d' ' |grep -v "./" |sort -u
	 fi
	fi
fi
}

# tiny_make_package
tiny_make_package() {
	PACKAGE_NAME=$1
	TARGET_NAME="$(dirname $PACKAGE_NAME)"
	PACKAGE_NAME="$(basename $PACKAGE_NAME)"
	TAR_NAME="$(basename $PACKAGE_NAME .tgz)"
	# this is probably not needed
	umask 022
	echo ""
	if [ "$(whoami)" = "root" ] ; then
		${TAR_STATIC} cvf $TAR_NAME.tar .
	else
		${TAR_STATIC} --owner=root --group=root -cvf $TAR_NAME.tar .
	fi
	echo ""
	echo "Gzipping $TAR_NAME.tar to $TAR_NAME.tar.gz"
	gzip -9 $TAR_NAME.tar
	echo "Renaming $TAR_NAME.tar.gz to $PACKAGE_NAME"
	mv $TAR_NAME.tar.gz $PACKAGE_NAME
	if [ ! "$TARGET_NAME" = "." ]; then
		echo "Moving $PACKAGE_NAME to $TARGET_NAME"
		mv $PACKAGE_NAME $TARGET_NAME
	fi
}

# Create package
make_package() {
if [[ "$FAILED" = "" ]] ; then
	# first get rid of any zero-length files 
	if ! [[ $FORCE_ZERO_LENGTH = "YES" ]] ; then
		cd $PKG_DIR ;
		if [[ $(find . -type f -size 0) ]] ; then
		  echo $CYAN"NOTICE! "$NORMAL" Zero-length files were found in the package tree These are"
		  echo "usually blank documents, so we remove them by default. You can always force"
		  echo "installation with: FORCE_ZERO_LENGTH=YES  if any of them are really needed."
		  echo "Zero-length files installed under /etc are allowed (some conf files are blank)."
		  echo $BLUE"List of removed files:"$NORMAL
		  for dir in $(ls |grep -v etc) ; do
		    ( cd $dir
		    find . -type f -size 0 -exec echo $(basename {}) \;
		    find . -type f -size 0 -exec rm -f {} \;
		    cd ../
		    )
		  done
		fi
		
		find . -type f -name '*.gz' -size 20c | while read file ; do
		echo "WARNING: Possible empty gzipped file $file"
		done
	fi
	
	echo -n $BLUE"Making installable package - "$NORMAL
	# Build the 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 [[ $? -ne 0 ]] ; then
	  echo ""
	  echo $RED"FAILED! "$NORMAL"Creation of package has failed."
	  FAILED="PACKAGE CREATION"
	else
	  [[ $QUIET = "YES" ]] && echo $GREEN"Done"$NORMAL || echo ""
	  echo $BLUE"Package Creation - "$GREEN"Successful! "$BLUE"- Package Location:"$NORMAL
	  echo $PACKAGE
	fi
	[[ $REALLY_INSTALL = "YES" ]] && really_install
fi
}

# Internal Routines

mini_installpkg() {
echo $BLUE"Installing package "$NORMAL"$PKG_NAME"
( cd $ROOT/ ; $TAR_STATIC -xzlUpvf - ) < $PACKAGE 2> /dev/null
DATABASE_FILE=$ROOT/$ADM_DIR_NAME/packages/$SHORT_NAME
make_database
if [ -x /sbin/ldconfig ]; then
    /sbin/ldconfig
fi
if [ -f $ROOT/install/doinst.sh ]; then
 echo "Executing install script for $SHORT_NAME..."
 ( cd $ROOT/ ; sh install/doinst.sh -install; )
 
fi
if [ -d $ROOT/install ]; then
    if [ -r $ROOT/install/doinst.sh ]; then
      cp $ROOT/install/doinst.sh $ROOT/$ADM_DIR_NAME/scripts/$SHORT_NAME
      chmod 755 $ROOT/$ADM_DIR_NAME/scripts/$SHORT_NAME
    fi
    # /install/doinst.sh and /install/slack-* are reserved locations for the package system.
    ( cd $ROOT/install ; rm -f doinst.sh slack-* *desc *require* 1> /dev/null 2>&1 )
    rmdir $ROOT/install 1> /dev/null 2>&1
fi
}

# really install the package only if REALLY_INSTALL="YES"
really_install() {
if [[ "$FAILED" = "" ]] && [[ $REALLY_INSTALL = "YES" ]] ; then
	if [[ "$INSTALLPKG" = "internal" ]] ; then
	mini_installpkg
	else
		echo $BLUE"Installing package $PKG_NAME"$NORMAL
		if [[  $QUIET="YES" ]] ; then
		 $INSTALLPKG $PACKAGE 2> /dev/null 1> /dev/null
		else
		 $INSTALLPKG $PACKAGE
		fi
	fi
fi
}