#!/usr/bin/env bash 

set +u
[ -z "$USER" ] && USER=$(id -un)
set -u

GUEST_OWNER=$USER


# Ces fonctions peuvent êtres utilisées par les scripts de configuration et
# de test d'un réseau.

error() {
	echo -e "\033[0;31;1mError in $SCRIPT !\033[0m" >&2
	echo
	if [ $READ -eq 1 ]; then
		echo
		echo "touche \"Entrée\" pour terminer."
		read
	fi

	exit 1

}

diagOld() {
	printf "%-70s" "$@"	
}

green() {
	local n=""
	[ "$1" = "-n" ] && { n="-n"; shift; }
	echo $n -e "\033[0;32;1m$@\033[0m"
}

red() {
	local n=""
	[ "$1" = "-n" ] && { n="-n"; shift; } 
	echo $n -e "\033[0;31;1m$@\033[0m"
}

diagResult() {
	[ "$1" = 0 ] && green "   ok" || red "   ko"
	echo
}

diagResultWithMessage() {
	echo
	echo -en "$1 ... "
        [ "$2" = 0 ] && green "   ok" || red "   ko"
        echo
}


diag() {
	local r
	local term="-t"
	
	#if [ "$1" = "-t" ]; then
	#	term="-t"
	#	shift
	#fi
	
	if [ "$1" = "-n" ]; then
		term=""
		shift
	fi
	echo -e "$2"
	echo -ne "   Please wait...\r"
	
	set +e
    vdn-ssh $term $1 "$3 &> /dev/null"
	r=$?
	set -e
	echo -ne "                               \r"
    #diagResult $r
    return $r
}


vdnTest() {
        local error=0
        local message="$1"
        local cmd="$2"

	b=$(echo "$1" | base64 | tr '/' '-')

        echo -n "$1 ... "
        eval $cmd &> /dev/null
        error=$?
	#echo -n ""

        [ $error = 0 ] && green ok || red ko

	VDN_TESTS_DIR=/tmp/vdn-$USER/tests
	[ ! -d $VDN_TESTS_DIR ] && mkdir -p $VDN_TESTS_DIR
	echo "$1" > $VDN_TESTS_DIR/$b
	echo $error >> $VDN_TESTS_DIR/$b

        #errors=$(($errors+$error))

        return $error
}


warning() {
	echo -e "\033[1;33;1mWarning in $SCRIPT !\033[0m" >&2
}

request() {
	echo
	echo -e "$@"
	echo
	echo -n "Confirmez (O/n) : "
	read
	if [ -z "$REPLY" -o "$REPLY" = "o" -o "$REPLY" = "O" ]; then
		return 0
	fi
	return 1
}


setDebugMode() {
	[ $VDN_DEBUG = 1 ] && set -x || :
}


setErrorHandler() {
	setDebugMode
	set +u
	[ -z "$SCRIPT" ] && SCRIPT=$(basename "$1") || :
	set -u
	trap "error" 0
}

echoStart() {
	echo
	echo "Start : $SCRIPT"
	#START_DATE=$(date +%s)
}

echoDone() {
	#echo -e "\033[0;32;1m$SCRIPT : done.\033[0m"
	echo
	echo -ne "\033[0;34;1mdone\033[0m (time : "
	gawk 'BEGIN {print strftime("%M:%S)",'$(date +%s)-$START_DATE')}'

}

echoDoneWithTestErrors() {
        #echo -e "\033[0;32;1m$SCRIPT : done.\033[0m"
	errors=${errors:-0}
        echo
	[ "$errors" = 0 ] && green -n ok || red -n ko	
	echo -en " (time : "
        gawk 'BEGIN {print strftime("%M:%S)",'$(date +%s)-$START_DATE')}'
}


unsetErrorHandler() {
	trap - 0
}

startGuests() {
	local i
	local n=0
	for i in $@; do
		echo -n "Alive $i ? : "
		if ! $VDN_PATH/bin/vdn-alive $i ; then
			echo "No : Start $i..."
			set +u
			#set -x
			if [ "$WITH_GUI" = 1 -o "$VDN_GUI" = 1 ]; then
				vdn-start -g $i
			elif [ $IN_BG = 1 ]; then
				vdn-start -b $i
			else
				vdn-start $i
			fi
			#set +x
			n=$((n+1))
			set -u
		else
			echo "Yes"
		fi
	done
	return $n
}

waitSsh() {
	for i in $@; do
		echo "Waiting ssh on $i..."
		local n=0
		#set -x
		until $VDN_PATH/bin/vdn-ssh root@$i : &> /dev/null; do
			if [ $n = 1 ]; then
				echo "Waiting ssh on $i..." >&2
				n=$(n+1)
			fi
			sleep 2
		done
	done
}

requireGuests() {
	set +e
	startGuests $@

	#echo "All guests started !"
	[ $? -ne 0 ] && sleep 1
	set -e
	return 0
}

startAndWaitSsh() {
	#echo "startAndWaitSsh :$DISABLE_SCAN"
	DISABLE_SCAN=${DISABLE_SCAN:-0}
	if [ "$DISABLE_SCAN" != 1 ]; then
		requireGuests $@
		sleep 1
		waitSsh $@
	fi
}

requireSshGuests() { # DEPRECATED
	startAndWaitSsh $@
}

setHostname() {
	echo "setHostname $1"
	vdn-ssh root@$1 "
        echo $1 > /etc/hostname
		hostname -F /etc/hostname
        "
}


setFile() {
	#echo "setFile $1 $2 (functions-script.sh)"
	#set -x
	vdn-ssh root@$1 "cat > $2"
	#set +x
}

setHosts() {
	echo "setHosts $1"
	setFile $1 /etc/hosts
}

setInterfaces() {
	echo "setInterfaces $1"
	setFile $1 /etc/network/interfaces
	#vdn-ssh root@$1 "ip route | grep -q default && ip route del default || : ; service networking restart"
	#cat /etc/network/interfaces
	#ip addr
	#ip route 
	vdn-ssh root@$1 "service networking restart"	
	#sleep 1
}

setForwarding() {
	echo "setForwarding $1"
	# cat /proc/sys/net/ipv4/ip_forward
	vdn-ssh root@$1 "
		sed -i -re 's/#(net.ipv4.ip_forward=1)/\1/g' /etc/sysctl.conf
		sysctl -p | grep net.ipv4.ip_forward
	"
}

setIpv6WorkAround() {
	vdn-ssh root@$1 "
	echo setIpv6WorkAround $1
	if ! grep -q \"^net.ipv6.conf.all.accept_dad = 0\" /etc/sysctl.conf; then
		cat << EOF >> /etc/sysctl.conf
#broken for uml/kvm/qemu, mcast hears itself
net.ipv6.conf.all.accept_dad = 0
net.ipv6.conf.all.dad_transmits = 0
net.ipv6.conf.default.accept_dad = 0
net.ipv6.conf.default.dad_transmits = 0
# and since the interfacs are there before sysctl is run, and the
# all target is an utter linux failure, we have to set it per interface
net.ipv6.conf.lo.accept_dad = 0
net.ipv6.conf.eth0.accept_dad = 0
net.ipv6.conf.eth1.accept_dad = 0
net.ipv6.conf.eth2.accept_dad = 0
net.ipv6.conf.lo.dad_transmits = 0
net.ipv6.conf.eth0.dad_transmits = 0
net.ipv6.conf.eth1.dad_transmits = 0
net.ipv6.conf.eth2.dad_transmits = 0
EOF
		sysctl -p &> /dev/null
		service networking restart
	fi
"
}

pauseRaw() {
        echo
        echo "*** touche \"Entrée\" pour terminer."
        read
}


pause() {
	set +u
	VDN_GUI=${VDN_GUI:-0}
	set +u
	#echo "PAUSE:$PAUSE RUN_PARALLEL:$RUN_PARALLEL IN_PARALLEL=$IN_PARALLEL VDN_GUI=$VDN_GUI VDN_SCRIPTS_LEVEL=$VDN_SCRIPTS_LEVEL"
	#echo "read..."
	#read
	#set -x
	#echo "$PAUSE = 1 -a $IN_PARALLEL = 0 -a \( $VDN_GUI = 1 -a $VDN_SCRIPTS_LEVEL = 1"
	if [ $PAUSE = 1 -a $IN_PARALLEL = 0 -a \( $VDN_GUI = 1 -a $VDN_SCRIPTS_LEVEL = 1 \) ]; then
		if [ "$NO_INTERACTIVE" != 1 ]; then
			echo
			echo "*** touche \"Entrée\" pour terminer."
			read
		fi
	else
		#echo VDN_SCRIPTS_LEVEL:$VDN_SCRIPTS_LEVEL
		if [ $READ = 1 -a $VDN_SCRIPTS_LEVEL -gt 2 ]; then
			#echo "reading"
			#echo "VDN_SCRIPTS_LEVEL:$VDN_SCRIPTS_LEVEL"
			#echo "sleep infinit disable"
			sleep infinity
			#while :; do 
			#	read
			#done
		fi
	fi
	
	#set +x
}

#parallelDisablePause() {
	#[ $RUN_PARALLEL = 1 ] && PAUSE=0 || :
#}

canRunParallel() {
	local r
	set +u
	[ $RUN_PARALLEL = 1 -a "$DISABLE_PARALLEL" != 1 -a $(echo $@ | wc -w) -gt 1 ] && r=0 || r=1
	#[ $RUN_PARALLEL = 1 -a "$DISABLE_PARALLEL" != 1 ] && r=0 || r=1
	set -u
	return $r
}



runParallel() {
	local tmp name

	#[ $RUN_PARALLEL = 1 ] && PAUSE=0 || :
	
	export RUN_PARALLEL
	#export IN_PARALLEL=1
	
	#export IN_PARALLEL=1
	#export PAUSE=0

	[ ! -d $HOME/.tmuxinator ] && (umask 077 && mkdir $HOME/.tmuxinator )

	tmp=$(mktemp -p $HOME/.tmuxinator vdn-tmuxinator-XXXXXX)
	name=$(basename $tmp)
	
	#echo "runParallel: PAUSE:$PAUSE"

	#sleep 3
	
	#if [ $VDN_DEBUG = 1 ]; then
        #tmuxinator new $name
    #else
    #
        #tmuxinator new $name &> /dev/null
    #fi

	
	#echo "NAME is $name"
	#echo "WRITE to $tmp.yml"

cat << EOF > $tmp.sh
#!/bin/bash

quit() { 
    tmuxinator stop $name; 
}

trap quit 0 

tput reset
echo -e '\n\n\n QUIT : Return / CTRL C' 
read
EOF

	cat << EOF > $tmp.conf
set -g mouse on
set -g status-bg white
set -g status-fg blue
set -g status-left '#[fg=blue](#S) #(whoami)@#H#[default]'
set -g pane-active-border-fg blue
EOF


	cat << EOF > $tmp.yml

name: $name
root: $PWD
tmux_options: -f $tmp.conf 

windows:
  - terminal:
      layout: tiled
      panes:
        - clear; bash "$tmp.sh"
EOF

	chmod 700 $tmp.yml

	local i n payload
	n=$(($#+1))
	#n=$(($#))
	payload=0
	if [ $(($n % 3)) != 0 ]; then
		payload=$(( (($n/3)+1)*3 - $n ))
	fi

	[ $n = 2 -o $n = 4 ] && payload=0 || :
	[ $n = 3 ] && payload=1 || :

	#echo "#:$# @:$@"
	#echo "N: $n"
	#echo "PAYLOAD: $payload"
	#sleep 10
	#set -x
	for i in $@; do
		echo "        - cd; export NETWORK_DIR=$NETWORK_DIR; export VDN_GUI=1; export READ=$READ; export PAUSE=$PAUSE; export FORCE_SEQUENTIAL=$FORCE_SEQUENTIAL; clear; $VDN_PATH/bin/vdn-scripts $i" >> $tmp.yml
	done

	for i in $(seq 1 $payload); do
		echo "        - cd; clear; echo -e \"\n\"' Not used !'; sleep infinity" >> $tmp.yml
	done
	#set +x
	#sleep 10
	
	#echo "Press Return"
	#read

	if [ $VDN_DEBUG = 1 ]; then
		tmuxinator start $name 
	else
		tmuxinator start $name &> /dev/null
	fi

	# dump

	local pane

    #for pane in $(tmux list-pane | sed -re 's/^.*(%[0-9]+).*$/\1/'); do
    #    echo "----------------------------"
    #    tmux capture-pane -S -100 -p -t $pane
    #done

	rm $tmp $tmp.yml $tmp.sh $tmp.conf

	#[ $VDN_DEBUG = 0 ] && clear
	#echo "leave: parallel"
}

fn_exists() {
	local r
	#set -x
	set | grep -q "$1 ()"
	r=$?
	#set +x
	return $r
}

prepareRun() {

	#echo "### prepareRun : "

	#setErrorHandler
	#set | grep test
	#echo "SCRIPT:$SCRIPT."
	#echo "ARGS:$ARGS."

	
	if [ -n "$ARGS" ]; then
		fn_exists $ARGS
	else
		fn_exists $SCRIPT
	fi
	local fn=$?

	#echo "FN:$fn (0 is true)"


	if [ $fn = 0 ]; then
		if [ -n "$ARGS" ]; then
			$ARGS
		else
        		$SCRIPT $@
		fi	
                exit
	fi

	#read

	# Not a function

	# is a script ?
	if [ -r $SCRIPT ]; then
		#echo "$SCRIPT is a script !"	
		#echo "ARGS:$ARGS"
		if [ -n "$ARGS" ]; then
        		SCRIPT=$ARGS
        		$SCRIPT
			exit
		fi

		return 0

	fi

	echo "$SCRIPT not a script !"

	#read

	#if [ -n "$ARGS" ]; then
	#	SCRIPT=$1
        #        shift
        #        $SCRIPT $@
        #        exit
	#fi

	exit
}

vdnExec() {
	local L=""

	for i in $@; do
		set | egrep -q "^$i \(\)"

		fn=$?
		#echo "$i => $fn"

		[ $fn = 0 ] && i="$SCRIPT:$i" 
		L="$L $i"
	done

	vdn-scripts $L
}

vdnExecWithErrors() {
	export SHOW_ERRORS=1
	vdnExec $@

}



runSequential() {
	local i
	local r
	local lerrors=0
	
	#export IN_PARALLEL=0
	
	#echo "runSeq: $@ PAUSE:$PAUSE"

	errors=${errors:-0}

	for i in $@; do
		#echo
		#echo -e "Run : $i [$(echo $i | tr ':' ' ')]"
		#echo
		SCRIPT=$i
		#echo "SCRIPT1:$SCRIPT"
		SCRIPT=$(echo $i | tr ':' ' ' | sed -re 's/^ *//' | cut -d ' ' -f 1)
		ARGS=$(echo $i | tr ':' ' ' | sed -re 's/^ *//' | gawk ' { print $2 $3 $4 $5 $6 $7 }')

        	#. $VDN_PATH/bin/functions-scripts.sh

		#echo "SCRIPT2:$SCRIPT"

		. $SCRIPT
		
        
		START_DATE=$(date +%s)
		
		set -e
		
		PAUSE=1


		#echo "runSeq : $SCRIPT args : $ARGS"
		if [ -z "$ARGS" ]; then
			run
			r=$?
		else
			$ARGS
			r=$?
			#echoDone
		fi

		set +u

		#echo "R:$r"
                if [ $r = 0 ]; then
                	success=$((success+1))
                else
                        errors=$((errors+1))
                        lerrors=$((lerrors+1))
	
			#echo "ERRORS ! : $errors"
			#echo "LERRORS ! : $lerrors"
                fi
		set -u

	done

	if [ $VDN_SCRIPTS_LEVEL = 1 ]; then
		if [ $errors != 0 ]; then
			red "Error(s) detected !"
		fi
	fi

	return $errors
}


[ "$VDN_DEBUG" = 1 ] && set -x || :