#!/bin/bash

SQLITE=/usr/bin/sqlite3

# Connector fifos directory
read TMPDIR < <(mktemp -d /dev/shm/bc_shell_XXXXXXX)

fd=1
# find next free fd
nextFd() {
    while [ -e /dev/fd/$fd ];do ((fd++)) ;done
}

# instanciator for myXxx() function associated to a started and long-running
# instance of the requested command and arguments and initial input data
# (the command will be associated to two descriptors IN and OUT, local to
#  the instanciated function)
newConnector() {
    local command="$1" cmd=${1##*/} args="$2" check="$3" verif="$4"
    local initfile cinfd=${cmd^^}IN coutfd=${cmd^^}OUT FIFO=$TMPDIR/$cmd input
    shift 4
    mkfifo $FIFO
    nextFd
    eval "exec $fd> >(LANG=C exec stdbuf -o0 $command $args >$FIFO 2>&1) ; $cinfd=$fd;"
    nextFd
    eval "exec $fd<$FIFO;$coutfd=$fd;"
    
    for initfile ;do
	cat >&${!cinfd} $initfile
    done

    source <(echo "my${cmd^}() {
		local in;
 		echo >&${!cinfd} \"\$1\" &&
 		read -u ${!coutfd} \${2:-in};
 		((\$#==2)) || echo \$in;
		}"
       )

    my${cmd^} $check input
    [ "$input" = "$verif" ] ||
	printf >&2 "WARNING: Don't match! '%s' <> '%s'.\n" "$verif" "$input"
    rm $FIFO
}

# SQL Connector
# Stronger, because output length is not fixed, could by empty.
declare bound SQLIN SQLOUT SQLERR lastsqlread
newSqlConnector() {
    local command="$1" cmd=${1##*/} args="$2" check="$3" verif="$4"
    # this work with "sqlite", but also with "mysql", "mariadb" or "postgresql"

    # First building some uniq bound string
    local _Bash64_refstr _out=-- _l _i _num
    printf -v _Bash64_refstr "%s" {0..9} {a..z} {A..Z} @ _ 0
    for ((_l=6;_l--;));do
	_num=$((RANDOM<<15|RANDOM))
	for ((_i=0;_i<30;_i+=6));do
	    _out+=${_Bash64_refstr:(_num>>_i)&63:1}
	done
    done
    printf -v bound "%s-%s-%s-%s-%s" ${_out:0:8} \
	   ${_out:8:4} ${_out:12:4} ${_out:16:4} ${_out:20};
    # Initiate long running sqlite with 2 output feeds.
    FIFOUT=$TMPDIR/sqlout
    FIFERR=$TMPDIR/sqlerr
    mkfifo $FIFOUT
    mkfifo $FIFERR
    nextFd
    eval "exec $fd> >(exec stdbuf -o0 $command $args >$FIFOUT 2>$FIFERR)"
    SQLIN=$fd
    nextFd
    eval "exec $fd<$FIFOUT;"
    SQLOUT=$fd
    nextFd
    eval "exec $fd<$FIFERR;"
    SQLERR=$fd
    rm $FIFOUT $FIFERR
}

# newSqlConnector /usr/bin/sqlite3 "-separator $'\t' -header /dev/shm/test.sqlite"
# newSqlConnector /usr/bin/psql    "-Anh hostname -F $'\t' --pset=footer=off user"
# newSqlConnector /usr/bin/mysql   "-h hostname -B -p database"

mySqlite() {
    # return nothing but errors via stderr (comment `echo >&2` line and
    # uncomment previous line with `eval ${result}_e` for changing this
    # behaviour) this set two (or tree if error) variables: `$1` containing
    # sql answer and `${1}_h` containing header fields (and ${1}_e for
    # errors if uncommented).
    local result=$1 line head=""
    shift
    echo >&$SQLIN "$@" # Send command request, then

    ### Ask for outputing bound... This for sqlite:
    echo >&$SQLIN "SELECT STRFTIME('%s',DATETIME('now')) AS \"$bound\";"
    ### This for psql:
    #  echo >&$SQLIN "SELECT EXTRACT('EPOCH' FROM now()) AS \"$bound\";"
    ### This for mysql:
    #  echo >&$SQLIN "SELECT UNIX_TIMESTAMP() AS \"$bound\";"

    read -ru $SQLOUT line
    if [ "$line" != "$bound" ] ;then
	IFS=$'\t' read -a ${result}_h <<< "$line";
	while read -ru $SQLOUT line && [ "$line" != "$bound" ] ;do
	    eval "$result+=(\"\$line\")"
	done
    fi
    read -ru $SQLOUT line
    lastsqlread="$line"
    # then once bound readed without timeout, we could read SQLERR with
    # very short timeout
    while read -ru $SQLERR -t .0002 line;do
	# eval "${result}_e+=(\"\$line\")"
	echo >&2 "$line"
    done
}
myPsql() {
    local result=$1 line head="";shift ; echo >&$SQLIN "$@";
    echo >&$SQLIN "SELECT EXTRACT('EPOCH' FROM now()) AS \"$bound\";"
    read -ru $SQLOUT line
    if [ "$line" != "$bound" ] ;then
	IFS=$'\t' read -a ${result}_h <<< "$line";
	while read -ru $SQLOUT line && [ "$line" != "$bound" ] ;do
	    eval "$result+=(\"\$line\")"
	done
    fi
    read -ru $SQLOUT line
    lastsqlread="$line"
    while read -ru $SQLERR -t .0002 line;do
	echo >&2 "$line"
    done
}
myMysql() {
    local result=$1 line head="" ;shift
    echo >&$SQLIN "$@"; echo >&$SQLIN "SELECT UNIX_TIMESTAMP() AS \"$bound\";"
    read -ru $SQLOUT line
    if [ "$line" != "$bound" ] ;then
	IFS=$'\t' read -a ${result}_h <<< "$line";
	while read -ru $SQLOUT line && [ "$line" != "$bound" ] ;do
	    eval "$result+=(\"\$line\")"
	done; fi
    read -ru $SQLOUT line
    lastsqlread="$line"
    while read -ru $SQLERR -t .0002 line;do echo >&2 "$line";done
}

# As each fifo used by connectors are already deleted, just drop
# fifo's directory on exit.
trap "rmdir $TMPDIR;exit" 0 1 2 3 6 9 15

###
### End of ``connectors'' definitions
###

#
# Exit here if script is sourced
[ "$0" = "$BASH_SOURCE" ] || {
    true
    return 0
}

#
### Sample use: define some connectors for further use...
#

# instanciate a long-running bc command which we will then be
# able to interact with with myBc().
# Initialize them by declaring `mil` function, to compute
# human readable, returning `A,XX.YYY` where A mean power of 1K
# and XX.YYY is value divided by 1024**A.
newConnector /usr/bin/bc "-l" 'mil(0)' '0,0' - <<-"EOF"
    define void mil (s) {
	if (s==0) { print "0,0\n"; return;};
	p=l(s)/l(1024);
	scale=0;
	p=p/1;
	scale=20;
	print p,",",s/1024^p,"\n";
	}
	EOF

# instanciate a long-running date command which we will then be able
# to interact with with myDate(), convert date input to UnixTimeStamp.
newConnector /bin/date '-f - +%s' @0 0

# instanciate a long-running sqlite command with file based on /dev/shm
# Interact with mySqlite

# Test if sqlite is present
if [ ! -x $SQLITE ];then
    echo >&2 "Tool '$SQLITE' not found (please correct SQLITE var if installed)."
    exit 1
fi

newSqlConnector $SQLITE "-separator $'\t' -header /dev/shm/test.sqlite"

# mySqlite foo 'DROP TABLE IF EXISTS files;'
# mySqlite foo 'CREATE TABLE files (perms,user,date UNSIGNED BIGINT,size UNSIGNED BIGINT,name);'
cat >&$SQLIN <<-EOSQLInit
	DROP TABLE IF EXISTS files;
	CREATE TABLE files (perms, user, date UNSIGNED BIGINT,
		size UNSIGNED BIGINT,name);
	EOSQLInit

declare -a ABR=(K M G T P)

{
    read headline
    echo "dtot=0;duse=0;" >&$BCIN
    while read filesystem type size used free prct mpoint;do
	echo >&$BCIN "dtot+=$used+$free;duse+=$used;"
	myBc "100*$used/($used+$free)" mpct
	myBc "mil($used)" Used
	myBc "mil($used+$free)" Total
	printf "%-26s %-8s %7.2f%s %7.2f%s %9s %7.2f%%\n" "$mpoint" "$type" \
	       ${Used#*,} ${ABR[${Used%,*}]} ${Total#*,} ${ABR[${Total%,*}]} \
	       $prct $mpct
    done
} < <(LANG=C df -kT)

myBc "mil(dtot)" Total
myBc "mil(duse)" Used
printf "%-36s%7.2f%s %7.2f%s\n" Total \
       ${Used#*,} ${ABR[${Used%,*}]} ${Total#*,} ${ABR[${Total%,*}]}

ABR=('' ${ABR[@]})
echo "ftot=0;" >&$BCIN

{
    read headline
    while read perm blk user group size month day yot name;do
	echo >&$BCIN "ftot+=$size"
	myDate "$month $day $yot" Date
	echo >&$SQLIN "INSERT INTO files values('$perm','$user',$Date,$size,'$name');"
#	myBc "mil($size)" Size
#	printf " %-11s %-12s %(%F %H:%M)T  %7.2f%-2s  %s\n" $perm $user \
#	       $Date ${Size#*,} ${ABR[${Size%,*}]}b "$name"
    done
} < <(LANG=C /bin/ls -l)

mySqlite myarray "SELECT * from files order by date;"

printf "%-12s %-12s %16s %10s  %s\n" "${myarray_h[@]}"
for line in "${myarray[@]}";do
    IFS=$'\t' read perm user date size name <<<"$line"
    myBc "mil($size)" Size
    printf " %-11s %-12s %(%F %H:%M)T  %7.2f%-2s  %s\n" $perm $user $date \
	   ${Size#*,} ${ABR[${Size%,*}]}b "$name"
    done
myBc "mil(ftot)" Total

mySqlite stot 'SELECT SUM(size) FROM files;'
myBc "mil($stot)" STotal

printf "%18sby bc:%7.2f%-2s,   by sql:%7.2f%-2s  %s\n" '' \
       ${Total#*,} ${ABR[${Total%,*}]}b ${STotal#*,} ${ABR[${STotal%,*}]}b Total

myBc ftot bctot
[ "$bctot" = "$stot" ] || echo "Strange: '$bctot' and '$stot' don't match!"

myDate now now
printf "%-14s: %(%a %d %b %T)T\n" \
       "Last SQL read" $lastsqlread "now by date" $now "now by bash" -1

mySid=$(ps ho sid $$)
ps --sid $mySid fw