_reef-pi

#!/bin/bash
###############################################################
# Bash completion script for reef-pi command line function
# it should be installed in 
#    /usr/share/bash-completion/completions/_reef-pi
# so that it's available in all bash terminal shells
###############################################################
_set_option_variables() {
    TOP_LEVEL_OPTIONS=("db daemon restore-db reset-password install --help -version")
    DB_OPTIONS="buckets list show create update delete --help"
    DAEMON_OPTIONS=("-config" "--help")
    RESET_PASSWORD_OPTIONS=("-user" "-password" "-config" "--help")
    RESTORE_DB_OPTIONS=("-backup" "-current" "-new" "--help")
    RESTORE_DB_BACKUP_OPTIONS=("/var/lib/reef-pi/reef-pi.db.old")
    RESTORE_DB_CURRENT_OPTIONS=("/var/lib/reef-pi/reef-pi.db")
    RESTORE_DB_NEW_OPTIONS=("/var/lib/reef-pi/reef-pi.db.new")
    INSTALL_OPTIONS=("-version")
    INPUT_OPTION="-input"
    OUTPUT_OPTION="-output"
    STORE_OPTION="-output"
    REEF_PI_LIST_ITEMS_CMD="sudo reef-pi db list "
    REEF_PI_LIST_REEF_PI_CMD="sudo reef-pi db list reef-pi "
    REEF_PI_BUCKETS_CMD="sudo reef-pi db buckets "
    REEF_PI_VERSION_CMD="sudo reef-pi -version "
    REEF_PI_CONFIG_PATH="/etc/reef-pi/reef-pi.yml"
    USER_ENTRY=0
    PASSWORD_ENTRY=1
}

# helper logging method
_e() { echo "$1" >> log; }

_get_buckets() 
{
    BUCKETS=("$(${REEF_PI_BUCKETS_CMD} | tr '\n' ' ')")
}

_parse_reef_pi_json_for_user_pwd() {
    PYTHON_CODE_TO_EXTRACT_USER_PWD=$(cat <<END_PY_USER
import json
import sys

stdin_str = ""
for line in sys.stdin:
    stdin_str += line

resp = json.loads(stdin_str)

print("%s"%(resp['credentials']['user']))
print("%s"%(resp['credentials']['password']))
    
END_PY_USER
)
    USER_PWD_SUGGESTION="$(echo ${REEF_PI_JSON} | python3 -c "$PYTHON_CODE_TO_EXTRACT_USER_PWD" )"
}

_get_user_pwd_suggestion_array()
{
    local USER_PWD_SUGGESTION
    _parse_reef_pi_json_for_user_pwd
    local IFS=$'\n'      # Change IFS to new line - convert new lines to array
    SUGGESTIONS=($USER_PWD_SUGGESTION)
}

_parse_reef_pi_json_for_user()
{
    local SUGGESTIONS
    _get_user_pwd_suggestion_array
    USER_SUGGESTION=${SUGGESTIONS[USER_ENTRY]}
}

_parse_reef_pi_json_for_password()
{
    local SUGGESTIONS
    _get_user_pwd_suggestion_array
    PASSWORD_SUGGESTION=${SUGGESTIONS[PASSWORD_ENTRY]}
}

_parse_reef_pi_json_for_items() {
    PYTHON_CODE_TO_EXTRACT_ID_AND_NAME=$(cat <<END_PY_ITEM
import json
import sys

stdin_str = ""
for line in sys.stdin:
    stdin_str += line

resp = json.loads(stdin_str)

for key in resp:
    print("%s <%s>"%(resp[key]['id'],resp[key]['name']))
    
END_PY_ITEM
)
    CONFIGURED_ITEM_SUGGESTIONS="$(echo ${CONFIGURED_ITEMS_JSON} | python3 -c "$PYTHON_CODE_TO_EXTRACT_ID_AND_NAME" )"
}

_get_item_type() 
{
    case ${ITEM} in
        ph_calibration | ph_readings) #convert the oddball ph entries
            ITEM_TYPE="phprobes"
        ;;
        reef-pi | system | errors) #buckets without items
            ITEM_TYPE=""
        ;;
        *)
            ITEM_TYPE=$ITEM
        ;;
    esac

    ITEM_TYPE=${ITEM_TYPE%_*} #truncate after underscore
}

_get_reef_pi_configured_items()
{
    local CONFIGURED_ITEMS_JSON
    if [[ ! -z "${ITEM_TYPE}" ]]; then
        CONFIGURED_ITEMS_JSON="$($REEF_PI_LIST_ITEMS_CMD $ITEM_TYPE)"
        _parse_reef_pi_json_for_items
    fi
}

_get_configured_item_suggestions()
{    
    local CONFIGURED_ITEM_SUGGESTIONS 
    _get_reef_pi_configured_items

    local IFS=$'\n'      # Change IFS to new line - convert new lines to array
    local suggestions=($CONFIGURED_ITEM_SUGGESTIONS)

    if [ "${#suggestions[@]}" == "1" ]; then #If array is size one, then get the leading number
        local number="${suggestions[0]/%\ */}"
        COMPREPLY=("$number")
    else
        for i in "${!suggestions[@]}"; do # pad entries to screen width for 1 option per line
            suggestions[$i]="$(printf '%*s' "-$COLUMNS"  "${suggestions[$i]}")"
        done
        COMPREPLY=("${suggestions[@]}")
    fi
}

_get_item_options()
{
    local ITEM_TYPE ITEM
    ITEM=${PREV}
    _get_item_type
    _get_configured_item_suggestions
}

_list_buckets()
{
    _get_buckets
    COMPREPLY=($(compgen -W "$BUCKETS" -- ${CUR}))
}

_db_list_handler()
{
    case ${COMP_CWORD} in
        3) # completing 3rd term
            _list_buckets
            ;;
        *)
            COMPREPLY=()
            ;;
    esac  
}

_db_create_handler()
{
    case ${COMP_CWORD} in
        3) # completing 3rd term
            _list_buckets
            ;;
        4) # completing 4th term
            COMPREPLY=($(compgen -W "$INPUT_OPTION" -- ${CUR}))
            ;;
        5) # completing 5th term
            COMPREPLY=($(compgen -f  -- "${CUR}")) #files for input
            ;;
        *) 
            COMPREPLY=()
            ;;
    esac 
}

_bucket_item_handler()
{
    case ${COMP_CWORD} in
        3) # completing 3rd term
            _list_buckets
            ;;
        4) # completing 4th term
            _get_item_options
            ;;
        *)
            COMPREPLY=()
            ;;
    esac  
}

_db_delete_handler()
{
    _bucket_item_handler
}

_db_show_handler()
{
    _bucket_item_handler
}

_db_update_handler()
{
    case ${COMP_CWORD} in
        3) # completing 3rd term
            _list_buckets
            ;;
        4) # completing 4th term
            _get_item_options
            ;; 
        5) # completing 5th term
            COMPREPLY=($(compgen -W "$INPUT_OPTION" -- ${CUR}))
            ;;
        6) # completing 6th term
            COMPREPLY=($(compgen -f  -- "${CUR}")) #files for input
            ;;
        *) 
            COMPREPLY=()
            ;;
    esac 
}

_db_handler()
{
    local action
    if [[ "${#COMP_WORDS[@]}" -gt "3" ]]; then
        action=${COMP_WORDS[2]}
    fi

    case ${COMP_CWORD} in
        2) # two arguments
            COMPREPLY=($(compgen -W "$DB_OPTIONS" -- ${CUR})) ;;
        3 | 4 | 5 | 6 ) # three or more
            case ${action} in
                buckets)  return  ;;
                list)     _db_list_handler ;;
                show)     _db_show_handler ;;
                create)   _db_create_handler ;;
                delete)   _db_delete_handler ;;
                update)   _db_update_handler ;;
            esac
            ;;
        *) 
            COMPREPLY=()
            ;;
    esac 
}

_get_reef_pi_user()
{
    local USER_SUGGESTION
    local REEF_PI_JSON="$($REEF_PI_LIST_REEF_PI_CMD)"
    _parse_reef_pi_json_for_user
    COMPREPLY=($(compgen -W "$USER_SUGGESTION" -- ${CUR}))
}

_get_reef_pi_password()
{
    local PASSWORD_SUGGESTION
    local REEF_PI_JSON="$($REEF_PI_LIST_REEF_PI_CMD)"
    _parse_reef_pi_json_for_password
    COMPREPLY=($(compgen -W "$PASSWORD_SUGGESTION" -- ${CUR}))
}

_remove_elements_from_array()
{
    declare -n source_array="$1"
    for target in "${ELEMENTS_TO_REMOVE[@]}"; do
        for i in "${!source_array[@]}"; do
            if [[ $target = ${source_array[i]} ]]; then
                unset 'source_array[i]'
            fi
        done
    done
}

_build_used_arguments_in_current_command_line()
{
    declare -n options_array="$1"
    # iterate throught the existing command line and remove options already used
   for argument in ${COMP_WORDS[*]}; do
        for i in "${!options_array[@]}"; do
            if [[ ${options_array[i]} = ${argument} ]]; then 
                ELEMENTS_TO_REMOVE+=(${argument})
            fi 
        done
    done
}

_get_valid_options()
{
   declare -n options="$1"
    local ELEMENTS_TO_REMOVE=()
    _build_used_arguments_in_current_command_line options
    _remove_elements_from_array options
}

_reset_password_user_handler()
{
    case ${PREV} in
        -user)  _get_reef_pi_user ;; 
        *)      COMPREPLY=()      ;;
    esac
}

_reset_password_password_handler()
{
    case ${PREV} in
        -password)  _get_reef_pi_password ;; 
        *)          COMPREPLY=()      ;;
    esac
}

_reset_password_config_handler()
{
    case ${PREV} in
        -config)  COMPREPLY=($(compgen -f -- "/etc/reef-pi/"; compgen -f -- ${CUR}))  ;; 
        *)        COMPREPLY=()      ;;
    esac
}

_reset_password_handler()
{
    case ${PREV} in
        -user)     _reset_password_user_handler ;;
        -password) _reset_password_password_handler ;;
        -config)   _reset_password_config_handler ;;
        *) 
            _get_valid_options RESET_PASSWORD_OPTIONS
            COMPREPLY=($(compgen -W "${RESET_PASSWORD_OPTIONS[*]}" -- ${CUR})) 
        ;;
    esac
}

_restore_db_backup_handler()
{
    case ${PREV} in
        -backup)  COMPREPLY=($(compgen -W "${RESTORE_DB_BACKUP_OPTIONS}" -- ${CUR})) ;; 
        *)      COMPREPLY=()      ;;
    esac
}

_restore_db_current_handler()
{
    case ${PREV} in
        -current)  COMPREPLY=($(compgen -W "${RESTORE_DB_CURRENT_OPTIONS}" -- ${CUR})) ;; 
        *)      COMPREPLY=()      ;;
    esac
}

_restore_db_new_handler()
{
    case ${PREV} in
        -new)  COMPREPLY=($(compgen -W "${RESTORE_DB_NEW_OPTIONS}" -- ${CUR})) ;; 
        *)      COMPREPLY=()      ;;
    esac
}

_restore_db_handler()
{
    case ${PREV} in
        -backup)  _restore_db_backup_handler ;;
        -current) _restore_db_current_handler ;;
        -new)     _restore_db_new_handler ;;
        *) 
            _get_valid_options RESTORE_DB_OPTIONS
            COMPREPLY=($(compgen -W "${RESTORE_DB_OPTIONS[*]}" -- ${CUR})) 
        ;;
    esac
}

_install_handler()
{
    case ${PREV} in
        -version)  
            local current_version=$($REEF_PI_VERSION_CMD)
            COMPREPLY=($(compgen -W "${current_version}" -- ${CUR})) 
        ;;
        *) 
            _get_valid_options INSTALL_OPTIONS
            COMPREPLY=($(compgen -W "${INSTALL_OPTIONS[*]}" -- ${CUR})) 
        ;;
    esac
}

_daemon_handler()
{
    case ${PREV} in
        -config)  
            COMPREPLY=($(compgen -W "${REEF_PI_CONFIG_PATH}" -- ${CUR})) 
        ;;
        *) 
            _get_valid_options DAEMON_OPTIONS
            COMPREPLY=($(compgen -W "${DAEMON_OPTIONS[*]}" -- ${CUR})) 
        ;;
    esac
}

_reef-pi_completions()
{
    _set_option_variables

    local CUR PREV category
    CUR=${COMP_WORDS[COMP_CWORD]}
    PREV=${COMP_WORDS[COMP_CWORD-1]}

    case ${COMP_CWORD} in
        1) # one argument
            COMPREPLY=($(compgen -W "$TOP_LEVEL_OPTIONS" -- ${CUR}))
            ;;
        2 | 3 | 4 | 5 | 6 | 7 ) # two or more arguments
            category=${COMP_WORDS[1]}
            case ${category} in
                daemon)         _daemon_handler ;;
                db)             _db_handler ;;
                install)        _install_handler ;;
                reset-password) _reset_password_handler ;;
                restore-db)     _restore_db_handler ;;
            esac
            ;;
        *)
            COMPREPLY=()
            ;;
    esac
}
complete -F _reef-pi_completions reef-pi