install

#!/usr/bin/env bash

# CI handling
CI=${CI:-False}
if [[ -n ${CI} ]]; then
    sudo() {
        "$@"
    }
fi

BASEDIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

source "${BASEDIR}/.installer/utils.sh"
source "${BASEDIR}/.installer/git.sh"
if [[ "$(uname)" == "Darwin" ]]; then
    source "${BASEDIR}/.installer/install_mac.sh"
else
    source "${BASEDIR}/.installer/install_arch.sh"
fi

install_links() {
    local cmd

    if command -v dotbot >/dev/null; then
        cmd="dotbot"
    else
        cmd="${BASEDIR}/dotbot/bin/dotbot"
    fi

    "${cmd}" -q -d "${BASEDIR}" -c "${BASEDIR}/install.conf.yaml"
}

post_install() {
    gem install \
        sqlint \
        neovim \
        2>/dev/null 1>/dev/null
    gem environment

    pipx ensurepath
    pipx install \
      cfn-lint \
      flake8 \
      pyinfra \
      pywal \
      wakatime \
      yamllint

    pipx install awsume[saml,fuzy]
    pipx inject awsume \
      awsume-console-plugin

    pipx install httpie
    pipx inject httpie \
      httpie-aws-auth

    pipx install ansible --include-deps
    pipx inject ansible \
      paramiko

    pipx inject flake8 \
      flake8-bugbear==21.11.29 \
      flake8-commas==2.1.0 \
      flake8-quotes==3.3.1 \
      flake8-print==4.0.0 \
      flake8-bandit==2.1.2 \
      flake8-comprehensions==3.7.0

    wal --theme base16-atelier-dune -n --vte
    wal-vtop >/dev/null
}

_env_binary() {
    # fetches path to binary of given *env
    # nodenv, jenv etc etc etc

    local env
    env="${1}"

    if ! command -v "${env}" >/dev/null 2>&1; then
        env_bin="${HOME}/.${env}/bin/${env}"
    else
        env_bin=$(command -v "${env}")
    fi

    echo "${env_bin}"
}

configure_envs() {
    configure_pyenv
    configure_jenv
    configure_goenv
    configure_nodenv
}

configure_nodenv() {
    local nodenv
    local nodenv_root

    nodenv=$(_env_binary "nodenv")
    nodenv_root=$($nodenv root)

    if [ ! -f "${nodenv_root}/version" ]; then
        echo "Installing latest Node"

        $nodenv latest install -s 14
        $nodenv global "$($nodenv latest --print-installed)"
        "${nodenv_root}/versions/$($nodenv latest --print-installed)/bin/npm" install --global --production "${BASEDIR}/package.json"

    else
        log_done "Node -> $(cat "${nodenv_root}/version")" "[  ]"
    fi

    $nodenv rehash
}

configure_goenv() {
    local goenv
    local goenv_root

    goenv=$(_env_binary "goenv")
    goenv_root=$($goenv root)

    if [ ! -f "${goenv_root}/version" ]; then
        echo "Installing latest GO"

        $goenv latest install -s 1 &&
            $goenv global "$($goenv latest --print-installed)"

        go="${goenv_root}/versions/$($goenv latest --print-installed)/bin/go"

        $go get -u \
            golang.org/x/lint/golint \
            golang.org/x/tools/gopls \
            github.com/golangci/golangci-lint/cmd/golangci-lint \
            github.com/stamblerre/gocode \
            github.com/cpuguy83/go-md2man
        command -v shfmt >/dev/null || GO111MODULE=on $go get mvdan.cc/sh/v3/cmd/shfmt
    else
        log_done "Go -> $(cat "${goenv_root}/version")" "[  ]"
    fi

    $goenv rehash
}

configure_pyenv() {
    local pyenv
    local pyenv_root
    local python_icon="[  ]"
    local neovim_icon="[  ]${python_icon}"

    pyenv=$(_env_binary "pyenv")
    pyenv_root=$($pyenv root)

    if [ ! -f "${pyenv_root}/version" ]; then
        log_notice "Installing latest Python" "${python_icon}"

        for py_major in {2,3}; do
            $pyenv latest install -s "${py_major}"
            "${pyenv_root}/versions/$($pyenv latest --print-installed "${py_major}")/bin/pip" install --upgrade pip
            "${pyenv_root}/versions/$($pyenv latest --print-installed "${py_major}")/bin/pip" install \
                -r "${BASEDIR}/requirements/system.txt" \
                -r "${BASEDIR}/requirements/utils.txt"
            log_done "Installed Python ${py_major}" "${python_icon}"
        done

        $pyenv global "$($pyenv latest --print-installed)"
    else
        log_done "Python -> $(cat "${pyenv_root}/version")"
    fi

    for py_major in {2,3}; do
        if [ ! -d "${pyenv_root}/versions/neovim${py_major}" ]; then
            log_notice "Initializing neovim setup for Python ${py_major}" "${neovim_icon}"
            $pyenv virtualenv "$($pyenv latest --print "${py_major}")" "neovim${py_major}"
            "${pyenv_root}/versions/neovim${py_major}/bin/pip" install --upgrade pip
            "${pyenv_root}/versions/neovim${py_major}/bin/pip" install -r "${BASEDIR}/requirements/neovim.txt"
        else
            local neovim_py_version
            neovim_py_version="$(
                "${pyenv_root}/versions/neovim${py_major}/bin/python" \
                    --version \
                    2>&1 |
                    awk '{print $2}'
            )"
            log_done "neovim${py_major} -> ${neovim_py_version}" "${neovim_icon}"
        fi
    done

    $pyenv rehash
}

configure_jenv() {
    local jenv
    local jenv_root

    jenv=$(_env_binary "jenv")
    jenv_root=$($jenv root)

    if [ ! -d "${jenv_root}/_versions/" ]; then
        mkdir "${jenv_root}/_versions/"
    fi
    if [ ! -f "${jenv_root}/version" ]; then
        echo "Installing latest Java"

        local javaVersion
        local downloadUrl
        local archiveName
        local jdkVersion
        local releaseType

        if [[ "$(uname)" == "Darwin" ]]; then
            # if latest is the one as from brew, do not download
            # but use brew provided
            if command -v java >/dev/null 2>&1; then
                if test -h /usr/libexec/java_home; then
                    log_info "Using brew provided java"
                    "${jenv}" add $(/usr/libexec/java_home)
                fi
            fi
        else
            javaVersion="$(http https://api.adoptopenjdk.net/v3/info/available_releases | jq -r '.most_recent_feature_release')"
            releaseType="ga"
            downloadUrl=$(
                http \
                    "https://api.adoptopenjdk.net/v3/assets/feature_releases/${javaVersion}/${releaseType}" \
                    architecture==x64 \
                    sort_method==DATE \
                    sort_order==DESC \
                    image_type==jdk \
                    jvw_impl==hotspot \
                    os==linux \
                    project==jdk \
                    vendor==adoptopenjdk |
                    jq -r '.[0]["binaries"][0]["package"]["link"]'
            )
            archiveName=$(echo "${downloadUrl}" | awk -F "/" '{print $NF}')

            if [ ! -f "/tmp/${archiveName}" ]; then
                aria2c \
                    -d "/tmp" \
                    -o "${archiveName}" \
                    -j 5 \
                    "${downloadUrl}"
            fi

            jdkVersion=$(tar -tf "/tmp/${archiveName}" | head -n 1 | sed -e 's|/||g')
            tar -xzf "/tmp/${archiveName}" -C "${jenv_root}/_versions/" && {
                $jenv add "${jenv_root}/_versions/${jdkVersion}"
                $jenv global "$($jenv versions | grep "${javaVersion}" | head -n 1 | awk -F' ' '{print $1}')"
            }

            if command -v java >/dev/null 2>&1; then
                if command -v update-alternatives >/dev/null 2>&1; then
                    echo "Enabling default java"
                    local default_java_home
                    default_java_home=$(update-alternatives --query java | grep Best | awk '{print $2}' | sed -e 's|bin/java||g')
                    if [ -d "${default_java_home}" ]; then
                        $jenv add "${default_java_home}"
                    fi
                fi
            fi
        fi

        $jenv enable-plugin export >/dev/null
        $jenv enable-plugin maven >/dev/null
    else
        log_done "Java -> $(cat "${jenv_root}/version")" "[  ]"
    fi

    $nodenv package-hooks install --all

    $jenv rehash
}

configure_nvim() {
    local goenv pyenv nodenv jenv new_path old_path

    goenv=$(_env_binary "goenv")
    pyenv=$(_env_binary "pyenv")
    nodenv=$(_env_binary "nodenv")
    jenv=$(_env_binary "jenv")

    old_path="${PATH}"
    new_path="${PATH}:$($goenv root)/shims:$($pyenv root)/shims:$($nodenv root)/shims:$($jenv root)/shims"

    export PATH="${new_path}"
    nvim --headless +PlugInstall +qall!
    nvim --headless +UpdateRemotePlugins +qall!
    export PATH="${old_path}"

    unset goenv
    unset pyenv
    unset nodenv
    unset jenv
    unset new_path
}

configure_wakatime() {
    local wakatime_api_key=""
    local wakatime_hostname=""
    local icon="[  ]"
    wakatime_hostname="$(hostname)"

    while [[ $# -gt 0 ]]; do
        arg="${1}"
        case "${arg}" in
        --wakatime-api-key)
            wakatime_api_key="${2}"
            shift
            shift
            ;;
        --wakatime-hostname)
            wakatime_hostname="${2}"
            shift
            shift
            ;;
        --force)
          if test -f "${HOME}/.wakatime.cfg"; then
            mv -f "${HOME}/.wakatime.cfg{,.bak}" >/dev/null ;
          fi
          shift
          ;;
        esac
    done

    if [ ! -f "${HOME}/.wakatime.cfg" ]; then
        log_notice "Configuring Wakatime" "${icon}"
        if [ -z "${wakatime_api_key}" ]; then
            log_die "--wakatime-api-key required..." "${icon}"
        else
            install -m 666 "${BASEDIR}/wakatime.cfg" "${HOME}/.wakatime.cfg"
            sed -e "
                s|%API_KEY%|${wakatime_api_key}|g;
                s|%HOSTNAME%|${wakatime_hostname}|g;
            " -i "${HOME}/.wakatime.cfg"
            log_done "Wakatime configured" "${icon}"
        fi
    else
        log_done "Wakatime configured" "${icon}"
    fi
}

if ((SHLVL > 1)); then
    echo "kornicameister/dotfiles"

    if ((EUID == 0)) && [[ -z ${CI:-} ]]; then
        log_die "Altough root is required to install packages, ./install must not be launched as root" "${icon}" 3
    fi

    install_packages
    install_links

    configure_envs
    configure_git "$@"
    configure_nvim
    configure_wakatime "$@"

    post_install
    screenfetch
fi