#!/bin/bash

MODULE_DIR=${ROOT_DIR}/remote

#Create tools directory if not exists
TOOL_DIR=${MODULE_DIR}/tools
INIT_DIR=${MODULE_DIR}/stage3.2

initial_checks ()
{
	for BIN in git locate
	do
		local TEST=$(which ${BIN})
		[ -z "$TEST" ] && pinfo "Installing $BIN..." && apt-get install $BIN
	done
}


read_config () 
{
	local TOOL_CONFIG=${TOOL_DIR}/${TOOL}/${TOOL}.conf

	[ ! -e ${TOOL_CONFIG} ] && perror "Config for '$TOOL' not found."

	. ${TOOL_CONFIG}
}

read_build () 
{
	local BUILD_SCRIPT=${TOOL_DIR}/${TOOL}/${TOOL}.build

	[ ! -e ${BUILD_SCRIPT} ] && perror "Build script for specified tool not found."

	. ${BUILD_SCRIPT}
}

copyfileswithdependencies ()
{
	[ ! -d build ] && pinfo "No build directory found, skipping dependency copying" && return 0
	cd build


	COPYFILES_LIST="list_wanted_stage3.2"
	[ -e ${COPYFILES_LIST} ] && rm ${COPYFILES_LIST}

		
	[ ! -z "${REQUIRED_BINARIES}" ] && pinfo "Gathering required binaries from config file..."
	for FILENAME in ${REQUIRED_BINARIES}
	do
		FILE=$(find . -name ${FILENAME} -type f -executable | xargs grep -l '^.ELF'|head -1) # FIXME: What happens on multiple matches? Maybe add " | head -1"
		if [ -z "$FILE" ]; then
			pwarning "\tNo Binary found for ${FILENAME}. Skipping." 
			continue
		fi
	pdebug "\tFound ${FILENAME} at ${FILE}"
	echo "${FILE}" >> "${COPYFILES_LIST}"  
	get_dynamic_dependencies -l "${TOOL_DIR}/${TOOL}/build" "$FILE" >> "${COPYFILES_LIST}"
	done 

	[ ! -z "${REQUIRED_LIBRARIES}" ] && pinfo "Gathering required libraries from config file..."
	for LIB in ${REQUIRED_LIBRARIES}
	do
		for LOCATION in $(find . -name ${LIB})
		do
			pdebug "* $LOCATION"
			echo "${LOCATION}" >> ${COPYFILES_LIST}
			get_dynamic_dependencies -l "${TOOL_DIR}/${TOOL}/build" ${LOCATION} >> ${COPYFILES_LIST}
		done
	done

	[ ! -z "${REQUIRED_DIRECTORIES}" ] && pinfo "Gathering required directories from config file..."
	local CURRENT_PWD=$(pwd) # Prevent calling pwd 50000 times inside the loop below
	for ENTRY in ${REQUIRED_DIRECTORIES}
	do
		pdebug "* ./$ENTRY"
		echo "./${ENTRY}" >> "${COPYFILES_LIST}"
		get_dynamic_dependencies -l "${TOOL_DIR}/${TOOL}/build" ${ENTRY} >> ${COPYFILES_LIST}


		#as as \n
		#echo "./${ENTRY}" >> "${COPYFILES_LIST}"
		#for BIN in $(find "./${ENTRY}" -type f -not -name '*.a' | xargs grep -l '^.ELF')
		#do
	#		pdebug "   Searching libs for ${BIN}..."
#			for i in $(ldd ${BIN} | awk '{print $1 $2 $3}' | grep -v ld-linux | grep -v libc.so | grep -v linux-gate | grep -v linux-vdso)
#			do
#				arrIN=(${i//=>/ })
#				pdebug "      Searching for ${arrIN[0]}...($i)"
#				local LOCAL_MATCHES=$(find . -name "$(echo ${arrIN[0]} | awk -F '.' '{print $1}')".so\*)
#				if [ "x${LOCAL_MATCHES}" != "x" ];
#				then
#					for llib in ${LOCAL_MATCHES};
#					do
#						pdebug "      Found locally, copying ${llib}"
#						echo ${llib} >> "${COPYFILES_LIST}"
#					done
#				else
#					if [ ! -z ${arrIN[1]} ] && [ "x${arrIN[1]}" != "xnot" ];
#					then
#						pdebug "      Not found locally but in system, copying ${arrIN[1]}"
#						echo ${arrIN[1]} >> "${COPYFILES_LIST}"
#						[ -L ${arrIN[1]} ] && echo $(readlink -f "${arrIN[1]}") >> "${COPYFILES_LIST}"
#					else
#						pwarning "Lib '${arrIN[0]}' from required dir '$ENTRY' neither found in build directory nor on this system."
#						pwarning "If this lib is not supplied by another module, this module will probably fail in your final system"
#					fi
#				fi
#			done
#		done
	done

	[ ! -z "${REQUIRED_FILES}" ] && pinfo "Gathering required files from config file..."
	for ENTRY in ${REQUIRED_FILES}
	do
		echo "./${ENTRY}" >> "${COPYFILES_LIST}"
	done


	#copy to initramfsdir
	pdebug "[stage32] Completed file list generation at ${TOOL_DIR}/${TOOL}/build/${COPYFILES_LIST}."
	if [ -s "$COPYFILES_LIST" ]; then
		local CLISTCOUNT=$(cat "$COPYFILES_LIST" | wc -l)
		pinfo "Copying $CLISTCOUNT files to stage 3.2 target directory."
		tar -cp $(cat ${COPYFILES_LIST}|sort -u) | tar -xp -C "${INIT_DIR}"
		local RET=$?
		[ "x$RET" != "x0" ] && perror "Could not tar-copy to $INIT_DIR"
	fi
	unset REQUIRED_BINARIES
	unset REQUIRED_LIBRARIES
	unset REQUIRED_DIRECTORIES
	unset REQUIRED_FILES
}

get_basic_libs () {
	
	[ ! -d ${INIT_DIR} ] && mkdir ${INIT_DIR}
	
	# copy libc and ld-linux separatly
	pinfo "Adding basic libs"
	BASICLIBS=""
	for i in $(ldd ${SHELL})
	do
        	if [ $(echo $i | grep '^/' | grep -c ld) -eq 1 -o  $(echo $i | grep '^/' | grep -c libc.so) -eq 1 ];
	        then
        	        pdebug "Adding $i"
	                BASICLIBS="${BASICLIBS} $i $(readlink -f "$i")"
	        fi
	done
	tar -cp ${BASICLIBS} | tar -xp -C ${INIT_DIR}
	local RET=$?
	[ "x$RET" != "x0" ] && perror "Could not tar-copy to $INIT_DIR"
}

generate_stage32 () {

	initial_checks

	get_basic_libs

	# if no arguments assume all.
	if [ "x$1" = "x" -o "x$1" = "xall" ]; then
		tools=$(ls ${TOOL_DIR})
		set -- $tools
	fi	

	# now iterate over given tools and copy them
	cd ${TOOL_DIR}
	while (( "$#" )); do
		TOOL=$1	
		TOOL_STR=""
		pinfo ">>>>>>>>>>>>>>>> Processing module [ $TOOL ]"
		TOOL_STR="[${TOOL}]"
		if [ -d ${TOOL} ]; then
			#[ "x$DEBUG" != "x1" ] \
			#	&& echo "Logging to ${TOOL_DIR}/${TOOL}/stage32.log" \
			#	&& exec 6>&1 > ${TOOL_DIR}/${TOOL}/stage32.log
			# TODO: Make above work with the new logging system (add function to logging.inc to switch logfile)
	 		cd "${TOOL}"
			pinfo "## Reading config"
			read_config
			pinfo "## Reading build"
			read_build
			pinfo "## Installing dependencies"
			install_dependencies
			pinfo "## Fetching source"
			fetch_source
			pinfo "## Building"
			build
			# remove *.la files as they might confuse libtool/linker of other tool packages
			find "${TOOL_DIR}/${TOOL}/build" -name '*.la' -exec rm -f {} \;
			pinfo "## Copying files with dependencies"
			copyfileswithdependencies
			pinfo "## Post copy"
			post_copy
			cd ${TOOL_DIR}

			# reset pipes
			#[ "x$DEBUG" != "x1" ] && exec 1>&6 6>&- 
			# TODO
			pinfo "## ## Module completed ## ##"
		else
			perror "Tool directory for '$TOOL' not found."
			# maybe make this a warning instead of error?
		fi
		shift
	done
	TOOL_STR=""
}

clean_tools() {
	if [ "x$1" = "x" -o "x$1" = "xall" ]; then
		#clean all
		if [ -d ${INIT_DIR} ]; then
			pinfo "Cleaning ${INIT_DIR}..."
			rm -rf "${INIT_DIR}" || perror "Error deleting $INIT_DIR"
			pinfo "done."
		fi
	        for TOOL in $(ls ${TOOL_DIR}); do
			clean_tool $TOOL
        	done
	else 
		while (( "$#" )); do
			clean_tool $1
			shift
		done
	fi
}

clean_tool() {
        TOOLDIR=${TOOL_DIR}/$1
	pinfo "Cleaning ${TOOLDIR}..."
	#[ -e ${TOOLDIR}/build/list_wanted_stage3.2 ] && cd ${INIT_DIR} \
	#	&& xargs rm < ${TOOLDIR}/build/list_wanted_stage3.2
	#[ -d ${TOOLDIR}/data ] && cd ${INIT_DIR} \
#		&& xargs rm < $(find ${TOOLDIR}/data -type f)
	if [ -e ${TOOLDIR}/.built ]; then
		rm "${TOOLDIR}/.built" || perror "Could not clear built flag"
	fi
	if [ -e ${TOOLDIR}/.fetched_source ]; then
		rm "${TOOLDIR}/.fetched_source" || perror "Could not clear fetched_source flag"
	fi
	if [ -d ${TOOLDIR}/build ]; then
		rm -rf "${TOOLDIR}/build" || perror "Could not delete build path"
	fi
	if [ -d ${TOOLDIR}/src ]; then
		rm -rf "${TOOLDIR}/src" || perror "Could not delete src path"
	fi
	if [ -e ${TOOLDIR}/list_binaries_and_files ]; then
		rm "${TOOLDIR}/list_binaries_and_files" || perror "Could not delete list_binaries_and_files"
	fi
	pinfo "done."
}

#generate_stage32 $@