#!/bin/bash

echo "==> CKIT - Construction KIT"


# ******************** SETTINGS ********************

#account ftp
ftpaddress="ftp.deelab.org"
foo=""
bar=""

#sito
httpaddress="http://www.deelab.org"
#organizzazione sito: $httpaddress/arch/$arch/

#cartella di compilazione
builddir="$HOME/pkg/yaourtbuild"

#cartella del repository NON DEVE ESSERE MAI TOCCATA
repodir="$HOME/pkg/CKIT"

#cache. dove pescare vecchi pacchetti. toccherà svuotarla a mano ogni tanto
#ho deciso di non automatizzare l'operazione di proposito
cachedir="$HOME/pkg/cache"

#nome repo
repo="deelab"

#architettura
arch="i686"

# ******************** SETTINGS ********************



# CONTROLLO AZIONE
if test -z "$1"; then
	echo "==> SOMARO! Devi darmi un'azione!"
	echo "==> Scegli tra check, update, build, build1, add o remove."
	exit 0
fi
touch $repodir/listabuild
touch $repodir/listacheck
echo "==> Ok, azione scelta $1."



# CHECK
if [ "$1" == "check" ]; then

	if [ -f $repodir/listacheck ]; then
		rm $repodir/listacheck;
	fi
	touch $repodir/listacheck
	cd $repodir

	if [ -f $repo.db.tar.gz ]; then
		rm $repo.db.tar.gz
	fi
	wget $httpaddress/arch/$arch/$repo.db.tar.gz &>/dev/null
	
	echo "==> Controllo le versioni dei pacchetti e stampo solo quelli che vanno aggiornati."

	REGEX=".*-(svn|cvs|hg|git|bzr|darcs|devel)"
	
	for i in $(tar -tf $repo.db.tar.gz | grep -vE 'desc|depends' | sed -e 's:\/$::g'); do 

		pacco=$(echo $i | rev | cut -d'-' -f3- | rev)
		foo=$(echo $i | rev | cut -d'-' -f2 | rev)
		bar=$(echo $i | rev | cut -d'-' -f1 | rev)
		repover=$(echo $foo-$bar)
		
		#controllo su aur
		url="http://aur.archlinux.org/packages/$pacco/$pacco/PKGBUILD"
		if PKGBUILD=$(wget -q -O - "$url"); then
			aurver="$(eval "$PKGBUILD" &>/dev/null; echo "$pkgver-$pkgrel")"
		else 
			aurver="Null"
		fi
		
		#controllo in locale
		if pacman -Q $pacco &> /dev/null; then
			localver="$(LANG=C pacman -Qi "$pacco" | awk '/^Version/ {print $3}')"
		else
			localver="Null"
		fi
		
		#controllo devel
		if [[ "$pacco" =~ $REGEX ]] && [ -d $builddir/$pacco ]; then
			cd $builddir/$pacco
			develver=$(makepkg -o 2>&1 | grep $pacco | awk '{print $6}')
			cd ~
			result=$(vercmp "$repover" "$develver")
		else
			develver="Null"
			result=$(vercmp "$repover" "$aurver")
		fi
				
		if [[ "$result" < 0 ]]; then
			echo "  -> $pacco REPO:$repover LOCAL:$localver AUR:$aurver DEVEL:$develver"
			echo $pacco >> /tmp/CKIT
			cat /tmp/CKIT $repodir/listacheck > /tmp/listacheck
			rm /tmp/CKIT
			mv /tmp/listacheck $repodir/listacheck
		fi
			
	done

fi # CHECK



# UPDATE
if [ "$1" == "update" ]; then
	echo "==> Aggiorno i PKGBUILD locali con quelli di AUR."
	
	for i in $(tar -tf $repo.db.tar.gz | grep -vE 'desc|depends' | sed -e 's:\/$::g'); do 
		pacco=$(echo $i | rev | cut -d'-' -f3- | rev)
		printf "  -> $pacco: aggiorno con il PKGBUILD di AUR? (y/n) "
		read risposta
		if [ "$risposta" == "y" ]; then
			cd $builddir
			wget http://aur.archlinux.org/packages/$pacco/$pacco.tar.gz &>/dev/null
			tar -xf "$pacco.tar.gz"
			rm $pacco.tar.gz
		fi
	done

fi # UPDATE



# BUILD
if [ "$1" == "build" ]; then
	# CONTROLLO GLI ARGOMENTI DEL BUILD
	if test -z "$2" || test -z "$3" || test -z "$4"; then
		echo "==> Per il build mi servono [pacchetto] [flag1] [flag2]"
		echo "==> flag1=1 per prendere da AUR il PKGBUILD"
		echo "==> flag2=1 per compilare da root"
		exit 0
	fi

	echo "==> Compilo senza uppare. Preparativi per il PKGBUILD."
	cd $builddir

	# PKGBUILD
	if [ "$3" == "1" ]; then
		echo "==> Tiro il pacco da aur"
		wget http://aur.archlinux.org/packages/$2/$2.tar.gz &>/dev/null
		tar -xf "$2.tar.gz"
		rm $builddir/$2.tar.gz
	else
		echo "==> Uso il PKGBUILD locale"
	fi

	cd $2

	# makepkg
	if [ "$4" == "1" ]; then
		echo "==> Compilo da root!"
		sudo makepkg -i --asroot
	else
		echo "==> Compilo da comune mortale!"
		makepkg -i
	fi

	if [ -f $2*-$arch.pkg.tar.gz ]; then
		echo "==> Ok, $2 fatto :)"
		cd $repodir
		mv $builddir/$2/$2*-$arch.pkg.tar.gz $repodir
	
		# AGGIORNO IL FILE LISTA GLOB RM
		echo $2 >> /tmp/CKIT
		cat /tmp/CKIT $repodir/listabuild > /tmp/listabuild
		rm /tmp/CKIT
		mv /tmp/listabuild $repodir/listabuild
	
		echo "==> Attualmente ci sono questi pacchetti da aggiungere al repo:"
		cat $repodir/listabuild
	else
		echo "==> Spiacente, il pacco $2 non compila :("
	fi

fi # BUILD



# BUILD1
if [ "$1" == "build1" ]; then
	echo "==> Processo i pacchetti ottenuti dal check."
	
	if [ $(stat -c%s $repodir/listacheck) == 0 ]; then
		echo "==> Non c'è niente da compilare, fai un check prima!"
		exit 0
	fi
	
	for pacco in $(cat $repodir/listacheck); do
		printf "==> $pacco: vuoi aggiornare? (y/n) "
		read risposta
		
		if [ "$risposta" == "y" ]; then
			cd $builddir
			printf "  -> Vuoi prendere il PKGBUILD da AUR? (y/n) "
			read risposta
			
			if [ "$risposta" == "y" ]; then
				wget http://aur.archlinux.org/packages/$pacco/$pacco.tar.gz &>/dev/null
				tar -xf "$pacco.tar.gz"
				rm $pacco.tar.gz
			else
				echo "  -> ok mantengo quello locale."
			fi
			cd $pacco
			printf "  -> Ti basta compilare da user? (y/n) "
			read risposta
			
			if [ "$risposta" == "y" ]; then
				makepkg -i &>/dev/null
			else
				sudo makepkg -i --asroot &>/dev/null
			fi
			
			if [ -f $pacco*-$arch.pkg.tar.gz ]; then
				echo "  -> Ok, $pacco fatto :)"
				cd $repodir
				mv $builddir/$pacco/$pacco*-$arch.pkg.tar.gz $repodir
	
				# AGGIORNO IL FILE LISTA GLOB RM
				echo $pacco >> /tmp/CKIT
				cat /tmp/CKIT $repodir/listabuild > /tmp/listabuild
				rm /tmp/CKIT
				mv /tmp/listabuild $repodir/listabuild
			else
				echo "  -> Spiacente, il pacco $pacco non compila :("
			fi
		fi
	done
	echo "==> Appena compilati i seguenti pacchetti: "
	cat $repodir/listabuild
fi # BUILD1



# ADD
if [ "$1" == "add" ]; then

	echo "==> Non compilo un cacchio, aggiungo al repo tutti pacchetti presenti nel workspace."
	cd $repodir
	
	# CONTROLLO SE ESISTONO PACCHETTI COMPILATI
	if [ $(stat -c%s $repodir/listabuild) == 0 ]; then
		echo "==> Non c'è niente da aggiungere, fai qualche pacco prima!"
		exit 0
	fi
	
	if [ -f $repo.db.tar.gz ]; then
		rm $repo.db.tar.gz
	fi
	wget $httpaddress/arch/$arch/$repo.db.tar.gz &>/dev/null
	
	#aggiungo al repo
	echo "==> Aggiungo al repo."
	for file in *$arch.pkg.tar.gz; do 
		repo-add $repo.db.tar.gz $file
	done
	
	#db
	echo "==> Invio il db."
	lftp -u "$foo,$bar" $ftpaddress/arch/$arch -e "put $repo.db.tar.gz; exit"
	
	#sego i vecchi
	echo "==> Sego i vecchi pacchetti."
	for riga in $(cat listabuild); do
		lftp -u "$foo,$bar" $ftpaddress/arch/$arch -e "glob rm -f $riga-*-*-$arch.pkg.tar.gz; exit"
	done
	rm lista*
	
	#invio i nuovi
	echo "==> Invio i nuovi pacchetti."
	for file in *$arch.pkg.tar.gz; do 
		lftp -u "$foo,$bar" $ftpaddress/arch/$arch -e "put $file; exit"
		mv $file $cachedir
	done
	
	echo "==> Fine aggiornamento repository."

fi # ADD



# REMOVE
if [ "$1" == "remove" ]; then

	# CONTROLLO GLI ARGOMENTI DEL REMOVE
	if test -z "$2"; then
		echo "==> Dammi anche un pacchetto da cavare però!"
		exit 0
	fi
	
	cd $repodir
	
	if [ -f $repo.db.tar.gz ]; then
		rm $repo.db.tar.gz
	fi
	wget $httpaddress/arch/$arch/$repo.db.tar.gz &>/dev/null
		
	repo-remove $repo.db.tar.gz $2
	echo "==> Segato dal DB!"
		
	echo "==> Invio il DB."
	lftp -u "$foo,$bar" $ftpaddress/arch/$arch -e "put $repo.db.tar.gz; exit"
   
	echo "==> Cancello il pacco."
	lftp -u "$foo,$bar" $ftpaddress/arch/$arch -e "glob rm -f $2-*-*-$arch.pkg.tar.gz; exit"

fi # REMOVE



# AZIONE NON VALIDA
if [ "$1" != "check" ] && [ "$1" != "update" ] && [ "$1" != "build" ] && [ "$1" != "build1" ] && [ "$1" != "add" ] && [ "$1" != "remove" ]; then
	echo "==> CAPRA! $1 non è un'azione valida!!!"
	exit 0
fi



foo="foo"
bar="bar"
cd ~
echo "==> Fine esecuzione CKIT!"