scratchpkg/scratch

#!/bin/bash

export LC_ALL=C
	
. /usr/share/scratchpkg/functions || exit 1

#
# helper func
#

confirm() {
	read -r -p "$1 (Y/n) " response
	case "$response" in
		[Nn][Oo]|[Nn]) echo "$2"; exit 2 ;;
		*) : ;;
	esac
}

needarg() {
	if [ -z "$@" ]; then
		msgerr "This operation require arguments!"
		return 1
	else
		return 0
	fi
}

getpkgcache() {
	
	for list in $(ls "$PACKAGE_DIR"); do
		[ -f "$PACKAGE_DIR"/$list ] && ALL_PACKAGES+=($list)
	done
	
	for list in $(ls "$SOURCE_DIR"); do
		[ -f "$SOURCE_DIR"/$list ] && ALL_SOURCES+=($list)
	done
	
	for repo in ${PORT_REPO[@]}; do
		for port in $(ls $repo); do
			if [ -f $repo/$port/$BUILD_SCRIPT ]; then
				. $repo/$port/$BUILD_SCRIPT
				PORT_PACKAGES+=($name-$version-$release.spkg.txz)
				if [ ! -z $source ]; then
					for src in ${source[@]}; do
						if [ $(echo $src | grep -E "(ftp|http|https)://") ]; then
							if [ $(echo $src | grep -E "::(ftp|http|https)://") ]; then
								sourcename="$(echo $src | awk -F '::' '{print $1}')"
							else
								sourcename="$(echo $src | rev | cut -d / -f 1 | rev)"
							fi
							SOURCE_NAMES+=($sourcename)
						fi
					done
				fi
			fi
		done
	done
	
	for i in ${PORT_PACKAGES[@]}; do
		for pkg in ${!ALL_PACKAGES[@]}; do
			if [ "${ALL_PACKAGES[pkg]}" = "$i" ]; then
				unset 'ALL_PACKAGES[pkg]'
				break
			fi
		done
	done
	
	for a in ${SOURCE_NAMES[@]}; do
		for src in ${!ALL_SOURCES[@]}; do
			if [ "${ALL_SOURCES[src]}" = "$a" ]; then
				unset 'ALL_SOURCES[src]'
				break
			fi
		done
	done
}

getportpath() {
	
	for repo in ${PORT_REPO[@]}; do
		if [[ -f $repo/$1/$BUILD_SCRIPT ]]; then
			echo "$(dirname $repo/$1/$BUILD_SCRIPT)"
			return 0
		fi
	done
	return 1
	
}

checkdep() {
	
	if getportpath "$1" >/dev/null; then
		pushd $(getportpath "$1")
			getpkginfo
		popd
	fi
	
	for dep in ${depends[@]}; do
		echo $dep
	done
	
	for mdep in ${makedepends[@]}; do
		echo $mdep
	done
	
}

#
# main func
#

missingdep() {
	
	for pkg in $(allinstalled); do
		msd=()
		msmd=()
		dep=$(installed_pkg_info depends $pkg)
		mdep=$(installed_pkg_info makedepends $pkg)
		if [ ${#dep[@]} -gt 0 ]; then
			for d in ${dep[@]}; do
				if [ ! -f "$INDEX_DIR"/$d/.pkginfo ]; then
					msd+=($d)
				fi
			done
		fi
		if [ ${#mdep[@]} -gt 0 ]; then
			for md in ${mdep[@]}; do
				if [ ! -f "$INDEX_DIR"/$md/.pkginfo ]; then
					msmd+=($md)
				fi
			done
		fi
		if [ ${#msd[@]} -gt 0 ]; then
			echo -e "${GREEN}$pkg${CRESET} missing ${RED}${msd[@]}${CRESET}"
		fi
		if [ ${#msmd[@]} -gt 0 ]; then
			echo -e "${GREEN}$pkg${CRESET} missing ${RED}${msmd[@]}${CRESET} ${BLUE}(make)${CRESET}"
		fi
	done

}

showportpath() {
	
	if PPATH=$(getportpath "$1"); then
		echo "$PPATH"
	else
		msgerr "Port '$1' not exist."
		exit 1
	fi
	
}

showtree() {
	
	if [ ! -f $INDEX_DIR/$1/.pkginfo ]; then
		msg "Package ${RED}$1${CRESET} not installed."
	else
		while IFS=' ' read -r line; do
			echo "$line"
		done < <(cat $INDEX_DIR/$1/.files)
	fi
	
}

checkowner() {

	for pkg in $(allinstalled); do
		for output in $(cat $INDEX_DIR/$pkg/.files | grep $1); do
			echo -e "${CYAN}$pkg${CRESET} => ${PURPLE}$output${CRESET}"
		done
	done
	
}

showdependent() {
	
	for port in ${PORT_REPO[@]}; do
		if [ -d $port ]; then
			for all in $(ls $port/*/$BUILD_SCRIPT | rev | cut -d '/' -f2 | rev 2>/dev/null); do
				if [ -f $port/$all/$BUILD_SCRIPT ]; then
					depend=$(cat $port/$all/$BUILD_SCRIPT | grep ^'# depends' | tr -d ':' | cut -d " " -f3-)
					for dep in ${depend[@]}; do
						if [ $dep = $1 ]; then
							GDP=yes
							if [ -d $INDEX_DIR/$all ]; then
								msginst "$all"
							else
								msgnoinst "$all"
							fi
						fi
					done
					makedepend=$(cat $port/$all/$BUILD_SCRIPT | grep ^'# makedepends' | tr -d ':' | cut -d " " -f3-)
					for mdep in ${makedepend[@]}; do
						if [ $mdep = $1 ]; then
							GDP=yes
							if [ -d $INDEX_DIR/$all ]; then
								msginst "$all"
							else
								msgnoinst "$all"
							fi
						fi
					done
				fi
			done
		fi
	done
	
	[ "$GDP" ] || msg "No package depends on '$1'."
}

showdependent2() {
	
	if [ ! -d $INDEX_DIR/$1 ]; then
		msg "Package ${RED}$1${CRESET} not installed."
		exit 1
	else
		for all_installed in $(ls $INDEX_DIR); do
			depend=$(cat $INDEX_DIR/$all_installed/.pkginfo | grep ^depends | cut -d " " -f3-)
				for dep in ${depend[@]}; do
					if [ $dep = $1 ]; then
						DP=yes
						echo -e "$all_installed"
					fi
				done
			makedepend=$(cat $INDEX_DIR/$all_installed/.pkginfo | grep ^makedepends | cut -d " " -f3-)
				for mdep in ${makedepend[@]}; do
					if [ $mdep = $1 ]; then
						DP=yes
						echo -e "$all_installed ${CYAN}(make)${CRESET}"
					fi
				done
		done
	fi
	
	[ "$DP" ] || msg "No package depends on '$1'."
}

catport() {
	
	if PPATH=$(getportpath "$1"); then
		cat "$PPATH/$BUILD_SCRIPT"
	else
		msgerr "Port '$1' not exist."
		exit 1
	fi
}

printreadme() {
	
	if PPATH=$(getportpath "$1"); then
		if [ -f "$PPATH/readme" ]; then
			cat "$PPATH/readme"
		else
			msgerr "Port '$1' does not have readme."
		fi
	else
		msgerr "Port '$1' not exist."
		exit 1
	fi
}

listports() {
	
	for repo in ${PORT_REPO[@]}; do
		if [ "$1" = "$(basename $repo)" ]; then
			REPO_EXIST=yes
			for ports in $(ls $repo/*/$BUILD_SCRIPT | rev | cut -d '/' -f2 | rev 2>/dev/null); do
				. "$repo/$ports/$BUILD_SCRIPT"
				if [ -f "$PACKAGE_DIR/$name-$version-$release.spkg.txz" ]; then
					echo -e "$name ${GREEN}$version${CRESET}-${BLUE}$release${CRESET} ${PURPLE}[*]${CRESET}"
				else
					echo -e "$name ${GREEN}$version${CRESET}-${BLUE}$release${CRESET}"
				fi
			done
		fi
	done
	
	[ "$REPO_EXIST" ] || msgerr "Repository ${RED}$1${CRESET} not exist."
	
}

listlocked() {
	
	for pkg in "$INDEX_DIR"/*/.pkginfo; do
		pkgpath=$(dirname $pkg)
		pkgname=$(basename $pkgpath)
		if [ -f "$pkgpath"/.lock ]; then
			echo -e "$pkgname"
		fi
	done
	
}

lockpkg() {
	
	needroot "Locking package"
	
	for pkg in "$@"; do
		if [ ! -d $INDEX_DIR/$pkg ]; then
			msgerr "Package '$pkg' is not installed."
		else
			touch $INDEX_DIR/$pkg/.lock && msg "Successfully locked package '$pkg'."
		fi
	done
	
}

unlockpkg() {
	
	needroot "Unlocking package"
	
	for pkg in "$@"; do
		if [ ! -d $INDEX_DIR/$pkg ]; then
			msgerr "Package '$pkg' is not installed."
		elif [ ! -f $INDEX_DIR/$pkg/.lock ]; then
			msgerr "Package '$pkg' is not locked."
		else
			rm $INDEX_DIR/$pkg/.lock && msg "Successfully unlocked package '$pkg'."
		fi
	done
	
}

foreignpkg() {
	
	for pkg in $(allinstalled); do
		if ! getportpath $pkg >/dev/null; then
			echo -e $pkg
		fi
	done
	
}

clearpkgcache() {
	
	needroot "Removing package & source cache"
	
	getpkgcache
	
	if [ ${#ALL_PACKAGES[@]} -gt 0 ]; then
		for pkg in ${ALL_PACKAGES[@]}; do
			rm -v $PACKAGE_DIR/$pkg
		done
	fi
	
	if [ ${#ALL_SOURCES[@]} -gt 0 ]; then
		for src in ${ALL_SOURCES[@]}; do
			rm -v $SOURCE_DIR/$src
		done
	fi
	
}

pkgcache() {
	
	getpkgcache
	
	if [ ${#ALL_PACKAGES[@]} -gt 0 ]; then
		ALL_PACKAGES_SIZE=$(pushd "$PACKAGE_DIR" && du -ch ${ALL_PACKAGES[@]} | grep total | awk '{print $1}' && popd)
	else
		ALL_PACKAGES_SIZE=0M
	fi
	
	if [ ${#ALL_SOURCES[@]} -gt 0 ]; then
		ALL_SOURCES_SIZE=$(pushd "$SOURCE_DIR" && du -ch ${ALL_SOURCES[@]} | grep total | awk '{print $1}' && popd)
	else
		ALL_SOURCES_SIZE=0M
	fi
	
	msg "${CYAN}Package cache ($ALL_PACKAGES_SIZE):${CRESET}"
	[ ${#ALL_PACKAGES[@]} -gt 0 ] && (echo ${ALL_PACKAGES[@]} | tr ' ' '\n') || echo "(none)"
	
	echo ""
	msg "${CYAN}Source cache ($ALL_SOURCES_SIZE):${CRESET}"
	[ ${#ALL_SOURCES[@]} -gt 0 ] && (echo ${ALL_SOURCES[@]} | tr ' ' '\n') || echo "(none)"
	
}

sysup() {
	
	needroot "Upgrading package"
	
	PKGOUTDATE=$(outdatepkg)
	
	if [ ! "$PKGOUTDATE" ]; then
		msg "All package is up to date."
		exit 0
	fi
	
	for i in ${PKGOUTDATE[@]}; do
		echo -ne "Calculating '$i' dependencies...\033[0K\r"
		deplist $i
	done
	echo -ne "\033[0K"
	for d in ${DEP[@]}; do
		if [ "$(echo ${PKGOUTDATE[@]} | tr ' ' '\n' | grep -x $d)" = "$d" ]; then
			msgupg "$d"
			WILLINSTALL+=($d)
		elif [ ! -e "$INDEX_DIR/$d/.pkginfo" ] && getportpath $d >/dev/null; then
			msgnew "$d"
			WILLINSTALL+=($d)
		fi
	done
		
	echo
	echo "These package(s) will be upgrade and installed..."
	echo
	confirm "Continue upgrade and install these package(s)?" "Package upgrade cancelled."
	echo
	for inst in ${WILLINSTALL[@]}; do # install all required dependencies and target packages itself
		if [ ! -e "$INDEX_DIR/$inst/.pkginfo" ]; then
			portinstall $inst -i || exit 1
		else
			portinstall $inst -u || exit 1
		fi
	done
	
}

outdatepkg() {
	for pkg in $(allinstalled); do
		if [ ! -e "$INDEX_DIR/$pkg/.lock" ] && getportpath $pkg >/dev/null; then
			. $(getportpath $pkg)/$BUILD_SCRIPT
			iversion=$(installed_pkg_info version $pkg)
			irelease=$(installed_pkg_info release $pkg)
			if [ "$release" != "$irelease" ] || [ "$version" != "$iversion" ]; then
				echo $name
			fi
		fi
	done
}

checkupdate() {
	
	for pkg in $(allinstalled); do
		if getportpath $pkg >/dev/null; then
			. $(getportpath $pkg)/$BUILD_SCRIPT
			iversion=$(installed_pkg_info version $pkg)
			irelease=$(installed_pkg_info release $pkg)
			[ -f "$INDEX_DIR/$pkg/.lock" ] && ITSLOCK="[locked]"
			outdatemsg="$name ${RED}$iversion-$irelease${CRESET} => ${GREEN}$version-$release${CRESET} ${BLUE}$ITSLOCK${CRESET}"
			newerinstmsg="$name ${RED}$iversion-$irelease${CRESET} => ${GREEN}$version-$release${CRESET} ${YELLOW}[newer installed]${CRESET} ${BLUE}$ITSLOCK${CRESET}"
			if [ "$version" !=  "$iversion" ]; then
				vercomp $version $iversion
				if [ $? = 2 ]; then
					echo -e "$outdatemsg"
					OUTDATE=yes
				elif [ $? = 1 ]; then
					echo -e "$newerinstmsg"
					OUTDATE=yes
				fi
			elif [ "$release" !=  "$irelease" ]; then
				vercomp $release $irelease
				if [ $? = 2 ]; then
					echo -e "$outdatemsg"
					OUTDATE=yes
				elif [ $? = 1 ]; then
					echo -e "$newerinstmsg"
					OUTDATE=yes
				fi
			fi
			unset ITSLOCK
		fi
	done
	
	[ ! "$OUTDATE" ] && msg "All package is up to date."
}

checkintegrity() {
	
	pushd $ROOT_DIR
		for pkg in $(allinstalled); do
			while IFS=' ' read -r line; do
					if [ ! -e "$line" ]; then
						echo -e "${BLUE}$pkg${CRESET} is missing: ${PURPLE}/$line${CRESET}"
						MISSING_FILE=yes
					fi
			done < <(cat $INDEX_DIR/$pkg/.files)
		done
	popd
	
	[ "$UID" != "0" ] && msg "${YELLOW}(check integrity is recommended run as root or using sudo)${CRESET}"
	[ ! "$MISSING_FILE" ] && msg "Your system file is consistent with package tree."
	
}

listorphan() {
	
	# fetch all depends in all installed package
	for pkg in $(allinstalled); do
		dep=$(installed_pkg_info depends $pkg)
		for deps in ${dep[@]}; do
			ALL_DEP+=($deps)
		done
	done
	
	# find orphan package
	for all in $(ls $INDEX_DIR); do
		ORPHAN=yes
		for depended in ${ALL_DEP[@]}; do
			if [ $depended = $all ]; then
				ORPHAN=no
				break
			fi
		done
		if [ "$ORPHAN" = yes ]; then
			iname=$(installed_pkg_info name $all)
			iversion=$(installed_pkg_info version $all)
			irelease=$(installed_pkg_info release $all)
			echo -e "$iname ${GREEN}$iversion${CRESET}-${BLUE}$irelease${CRESET}"
		fi
	done
	
}

listinstalled() {
	
	for pkg in $(allinstalled); do
		iname=$(installed_pkg_info name $pkg)
		iversion=$(installed_pkg_info version $pkg)
		irelease=$(installed_pkg_info release $pkg)
		echo -e "$iname ${GREEN}$iversion${CRESET}-${BLUE}$irelease${CRESET}"
	done
	
}

duplicateports() {
	
	dup=$(find ${PORT_REPO[@]} -type d -print | egrep -xv "($(echo ${PORT_REPO[@]} | tr ' ' '|'))" | \
		rev | cut -d '/' -f1 | rev | sort | uniq -d)
	
	if [ "$dup" ]; then
		for dp in $dup; do
			for repo in ${PORT_REPO[@]}; do
				reponame=$(basename $repo)
				[ -d $repo/$dp ] && echo "$repo/$dp"
			done
		done
	else
		msg "No duplicate ports found."
	fi
	
}

searchpkg() {
	
	for port in ${PORT_REPO[@]}; do
		if [ -d $port ]; then
			pushd $port
				OUTPUT=$(grep -R description | grep "$BUILD_SCRIPT:# description[[:blank:]]*:" | sed "s/$BUILD_SCRIPT:# description[[:blank:]]*://" | grep -i "$1" | cut -d '/' -f1)
			popd
			if [ -n "$OUTPUT" ]; then
				found=yes
				for out in ${OUTPUT[@]}; do
					if [ -f $port/$out/$BUILD_SCRIPT ]; then
						pushd $port/$out
							getpkginfo
						popd
						if [ ! -z "$name" ] && [ ! -z "$version" ] && [ ! -z "$release" ]; then
							portname=$(basename $port)
							search_result="${BLUE}($portname)${CRESET} ${PURPLE}$name${CRESET} ${CYAN}$version-$release${CRESET} $description"
							if [ -e $INDEX_DIR/$name/.pkginfo ]; then
								echo -e "[${GREEN}*${CRESET}] $search_result"
							else
								echo -e "[ ] $search_result"
							fi
							unset description
						fi
					fi
				done
			fi
		fi
	done
	if [ ! "$found" ]; then
		msg "No matching package found."
	fi
}

showdepends() {
	
	if getportpath "$1" >/dev/null; then
		pushd $(getportpath "$1")
			getpkginfo
		popd
	else
		msgerr "Port ${RED}$1${CRESET} not exist."
		exit 1
	fi
			
	for dep in ${depends[@]}; do
		if [ -d $INDEX_DIR/$dep ]; then
			msginst "$dep"
		elif getportpath $dep >/dev/null; then
			msgnoinst "$dep"
		else
			msgmiss "$dep"
		fi
	done
			
	for mdep in ${makedepends[@]}; do
		if [ -d $INDEX_DIR/$mdep ]; then
			msginst "$mdep"
		elif getportpath $mdep >/dev/null; then
			msgnoinst "$mdep"
		else
			msgmiss "$mdep"
		fi
	done
}	

deplist() {
	
	# check currently process package for loop
	if [ ${#CHECK[@]} -gt 0 ]; then
		if [[ "$(echo ${CHECK[@]} | tr " " "\n" | grep -x $1)" == "$1" ]]; then
			return 0
		fi
	fi
	
	#if [[ $(echo ${DEP[@]} | tr " " "\n" | grep -x $i) = "$i" ]]; then
		#return 0
	#fi
	
	# add package to currently process
	CHECK+=($1)
	
	# check dependencies	
	for i in $(checkdep $1); do
		if [[ $(echo ${DEP[@]} | tr " " "\n" | grep -x $i) = "" ]]; then
			deplist $i
		fi
	done
	
	# add dependency to list checked dep
	if [[ $(echo ${DEP[@]} | tr " " "\n" | grep -x $1) = "" ]]; then
		DEP+=($1)
	fi
	
	# delete process package array
	for i in "${!CHECK[@]}"; do
		if [[ ${CHECK[i]} = "$1" ]]; then
			unset 'CHECK[i]'
		fi
	done
	
}

portinstall() {
	
	if getportpath "$1" >/dev/null; then
		pushd "$(getportpath $1)"
			shift
			buildpkg "$@" || exit 1
		popd
	else
		msgerr "Port '$1' not found."
	fi
}

updports() {
	
	checktool httpup
	
	needroot "Updating ports"
	
	if [ ! -e /etc/scratchpkg.repo ]; then
		msgerr "Repo file not found! (/etc/scratchpkg.repo)"
		exit 1
	fi

	while read repodir repourl junk; do
		case $repodir in
			""|"#"*) continue ;;
		esac
		if [ -n "$repodir" ] && [ -n "$repourl" ]; then
			httpup sync $repourl $repodir
		fi
	done < /etc/scratchpkg.repo
	
}

help() {
	
	cat << EOF
Usage:
    $(basename $0) [ mode ] [ <pkgname> <options> ]	

mode:
    install   <packages>      install packages and its dependencies
    upgrade   <packages>      upgrade packages and install new dependencies (if any)
    build     <package>       build only packages
    remove    <packages>      remove packages in system
    depends   <package>       show depends of a package
    deplist   <packages>      show list dependencies of a package
    search    <pattern>       search packages in port's repos
    lock      <packages>      lock packages from upgrade
    unlock    <packages>      unlock packages from upgrade
    listport  <repo>          list ports of a repo
    cat       <package>       view a package build scripts
    dependent <package>       show package's dependent
    own       <file>          show package's owner of file
    pkgtree   <package>       show list files of installed package
    path      <package>       show package's buildscripts path
    sync                      update port's repo
    sysup                     full system update
    dup                       print duplicate ports in repo
    readme                    print readme file if exist
    listinst                  list installed package in system
    listorphan                list orphan package
    integrity                 check integrity of package's files
    outdate                   check for outdate packages
    cache                     print leftover cache
    rmcache                   remove leftover cache
    missingdep                check for mising dependency of installed package
    foreignpkg                print package installed without port in repo
    listlocked                print locked packages
    help                      print this help message
	
options for:		
    build
        -f, --force-rebuild    force rebuild
        -m, --skip-mdsum       skip md5sum check for sources
        -d, --no-dep           skip dependency check
        -e, --extract          extract only
        -w, --keep-work        keep woring directory
        -o, --download         download source files only
        --redownload           re-download source files
        --srcdir=<path>        override default SOURCE_DIR
        --pkgdir=<path>        override default PACKAGE_DIR
        --no-preinstall        skip pre-install script
        
    install
        -d, --no-dep           skip installing dependencies
        -c, --ignore-conflict  skip file conflict check
        -r, --reinstall        reinstall installed package
        -v, --verbose          print install process
        --no-preinstall        skip pre-install script
        --no-postinstall       skip post-install script
		
    upgrade
        -d, --no-dep           skip installing dependencies (new dependencies)
        -c, --ignore-conflict  skip file conflict check
        -v, --verbose          print install process
        --no-backup            skip backup configuration file
        --no-preupgrade        skip pre-upgrade script
        --no-postupgrade       skip post-upgrade script
		
    remove
        -d, --no-dep           skip dependency check
        -v, --verbose          print removed files
        --no-preremove         skip pre-remove script
        --no-postremove        skip post-remove script
		
global options:
        --no-color             disable colour for output
        --debug                debug $(basename $0) script

EOF
	
}

extract_opt() {
	for opt in $@; do
		case $opt in
			--*=*) OPTS+=($opt) ;;
			  --*) OPTS+=($opt) ;;
			   -*) for (( i=1; i<${#opt}; i++ )); do OPTS+=(-${opt:$i:1}); done ;;
			    *) OPTS+=($opt) ;;
		esac
	done
	echo "${OPTS[@]}"
}

# set mode
mode=$1
shift

# strip global options
for i in $(extract_opt $@); do
	case $i in
		--no-color) nocolor ;;
		--debug) set -x ;;
		*) ARG+=($i)
	esac
done

checkdirexist "$INDEX_DIR"

if [ -f /etc/scratchpkg.repo ]; then
	while read repodir repourl junk; do
		case $repodir in
			""|"#"*) continue ;;
		esac
		PORT_REPO+=($repodir)
	done < /etc/scratchpkg.repo
fi

# build mode
if [ "$mode" = "build" ]; then
	parseopt() {
		while [ "$1" ]; do
			case $1 in
				-f|-m|-d|-e|-w|-o|--srcdir=*|--pkgdir=*) OPTS+=($1) ;;
				--skip-mdsum|--no-dep|--extract|--keep-work|--download) OPTS+=($1) ;;
				--force-rebuild|--redownload|--no-preinstall) OPTS+=($1) ;;
				-*) msgerr "Invalid option! ($1)"; exit 1 ;;
				*) PKG=$1 ;;
			esac
			shift
		done
	}
	parseopt ${ARG[@]}
	needarg "$PKG" || exit 1
	if getportpath "$PKG" >/dev/null; then
		portinstall "$PKG" "${OPTS[@]}"
	else
		msgerr "Package '$PKG' not exist."
		exit 1
	fi
	exit $?
fi

# install mode
if [ "$mode" = "install" ]; then
	parseopt() {
		while [ "$1" ]; do
			case $1 in
				-v|-c|--verbose|--ignore-conflict) OPTS+=($1) ;;
				--no-preinstall|--no-postinstall) OPTS+=($1) ;;
				-r|--reinstall) OPTS+=($1); REINSTALL=1 ;;
				-d|--no-dep) NO_DEP=1 ;;
				-*) msgerr "Invalid option! ($1)"; exit 1 ;;
				*) PKG+=($1) ;;
			esac
			shift
		done
	}
	parseopt ${ARG[@]}
	if [ "$NO_DEP" ]; then
		portinstall "${PKG[@]}" -i ${OPTS[@]}
	elif [ "$REINSTALL" ]; then
		portinstall "${PKG[@]}" -r ${OPTS[@]}
	else
		for pkg in ${PKG[@]}; do # check for existence of package
			if ! getportpath "$pkg" >/dev/null; then
				msgerr "Package '$pkg' not exist."
				exit 1
			fi
		done
		for pkg in ${PKG[@]}; do # calculate dependencies for all target packages
			if [ -e "$INDEX_DIR/$pkg/.pkginfo" ]; then
				msg "Package ${GREEN}$pkg${CRESET} already installed."
			else
				echo -e "Calculating $pkg dependencies..."
				deplist "$pkg"
			fi
		done
		if [ ${#DEP[@]} -gt 0 ]; then
			for dep in ${DEP[@]}; do
				if getportpath "$dep" >/dev/null; then
					if [ ! -e "$INDEX_DIR/$dep/.pkginfo" ]; then
						WILLINSTALL+=($dep)
					fi
				else
					MISSINGPKG+=($dep)
				fi
			done
			echo
			echo "Package(s) will be installed : ${#WILLINSTALL[@]}"
			echo "Missing dependencies         : ${#MISSINGPKG[@]}"
			echo
			confirm "Continue install these package(s)?" "Package installation cancelled."
			echo
			for inst in ${WILLINSTALL[@]}; do # install all required dependencies and target packages itself
				portinstall $inst -i ${OPTS[@]}
			done
		fi
	fi
	exit 0
fi

# upgrade mode
if [ "$mode" = "upgrade" ]; then
	parseopt() {
		while [ "$1" ]; do
			case $1 in
				--no-backup|--no-preupgrade|--no-postupgrade) OPTS+=($1) ;;
				-v|-c|--verbose|--ignore-conflict) OPTS+=($1) ;;
				-d|--no-dep) NO_DEP=1 ;;
				-*) msgerr "Invalid option! ($1)"; exit 1 ;;
				*) PKG+=($1) ;;
			esac
			shift
		done
	}
	parseopt ${ARG[@]}
	needarg "$PKG" || exit 1
	for pkg in ${PKG[@]}; do # check for existence of package
		if [ ! -e "$INDEX_DIR/$pkg/.pkginfo" ]; then
			msgerr "Package '$pkg' not installed."
			exit 1
		fi
		if ! getportpath "$pkg" >/dev/null; then
			msgerr "Package '$pkg' not exist."
			exit 1
		fi
	done
	if [ ! "$NO_DEP" ]; then
		for pkg in ${PKG[@]}; do # calculate dependencies for all target packages
			echo -ne "Calculating $pkg dependencies...\033[0K\r"
			deplist "$pkg"
		done
		echo -ne "\033[0K"
		for dep in ${DEP[@]}; do # install new dep (if any)
			if [ ! -e "$INDEX_DIR/$dep/.pkginfo" ]; then
				if getportpath "$dep" >/dev/null; then
					portinstall $dep -i
				fi
			fi
		done
	fi
	for pkg in ${PKG[@]}; do # upgrade all target packages
		portinstall $pkg -ud ${OPTS[@]}
	done
	exit $?
fi

# remove mode
if [ "$mode" = "remove" ]; then
	parseopt() {
		while [ "$1" ]; do
			case $1 in
				--no-preremove|--no-postremove) OPTS+=($1) ;;
				-d|-v|--no-dep|--verbose) OPTS+=($1) ;;
				-*) msgerr "Invalid option! ($1)"; exit 1 ;;
				*) PKG+=($1) ;;
			esac
			shift
		done
	}
	parseopt ${ARG[@]}
	needarg "$PKG" || exit 1
	removepkg ${PKG[@]} ${OPTS[@]}
	exit $?
fi

if [ "$mode" = "depends" ]; then
	needarg "$ARG" || exit 1
	if getportpath "$ARG" >/dev/null; then
		showdepends "$ARG"
	else
		msgerr "Port '$ARG' not exist!"
		exit 1
	fi
	exit 0
fi

if [ "$mode" = "deplist" ]; then
	parseopt() {
		while [ "$1" ]; do
			case $1 in
				-*) msgerr "Invalid option! ($1)"; exit 1 ;;
				*) PKG+=($1) ;;
			esac
			shift
		done
	}
	parseopt ${ARG[@]}
	needarg "$PKG" || exit 1
	for pkg in ${PKG[@]}; do
		if ! getportpath "$pkg" >/dev/null; then
			msgerr "Package '$pkg' not exist."
			exit 1
		fi
	done
		for pkg in ${PKG[@]}; do
			echo -ne "Calculating $pkg dependencies...\033[0K\r"
			deplist "$pkg"
		done
		echo -ne "\033[0K"
	for i in ${DEP[@]}; do
		if [ -e "$INDEX_DIR/$i/.pkginfo" ]; then
			msginst "$i"
		elif ! getportpath "$i" >/dev/null; then
			msgmiss "$i"
		else
			msgnoinst "$i"
		fi
	done
	exit 0
fi
	
# print help message
if [ "$mode" = "help" ]; then
	help
	exit 0
fi
	
# list installed package in system
if [ "$mode" = "listinst" ]; then
	listinstalled
	exit 0
fi
		
# list orphan package (package which is no other
# package depends on it)
if [ "$mode" = "listorphan" ]; then
	listorphan
	exit 0
fi
		
# check integrity (check between package index and files in system)
if [ "$mode" = "integrity" ]; then
	checkintegrity
	exit 0
fi
		
# check package for update
if [ "$mode" = "outdate" ]; then
	checkupdate
	exit 0
fi
		
# search for old package and source cache
if [ "$mode" = "cache" ]; then
	pkgcache
	exit 0
fi
		
# delete old package and sources cache
if [ "$mode" = "rmcache" ]; then
	clearpkgcache
	exit 0
fi
		
# search for missing dependency for installed package
if [ "$mode" = "missingdep" ]; then
	missingdep
	exit 0
fi
	
# search for foreign port (installed package with no port in repos)
if [ "$mode" = "foreignpkg" ]; then
	foreignpkg
	exit 0
fi
		
# list locked package
if [ "$mode" = "listlocked" ]; then
	listlocked
	exit 0
fi
	
# print duplicate ports
if [ "$mode" = "dup" ]; then
	duplicateports
	exit 0
fi

# lock package from upgrade
if [ "$mode" = "lock" ]; then
	needarg "$ARG" || exit 1
	lockpkg "${ARG[@]}"
	exit 0
fi

# unlock package from upgrade
if [ "$mode" = "unlock" ]; then
	needarg "$ARG" || exit 1
	unlockpkg "${ARG[@]}"
	exit 0
fi
	
# list ports for repo (input: repo name)
if [ "$mode" = "listport" ]; then
	needarg "$ARG" || exit 1
	listports "$ARG"
	exit 0
fi
	
# print out port's spkgbuild (input: port name)
if [ "$mode" = "cat" ]; then
	needarg "$ARG" || exit 1
	catport "$ARG"
	exit 0
fi
	
# list dependents for port (check through repo. input: port name)
if [ "$mode" = "dependent" ]; then
	needarg "$ARG" || exit 1
	showdependent "$ARG"
	exit 0
fi
	
# show package owner of files (input: filename)
if [ "$mode" = "own" ]; then
	needarg "$ARG" || exit 1
	checkowner "$ARG"
	exit 0
fi
	
# show files own by package (input: port name)
if [ "$mode" = "pkgtree" ]; then
	needarg "$ARG" || exit 1
	showtree "$ARG"
	exit 0
fi
	
# create port's template (input: port name)
if [ "$mode" = "path" ]; then
	needarg "$ARG" || exit 1
	showportpath "$ARG"
	exit 0
fi

# update ports
if [ "$mode" = "sync" ]; then
	updports
	exit 0
fi

# search ports
if [ "$mode" = "search" ]; then
	needarg "$ARG" || exit 1
	searchpkg $ARG
	exit 0
fi

# print readme for ports
if [ "$mode" = "readme" ]; then
	needarg "$ARG" || exit 1
	printreadme $ARG
	exit 0
fi

# update all ports
if [ "$mode" = "sysup" ]; then
	sysup
	exit 0
fi

echo "Run '$(basename $0) help' to see available mode and options"

exit 0