#!/bin/bash
################################################################################
# Author: Fred (support@qo-op.com)
# Version: 0.1
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
###########################################################################################
###########################################################################################
# Lit les données reçues depuis un lecteur de QR Code branché en USB/SERIE (/dev/ttyACM0)
# Interpète les G1QRcodes et les G1Tag (R/W)
# Saisie du montant à transférer par pavé numérique
###########################################################################################

echo "REWRITING NEEDED"
exit 
########################################################################

echo "__SUB:tag_READ_XY.sh: QRCODE READER : START"
function log () {
		echo "$line
$1" >> /tmp/tag_READ_XY.log
}
source ./init.sh
source ./functions.sh
##############################################
# NODE ENVIRONEMENT DETECTION
##############################################
YOU=$(ps auxf --sort=+utime | grep -w ipfs | grep -v -E 'color=auto|grep' | tail -n 1 | cut -d " " -f 1);
IPFSNODEID=$(su $YOU -c "ipfs id -f='<id>\n'")
NODE_UIDNA=$(cat "/home/$YOU/.zen/ipfs/.$IPFSNODEID/G1SSB/_uidna")

MY_PATH="`dirname \"$0\"`"              # relative
MY_PATH="`( cd \"$MY_PATH\" && pwd )`"  # absolutized and normalized

SWARM_G1PUBKEY=$(cat "${GPATH}/g1sms.pub.key")
SWARM_G1AUTHFILE="${GPATH}/g1sms.priv.key"
if [[ ! -f $SWARM_G1AUTHFILE ]]; then echo "ERREUR CLEF DECHIFFRAGE!"; exit; fi

## INIT NODE G1 PUB & PRIV KEY
NODE_G1PUBKEY=$(cat "${GPATH}/g1sms.preoni.pub.key")
NODE_PUBSECFILE="${GPATH}/g1sms.preoni.priv.key"


if [[ ! -e "/dev/ttyACM0" ]]; then echo "Branchez votre lecteur de QR code!"; exit; fi
##############################################

# DOUCHETTE ES TU LA?
./tools/4LETTER.scroll.py "G1TX START"
./tools/4LETTER.clock.py &
clockpid=$!

# TABLEAU MEMOIRE DE SCAN
declare -a act
declare -a obj
declare -a val

cat /dev/ttyACM0 | while read line; do
    kill $clockpid

    lon=${#line}
    pref=$(echo $line | cut -d ":" -f 1)
    qrvalue=$(echo $line | cut -d ":" -f 2)
    log "__SUB:tag_READ_X.sh: SCAN /dev/ttyACM0 ($lon) :: $line"

    case $pref in
    RJ)
        R=$(echo $qrvalue | cut -d '#' -f 1)
        J=$(echo $qrvalue | cut -d '#' -f 2)
        log "__SUB:tag_READ_X.sh: Lecture G1Tag $R $J"
        # IPFS READ
        ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
        if [[ "$ID" == "" ]]; then
            ./tools/4LETTER.scroll.py ">> BAD G1TAG <<"
            continue
        fi
        # Get First R Tag name word and remove space for RR
        FID=$(echo $ID | awk '{print toupper($1)}')
        RR=$(echo $ID | sed s/\ //g)

        ./tools/4LETTER.scroll.py "${#act[@]} $FID > "
        RVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount");
        CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')

        PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
        if [[ "$PASSENGER" != "" ]]; then
            ./tools/4LETTER.scroll.py "G1TAG PASSENGER $RVALUE ZEN"
        else
            G1VAL=$(bc -l <<< "scale=2; $RVALUE / 100" | cut -d '.' -f 1)
            log "__SUB:tag_READ_X.sh: G1Tag $FID. Valeur $RVALUE $CURRENCY = $G1VAL G1"
            ./tools/4LETTER.scroll.py "$RVALUE ZEN *** $G1VAL G1"
        fi
        cmd="RJ"
        CASHBACK=""
        val+=("$RVALUE")
    ;;

    BJ)
        BB=$(echo $qrvalue | cut -d '#' -f 1)
        J=$(echo $qrvalue | cut -d '#' -f 2)
        log "__SUB:tag_READ_X.sh: Ouverture G1Tag $BB $J"
        #
        ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
        if [[ "$ID" == "" ]]; then
            ./tools/4LETTER.scroll.py ">> BAD G1TAG <<"
            continue
        fi
        FID=$(echo $ID | awk '{print toupper($1)}')
        RR=$(echo $ID | sed s/\ //g)

        ./tools/4LETTER.scroll.py "${#act[@]} $FID TX >>"
        BVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount")
        CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')

        PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
        # DIG PUBLISHING KEY
        if [[ -f ~/.ipfs/keystore/$RR ]]; then
            log "__SUB:tag_READ_X.sh: Clef de publication IPFS $RR déjà présente"
        else
            rm /tmp/TAG_publishkey.B.gpg
            su $YOU -c "ipfs get -o /tmp/ /ipns/$J/TAG_publishkey.B.gpg"
            ./tools/4LETTER.scroll.py "** GPG **"
            gpg -d --output /tmp/ipns.key --pinentry-mode=loopback --passphrase $BB /tmp/TAG_publishkey.B.gpg
            # CHECK IF OK
            if [[ ! -f /tmp/ipns.key ]]; then
                ./tools/4LETTER.scroll.py ">> BAD GPG KEY <<"
                continue
            fi
            mv /tmp/ipns.key ~/.ipfs/keystore/$RR
            log "__SUB:tag_READ_X.sh: Récupération de la clef de publication $RR"
        fi
        if [[ "$PASSENGER" != "" ]]; then
            log "__SUB:tag_READ_X.sh: !!!! $FID REC Tag = $BVALUE $CURRENCY"
            ./tools/4LETTER.scroll.py "G1TAG PASSENGER $BVALUE ZEN"
        else
            G1VAL=$(bc -l <<< "scale=2; $BVALUE / 100" | cut -d '.' -f 1)
            log "__SUB:tag_READ_X.sh: Ce G1 Tag $FID contient $BVALUE $CURRENCY"
            ./tools/4LETTER.scroll.py "$BVALUE ZEN *** $G1VAL G1 MAX"
        fi
        cmd="BJ"
        val+=("$BVALUE")
    ;;

    *)
        if [[ $lon -eq 44 ]]; then
            ./tools/4LETTER.scroll.py "PORTEFEUILLE G1 >>>>>>>> ${#act[@]}" &
            J=$qrvalue
            if [[ "$J" != "${obj[0]}" ]]; then
                VALUE=$(silkaj_balance $J)

                if [[ "$(echo $VALUE | cut -d ':' -f 1)" != "Error" && "$VALUE" != "" ]]; then
                    log "__SUB:tag_READ_X.sh: Ce compte monnaie libre contient $VALUE G1"
                    NOPOINT=$(echo $VALUE | cut -d '.' -f 1)
                    ./tools/4LETTER.scroll.py " $NOPOINT G1 *** $NOPOINT G1 "
                    CASHBACK="$J"
                    cmd="G1"
                    val+=("$VALUE")
                else
                    if [[ "$VALUE" == "" ]]; then
                        log "__SUB:tag_READ_X.sh: ERREUR TIMEOUT. CHANGE SILKAJ SERVER: $DUNITER" 
                        ./tools/4LETTER.scroll.py "ERREUR TIMEOUT SILKAJ"
                        ./timeout.sh -t 1 ./tools/4LETTER.spinner.py
                        CASHBACK=""
                    else
                        log "__SUB:tag_READ_X.sh: ERREUR QRCODE ILLISIBLE. longueur $J = ${#J}"
                        ./tools/4LETTER.scroll.py "ERREUR QRCODE INCONNU"
                        ./timeout.sh -t 1 ./tools/4LETTER.spinner.py
                        CASHBACK=""
                    fi
                fi
            else
                ./tools/4LETTER.scroll.py " 2 X "
            fi
        else
            ./tools/4LETTER.scroll.py "ERREUR QRCODE INCONNU"
        fi

    ;;

    esac

    ###############################################################
    # APRES G1 CASHBACK : G1 Tag BJ WRITE => ENCAISSEMENT
    if [[ "${cmd}" == "BJ" && "$CASHBACK" != "" && -f ~/.ipfs/keystore/${RR} ]]; then
        ./tools/4LETTER.scroll.py "ZEN -> G1"
        log "__SUB:tag_READ_X.sh: G1 tag de $BVALUE G1 ! /ipns/$J Virement vers $CASHBACK? "

        ./tools/4LETTER.spinner.py &
        spinnerpid=$!

        # ipfs get G1Tag vers ./TAG/${RR}
        mkdir -p ./TAG/${RR}; rm -f ./TAG/${RR}/*; chown -R $YOU ./TAG/${RR}/
        log "__SUB:tag_READ_X.sh: ipfs get --output=./TAG/${RR} /ipns/$J"
        su $YOU -c "ipfs get --output=./TAG/${RR} /ipns/$J"

        if [[ $(cat ./TAG/${RR}/TAG_passenger) != "" ]]; then ./tools/4LETTER.scroll.py "IMPOSSIBLE TAG PASSENGER $BVALUE ZEN"; continue; fi

        # Make Silkaj TX
        G1VAL=$(bc -l <<< "scale=2; $BVALUE / 100" | cut -d '.' -f 1)
        log "__SUB:tag_READ_X.sh: Silkaj TX $SWARM_G1AUTHFILE ($G1VAL) -> $CASHBACK"
        PAY=$(./silkaj/silkaj transaction --auth-file -file="$SWARM_G1AUTHFILE" --amount=$G1VAL --output=$CASHBACK --comment="[G1sms+] G1Tag $RR ZEN -> G1" -y)

        log "__SUB:tag_READ_X.sh: Silkaj output = $PAY"
        # Stop 1LETTER.spinner.py
        kill $spinnerpid
 
        if [[ "$(echo $PAY | cut -d '|' -f 1)" == "KO" && "$PAY" != "" ]]; then
            new=$(./checknodes.sh "BAN")
            sms_ERROR "$ADMINPHONE" "Il est survenu un problème avec un virement. Retour silkaj: $PAY ... $new";
            ./tools/4LETTER.scroll.py "ERREUR SILKAJ ERREUR"
        else
        # ENCAISSEMENT G1Tag
            ./tools/4LETTER.scroll.py "VIR ${FID} $G1VAL G1 -> OK "
            # CAPTURE / DESTRUCTION du G1 Tag
            echo "0" > "./TAG/${RR}/TAG_amount"
            echo "${J}" > "./TAG/${RR}/TAG_ipns"

            # Iterate
            if [[ -f ./TAG/${RR}/TAG_n ]]; then NN=$(cat ./TAG/${RR}/TAG_n); ((NN++)); else NN=0; fi

            # TAG_actions
            echo "$NN" > "./TAG/${RR}/TAG_n"
            echo "${NANODATE}" > "./TAG/${RR}/TAG_nanodate"
            echo "${IPFSNODEID}" > "./TAG/${RR}/TAG_writerid"

            # EMPTY G1TAG ID AND REMOVE PUBLISHKEYS
            echo "" > "./TAG/${RR}/TAG_id"
            rm -f ./TAG/TAG_publishkey.*

            log "__SUB:tag_READ_X.sh: Destruction G1Tag TAG_id $NN.${NANODATE} (par NODE ${IPFSNODEID}) => Value = 0"
            I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
            # TAG_chain
            echo "$I" > "./TAG/${RR}/TAG_chain"
            I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
            # IPNS $RR PUBLISH
            J=$(su $YOU -c "ipfs name publish -k ${RR} --quieter /ipfs/${I}")

            log "__SUB:tag_READ_X.sh: Destruction de ce G1 Tag publish -k ${RR} --quieter /ipfs/${I} :: ipfs ls /ipns/$J"
            ./tools/4LETTER.scroll.py "DETRUIRE G1TAG ${FID}"

            # CLEAN IPFS keystore: remove NOT created NODE keys
            SOURCENODEID=$(cat "./TAG/${RR}/TAG_nodeid")
            if [[ "${SOURCENODEID}" != "${IPFSNODEID}" ]]; then
                rm -f ~/.ipfs/keystore/${RR}
            fi
        fi
    else
        # AJOUT MEMOIRE SCAN
        ./timeout.sh -t 1 ./tools/4LETTER.spinner.py
        act+=("$cmd")
        obj+=("$J")
    fi

    
    # FLUSH MEMOIRE 2 SCAN
    if [[ ${#act[@]} -eq 2 ]]; then
        echo "${act[@]}"
        echo "${obj[@]}"
        echo "${val[@]}"
        ###############################################################
        # PRESENTATION RJ puis BJ différents Tag WRITE = TRANSFERT G1 TAG
        if [[ "${act[0]}" == "RJ" &&  "${act[1]}" == "BJ"  && "${obj[0]}" != "${obj[1]}" ]]; then
            PASSENGER=$(su $YOU -c "ipfs cat /ipns/${obj[1]}/TAG_passenger");
            if [[ "$PASSENGER" != "" ]]; then
                ./tools/4LETTER.scroll.py "IMPOSSIBLE TAG PASSENGER";
            else
                ###########################################################
                # READ KEYBOARD VALUE !!! 4 DIGIT REMOVING LEADING 0
                COMBIEN=$(./tools/matrixKeypad.py | sed 's/^0*//')
                if [[ $COMBIEN -le ${val[1]} ]]; then
                    COMBIENZEN=$(bc -l <<< "$COMBIEN * 100")
                    log "__SUB:tag_READ_X.sh: Transfert de G1 Tag à G1 Tag. $COMBIEN"
                    ./tools/4LETTER.scroll.py "G1TAG ${FID} -> TX $COMBIENZEN ZEN *** $COMBIEN G1"
                    log "__SUB:tag_READ_X.sh: ./tag_OP.sh ${obj[1]} ${obj[0]} $COMBIENZEN $SWARM_G1AUTHFILE"
                    ./tag_OP.sh ${obj[1]} ${obj[0]} $COMBIENZEN "$SWARM_G1AUTHFILE"
                else
                    ./tools/4LETTER.scroll.py "ERREUR $COMBIEN > VALEUR DE ${FID} *** ${val[1]} ZEN"
                fi
            fi
            CASHBACK=""
        fi
        ###############################################################
        # PRESENTATION BJ identiques TRANSFORMATION G1 TAG en REC TAG
        if [[ "${act[0]}" == "BJ" &&  "${act[1]}" == "BJ"  && "${obj[0]}" == "${obj[1]}" ]]; then
            PASSENGER=$(su $YOU -c "ipfs cat /ipns/${obj[0]}/TAG_passenger");
            if [[ "$PASSENGER" != "" ]]; then
                ./tools/4LETTER.scroll.py "DEJA TAG PASSENGER";
            else
                log "__SUB:tag_READ_X.sh: Transformation du G1 Tag en Rec Tag. ${val[0]} = ${val[1]}"
                ./tools/4LETTER.scroll.py "TRASNFORMATION G1TAG ${val[0]} ZEN EN PASSENGER ${FID}";
                log "__SUB:tag_READ_X.sh: $(./tag_OP.sh ${obj[0]} ${obj[0]} 0 $SWARM_G1AUTHFILE)"
            fi
            CASHBACK=""
        fi

        act=()
        obj=()
        val=()
        # END OF 2-PASS READ
        ./timeout.sh -t 2 ./tools/4LETTER.spinner.py
    fi
    
    ./tools/4LETTER.blink.py
    ./tools/4LETTER.clock.py &
    clockpid=$!
done