#!/usr/bin/env bash

#
# Author David Bruno Cortarello <Nomius>. Redistribute under the terms of the
# BSD-lite license. Bugs, suggests, nor projects: nomius@users.berlios.de.
# Bassed on the source code of pkgtools by Patrick Volkerding.
#
# Program: kpkg
# Version: 3.0
#
#
# Copyright (c) 2005-2008, David B. Cortarello
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
#   * Redistributions of source code must retain the above copyright notice
#     and the following disclaimer.
#   * Redistributions in binary form must reproduce the above copyright notice
#     and the following disclaimer in the documentation and/or other materials
#     provided with the distribution.
#   * Neither the name of Kwort nor the names of its contributors may be used
#     to endorse or promote products derived from this software without
#     specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
#

# db:
# /{KPKG_DB_HOME}/repos/${PKG_MIRROR}/serie/pkgname/data
#data:
# PKG_SERIE="serie"
# PKG_NAME="pkgname"
# PKG_VERSION="version"
# PKG_ARCH="arch"
# PKG_BUILD="build"
# PKG_AUTHOR="author"
# PKG_EXTENSION="extension"
# PKG_MD5="md5"
# PKG_MIRROR_PROTOCOL="a protocol supported by wget" # Like "http://" or "ftp://", etc
# PKG_MIRROR="an alternative mirror to get this package" # Only the address, like google.com or "200.3.124.37"
# PKG_MIRROR_PATH="an alternative path to get this package on the mirror" "without the first and the last slash, like "pub/kwort" or "packages"
#
#/{KPKG_DB_HOME}/installed/serie/pkgname/status
#status:
# PKG_INST_NAME="pkgname"
# PKG_INST_VERSION="version"
# PKG_INST_ARCH="arch"
# PKG_INST_BUILD="build"
# PKG_INST_AUTHOR="author"
# PKG_INST_EXTENSION="extension"
# PKG_INST_MIRROR="a protocol supported by wget" # This is set by kpkg
#
#Global variables:
# REINSTALL:     yes|no
# DROP:          yes|no
# REDOWNLOAD:    yes|no
# MIRROR:        curl protocol supported mirror
# MIRROR_PATH:   mirror path in MIRROR
# ROOT:          a location to install the given package (default /)
# STANDALONE:    yes|no to third party package (default yes)
# SERIE:         a serie name
# KWORT_VERSION: kwort version (don't change unless you know what you are doing)
# KPKG_DB_HOME:  kwort database home (default /var/packages)

###################### SANITIZE ENVIRONMENT FUNCTIONS ########################

if [ -e /etc/kpkg.conf ]; then
	source /etc/kpkg.conf
	if [ -z "${KWORT_VERSION}" ]; then
		KWORT_VERSION="2.4"
	fi
	if [ -z "${KPKG_DB_HOME}" ]; then
		KPKG_DB_HOME="/var/packages"
	fi
else
	KWORT_VERSION="2.4"
	KPKG_DB_HOME=/var/packages
fi

KPKG_VERSION='3.0'

function traping(){
	if [ ! -z "${1}" ]; then
		trap "rm -rf ${TMP}; rm -f ${1}; exit" EXIT INT TERM
	fi
	trap "rm -rf ${TMP}; exit" EXIT INT TERM
}

function kpkg_sanitize_environment(){
	TMP="/tmp/kpkg_tmp$$"
	rm -rf ${TMP}
	mkdir -p ${TMP}
	umask 022
	chmod 0700 ${TMP}
	if [ -z "${MIRROR}" ]; then
		MIRROR_PROTOCOL='ftp://'
		MIRROR="200.3.124.37" # Kwort default mirror
		MIRROR_PATH="pub/kwort/${KWORT_VERSION}/packages" # Kwort mirror default path
	fi
}

function kpkg_empty_environment(){
	rm -rf ${ROOT}/install >/dev/null 2>&1
	if [ -d "${TMP}" ]; then
		rm -rf ${TMP}
	fi
}

function kpkg_clean_variables(){
	PKG=""
	PKG_NAME=""
	PKG_SERIE=""
	PKG_VERSION=""
	PKG_ARCH=""
	PKG_BUILD=""
	PKG_EXTENSION=""
	PKG_MD5=""
	PKG_INST_NAME=""
	PKG_INST_SERIE=""
	PKG_INST_VERSION=""
	PKG_INST_ARCH=""
	PKG_INST_BUILD=""
	PKG_MIRROR_PROTOCOL=""
	PKG_MIRROR=""
	PKG_MIRROR_PATH=""
	PKG_STATUS=""
}

function kpkg_get_standalone_package_data(){
	fullname_with_ext=$(basename ${1})
	IFS='.'
	b=(${fullname_with_ext/*-/})
	for((x=1;x<=$((${#b[@]} - 1));x++)); do
		if [ -z "${PKG_EXTENSION}" ]; then
			PKG_EXTENSION=${b[${x}]}
		else
			PKG_EXTENSION="${PKG_EXTENSION}.${b[${x}]}"
		fi
	done
	if [ -e "${1}" ]; then
		PKG_MD5=$(md5sum "${1}" | cut -d \  -f 1)
	fi
	fullname=$(basename "${1}" ".${PKG_EXTENSION}")
	IFS='-'
	fullname_array=(${fullname})
	i=$((${#fullname_array[@]} - 1))
	PKG_BUILD=${fullname_array[${i}]/[A-Za-z]*/}
	PKG_AUTHOR=$(echo ${fullname_array[${i}]} | sed "s/^[0-9]*//g")
	i=$((${i} - 1))
	PKG_ARCH=${fullname_array[${i}]}
	i=$((${i} - 1))
	PKG_VERSION=${fullname_array[${i}]}
	i=$((${i} - 1))
	for((x=0;x<=${i};x++)); do
		if [ -z "${PKG_NAME}" ]; then
			PKG_NAME="${fullname_array[${x}]}"
		else
			PKG_NAME="${PKG_NAME}-${fullname_array[${x}]}"
		fi
	done
	IFS=" "
	if [[ "${STANDALONE}" == [nN][oO] ]]; then
		if [ "${SERIE}" != "" ]; then
			PKG_SERIE=${SERIE}
		else
			PKG_SERIE="noserie"
		fi
	else
		PKG_SERIE="standalone"
		PKG_NAME="${PKG_NAME}-tpp"
		i=1
		while [ ! -z "$(find ${KPKG_DB_HOME}/installed -type d -maxdepth 2 -mindepth 2 -name "${PKG_NAME}${i}")" ]; do
			i=$((${i} + 1))
		done
		PKG_NAME="${PKG_NAME}${i}"
	fi
}


############################# DATABASE FUNCTIONS #############################


function kpkg_update_mirror(){
	kpkg_sanitize_environment
	traping "${TMP}/db.tar.gz"
	pushd ${TMP} >/dev/null
	wget ${MIRROR_PROTOCOL}${MIRROR}/${MIRROR_PATH}/../db.tar.gz -O db.tar.gz
	if [ $? -eq 0 ]; then
		rm -f "${MIRROR}"
		mkdir -p ${KPKG_DB_HOME}/repos/${MIRROR}
		cd ${KPKG_DB_HOME}/repos/${MIRROR}
		tar xpzf ${TMP}/db.tar.gz
		echo "Done (update) ${MIRROR}."
		ret=0
	else
		rm -f db.tar.gz 1>/dev/null 2>&1
		echo "Database download corrupted, aborting."
		ret=1
	fi
	kpkg_empty_environment
	return ${ret}
}

function kpkg_update(){
	i=0
	cd ${KPKG_DB_HOME}/repos
	if [[ "${1}" == [Aa][Ll][Ll] ]]; then
		for x in *; do 
			if [ "${x}" != "local" ]; then
				datafile=$(ls */*/*/data | head -n 1)
				if [ -e "${datafile}" ]; then
					MIRROR=${x}
					source "${datafile}"
					MIRROR_PROTOCOL="${PKG_MIRROR_PROTOCOL}"
					MIRROR_PATH="${PKG_MIRROR_PATH}"
					kpkg_update_mirror
					i=$((${i} + $?))
				fi
			fi
		done
	else
		kpkg_update_mirror
		i=$((${i} + $?))
	fi
	if [ ${i} -ne 0 ]; then
		echo "${i} failed to update"
	fi
}

function kpkg_give_package_vars(){
	PKG=`find . -type d -maxdepth 2 -mindepth 2 -name ${1}`
	if [ -z "${PKG}" ]; then
		return 1
	fi
	source ${PKG}/data 2>/dev/null
	if [ -e /var/packages/installed/${PKG_SERIE}/${PKG_NAME}/status ]; then
		source /var/packages/installed/${PKG_SERIE}/${PKG_NAME}/status 2>/dev/null
	fi
	return 0
}

function kpkg_package_search_in_repos(){
	cd ${KPKG_DB_HOME}/repos
	if [ -z "${MIRROR}" ]; then
		i=0
		for x in *; do
			PKGS[${i}]=`find ${x} -type d -maxdepth 2 -mindepth 2 -name $(basename ${1})`
			if [ -n "${PKGS[${i}]}" ]; then
				i=$((${i} + 1))
			fi
		done
		if [ ${i} -eq 0 ]; then
			echo "Package not found."
			return 1
		fi
		if [ ${i} -gt 1 ]; then
			echo "More than one package was found in several mirrors."
			echo "Set the MIRROR variable to choose from which on you want to install."
			for((n=0;n<${i};n++)); do
				echo " * ${PKGS[${n}]/\/*/}"
			done
			return 1
		fi
		cd "${PKGS[0]/\/*/}"
		PKG="$(basename ${PKGS[0]})"
		unset PKGS
	elif [ ! -d "${MIRROR}" ]; then
		echo "Mirror set, but not found in database."
		return 1
	else
		cd "${MIRROR}"
		PKGS=`find . -type d -maxdepth 2 -mindepth 2 -name $(basename ${1})`
		if [ -z "${PKGS}" ]; then
			echo "Package not found."
			return 1
		fi
		PKG=$(basename ${PKG})
	fi
	return 0
}

function kpkg_package_search(){
	if [ "${1}" = "exact" ]; then
		PKG_FOUND=`find . -type d -maxdepth 2 -mindepth 2 -name "${2}"`
		if [ -z "${PKG_FOUND}" ]; then
			return 1
		fi
		source  ${PKG_FOUND}/status >/dev/null 2>&1
	else
		PKG_FOUND=`find . -type d -maxdepth 2 -mindepth 2 -name "*${2}*"`
		if [ -z "${PKG_FOUND}" ]; then
			return 1
		fi		
	fi		
	return 0
}

function kpkg_create_new_installed_db_component(){
	mkdir -p ${KPKG_DB_HOME}/installed/${PKG_SERIE}/${PKG_NAME}
}

function kpkg_mark_package_as_installed(){
	status_file=${KPKG_DB_HOME}/installed/${PKG_SERIE}/${PKG_NAME}/status
	echo "PKG_INST_NAME=\"${PKG_NAME}\"" > ${status_file}
	echo "PKG_INST_VERSION=\"${PKG_VERSION}\"" >> ${status_file}
	echo "PKG_INST_ARCH=\"${PKG_ARCH}\"" >> ${status_file}
	echo "PKG_INST_BUILD=\"${PKG_BUILD}\"" >> ${status_file}
	echo "PKG_INST_AUTHOR=\"${PKG_AUTHOR}\"" >> ${status_file}
	echo "PKG_INST_EXTENSION=\"${PKG_EXTENSION}\"" >> ${status_file}
	echo "PKG_INST_SERIE=\"${PKG_SERIE}\"" >> ${status_file}
	echo "PKG_INST_MIRROR=\"${PKG_MIRROR}\"" >> ${status_file}
	unset status_file
}

function kpkg_unregister_installed_package(){
	rm -rf ${KPKG_DB_HOME}/installed/${PKG_INST_SERIE}/${PKG_INST_NAME} >/dev/null 2>&1
}   

function kpkg_create_new_db_component_in_local_mirror(){
	data_file=${KPKG_DB_HOME}/repos/local/${PKG_SERIE}/${PKG_NAME}/data
	mkdir -p $(dirname "${data_file}")
	echo "PKG_NAME=\"${PKG_NAME}\"" > ${data_file}
	echo "PKG_SERIE=\"${PKG_SERIE}\"" >> ${data_file}
	echo "PKG_VERSION=\"${PKG_VERSION}\"" >> ${data_file}
	echo "PKG_ARCH=\"${PKG_ARCH}\"" >> ${data_file}
	echo "PKG_BUILD=\"${PKG_BUILD}\"" >> ${data_file}
	echo "PKG_AUTHOR=\"${PKG_AUTHOR}\"" >> ${data_file}
	echo "PKG_EXTENSION=\"${PKG_EXTENSION}\"" >> ${data_file}
	echo "PKG_MD5=\"${PKG_MD5}\"" >> ${data_file}
	echo "PKG_MIRROR_PROTOCOL=\"${PKG_MIRROR_PROTOCOL}\"" >> ${data_file}
	echo "PKG_MIRROR=\"${PKG_MIRROR}\"" >> ${data_file}
	echo "PKG_MIRROR_PATH=\"${PKG_MIRROR_PATH}\"" >> ${data_file}
}

kpkg_unregister_package_from_local_mirror(){
	rm -rf ${KPKG_DB_HOME}/repos/local/${PKG_SERIE}/${PKG_NAME}
}

############### KWORT ESSENTIAL PACKAGE MANAGMENT FUNCTION ###################


function kpkg_package_return_information_tar.lzma(){
	COMPRESSED=`du -b "${package}" | awk -F " " '{print $1}'`
	UNCOMPRESSED=`lzmainfo "${package}" | grep Uncompressed | awk -F " " '{print $5}' | cut -d '(' -f 2`
	if [ -n "${COMPRESSED}" ]; then
		COMPRESSED="`expr $COMPRESSED / 1024` K"
	fi
	if [ -n "${UNCOMPRESSED}" ]; then
		UNCOMPRESSED="`expr $UNCOMPRESSED / 1024` K"
	else
		UNCOMPRESSED=unknown
	fi
}   

function kpkg_package_return_information_tgz(){
	COMPRESSED=`du -b ${package} | awk -F " " '{print $1}'`
	UNCOMPRESSED=`gzip -l $package | grep -v uncompressed | awk -F " " '{print $2}'`
	if [ -n "${COMPRESSED}" ]; then
		COMPRESSED="`expr $COMPRESSED / 1024` K"
	fi
	if [ -n "${UNCOMPRESSED}" ]; then
		UNCOMPRESSED="`expr $UNCOMPRESSED / 1024` K"
	else
		UNCOMPRESSED=unknown
	fi
}

function kpkg_uncompress_tgz(){
	TAR=tar
	pushd $ROOT/ >/dev/null
	$TAR xzlpvf ${package} >> ${TMP}/files.log 2> /dev/null
	ret=$?
	popd >/dev/null
	return ${ret}
}

function kpkg_uncompress_tar.lzma(){
	TAR=tar
	pushd $ROOT/ >/dev/null
	$TAR xalpvf ${package} >> ${TMP}/files.log 2> /dev/null
	ret=$?
	popd >/dev/null
	return ${ret}
}

function kpkg_get_desc_tar.lzma(){
	if [ -e /install/slack-desc ]; then
		cat /install/slack-desc
	fi
}

function kpkg_get_desc_tgz(){
	if [ -e /install/slack-desc ]; then
		cat /install/slack-desc
	fi 
}

function kpkg_run_finish_commands_tar.lzma(){
	if [ -x /sbin/ldconfig ]; then
		/sbin/ldconfig
	fi 
	if [ -f $ROOT/install/doinst.sh ]; then
		( cd ${ROOT}/ ; sh install/doinst.sh -install; )
	fi 
}

function kpkg_run_finish_commands_tgz(){
	if [ -x /sbin/ldconfig ]; then
		/sbin/ldconfig
	fi 
	if [ -f $ROOT/install/doinst.sh ]; then
		( cd ${ROOT}/ ; sh install/doinst.sh -install; )
	fi 
}

function kpkg_extra_commands_db_tar.lzma(){
	fullname=${KPKG_DB_HOME}/installed/${PKG_SERIE}/${PKG_NAME}/${PKG_NAME}-${PKG_VERSION}-${PKG_ARCH}-${PKG_BUILD}${PKG_AUTHOR}
	if [ -f $ROOT/install/doinst.sh ]; then
		cat $ROOT/install/doinst.sh | sed -n 's,^( *cd \([^ ;][^ ;]*\) *; *rm -rf \([^ )][^ )]*\) *) *$,\1/\2,p' >> ${fullname}
	fi
}

function kpkg_extra_commands_db_tgz(){
	fullname=${KPKG_DB_HOME}/installed/${PKG_SERIE}/${PKG_NAME}/${PKG_NAME}-${PKG_VERSION}-${PKG_ARCH}-${PKG_BUILD}${PKG_AUTHOR}
	if [ -f $ROOT/install/doinst.sh ]; then
		cat $ROOT/install/doinst.sh | sed -n 's,^( *cd \([^ ;][^ ;]*\) *; *rm -rf \([^ )][^ )]*\) *) *$,\1/\2,p' >> ${fullname}
	fi
}


########################## KPKG INSTALL FUNCTIONS #############################


function kpkg_init_installdb_pkg(){
	package="${1}"
	kpkg_package_return_information_${PKG_EXTENSION}
	echo "PACKAGE NAME: ${PKG_NAME}" > ${TMP}/init.log
	echo "COMPRESSED PACKAGE SIZE: $COMPRESSED" >> ${TMP}/init.log
	echo "UNCOMPRESSED PACKAGE SIZE: $UNCOMPRESSED" >> ${TMP}/init.log
	echo "PACKAGE LOCATION: ${KPKG_DB_HOME}/installed/${PKG_SERIE}/${PKG_NAME}" >> ${TMP}/init.log
}   

function kpkg_finish_installdb_pkg(){
	fullname=${KPKG_DB_HOME}/installed/${PKG_SERIE}/${PKG_NAME}/${PKG_NAME}-${PKG_VERSION}-${PKG_ARCH}-${PKG_BUILD}${PKG_AUTHOR}
	kpkg_get_desc_${PKG_EXTENSION} > ${TMP}/desc.log
	cat ${TMP}/init.log > ${fullname}
	if [ -s ${TMP}/desc.log ]; then
		echo "PACKAGE DESCRIPTION:" >> ${fullname}
		cat ${TMP}/desc.log >> ${fullname}
	fi  
	echo "FILE LIST:" >> ${fullname}
	cat ${TMP}/files.log >> ${fullname}
	kpkg_extra_commands_db_${PKG_EXTENSION}
}   

function kpkg_installpkg(){
	kpkg_sanitize_environment
	kpkg_create_new_installed_db_component
	kpkg_init_installdb_pkg ${check_file}
	kpkg_uncompress_${PKG_EXTENSION}
	if [ $? -ne  0 ]; then
		kpkg_empty_environment
		return 1
	fi
	kpkg_finish_installdb_pkg
	kpkg_run_finish_commands_${PKG_EXTENSION}
	kpkg_mark_package_as_installed
	kpkg_empty_environment
	return 0
}

function kpkg_install_standalone_package(){
	kpkg_clean_variables
	kpkg_sanitize_environment
	kpkg_get_standalone_package_data "${1}"
	PKG_MIRROR_PROTOCOL="file://"
	PKG_MIRROR="local"
	PKG_MIRROR_PATH=""
	kpkg_create_new_db_component_in_local_mirror
	kpkg_create_new_installed_db_component
	kpkg_init_installdb_pkg "${1}"
	kpkg_uncompress_${PKG_EXTENSION}
	if [ $? -ne  0 ]; then
		kpkg_empty_environment
		return 1
	fi
	kpkg_finish_installdb_pkg
	kpkg_run_finish_commands_${PKG_EXTENSION}
	kpkg_mark_package_as_installed
	kpkg_empty_environment
	return 0
}

function kpkg_install(){
	if [ -e "${1}" ]; then
		kpkg_install_standalone_package "${1}"
		echo "Done (install) ${1}."
		return 0
	fi
	kpkg_package_search_in_repos "${1}"
	if [ -z "${PKG}" ]; then
		return 1
	fi
	kpkg_give_package_vars ${PKG}
	if [[ -d "${KPKG_DB_HOME}/installed/${PKG_SERIE}/${PKG_NAME}" ]] && [[ "${REINSTALL}" != [Yy][Ee][Ss] ]]; then
		echo "Package already installed (use: REINSTALL=yes to reinstall anyways)."
		return 1
	fi
	check_file="${KPKG_DB_HOME}/repos/${PKG_MIRROR}/${PKG_SERIE}/${PKG_NAME}/${PKG_NAME}-${PKG_VERSION}-${PKG_ARCH}-${PKG_BUILD}${PKG_AUTHOR}.${PKG_EXTENSION}"
	if [ ! -e "${check_file}" -o "$(md5sum ${check_file} | cut -d \  -f 1)" != "${PKG_MD5}" ]; then
		rm -f "${check_file}"
		fork=$(kpkg_download "${PKG}")
		if [ $? -ne 0 ]; then
			echo "Failed (download) ${PKG_NAME}"
			return 1
		fi
	fi
	kpkg_installpkg
	if [ $? -ne 0 ]; then
		echo "Failed (install) ${PKG_NAME}."
		return 1
	fi
	echo "Done (install) ${PKG_NAME}."
	return 0
}


########################## KPKG DOWNLOAD FUNCTIONS ############################


function kpkg_downloadpkg(){
	fullname=${PKG_SERIE}/${PKG_NAME}-${PKG_VERSION}-${PKG_ARCH}-${PKG_BUILD}${PKG_AUTHOR}.${PKG_EXTENSION}
	download_name=${KPKG_DB_HOME}/repos/${PKG_MIRROR}/${PKG_SERIE}/${PKG_NAME}/${PKG_NAME}-${PKG_VERSION}-${PKG_ARCH}-${PKG_BUILD}${PKG_AUTHOR}.${PKG_EXTENSION}
	traping ${download_name}
	wget ${PKG_MIRROR_PROTOCOL}${PKG_MIRROR}/${PKG_MIRROR_PATH}/${fullname} -O ${download_name}
	if [ $? -ne 0 ]; then
		return 1
	fi 
	unset download_name fullname
	return 1
}

function kpkg_download(){
	kpkg_package_search_in_repos "${1}"
	if [ -z "${PKG}" ]; then
		return 1
	fi
	kpkg_give_package_vars ${PKG}
	if [ "${PKG_MIRROR_PROTOCOL}" = "file://" ]; then
		echo "Package not found in database."
		return 1
	fi
	check_new="${PKG_SERIE}/${PKG_NAME}/${PKG_NAME}-${PKG_VERSION}-${PKG_ARCH}-${PKG_BUILD}${PKG_AUTHOR}.${PKG_EXTENSION}"
	if [[ -e "${check_new}" ]] && [[ "${REDOWNLOAD}" != [yY][eE][sS] ]]; then
		echo "Package already downloaded (use: REDOWNLOAD=yes to redownload anyways)."
		return 1
	fi
	if [ -e "${check_new}" ]; then
		rm -f "${check_new}"
	fi
	kpkg_downloadpkg
	if [ $? -eq 0 ]; then
		if [ "${PKG_MD5}" != "$(md5sum ${check_new} | cut -d \  -f 1)" ]; then
			rm -f "${check_new}"
			echo "Package corrupted, aborting."
			return 1
		fi
	else
		echo "Error downloading package."
		return 1
	fi
	echo "Done (download) ${PKG}."
	return 0
}


########################### KPKG REMOVE FUNCTIONS #############################


function kpkg_remove_files(){
	pushd / >/dev/null
	while read file; do
		if [ "${file}" = "FILE LIST:" ]; then
			return 0
		fi
		if [ -f "${file}" -o -h "${file}" ]; then
			rm -f "${file}"
		fi
		if [ -d "${file}" ]; then
			files_inside_dir=$(ls -A ${file} | wc -l)
			if [ "${files_inside_dir}" = "0" ]; then
				rmdir "${file}"
			fi  
		fi  
	done < <(tac ${fullname})
	popd >/dev/null
}

function kpkg_removepkg(){
    kpkg_remove_files
	kpkg_unregister_installed_package
	if [ "${PKG_MIRROR_PROTOCOL}" = "file://" ]; then
		kpkg_unregister_package_from_local_mirror
	fi
}

function kpkg_remove(){
	cd ${KPKG_DB_HOME}/installed
	kpkg_package_search exact "${1}"
	if [ $? -ne 0 ]; then
		echo "Package not found in database."
		return 1
	fi
    fullname="${KPKG_DB_HOME}/installed/${PKG_INST_SERIE}/${PKG_INST_NAME}/${PKG_INST_NAME}-${PKG_INST_VERSION}-${PKG_INST_ARCH}-${PKG_INST_BUILD}${PKG_INST_AUTHOR}"
    if [ ! -e "${fullname}" ]; then
        echo "Package not installed."
        return 1
    fi
    kpkg_removepkg
    echo "Done (remove) ${1}."
	return 0
}


########################### KPKG SEARCH FUNCTIONS #############################


function print_search_given_data(){
    if [ "${1}" == "standalone" ]; then
        echo " * serie:     ${1} (Third party package)"
    else 
        echo " * serie:     ${1}"
    fi
    echo " * version:   ${2}"
    echo " * arch:      ${3}"
    echo " * build:     ${4}"
    echo " * author:    ${5}"
    echo " * extension: ${6}"
    echo " * mirror:    ${7}"
}

# The next function sucks! It transform a linear method in a cuadratic algorithm
# So yeah, it sucks!
function kpkg_search_in_array(){
	if [ ${#INST[@]} -eq 0 ]; then
		return 0
	fi
	for((i=0;i<${#INST[@]};i++)); do
		nPKG=$(echo "${INST[${i}]}" | cut -d '|' -f 1)
		mPKG=$(echo "${INST[${i}]}" | cut -d '|' -f 2)
		if [ "${mPKG}" = "${PKG_MIRROR}" ]; then
			return 0
		fi
	done
	return 1
}

function kpkg_search(){
	cd ${KPKG_DB_HOME}
	i=0
	for KPKG_MIRROR in installed repos/*; do
		pushd "${KPKG_MIRROR}" >/dev/null
		kpkg_package_search noexact "${1}"
		for xPKG in ${PKG_FOUND}; do
			if [ "${KPKG_MIRROR}" = "installed" ]; then
				source ${xPKG}/status
				INST[${i}]="${PKG_NAME}|${PKG_MIRROR}"
				echo "Package found (installed): ${PKG_INST_NAME}"
				print_search_given_data "${PKG_INST_SERIE}" "${PKG_INST_VERSION}" "${PKG_INST_ARCH}" "${PKG_INST_BUILD}" "${PKG_INST_AUTHOR}" "${PKG_INST_EXTENSION}" "${PKG_INST_MIRROR}"
				datafile="${KPKG_DB_HOME}/repos/${PKG_INST_MIRROR}/${PKG_INST_SERIE}/${PKG_INST_NAME}/data"
				if [ -e ${datafile} ]; then
					source ${datafile}
					if [ "${PKG_INST_VERSION}" != "${PKG_VERSION}" -o "${PKG_INST_BUILD}" != "${PKG_BUILD}" ]; then
						echo "THERE IS A NEW VERSION OF THIS PACKAGE"
					fi
				fi
				echo
			else
				if [ ${KPKG_MIRROR} != "local" ]; then
					source ${xPKG}/data
					kpkg_search_in_array 
					if [ $? -eq 0 ]; then
						echo "Package found: ${PKG_NAME}"
						print_search_given_data "${PKG_SERIE}" "${PKG_VERSION}" "${PKG_ARCH}" "${PKG_BUILD}" "${PKG_AUTHOR}" "${PKG_EXTENSION}" "${PKG_MIRROR}"
						echo
					fi
				fi
			fi
			kpkg_clean_variables
		done
		popd >/dev/null
		unset PKG_FOUND INST
	done
	return 0
}


########################### KPKG UPGRADE FUNCTIONS ############################


function kpkg_upgrade_serie(){
	if [ ! -d "${1}" ]; then
		echo "Serie not found."
		return 1
	fi
	pushd "${1}" >/dev/null
	for x in *; do
		if [ -d "${x}" ]; then
			source ${x}/status >/dev/null 2>&1
			if [ "${PKG_INST_MIRROR}" != "local" ]; then
				source "${KPKG_DB_HOME}/${PKG_INST_MIRROR}/${PKG_INST_SERIE}/${PKG_INST_NAME}/${PKG_INST_NAME}/data"
				if [ "${PKG_VERSION}" != "${PKG_INST_VERSION}" ]; then
					kpkg remove ${PKG_NAME}
					MIRROR=${PKG_INST_MIRROR} kpkg install ${PKG_NAME}
				fi
			fi
			kpkg_clean_variables
		fi
	done
	popd >/dev/null
}

function kpkg_upgrade(){
	cd ${KPKG_DB_HOME}/installed
	if [ ! -z "${1}" ]; then
		kpkg_upgrade_serie ${1}
		return 0
	fi
	for x in *; do
		if [ -d "${x}" ]; then
			kpkg_upgrade_serie ${x}
		fi
	done
	return 0
}


################################ INITIAL PROGRAM  ############################


function say_help(){
cat << EOF
Usage: kpkg OPTION [package,series]
 update           update the local packages database
 install          install local package or from a mirror
 download         download a package from the mirror
 remove           remove a package from the system
 search           search for a package in the system and in the mirror
 upgrade          upgrade the whole system or a package series

Kpkg ${KPKG_VERSION} by David B. Cortarello (Nomius) <nomius@users.berlios.de>
EOF
}

traping
case "${1}" in
	search)
		shift 1
		for i in $@; do
			kpkg_clean_variables
			kpkg_search ${i}
		done
	;;
	download)
		shift 1
		for i in $@; do
			kpkg_clean_variables
			kpkg_download ${i}
		done
	;;
	install)
		shift 1
		for i in $@; do
			kpkg_clean_variables
			kpkg_install ${i}
		done
	;;
	remove)
		shift 1
		for i in $@; do
			kpkg_clean_variables
			kpkg_remove ${i}
		done
	;;
	upgrade)
		shift 1
		if [ -z "${1}" ]; then
			kpkg_upgrade
		else
			for i in $*; do
				kpkg_upgrade ${i}
			done
		fi
	;;
	update)
		kpkg_update "${2}"
	;;
	*)
		say_help
	;;
esac