#!/bin/bash
################################################################################
# Author: Fred (support@qo-op.com)
# Version: 0.1
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
###########################################################################################
###########################################################################################
echo "__SUB:tag_READ.sh: QRCODE READER : START"
source ./shell/init.sh
source ./shell/functions.sh

# DOUCHETTE ES TU LA?
if [ ! $G1TX ]; then ./shell/parle.sh "Branchez votre lecteur de QR code!"; exit; fi

# TABLEAU MEMOIRE DE SCAN
declare -a act
declare -a obj
declare -a val
./shell/parle.sh "Lecteur de G1 Tag. OK. Prêt"

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

    case $pref in
    RJ)
        ./shell/parle.sh "R J"
        R=$(echo $qrvalue | cut -d '#' -f 1)
        J=$(echo $qrvalue | cut -d '#' -f 2)
        log "__SUB:tag_READ.sh: Lecture G1Tag $R $J"
        #
        ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
        if [[ "$ID" == "" ]]; then
            ./shell/parle.sh "G1 Tag déjà capturé, veuillez le détruire!";
            sms_SEND "$ADMINPHONE" "ADMIN! FRAUDE G1Tag RJ $R $J"
            # TODO: ENQUETER auprès du CREATEUR de ce G1 Tag !!
            continue
        fi
        RR=$(echo $ID | sed s/\ //g)
        FID=$(echo $ID | awk '{print toupper($1)}')
        RVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount");
        CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')
        if [[ "$CURRENCY" == "zen" ]]; then CUR="zène"; else CUR=$CURRENCY; fi # Correction du défaut de prononciation.
        PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
        if [[ "$PASSENGER" != "" ]]; then
            ./shell/parle.sh "Rec Tag Machine $PASSENGER! Valeur $RVALUE $CUR";
        else
            G1VAL=$(bc -l <<< "scale=2; $RVALUE / 100" | cut -d '.' -f 1)
            log "__SUB:tag_READ.sh: G1Tag $FID. Valeur $RVALUE $CURRENCY = $G1VAL G1"
            ./shell/parle.sh "G1 Tag $FID. Valeur $RVALUE $CUR convertible en $G1VAL June"
        fi
        cmd="RJ"
        CASHBACK=""
        val+=("$RVALUE")
    ;;

    BJ)
        ./shell/parle.sh "B J"
        BB=$(echo $qrvalue | cut -d '#' -f 1)
        J=$(echo $qrvalue | cut -d '#' -f 2)
        log "__SUB:tag_READ.sh: Ouverture G1Tag $BB $J"
        #
        ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
        FID=$(echo $ID | awk '{print toupper($1)}')
        if [[ "$ID" == "" ]]; then
            ./shell/parle.sh "G1 Tag inconnu! veuillez le détruire!";
            # sms_SEND "$ADMINPHONE" "ADMIN! FRAUDE G1Tag BJ $B $J"
            # TODO: ENQUETER auprès du CREATEUR de ce G1 Tag !!
            continue
        fi
        RR=$(echo $ID | sed s/\ //g)
        BVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount")
        CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')
        if [[ "$CURRENCY" == "zen" ]]; then CUR="zène"; else CUR=$CURRENCY; fi # Correction du défaut de prononciation.
        PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
        # DIG PUBLISHING KEY
        if [[ -f /home/$YOU/.ipfs/keystore/$RR ]]; then
            log "__SUB:tag_READ.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"
            # CHECK IF OK
            gpg -d --output /tmp/ipns.key --pinentry-mode=loopback --passphrase $BB /tmp/TAG_publishkey.B.gpg
            if [[ ! -f /tmp/ipns.key ]]; then
                ./shell/parle.sh "Erreur. Problème de déchiffrage PGP ${FID}! Vérifiez vos logs";
                log "__SUB:tag_READ.sh: ERROR! gpg -d --output /tmp/ipns.key --pinentry-mode=loopback --passphrase $BB /tmp/TAG_publishkey.B.gpg"
                continue
            fi
            mv /tmp/ipns.key /home/$YOU/.ipfs/keystore/$RR
            log "__SUB:tag_READ.sh: Récupération de la clef de publication $RR"
            ./shell/parle.sh "Récupération clef de publication du G1 Tag ${FID}"
        fi
        if [[ "$PASSENGER" != "" ]]; then
            log "__SUB:tag_READ.sh: !!!! REC Tag = $BVALUE $CURRENCY"
            ./shell/parle.sh "Rec Tag Machine! Valeur $BVALUE $CUR";
        else
            log "__SUB:tag_READ.sh: Ce G1 Tag contient $BVALUE $CURRENCY"
            ./shell/parle.sh "Ce G1 Tag contient $BVALUE $CUR"      
        fi
        cmd="BJ"
        val+=("$BVALUE")
    ;;

    *)
        if [[ $lon -eq 44 ]]; then
            ./shell/parle.sh "Portefeuille G1?"
            J=$qrvalue
            if [[ "$J" != "${obj[0]}" ]]; then
                VALUE=$(./shell/timeout.sh -t 15 ./silkaj/silkaj amount $J)

                if [[ "$(echo $VALUE | cut -d ':' -f 1)" != "Error" && "$VALUE" != "" ]]; then
                    log "__SUB:tag_READ.sh: Ce compte monnaie libre contient $VALUE G1"
                    ./shell/parle.sh "Ce compte monnaie libre contient $VALUE G1"
                    CASHBACK="$J"
                    cmd="G1"
                    val+=("$VALUE")
                else
                    log "__SUB:tag_READ.sh: ERREUR QR code illisible. longueur $J = ${#J}"
                    if [[ "$VALUE" == "" ]]; then
                        DUNITER=$(./shell/checknodes.sh 'BAN')
                        echo "TIMEOUT. CHANGE SILKAJ SERVER: $DUNITER"
                        ./shell/parle.sh "Temps dépassé. Changement de serveur $DUNITER"
                        CASHBACK=""
                    else
                        ./shell/parle.sh "QR code inconnu."
                        CASHBACK=""
                    fi
                fi
            else
                ./shell/parle.sh "Ce compte monnaie libre contient ${val[0]} G1"
            fi
        else
            ./shell/parle.sh "QR code de type inconnu"
        fi

    ;;

    esac

    ###############################################################
    # APRES G1 CASHBACK : G1 Tag BJ WRITE => ENCAISSEMENT
    if [[ "${cmd}" == "BJ" && "$CASHBACK" != "" && -f /home/$YOU/.ipfs/keystore/${RR} ]]; then
        ./shell/parle.sh "Encaissement du G1 Tag"
        log "__SUB:tag_READ.sh: G1 tag de $BVALUE G1 ! /ipns/$J Virement vers $CASHBACK? "

        ./shell/parle.sh "vers portefeuille G1"
        # ipfs get G1Tag vers ./TAG/${RR}
        mkdir -p ./TAG/${RR}; rm -f ./TAG/${RR}/*; chown -R $YOU ./TAG/${RR}/
        log "__SUB:tag_READ.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 ./shell/parle.sh "Impossible à encaisser. REC Tag ${FID}. $(cat ./TAG/${RR}/TAG_passenger) de Valeur $BVALUE "; continue; fi

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

        log "__SUB:tag_READ.sh: Silkaj output = $PAY"
        if [[ "$(echo $PAY | cut -d '|' -f 1)" == "KO" ]]; then
            new=$(./shell/checknodes.sh "BAN")
            sms_ERROR "$ADMINPHONE" "Il est survenu un problème avec un virement. Retour silkaj: $PAY ... $new";
            ./shell/parle.sh "Erreur de virement. Changement de serveur Duniter. Veuillez recommencer"
        else
        # ENCAISSEMENT G1Tag
            ./shell/parle.sh "Transfert du Tag ${FID} de $G1VAL G1 vers portefeuille 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.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.sh: Destruction de ce G1 Tag publish -k ${RR} --quieter /ipfs/${I} :: ipfs ls /ipns/$J"
            ./shell/parle.sh "${FID} G1 Tag vide. Merci de détruire ce G1 Tag!"

            # CLEAN IPFS keystore: remove NOT created NODE keys
            SOURCENODEID=$(cat "./TAG/${RR}/TAG_nodeid")
            if [[ "${SOURCENODEID}" != "${IPFSNODEID}" ]]; then
                rm -f /home/$YOU/.ipfs/keystore/${RR}
            fi
        fi
    else
        # AJOUT MEMOIRE SCAN
        ./shell/parle.sh "Mémorisation"
        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
                ./shell/parle.sh "Rec Tag Machine non transférable!";
            else
                log "__SUB:tag_READ.sh: Transfert de G1 Tag à G1 Tag. $BVALUE $CUR"
                ./shell/parle.sh "Transfert de ${val[1]} $CUR vers le G1 Tag ${FID}"
                log "__SUB:tag_READ.sh: $(./shell/tag_OP.sh ${obj[1]} ${obj[0]} ${val[1]} $SWARM_G1AUTHFILE)"
            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
                ./shell/parle.sh "Déjà Rec Tag Machine!";
            else
                log "__SUB:tag_READ.sh: Transformation du G1 Tag en Rec Tag. ${val[0]} = ${val[1]}"
                ./shell/parle.sh "Transformation du G1 Tag ${val[0]} $CUR en Rec Tag chargé de ${FID}..."
                log "__SUB:tag_READ.sh: $(./shell/tag_OP.sh ${obj[0]} ${obj[0]} 0 $SWARM_G1AUTHFILE)"
            fi
            CASHBACK=""
        fi

        act=()
        obj=()
        val=()
        ./shell/parle.sh "Nouveau cycle de lecture."
    fi
    
    ./shell/parle.sh "Flasher un QR code"

done