checkinstall

#!/usr/bin/env bash
#
# PEPATAC pipeline installation check
#

if [ $# -gt 0 ] ; then
  echo "Usage: checkinstall"
  exit 1
fi

set -o pipefail
# set -e

echo -e "-----------------------------------------------------------"
echo -e "                                                           "
echo -e "             PEPATAC installation check                    "
echo -e "                                                           "
echo -e "-----------------------------------------------------------"


################################################################################
# Helpful functions
trim() {
    local var="$*"
    # remove leading whitespace characters
    var="${var#"${var%%[![:space:]]*}"}"
    # remove trailing whitespace characters
    var="${var%"${var##*[![:space:]]}"}"   
    printf '%s' "$var"
}

is_executable() {
    if [ -x "$(command -v $1)" ]; then
        return 0
    else
        return 1
    fi
}

pip_show() {
    if pip show -q $1; then
        return 0
    else
        return 1
    fi
}

RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
NC='\033[0m' # No Color

fail() {
    printf "${RED}\u2716 $@${NC}\n"
}

success() {
    printf "${GREEN}\xE2\x9C\x94 $@${NC}\n"
}

warn() {
    printf "${YELLOW}\u26A0 $@${NC}\n"
}

################################################################################
echo -e "Checking base requirements...                              "

BASE_REQS=0

declare -a requiredPkgs=("looper")

for package in ${requiredPkgs[@]}; do
    if ! pip_show $package; then
        echo $(fail "ERROR: PEPATAC requires the Python package, $package. Try pip install $package.")
        printf "\n"
        exit 1
    fi
done

if [ $BASE_REQS -eq 0 ]; then
    echo $(success "SUCCESS: Minimum requirements met.")
fi  


################################################################################
echo -e "-----------------------------------------------------------"
echo -e "Checking native installation...                            "
NATIVE_INSTALL=0

# Check Python
if ! is_executable "python"; then
    echo $(warn "WARNING: PEPATAC requires python 3.0 or greater. Install python and checkinstall again.")
    printf "\n"
    NATIVE_INSTALL=1
    BULKER_INSTALL=1
else
    ver=$(python -V 2>&1 | sed 's/.* \([0-9]\).\([0-9]\).*/\1\2/')
    if [ "$ver" -lt "30" ]; then
        echo $(warn "WARNING: PEPATAC requires python 3.0 or greater. Update python and checkinstall again.")
        printf "\n"
        NATIVE_INSTALL=1
        BULKER_INSTALL=1
    fi
fi

# Check Python packages
if ! is_executable "pip"; then
    echo $(warn "WARNING: Please install pip and checkinstall again.")
    printf "\n"
    NATIVE_INSTALL=1
    BULKER_INSTALL=1
fi

if [ -f "requirements.txt" ]; then
    REQS="requirements.txt"
else
    REQS=$(curl https://raw.githubusercontent.com/databio/pepatac/master/requirements.txt)
fi

while IFS= read -r line; do
    [ "${line:0:1}" = "#" ] && continue
    
    if [[ $line == *","* ]]; then
        IFS=',' read -r -a array <<< "$line"
        first_half=${array[0]}
        # Check the maximum requirement
        IFS='<' read -r -a array <<< "$first_half"
        package=${array[0]}
        required=${array[2]}
        required=$(trim ${required})
        
        IFS='.' read -r -a required_version <<< "$required"
        declare -i rmajor
        declare -i rminor
        declare -i rpatch
        rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
        rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
        rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

        if ! pip_show "${package}"; then
            echo $(warn "WARNING: PEPATAC requires the Python package, $package, < $required. Try pip install $package and checkinstall again.")
            printf "\n"
            NATIVE_INSTALL=1
            BULKER_INSTALL=1
        else
            installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
            installed=$(trim ${installed})
            IFS='.' read -r -a installed_version <<< "$installed"
            declare -i imajor
            declare -i iminor
            declare -i ipatch
            imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
            iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
            ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

            if ! [ -z "$required" ]; then
                if [ $imajor -gt $rmajor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, < $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -gt $rminor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, < $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -gt $rpatch ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, < $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                else
                    echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                fi
            else
                echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
            fi
        fi
        
        
        second_half=${array[2]}
        # Check the minimum requirement
        IFS='>=' read -r -a array <<< "$second_half"
        required=${array[2]}
        required=$(trim ${required})

        IFS='.' read -r -a required_version <<< "$required"
        declare -i rmajor
        declare -i rminor
        declare -i rpatch
        rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
        rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
        rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

        if ! pip_show "${package}"; then
            echo $(warn "WARNING: PEPATAC requires the Python package, $package, >= $required. Try pip install $package and checkinstall again.")
            printf "\n"
            NATIVE_INSTALL=1
            BULKER_INSTALL=1
        else
            installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
            installed=$(trim ${installed})
            IFS='.' read -r -a installed_version <<< "$installed"
            declare -i imajor
            declare -i iminor
            declare -i ipatch
            imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
            iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
            ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

            if ! [ -z "$required" ]; then
                if [ $imajor -lt $rmajor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -lt $rminor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -lt $rpatch ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                else
                    echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                fi
            else
                echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
            fi
        fi
    elif [[ $line == *">="* ]]; then
        IFS='>=' read -r -a array <<< "$line"
        package=${array[0]}
        required=${array[2]}
        required=$(trim ${required})
        
        IFS='.' read -r -a required_version <<< "$required"
        declare -i rmajor
        declare -i rminor
        declare -i rpatch
        rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
        rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
        rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

        if ! pip_show "${package}"; then
            echo $(warn "WARNING: PEPATAC requires the Python package, $package, >= $required. Try pip install $package and checkinstall again.")
            printf "\n"
            NATIVE_INSTALL=1
            BULKER_INSTALL=1
        else
            installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
            installed=$(trim ${installed})
            IFS='.' read -r -a installed_version <<< "$installed"
            declare -i imajor
            declare -i iminor
            declare -i ipatch
            imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
            iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
            ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

            if ! [ -z "$required" ]; then
                if [ $imajor -lt $rmajor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -lt $rminor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -lt $rpatch ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                else
                    echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                fi
            else
                echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
            fi
        fi
    elif [[ $line == *"=="* ]]; then
        IFS='==' read -r -a array <<< "$line"
        package=${array[0]}
        required=${array[2]}
        required=$(trim ${required})
        
        IFS='.' read -r -a required_version <<< "$required"
        declare -i rmajor
        declare -i rminor
        declare -i rpatch
        rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
        rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
        rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

        if ! pip_show "${package}"; then
            echo $(warn "WARNING: PEPATAC requires the Python package, $package, >= $required. Try pip install $package and checkinstall again.")
            printf "\n"
            NATIVE_INSTALL=1
            BULKER_INSTALL=1
        else
            installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
            installed=$(trim ${installed})
            IFS='.' read -r -a installed_version <<< "$installed"
            declare -i imajor
            declare -i iminor
            declare -i ipatch
            imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
            iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
            ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

            if ! [ -z "$required" ]; then
                if [ $imajor -lt $rmajor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, == $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -lt $rminor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, == $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -lt $rpatch ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, == $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                else
                    echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                fi
            else
                echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
            fi
        fi
    else
        IFS='<' read -r -a array <<< "$line"
        package=${array[0]}
        required=${array[2]}
        required=$(trim ${required})
        
        IFS='.' read -r -a required_version <<< "$required"
        declare -i rmajor
        declare -i rminor
        declare -i rpatch
        rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
        rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
        rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

        if ! pip_show "${package}"; then
            echo $(warn "WARNING: PEPATAC requires the Python package, $package, >= $required. Try pip install $package and checkinstall again.")
            printf "\n"
            NATIVE_INSTALL=1
            BULKER_INSTALL=1
        else
            installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
            installed=$(trim ${installed})
            IFS='.' read -r -a installed_version <<< "$installed"
            declare -i imajor
            declare -i iminor
            declare -i ipatch
            imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
            iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
            ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

            if ! [ -z "$required" ]; then
                if [ $imajor -lt $rmajor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -lt $rminor ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -lt $rpatch ]; then
                    echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                    printf "\n"
                    NATIVE_INSTALL=1
                    BULKER_INSTALL=1
                else
                    echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                fi
            else
                echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
            fi
        fi
    fi
done < $REQS

# Check tool installation
declare -a requiredCommands=("perl" "awk" "grep" "sed" "bedtools" "bowtie2" "macs3" "preseq" "samblaster" "samtools" "skewer" "bedToBigBed" "bigWigCat" "wigToBigWig" "Rscript")

for cmd in ${requiredCommands[@]}; do
    if ! is_executable $cmd; then
        echo $(warn "WARNING: Install $cmd and checkinstall again.")
        # printf "\n"
        NATIVE_INSTALL=1
    else
        echo -e $(success "SUCCESS: ${cmd}")
    fi
done

## Check R packages
if ! is_executable "R"; then
    echo $(warn "WARNING: PEPATAC requires R 3.5 or greater. Install R and checkinstall again.")
    printf "\n"
    NATIVE_INSTALL=1
else
    rVer=$(R --version 2>&1 | grep 'R version' | awk '{print $3}')
    rVer=$(echo "${rVer//.}")
    if [ "$rVer" -lt "350" ]; then
        echo $(warn "WARNING: Please update R to >=3.5 and checkinstall again.")
        printf "\n"
        NATIVE_INSTALL=1
    fi
fi

declare -a requiredRPackages=("optigrab" "devtools" "GenomicDistributions" "PEPATACr" "data.table" "pepr" "gplots" "grid" "ggplot2" "scales" "IRanges" "GenomicRanges")
for package in ${requiredRPackages[@]}; do
    cmd=$(echo "Rscript -e 'library(\"$package\")'")
    packageInstalled=$(eval $cmd 2>&1)
    if [[ "$packageInstalled" == *Error* ]]; then
        echo $(warn "WARNING: Please install the R package, $package, and checkinstall again.")
        printf "\n"
        NATIVE_INSTALL=1
    else
        echo -e $(success "SUCCESS: R package: ${package}")
    fi
done

################################################################################
echo -e "-----------------------------------------------------------"
echo -e "Checking conda installation...                             "
CONDA_INSTALL=0

if ! is_executable "conda"; then
    echo $(warn "WARNING: Install conda to use conda environments and checkinstall again.")
    printf "\n"
    CONDA_INSTALL=1
else
    eval "$(conda shell.bash hook)"
    
    # Check if a pepatac conda environment exists
    CONDA_ENVS=$(conda env list | grep -c '^pepatac\s')
    
    if [[ "$CONDA_ENVS" == 1 ]]; then
        conda activate pepatac

        unset PYTHONPATH
        unset R_LIBS

        # Check Python
        if ! is_executable "python"; then
            echo $(warn "WARNING: PEPATAC requires python 3.0 or greater. Install python and checkinstall again.")
            printf "\n"
            CONDA_INSTALL=1
        else
            #echo "which python: $(which python)"
            ver=$(python -V 2>&1 | sed 's/.* \([0-9]\).\([0-9]\).*/\1\2/')
            if [ "$ver" -lt "30" ]; then
                echo $(warn "WARNING: PEPATAC requires python 3.0 or greater. Update python and checkinstall again.")
                printf "\n"
                CONDA_INSTALL=1
            fi
        fi

        # Check Python packages
        if ! is_executable "pip"; then
            echo $(warn "WARNING: PEPATAC requires pip. Please install pip and checkinstall again.")
            printf "\n"
            CONDA_INSTALL=1
        fi

        if [ -f "requirements.txt" ]; then
            REQS="requirements.txt"
        else
            REQS=$(curl https://raw.githubusercontent.com/databio/pepatac/master/requirements.txt)
        fi

        while IFS= read -r line; do
            [ "${line:0:1}" = "#" ] && continue
            
            if [[ $line == *","* ]]; then
                IFS=',' read -r -a array <<< "$line"
                first_half=${array[0]}
                # Check the maximum requirement
                IFS='<' read -r -a array <<< "$first_half"
                package=${array[0]}
                required=${array[2]}
                required=$(trim ${required})
                
                IFS='.' read -r -a required_version <<< "$required"
                declare -i rmajor
                declare -i rminor
                declare -i rpatch
                rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
                rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
                rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

                if ! pip_show "${package}"; then
                    echo $(warn "WARNING: PEPATAC requires the Python package, $package, < $required. Try pip install $package and checkinstall again.")
                    printf "\n"
                    CONDA_INSTALL=1
                else
                    installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
                    installed=$(trim ${installed})
                    IFS='.' read -r -a installed_version <<< "$installed"
                    declare -i imajor
                    declare -i iminor
                    declare -i ipatch
                    imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
                    iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
                    ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

                    if ! [ -z "$required" ]; then
                        if [ $imajor -gt $rmajor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, < $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -gt $rminor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, < $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -gt $rpatch ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, < $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        else
                            echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                        fi
                    else
                        echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
                    fi
                fi
                
                
                second_half=${array[2]}
                # Check the minimum requirement
                IFS='>=' read -r -a array <<< "$second_half"
                required=${array[2]}
                required=$(trim ${required})

                IFS='.' read -r -a required_version <<< "$required"
                declare -i rmajor
                declare -i rminor
                declare -i rpatch
                rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
                rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
                rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

                if ! pip_show "${package}"; then
                    echo $(warn "WARNING: PEPATAC requires the Python package, $package, >= $required. Try pip install $package and checkinstall again.")
                    printf "\n"
                    CONDA_INSTALL=1
                else
                    installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
                    installed=$(trim ${installed})
                    IFS='.' read -r -a installed_version <<< "$installed"
                    declare -i imajor
                    declare -i iminor
                    declare -i ipatch
                    imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
                    iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
                    ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

                    if ! [ -z "$required" ]; then
                        if [ $imajor -lt $rmajor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -lt $rminor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -lt $rpatch ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        else
                            echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                        fi
                    else
                        echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
                    fi
                fi
            elif [[ $line == *">="* ]]; then
                IFS='>=' read -r -a array <<< "$line"
                package=${array[0]}
                required=${array[2]}
                required=$(trim ${required})
                
                IFS='.' read -r -a required_version <<< "$required"
                declare -i rmajor
                declare -i rminor
                declare -i rpatch
                rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
                rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
                rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

                if ! pip_show "${package}"; then
                    echo $(warn "WARNING: PEPATAC requires the Python package, $package, >= $required. Try pip install $package and checkinstall again.")
                    printf "\n"
                    CONDA_INSTALL=1
                else
                    installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
                    installed=$(trim ${installed})
                    IFS='.' read -r -a installed_version <<< "$installed"
                    declare -i imajor
                    declare -i iminor
                    declare -i ipatch
                    imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
                    iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
                    ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

                    if ! [ -z "$required" ]; then
                        if [ $imajor -lt $rmajor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -lt $rminor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -lt $rpatch ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        else
                            echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                        fi
                    else
                        echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
                    fi
                fi
            elif [[ $line == *"=="* ]]; then
                IFS='==' read -r -a array <<< "$line"
                package=${array[0]}
                required=${array[2]}
                required=$(trim ${required})
                
                IFS='.' read -r -a required_version <<< "$required"
                declare -i rmajor
                declare -i rminor
                declare -i rpatch
                rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
                rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
                rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

                if ! pip_show "${package}"; then
                    echo $(warn "WARNING: PEPATAC requires the Python package, $package, >= $required. Try pip install $package and checkinstall again.")
                    printf "\n"
                    CONDA_INSTALL=1
                else
                    installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
                    installed=$(trim ${installed})
                    IFS='.' read -r -a installed_version <<< "$installed"
                    declare -i imajor
                    declare -i iminor
                    declare -i ipatch
                    imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
                    iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
                    ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

                    if ! [ -z "$required" ]; then
                        if [ $imajor -lt $rmajor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, == $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -lt $rminor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, == $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -lt $rpatch ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, == $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        else
                            echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                        fi
                    else
                        echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
                    fi
                fi
            else
                IFS='<' read -r -a array <<< "$line"
                package=${array[0]}
                required=${array[2]}
                required=$(trim ${required})
                
                IFS='.' read -r -a required_version <<< "$required"
                declare -i rmajor
                declare -i rminor
                declare -i rpatch
                rmajor=$(echo "${required_version[0]}" | awk '{ print $1+0; exit }')
                rminor=$(echo "${required_version[1]}" | awk '{ print $1+0; exit }')
                rpatch=$(echo "${required_version[2]}" | awk '{ print $1+0; exit }')

                if ! pip_show "${package}"; then
                    echo $(warn "WARNING: PEPATAC requires the Python package, $package, >= $required. Try pip install $package and checkinstall again.")
                    printf "\n"
                    CONDA_INSTALL=1
                else
                    installed=$(pip show ${package} | grep -iw 'Version' | awk -F':' '{print $2}' | tr -d '\n')
                    installed=$(trim ${installed})
                    IFS='.' read -r -a installed_version <<< "$installed"
                    declare -i imajor
                    declare -i iminor
                    declare -i ipatch
                    imajor=$(echo "${installed_version[0]}" | awk '{ print $1+0; exit }')
                    iminor=$(echo "${installed_version[1]}" | awk '{ print $1+0; exit }')
                    ipatch=$(echo "${installed_version[2]}" | awk '{ print $1+0; exit }')

                    if ! [ -z "$required" ]; then
                        if [ $imajor -lt $rmajor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -lt $rminor ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        elif [ $imajor -eq $rmajor ] && [ $iminor -eq $rminor ] && [ $ipatch -lt $rpatch ]; then
                            echo $(warn "WARNING: PEPATAC requires the python package, $package, >= $required. Try pip install --upgrade $package and checkinstall again.")
                            printf "\n"
                            CONDA_INSTALL=1
                        else
                            echo -e $(success "SUCCESS: Python package ${package}\trequired: ${required}\tinstalled: ${installed}")
                        fi
                    else
                        echo -e $(success "SUCCESS: Python package ${package}\trequired: any\tinstalled: ${installed_version}")
                    fi
                fi
            fi
        done < $REQS

        # Check tool installation
        declare -a requiredCommands=("perl" "awk" "grep" "sed" "bedtools" "bowtie2" "macs3" "preseq" "samblaster" "samtools" "skewer" "bedToBigBed" "bigWigCat" "wigToBigWig" "Rscript")

        for cmd in ${requiredCommands[@]}; do
            if ! is_executable $cmd; then
                echo $(warn "WARNING: Please install $cmd and checkinstall again.")
                printf "\n"
                CONDA_INSTALL=1
            else
                echo -e $(success "SUCCESS: ${cmd}")
            fi
        done

        ## Check R packages
        if ! is_executable "R"; then
            echo $(warn "WARNING: PEPATAC requires R 3.5 or greater.\n Please install R>=3.5 and checkinstall again.")
            printf "\n"
            exit 1
        else
            rVer=$(R --version 2>&1 | grep 'R version' | awk '{print $3}')
            rVer=$(echo "${rVer//.}")
            if [ "$rVer" -lt "350" ]; then
                echo $(warn "WARNING: PEPATAC requires R 3.5 or greater. Update R and checkinstall again.")
                printf "\n"
                CONDA_INSTALL=1
            fi
        fi

        declare -a requiredRPackages=("optigrab" "devtools" "GenomicDistributions" "PEPATACr" "data.table" "pepr" "gplots" "grid" "ggplot2" "scales" "IRanges" "GenomicRanges")
        for package in ${requiredRPackages[@]}; do
            cmd=$(echo "Rscript -e 'library(\"$package\")'")
            packageInstalled=$(eval $cmd 2>&1)
            if [[ "$packageInstalled" == *Error* ]]; then
                echo $(warn "WARNING: Please install the R package, $package, and checkinstall again.")
                printf "\n"
                CONDA_INSTALL=1
            else
                echo -e $(success "SUCCESS: R package: ${package}")
            fi
        done

        conda deactivate
    else
        echo -e "The pepatac conda environment is not present."
        CONDA_INSTALL=1
    fi
fi

################################################################################
echo -e "-----------------------------------------------------------"
echo -e "Checking bulker installation...                            "
BULKER_INSTALL=0

if ! is_executable "docker"; then
    DOCKER=1
else
    DOCKER=0
fi

if ! is_executable "singularity"; then
    SINGULARITY=1
else
    SINGULARITY=0
fi

if [ "$DOCKER" -eq 0 ]; then 
    CMD_CHECK=$(docker --help)
    if [ $? -eq 0 ]; then
        echo -e $(success "SUCCESS: docker.")
    else
        echo -e $(warn "WARNING: Docker is a recognized command, but does not appear to be active. Please ensure docker is running and checkinstall again.")
        DOCKER=1
    fi
fi

if [ "$SINGULARITY" -eq 0 ]; then
    echo -e $(success "SUCCESS: singularity.")
fi

if [ "$DOCKER" -eq 1 ] && [ "$SINGULARITY" -eq 1 ]; then
    echo -e $(fail "ERROR: bulker")
    BULKER_INSTALL=1
else
    if ! is_executable "bulker"; then
        echo $(warn "WARNING: To use bulker, pip install bulker and checkinstall again.")
        printf "\n"
        BULKER_INSTALL=1
    else
        BULKER_INSTALL=0
        echo -e $(success "SUCCESS: bulker")
    fi

    CWD=$(pwd)

    if [ -f "sample_pipeline_interface.yaml" ]; then
        IFACE="sample_pipeline_interface.yaml"
        CRATE=$(cat $IFACE | grep 'bulker_crate' | tr " " "\n" | tail -n 1)
    else
        IFACE=$(curl https://raw.githubusercontent.com/databio/pepatac/master/sample_pipeline_interface.yaml)
        CRATE=$(echo $IFACE | tr " " "\n" | grep -A1 'bulker_crate' | tail -n 1)
    fi

    yes n | bulker load $CRATE
    if [ $? -eq 0 ]; then
        echo $(warn "WARNING: Could not bulker load ${CRATE}. Check out https://bulker.databio.org/en/latest/install/.")
        printf "\n"
        BULKER_INSTALL=1
    fi

    if [ -f "$CWD/pipelines/pepatac.py" ]; then
        PIPELINE=$(cat "$CWD/pipelines/pepatac.py")
    else
        PIPELINE=$(curl https://raw.githubusercontent.com/databio/pepatac/master/pipelines/pepatac.py)
    fi

    CMD_CHECK=$(bulker run ${CRATE} $PIPELINE --help)
    EXIT_CODE=$(echo $?)
    isActivatable=$(echo "${EXIT_CODE}" | awk '{ print $1+0; exit }')
    if [ "$isActivatable" -eq 0 ]; then
        BULKER_INSTALL=0
        echo -e $(success "SUCCESS: bulker run ${CRATE}")
    else            
        echo $(warn "WARNING: Could not activate the bulker crate, ${CRATE}. Check out https://bulker.databio.org/en/latest/install/.")
        printf "\n"
        BULKER_INSTALL=1
    fi
fi

################################################################################
echo -e "-----------------------------------------------------------"
echo -e "             PEPATAC checkinstall results                  "

if [ "$NATIVE_INSTALL" -eq 0 ]; then
    echo -e $(success "SUCCESS: PEPATAC can be run using native installations!")
else
    echo -e $(fail "ERROR: PEPATAC cannot be run using native installations.")
fi

if [ "$CONDA_INSTALL" -eq 0 ]; then
    echo -e $(success "SUCCESS: PEPATAC can be run using conda installation!")
else
    echo -e $(fail "ERROR: PEPATAC cannot be run via conda.")
fi

if [ "$DOCKER" -eq 0 ]; then
    echo -e $(success "SUCCESS: PEPATAC can be run using docker!")
else
    echo -e $(fail "ERROR: PEPATAC cannot be run using docker.")
fi

if [ "$SINGULARITY" -eq 0 ]; then
    echo -e $(success "SUCCESS: PEPATAC can be run using singularity!")
else
    echo -e $(fail "ERROR: PEPATAC cannot be run using singularity.")
fi

if [ "$BULKER_INSTALL" -eq 0 ]; then
    echo -e $(success "SUCCESS: PEPATAC can be run using bulker!")
else
    echo -e $(fail "ERROR: PEPATAC cannot be run using bulker.")
fi

if [ "$NATIVE_INSTALL" -eq 1 ] && [ "$CONDA_INSTALL" -eq 1 ] && [ "$BULKER_INSTALL" -eq 1 ]; then
    echo -e "ERROR: PEPATAC is not successfully installed. Check the above output for direction on missing tools or packages."
fi

echo -e "-----------------------------------------------------------"