#!/bin/bash
set -e

SED_PARAM=""
unameOut="$(uname -s)"
case "${unameOut}" in
    Linux*)     SED_PARAM=" -i ";;
    Darwin*)    SED_PARAM=" -i '' ";;
    *)          exit 1
esac

SCRIPT_PATH="scripts/deploy.sh"
UNIT_DIR="/etc/systemd/system"
# Copies locales des scripts de bootstrap, déposées à la main sur l'host.
SCRIPTS_DIR="/opt/two/scripts"

info () { echo "== ${1}"; }
warn () { echo "!! ${1}" >&2; }
die  () { echo "!! ${1}" >&2; exit 1; }

exec_with_dry_run () {
  if [[ ${1} -eq ${FLAGS_TRUE} ]]; then
    echo "# ${2}"
  else
    eval "${2}" 2> /tmp/error || \
    {
      echo -e "failed with following error";
      output=$(cat /tmp/error | sed -e "s/^/ error -> /g");
      echo -e "${output}";
      return 1;
    }
  fi
  return 0
}

# `set -e` est inopérant dans main : bash désactive errexit dans le corps d'une
# fonction appelée depuis une liste `||` (cf. dernières lignes du fichier), y
# compris dans les fonctions qu'elle appelle. Les étapes qui ne doivent pas
# échouer silencieusement passent donc par run().
run () {
    exec_with_dry_run "${1}" "${2}" || die "échec : ${2}"
}

check_latest_script () {
    REMOTE_URL="${1}"
    LOCAL_PATH="${2}"

    REMOTE=$(curl --silent "${REMOTE_URL}" | sha256sum)
    LOCAL=$(cat ${LOCAL_PATH} | sha256sum)

    [[ "${REMOTE}" == "${LOCAL}" ]] || return 1
    return 0
}

# Liste les units actives correspondant à un motif, une par ligne.
# Sortie vide si aucune ne tourne — ce n'est pas une erreur.
list_active_units () {
    PATTERN="${1}"
    systemctl list-units --state=active --no-legend --plain "${PATTERN}" 2>/dev/null \
        | awk '{print $1}' || true
}

# Units non instanciables du profil (agent.service) : celles qu'on arrête et
# démarre nommément.
profile_main_units () {
    for unit in $(profile_units "${1}")
    do
        case "${unit}" in
            *@.service) continue ;;
            *)          echo "${unit}" ;;
        esac
    done
}

# Instances actives des templates du profil (dnsmasq@vpc_br, metadata@i-xxx).
# À relever AVANT l'arrêt : c'est la seule façon de savoir lesquelles
# redémarrer ensuite.
active_instances () {
    for unit in $(profile_units "${1}")
    do
        case "${unit}" in
            *@.service) list_active_units "${unit%@.service}@*" ;;
        esac
    done
}

stop_services () {
    DRY_RUN="${1}"
    PROFILE="${2}"
    INSTANCES="${3}"

    # Les units principales en premier : sur le profil kvm, l'agent pilote les
    # autres units, on ne veut pas qu'il observe leur disparition.
    for unit in $(profile_main_units "${PROFILE}")
    do
        run "${DRY_RUN}" "systemctl stop '${unit}'"
    done

    for unit in ${INSTANCES}
    do
        run "${DRY_RUN}" "systemctl stop '${unit}'"
    done
}

start_services () {
    DRY_RUN="${1}"
    PROFILE="${2}"
    INSTANCES="${3}"

    # Ordre inverse de l'arrêt : les dépendances d'abord, les units principales
    # en dernier. Une instance qui refuse de repartir (VM disparue entre-temps)
    # ne doit pas empêcher le redémarrage de l'agent, d'où le simple warn.
    for unit in ${INSTANCES}
    do
        exec_with_dry_run "${DRY_RUN}" "systemctl start '${unit}'" \
            || warn "démarrage de ${unit} en échec — poursuite"
    done

    for unit in $(profile_main_units "${PROFILE}")
    do
        run "${DRY_RUN}" "systemctl start '${unit}'"
    done
}

# ------------------------------------------------------------------- profils
#
# Un profil décrit ce qu'un host doit recevoir : ses units systemd, ses
# exécutables et son script de préparation. Rien n'est déployé qui ne soit
# listé par le profil — un host intel ne reçoit pas l'agent kvm. Ajouter un
# profil = ajouter une branche dans les trois fonctions ci-dessous et livrer un
# bootstrap_<profil>.sh exposant bootstrap_host().
#
#   kvm    hyperviseur QEMU/KVM : agent + metadata + dnsmasq, bridges, br_netfilter
#   intel  réservé, non implémenté

profile_units () {
    case "${1}" in
        kvm)   echo "agent.service dnsmasq@.service metadata@.service" ;;
        intel) echo "" ;;
        *)     return 1 ;;
    esac
}

# Noms courts des exécutables, tels qu'ils apparaîtront dans /opt/two/bin.
# Un asset de release les porte soit à l'identique (run-dnsmasq-in-netns.sh),
# soit suffixé par la plateforme (agent → agent_linux_amd64).
profile_binaries () {
    case "${1}" in
        kvm)   echo "agent metadata run-dnsmasq-in-netns.sh" ;;
        intel) echo "" ;;
        *)     return 1 ;;
    esac
}

# Script de préparation de l'host, sourcé par run_bootstrap. Vide = le profil
# n'a rien à préparer. Paquets, kernel et réseau appartiennent au profil, pas à
# deploy.sh.
profile_bootstrap () {
    case "${1}" in
        kvm)   echo "bootstrap_kvm.sh" ;;
        intel) echo "" ;;
        *)     return 1 ;;
    esac
}

# Charge le script de bootstrap du profil et lui passe la main.
#
# Même logique que ./libs/shflags : copie locale d'abord, dépôt ensuite.
#   1. /opt/two/scripts/<nom>  — déposé à la main sur l'host, permet de figer ou
#                                de patcher un profil sans toucher au dépôt
#   2. la branche demandée     — cas courant sur un host neuf
#
# Le fichier ne contenant que des définitions de fonctions, il supporte l'`eval`
# — au contraire de deploy.sh, dont la garde BASH_SOURCE finale déclencherait
# main(). `curl --fail` reste indispensable : sans lui, le corps d'un 404
# (« Not found. ») serait évalué comme du shell. En cas d'échec, curl ne produit
# rien, l'eval est un no-op et c'est le contrôle de bootstrap_host() qui tranche.
run_bootstrap () {
    DRY_RUN="${1}"
    PROFILE="${2}"
    GIT_SERVER="${3}"
    REPO_PATH="${4}"
    BRANCH="${5}"

    NAME=$(profile_bootstrap "${PROFILE}") || die "profil inconnu : ${PROFILE}"
    [[ -n "${NAME}" ]] || { info "bootstrap : rien à préparer pour le profil ${PROFILE}"; return 0; }

    BOOTSTRAP_URL="${GIT_SERVER}${REPO_PATH}raw/branch/${BRANCH}scripts/${NAME}"
    info "bootstrap du profil ${PROFILE} (${SCRIPTS_DIR}/${NAME} ou ${BOOTSTRAP_URL})"

    # shellcheck source=/dev/null
    [[ -f "${SCRIPTS_DIR}/${NAME}" ]] && . "${SCRIPTS_DIR}/${NAME}" || eval "$(curl --silent --fail "${BOOTSTRAP_URL}")"

    command -v bootstrap_host >/dev/null 2>&1 \
        || die "bootstrap_host() introuvable — ni ${SCRIPTS_DIR}/${NAME} ni ${BOOTSTRAP_URL} n'ont pu être chargés"

    bootstrap_host "${DRY_RUN}" "${FLAGS_packages}" "${FLAGS_network}" \
        "${FLAGS_uplink}" "${FLAGS_bridge}" "${FLAGS_pub_bridge}" "${FLAGS_rollback}"
}

# ------------------------------------------------------------------- release

resolve_tag () {
    TAG="${1}"
    GIT_SERVER="${2}"
    REPO_PATH="${3}"

    [[ -n "${TAG}" ]] && { echo "${TAG}"; return 0; }
    curl --silent "${GIT_SERVER}api/v1/repos/${REPO_PATH}releases/?limit=1" | jq -r '.[0].tag_name'
}

# Assets de la release, un objet JSON compact par ligne.
release_assets () {
    GIT_SERVER="${1}"
    REPO_PATH="${2}"
    RELEASE_TAG="${3}"

    curl --silent "${GIT_SERVER}api/v1/repos/${REPO_PATH}releases/tags/${RELEASE_TAG}" | jq -c '.assets[]'
}

# Nom complet de l'asset correspondant à un nom court : exact, ou suffixé par la
# plateforme (agent → agent_linux_amd64). Vide si absent de la release.
asset_name () {
    echo "${1}" | jq -r --arg s "${2}" 'select(.name == $s or (.name | startswith($s + "_"))) | .name' | head -1
}

asset_url () {
    echo "${1}" | jq -r --arg n "${2}" 'select(.name == $n) | .browser_download_url' | head -1
}

# Télécharge dans les répertoires versionnés les seuls assets réclamés par le
# profil. Aucun impact sur les services en cours, donc aucune raison de les
# arrêter pendant ce temps.
fetch_assets () {
    DRY_RUN="${1}"
    PROFILE="${2}"
    ASSETS="${3}"

    info "assets de la release ${TAG} pour le profil ${PROFILE}"

    run "${DRY_RUN}" "mkdir -p '${BIN_PATH}'"
    run "${DRY_RUN}" "mkdir -p '${UNIT_PATH}'"
    run "${DRY_RUN}" "mkdir -p '${LN_PATH}'"

    for unit in $(profile_units "${PROFILE}")
    do
        UNIT_URL=$(asset_url "${ASSETS}" "${unit}")
        [[ -n "${UNIT_URL}" ]] || die "unit absente de la release ${TAG} : ${unit}"
        run "${DRY_RUN}" "curl --silent '${UNIT_URL}' -o '${UNIT_PATH}${unit}'"
    done

    for short in $(profile_binaries "${PROFILE}")
    do
        FULL_NAME=$(asset_name "${ASSETS}" "${short}")
        [[ -n "${FULL_NAME}" ]] || die "exécutable absent de la release ${TAG} : ${short}"
        BIN_URL=$(asset_url "${ASSETS}" "${FULL_NAME}")
        run "${DRY_RUN}" "curl --silent '${BIN_URL}' -o '${BIN_PATH}${FULL_NAME}'"
        run "${DRY_RUN}" "chmod +x '${BIN_PATH}${FULL_NAME}'"
    done
}

# Installe les units du profil depuis la release. Les templates (dnsmasq@,
# metadata@) ne sont pas activés : l'agent les instancie au fil des subnets et
# des VMs.
install_units () {
    DRY_RUN="${1}"
    PROFILE="${2}"

    UNITS=$(profile_units "${PROFILE}") || die "profil inconnu : ${PROFILE}"
    [[ -n "${UNITS}" ]] || { info "units : aucune pour le profil ${PROFILE}"; return 0; }

    info "units du profil ${PROFILE}"

    for unit in ${UNITS}
    do
        if [[ ${DRY_RUN} -ne ${FLAGS_TRUE} ]] && [[ ! -f "${UNIT_PATH}${unit}" ]]
        then
            die "unit absente des assets de la release ${TAG} : ${unit}"
        fi
        run "${DRY_RUN}" "install -m 0644 '${UNIT_PATH}${unit}' '${UNIT_DIR}/${unit}'"
    done

    run "${DRY_RUN}" "systemctl daemon-reload"

    for unit in ${UNITS}
    do
        case "${unit}" in
            *@.service) continue ;;
        esac
        run "${DRY_RUN}" "systemctl enable '${unit}'"
    done
}

# Bascule des liens symboliques, services arrêtés : c'est la seule fenêtre
# d'indisponibilité réelle.
switch_binaries () {
    DRY_RUN="${1}"
    PROFILE="${2}"
    ASSETS="${3}"

    BINARIES=$(profile_binaries "${PROFILE}")
    [[ -n "${BINARIES}" ]] || { info "bascule : aucun exécutable pour le profil ${PROFILE}"; return 0; }

    info "bascule des binaires"

    INSTANCES=$(active_instances "${PROFILE}")

    stop_services "${DRY_RUN}" "${PROFILE}" "${INSTANCES}"

    for short in ${BINARIES}
    do
        FULL_NAME=$(asset_name "${ASSETS}" "${short}")
        run "${DRY_RUN}" "rm -f '${LN_PATH}${short}'"
        run "${DRY_RUN}" "ln -s '${BIN_PATH}${FULL_NAME}' '${LN_PATH}${short}'"
    done

    start_services "${DRY_RUN}" "${PROFILE}" "${INSTANCES}"
}

# ----------------------------------------------------------------------------

main () {
    [[ -f ./libs/shflags ]] && . ./libs/shflags || eval "$(curl --silent https://git.g3e.fr/H6N/tools/raw/branch/main/libs/shflags)"

    DEFINE_boolean 'dryrun'     false                 'Enable dry-run mode'                            'd'
    DEFINE_boolean 'up_script'  true                  'Upgrade script'                                 's'
    DEFINE_string  'git_server' 'https://git.g3e.fr/' 'Git Server'                                     'g'
    DEFINE_string  'repo_path'  'syonad/two/'         'Path of repository'                             'r'
    DEFINE_string  'branch'     'main/'               'Branch name'                                    'b'
    DEFINE_string  'tag'        ''                    'Tag name'                                       't'
    DEFINE_string  'profile'    'kvm'                 'Host profile: kvm'                              'p'
    DEFINE_boolean 'bootstrap'  false                 'Prepare the host (packages, kernel, network)'   'i'
    DEFINE_boolean 'packages'   true                  'Install profile packages during --bootstrap'    'k'
    DEFINE_boolean 'network'    true                  'Configure bridges during --bootstrap'           'n'
    DEFINE_string  'uplink'     'eno1'                'Physical uplink interface'                      'u'
    DEFINE_string  'bridge'     'br-000000'           'Main bridge, uplink is enslaved to it'          'B'
    DEFINE_string  'pub_bridge' 'br-public'           'Reserved empty bridge'                          'P'
    DEFINE_integer 'rollback'   120                   'Rollback reboot delay in seconds'               'R'

    FLAGS "$@" || exit $?
    eval set -- "${FLAGS_ARGV}"

    profile_units "${FLAGS_profile}" >/dev/null || die "profil inconnu : ${FLAGS_profile}"

    # --noup_script court-circuite la vérification : seul moyen de dérouler un
    # script en cours de modification, encore absent de la branche.
    #
    # L'ancien idiome `check_latest_script || ( ... ; exit 1 )` ne s'arrêtait pas
    # réellement : le `exit 1` d'un sous-shell placé en fin de liste `||` est
    # ignoré parce qu'errexit est désactivé dans le corps de main. Le script
    # s'écrasait puis continuait à exécuter sa version périmée en mémoire. D'où
    # le die() explicite.
    if [[ ${FLAGS_up_script} -eq ${FLAGS_TRUE} ]]
    then
        SCRIPT_URL="${FLAGS_git_server}${FLAGS_repo_path}raw/branch/${FLAGS_branch}${SCRIPT_PATH}"
        if ! check_latest_script "${SCRIPT_URL}" "${0}"
        then
            run "${FLAGS_dryrun}" "curl --silent '${SCRIPT_URL}' -o '${0}'"
            die "script local différent de la branche ${FLAGS_branch} — mis à jour, relancer"
        fi
    fi

    # Préparation de l'host avant tout téléchargement : elle ne dépend pas de la
    # release, et les paquets comme le réseau conditionnent la suite.
    [[ ${FLAGS_bootstrap} -eq ${FLAGS_TRUE} ]] && \
        run_bootstrap "${FLAGS_dryrun}" "${FLAGS_profile}" "${FLAGS_git_server}" "${FLAGS_repo_path}" "${FLAGS_branch}"

    TAG=$(resolve_tag "${FLAGS_tag}" "${FLAGS_git_server}" "${FLAGS_repo_path}")
    [[ -n "${TAG}" && "${TAG}" != "null" ]] || die "impossible de déterminer la release à déployer"

    BIN_PATH="/opt/two/${TAG}/bin/"
    UNIT_PATH="/opt/two/${TAG}/units/"
    LN_PATH="/opt/two/bin/"

    ASSETS=$(release_assets "${FLAGS_git_server}" "${FLAGS_repo_path}" "${TAG}")
    [[ -n "${ASSETS}" ]] || die "aucun asset dans la release ${TAG}"

    fetch_assets "${FLAGS_dryrun}" "${FLAGS_profile}" "${ASSETS}"

    # Les units sont installées avant la bascule : stop_services arrête les
    # units principales du profil, qui doivent donc déjà exister.
    install_units   "${FLAGS_dryrun}" "${FLAGS_profile}"
    switch_binaries "${FLAGS_dryrun}" "${FLAGS_profile}" "${ASSETS}"
}

[[ "${BASH_SOURCE[0]}" == "${0}" ]] && (main "$@" || exit 1)
[[ "${BASH_SOURCE[0]}" == "" ]] && (main "$@"  || exit 1)