#!/bin/bash
#
# PREPARA IL PC: accesso AWS, accesso Gitea, git, chiave SSH, nomi dei server.
#
#   ./configura.sh
#
# Si lancia nel proprio terminale: chiede le chiavi AWS e la password Gitea
# con l'input nascosto, e un assistente AI non puo' rispondere al posto tuo.
# Si puo' rilanciare: quello che e' gia' a posto non viene toccato.
# Non crea accessi: quelli li crea un amministratore, qui si usano.

set -u
cd "$(dirname "$0")" || exit 1
. ./comune.sh

# --------------------------------------------------------------------------
titolo "1. AWS"
# --------------------------------------------------------------------------
# La chiave di accesso la crea la persona dalla console (Security
# credentials → Create access key): qui la si incolla una volta e finisce in
# ~/.aws/credentials, dove la leggono la AWS CLI e gli script dei progetti.
if ! c_e aws ; then
  male "AWS CLI non installata: installala e rilancia questo script."
elif IDENTITA="$(aws sts get-caller-identity --query Arn --output text 2> /dev/null)" ; then
  ok "accesso AWS: ${IDENTITA##*/}"
else
  echo "  Serve la tua chiave di accesso AWS, due pezzi. La crei nella console AWS:"
  echo "  il tuo nome in alto a destra → Security credentials → Create access key (uso: CLI)."
  echo "  Non si vede mentre la incolli, ed e' normale."
  read -r -s -p "  Access key ID (inizia con AKIA): " CHIAVE_ID ; echo
  read -r -s -p "  Secret access key: " CHIAVE_SEGRETA ; echo
  CHIAVE_ID="$(printf '%s' "$CHIAVE_ID" | tr -d '[:space:]')"
  CHIAVE_SEGRETA="$(printf '%s' "$CHIAVE_SEGRETA" | tr -d '[:space:]')"
  aws configure set aws_access_key_id "$CHIAVE_ID"
  aws configure set aws_secret_access_key "$CHIAVE_SEGRETA"
  aws configure set region "$AWS_REGIONE"
  unset CHIAVE_SEGRETA
  if IDENTITA="$(aws sts get-caller-identity --query Arn --output text 2> /dev/null)" ; then
    ok "accesso AWS: ${IDENTITA##*/}"
  else
    male "AWS non accetta questa chiave: controlla di aver copiato i due pezzi interi, o creane un'altra."
  fi
fi

# --------------------------------------------------------------------------
titolo "2. Gitea"
# --------------------------------------------------------------------------
# Alla persona si chiede la password, non un token: il token lo crea lo
# script con l'API di Gitea, cosi' non c'e' da cercarlo fra le impostazioni.
# Gitea rifiuta la password provvisoria finche' non la si cambia nel browser.
UTENTE="$(utente_gitea)"
if [ -n "$UTENTE" ] ; then
  ok "token Gitea gia' salvato (utente $UTENTE)"
else
  echo "  Se non l'hai ancora fatto, entra su $GITEA_URL e cambia la password provvisoria."
  read -r -p "  Il tuo utente Gitea (nome.cognome): " UTENTE_DATO
  read -r -s -p "  La tua password Gitea (non si vede, ed e' normale): " PASSWORD ; echo
  # utente:password passano a curl da stdin, non dalla riga di comando
  # (che chiunque sul PC vede con ps). Virgolette e \ vanno protette.
  PASSWORD_CURL="$(printf '%s:%s' "$UTENTE_DATO" "$PASSWORD" | sed 's/[\\"]/\\&/g')"
  NOME_TOKEN="oto-$(hostname | tr -dc 'A-Za-z0-9-' | head -c 20)-$(date +%Y%m%d%H%M%S)"
  RISPOSTA="$(printf 'user = "%s"\n' "$PASSWORD_CURL" \
    | curl -s --max-time 15 -K - -w '\n%{http_code}' -X POST \
        -H 'Content-Type: application/json' \
        -d "{\"name\":\"$NOME_TOKEN\",\"scopes\":[\"write:repository\",\"write:user\",\"read:organization\"]}" \
        "$GITEA_URL/api/v1/users/$UTENTE_DATO/tokens")"
  unset PASSWORD PASSWORD_CURL
  CODICE="${RISPOSTA##*$'\n'}"
  TOKEN="$(printf '%s' "${RISPOSTA%$'\n'*}" | sed -n 's/.*"sha1":"\([^"]*\)".*/\1/p')"
  if [ "$CODICE" = "201" ] && [ -n "$TOKEN" ] ; then
    mkdir -p "$(dirname "$TOKEN_GITEA_FILE")"
    chmod 700 "$(dirname "$TOKEN_GITEA_FILE")"
    ( umask 077 ; printf '%s\n' "$TOKEN" > "$TOKEN_GITEA_FILE" )
    unset TOKEN
    UTENTE="$(utente_gitea)"
    ok "accesso Gitea salvato in $TOKEN_GITEA_FILE (utente $UTENTE)"
  elif [ "$CODICE" = "403" ] ; then
    male "Gitea chiede prima di cambiare la password provvisoria: entra su $GITEA_URL, cambiala e rilancia."
  elif [ "$CODICE" = "401" ] ; then
    male "utente o password sbagliati: rilancia e riprova."
  else
    male "Gitea non ha creato l'accesso (HTTP ${CODICE:-nessuna risposta}): rilancia, o chiedi all'amministratore."
  fi
fi

# git: chi sei, e come si ricorda le credenziali. Il token vale anche come
# password per git: lo si scrive una volta in ~/.git-credentials.
if [ -n "$UTENTE" ] ; then
  [ -n "$(git config --global user.name)" ] || git config --global user.name "$UTENTE"
  if [ -z "$(git config --global user.email)" ] ; then
    read -r -p "  La tua email di lavoro (per i commit): " EMAIL
    [ -n "$EMAIL" ] && git config --global user.email "$EMAIL"
  fi
  [ -n "$(git config --global credential.helper)" ] || git config --global credential.helper store
  CREDENZIALI="$HOME/.git-credentials"
  if ! grep -q "@$GITEA_HOST" "$CREDENZIALI" 2> /dev/null ; then
    ( umask 077 ; printf 'https://%s:%s@%s\n' "$UTENTE" "$(token_gitea)" "$GITEA_HOST" >> "$CREDENZIALI" )
  fi
  ok "git configurato ($(git config --global user.name) <$(git config --global user.email)>)"
fi

# --------------------------------------------------------------------------
titolo "3. Chiave SSH"
# --------------------------------------------------------------------------
if [ -f "$CHIAVE_SSH" ] ; then
  ok "chiave gia' presente: $CHIAVE_SSH"
else
  mkdir -p "$HOME/.ssh" && chmod 700 "$HOME/.ssh"
  COMMENTO="${UTENTE:-$(whoami)}@oto"
  ssh-keygen -q -t ed25519 -f "$CHIAVE_SSH" -C "$COMMENTO" -N "" \
    && ok "chiave creata: $CHIAVE_SSH"
fi
# La parte pubblica va sul proprio profilo Gitea: e' da li' che
# l'amministratore la prende per metterla sui server, senza che la persona
# debba mandarla a nessuno.
if [ -f "$CHIAVE_SSH.pub" ] && [ -n "$UTENTE" ] ; then
  PUBBLICA="$(awk '{print $1" "$2}' "$CHIAVE_SSH.pub")"
  if curl -s --max-time 10 -H "Authorization: token $(token_gitea)" "$GITEA_URL/api/v1/user/keys" \
      | grep -qF "${PUBBLICA#* }" ; then
    ok "chiave pubblica gia' sul tuo profilo Gitea"
  else
    CODICE="$(curl -s -o /dev/null --max-time 10 -w '%{http_code}' -X POST \
      -H "Authorization: token $(token_gitea)" -H 'Content-Type: application/json' \
      -d "{\"title\":\"oto $(hostname | tr -dc 'A-Za-z0-9-')\",\"key\":\"$PUBBLICA\"}" \
      "$GITEA_URL/api/v1/user/keys")"
    if [ "$CODICE" = "201" ] ; then
      ok "chiave pubblica caricata sul tuo profilo Gitea: l'amministratore la prende da li'"
    else
      attento "non riesco a caricare la chiave su Gitea (HTTP $CODICE). Manda all'amministratore questa riga, e' la parte pubblica:"
      echo "    $(cat "$CHIAVE_SSH.pub")"
    fi
  fi
  echo "  Il file $CHIAVE_SSH, senza .pub, non esce mai da questo PC."
fi

# --------------------------------------------------------------------------
titolo "4. Nomi dei server in ~/.ssh/config"
# --------------------------------------------------------------------------
# Un blocco fra due segni, riscritto intero a ogni giro: cosi' quando cambia
# un server basta rilanciare. Un nome gia' definito fuori dal blocco non si
# tocca (e' una configurazione tua).
CONFIG="$HOME/.ssh/config"
touch "$CONFIG" && chmod 600 "$CONFIG"
INIZIO="# >>> OTO (scritto da _OTO_IT_onboard/configura.sh) >>>"
FINE_BLOCCO="# <<< OTO <<<"
# Confronto esatto, non una regex: il segno contiene "/" e "(".
FUORI="$(awk -v i="$INIZIO" -v f="$FINE_BLOCCO" '$0 == i {dentro=1; next} $0 == f {dentro=0; next} !dentro' "$CONFIG")"

# La chiave con ~ e non col percorso intero: su Windows Git Bash scriverebbe
# /c/Users/..., che l'OpenSSH di Windows (quello di VS Code) non capisce.
CHIAVE_CONFIG="~${CHIAVE_SSH#"$HOME"}"
BLOCCO="$INIZIO"
for VOCE in "$STAGING_NOME $STAGING_HOST" "$PRODUZIONE_NOME $PRODUZIONE_HOST" ; do
  set -- $VOCE
  if printf '%s\n' "$FUORI" | grep -qE "^Host[[:space:]]+$1([[:space:]]|\$)" ; then
    attento "$1 e' gia' definito in $CONFIG: lo lascio com'e'"
    continue
  fi
  BLOCCO="$BLOCCO
Host $1
  HostName $2
  User $UTENTE_SERVER
  IdentitiesOnly yes
  IdentityFile $CHIAVE_CONFIG
"
done
BLOCCO="$BLOCCO$FINE_BLOCCO"

{ printf '%s\n' "$FUORI" | sed -e :a -e '/^\n*$/{$d;N;ba' -e '}' ; echo ; printf '%s\n' "$BLOCCO" ; } > "$CONFIG.nuovo" \
  && mv "$CONFIG.nuovo" "$CONFIG" && chmod 600 "$CONFIG"
ok "ssh $STAGING_NOME e ssh $PRODUZIONE_NOME: configurati"

# --------------------------------------------------------------------------
titolo "Fatto"
# --------------------------------------------------------------------------
echo "  Ora: importa il file della VPN, poi lancia ./verifica.sh"