#!/bin/bash
# Kit de entrada do dsgit para UM usuario (Linux, macOS e Git Bash no Windows). Idempotente; desfazer: sair.sh.
# Uso:  bash entrar.sh
#   Token: pede sem eco. Reutiliza, nesta ordem: variavel DSGIT_TOKEN, arquivo DSGIT_TOKEN_FILE, cofre de credenciais.
#   DSGIT_URL  (padrao https://dsgit.dsmarketing.com.br)     DSGIT_USER (opcional: exige que o token seja deste usuario)
# O que faz: confere o acesso; guarda o token no cofre de credenciais do sistema; configura o git so para este host;
# instala em ~/.dsgit/bin a CLI tea, o servidor MCP forgejo-mcp (versoes fixas, sha256 conferido) e o comando "dsgit";
# registra o MCP "dsgit" no Claude Code (escopo de usuario, sem token no arquivo); poe um bloco removivel no perfil
# do shell; roda o autoteste. NAO grava o token em repositorio, em ~/.gitconfig nem em variavel de ambiente.
# Unico lugar fora do cofre onde o token fica em texto: a configuracao da tea no perfil do usuario (limite da tea).
set -euo pipefail
URL="${DSGIT_URL:-https://dsgit.dsmarketing.com.br}"; URL="${URL%/}"; HOST="${URL#https://}"
[ "$HOST" != "$URL" ] || { echo "ERRO: DSGIT_URL precisa ser https://"; exit 1; }
K="$(cd "$(dirname "$0")" && pwd)"; D="$HOME/.dsgit"; B="$D/bin"
TEA_V=0.16.0; MCP_V=2.30.2
case "$(uname -s)-$(uname -m)" in   # plataforma | sha256 da tea | sha256 do forgejo-mcp (.tar.gz)
  MINGW*-x86_64|MSYS*-x86_64) SO=windows; TEA_A=windows-amd64.exe; TEA_S=3f42442c77ed8fee218186376cb2bfdfc52a4d2d5ecbf08c5552a290d3d08fdd; X=.exe ;;
  Linux-x86_64)   SO=linux;  TEA_A=linux-amd64;  TEA_S=9c142c8a0b31485eea2387031c1c404f12b7141075eb4ffbd7ced49441590636; MCP_A=linux_amd64;  MCP_S=a2a485062108aaa9c74688e4fabdf6872ed1cf3ad9b4b08f09689651a5ed27bd; X= ;;
  Linux-aarch64)  SO=linux;  TEA_A=linux-arm64;  TEA_S=0e14a036322eeb1fc55e266acafeb8490e523ed99f9232034ae74861e2339879; MCP_A=linux_arm64;  MCP_S=e96df6123016bce11e936235c82763642ffa5d69ff053ff27d3195db9c683df0; X= ;;
  Darwin-x86_64)  SO=darwin; TEA_A=darwin-amd64; TEA_S=792fd7866a79ebb74d6cdbc01af0d8263e1814a0354911cf1e210fbec16f5bfb; MCP_A=darwin_amd64; MCP_S=2332024d61dc335f463e86ef6e794ea1deb10ce004a80f84c4336aeceeae6927; X= ;;
  Darwin-arm64)   SO=darwin; TEA_A=darwin-arm64; TEA_S=f7f70f57dac1616d17edc0d010469648222642bf3462e09c05bca26b38f3dfdb; MCP_A=darwin_arm64; MCP_S=e39665123520073d267a83de7d1e08a684a6bfe6e5c440633ee9e703ee1d2b78; X= ;;
  *) echo "ERRO: plataforma nao prevista: $(uname -s)-$(uname -m)"; exit 1 ;;
esac
sha(){ if command -v sha256sum >/dev/null; then sha256sum "$1"; else shasum -a 256 "$1"; fi | cut -d' ' -f1; }
passo(){ echo "-- $1"; }
for c in git curl; do command -v $c >/dev/null || { echo "ERRO: falta o comando $c"; exit 1; }; done

passo "(a) acesso a $URL"
[ "$(curl -sS -m 20 -o /dev/null -w '%{http_code}' "$URL/user/login")" = 200 ] || { echo "ERRO: $URL nao respondeu 200 (rede? VPN da Under em tunel completo nao abre o dsgit)"; exit 1; }

passo "(b) token pessoal"
cofre(){ printf 'protocol=https\nhost=%s\n\n' "$HOST" | GIT_TERMINAL_PROMPT=0 GCM_INTERACTIVE=never git credential fill 2>/dev/null | sed -n 's/^password=//p'; }
quem(){ printf 'Authorization: token %s\n' "$1" | curl -sS -m 20 -H @- "$URL/api/v1/user" 2>/dev/null; }
campo(){ grep -o "\"$1\":\"[^\"]*\"" | head -n1 | sed 's/^[^:]*:"//; s/"$//'; }
tok="${DSGIT_TOKEN:-}"; origem="variavel DSGIT_TOKEN"
[ -n "$tok" ] || { [ -n "${DSGIT_TOKEN_FILE:-}" ] && tok="$(tr -d '\r\n ' < "$DSGIT_TOKEN_FILE")" && origem="arquivo DSGIT_TOKEN_FILE"; } || true
[ -n "$tok" ] || { tok="$(cofre)"; origem="cofre de credenciais"; }
if [ -z "$tok" ]; then
  [ -r /dev/tty ] || { echo "ERRO: sem terminal para pedir o token; use DSGIT_TOKEN_FILE=<arquivo>"; exit 1; }
  echo "   Crie em $URL/user/settings/applications (escopos no LEIAME) e cole aqui."
  read -rsp "   Token (nao aparece na tela): " tok < /dev/tty; echo; tok="$(printf '%s' "$tok" | tr -d '\r\n ')"; origem="digitado"
fi
EU="$(quem "$tok")"; LOGIN="$(campo login <<<"$EU")"
[ -n "$LOGIN" ] || { echo "ERRO: o token ($origem) nao foi aceito pela API. Gere outro e rode de novo."; exit 1; }
[ -z "${DSGIT_USER:-}" ] || [ "$LOGIN" = "$DSGIT_USER" ] || { echo "ERRO: o token e do usuario '$LOGIN', esperado '$DSGIT_USER'"; exit 1; }
echo "   token aceito ($origem): usuario $LOGIN"

passo "(c) cofre de credenciais e (d) git para o host"
if [ -z "$(git config --get-all credential.helper || true)" ]; then   # so mexe se o usuario nao tem nenhum
  case $SO in
    windows) H=manager ;;
    darwin)  H=osxkeychain ;;
    linux)   H="$(ls /usr/lib/git-core/git-credential-libsecret /usr/libexec/git-core/git-credential-libsecret 2>/dev/null | head -n1 || true)"
             if [ -z "$H" ]; then mkdir -p "$D"; ( umask 077; touch "$D/git-credentials" ); H="store --file $D/git-credentials"
               echo "   AVISO: sem libsecret; o token fica em $D/git-credentials (600). Instale git-credential-libsecret para usar o chaveiro."; fi ;;
  esac
  git config --global "credential.$URL.helper" "$H"
fi
[ $SO != windows ] || git config --global "credential.$URL.provider" generic   # GCM nao sonda o host nem abre janela
git config --global "credential.$URL.username" "$LOGIN"
printf 'protocol=https\nhost=%s\nusername=%s\npassword=%s\n\n' "$HOST" "$LOGIN" "$tok" | git credential approve
[ "$(cofre)" = "$tok" ] || { echo "ERRO: o cofre de credenciais nao devolveu o token gravado"; exit 1; }
# identidade (user.name/user.email) valida SO em clones deste host; a identidade global do usuario nao muda
mkdir -p "$B"
NOME="$(campo full_name <<<"$EU")"; EMAIL="$(campo email <<<"$EU")"
[ -n "$NOME" ] || NOME="$(git config --global user.name || true)"
git config --file "$D/gitconfig" user.name "${NOME:-$LOGIN}"; git config --file "$D/gitconfig" user.email "$EMAIL"
git config --global "includeIf.hasconfig:remote.*.url:$URL/**.path" "~/.dsgit/gitconfig"

passo "(e) CLI tea $TEA_V"
if [ ! -f "$B/tea$X" ] || [ "$(sha "$B/tea$X")" != "$TEA_S" ]; then
  curl -fsSL -m 300 -o "$B/tea$X.novo" "https://gitea.com/gitea/tea/releases/download/v$TEA_V/tea-$TEA_V-$TEA_A"
  [ "$(sha "$B/tea$X.novo")" = "$TEA_S" ] || { rm -f "$B/tea$X.novo"; echo "ERRO: sha256 da tea nao confere"; exit 1; }
  chmod +x "$B/tea$X.novo"; mv -f "$B/tea$X.novo" "$B/tea$X"
fi
"$B/tea" logout dsgit >/dev/null 2>&1 || true
GITEA_SERVER_TOKEN="$tok" "$B/tea" login add --name dsgit --url "$URL" >/dev/null
[ $SO = windows ] || chmod 600 "${XDG_CONFIG_HOME:-$HOME/.config}/tea/config.yml" 2>/dev/null || true

passo "(f) servidor MCP forgejo-mcp $MCP_V"
if [ $SO = windows ]; then   # o projeto nao publica .exe. 1o tenta o pacote generico do dsgit (se ja publicado);
  # depois o compilar-mcp-windows.sh confere o sha256 fixado e, se nao bater, compila a tag (4 a 13 min na 1a vez).
  [ -f "$B/forgejo-mcp.exe" ] || { printf 'Authorization: token %s\n' "$tok" | curl -fsSL -m 120 -H @- -o "$B/forgejo-mcp.exe" \
    "$URL/api/packages/dsgit/generic/forgejo-mcp/$MCP_V/forgejo-mcp.exe" 2>/dev/null || rm -f "$B/forgejo-mcp.exe"; }
  bash "$K/compilar-mcp-windows.sh" "$B/forgejo-mcp.exe" | sed 's/^/   /'
elif [ ! -f "$B/forgejo-mcp" ] || [ "$("$B/forgejo-mcp" --version 2>/dev/null)" != "forgejo-mcp $MCP_V" ]; then
  T="$(mktemp -d)"; curl -fsSL -m 300 -o "$T/m.tgz" "https://codeberg.org/goern/forgejo-mcp/releases/download/v$MCP_V/forgejo-mcp_${MCP_V}_$MCP_A.tar.gz"
  [ "$(sha "$T/m.tgz")" = "$MCP_S" ] || { rm -rf "$T"; echo "ERRO: sha256 do forgejo-mcp nao confere"; exit 1; }
  tar -xzf "$T/m.tgz" -C "$T"; mv -f "$(find "$T" -type f -name forgejo-mcp | head -n1)" "$B/forgejo-mcp"; chmod +x "$B/forgejo-mcp"; rm -rf "$T"
fi
cp "$K/dsgit" "$B/dsgit"; chmod +x "$B/dsgit"
CL="$(command -v claude || ls "$HOME/.local/bin/claude" "$HOME/.local/bin/claude.exe" 2>/dev/null | head -n1 || true)"
if [ -n "$CL" ]; then   # so o servidor "dsgit"; os outros servidores MCP do usuario nao sao tocados
  "$CL" mcp remove -s user dsgit >/dev/null 2>&1 || true
  if [ $SO = windows ]; then G="$(cygpath -w /)"; "$CL" mcp add -s user dsgit -- "${G%\\}\\bin\\bash.exe" "$(cygpath -m "$B/dsgit")" mcp >/dev/null
  else "$CL" mcp add -s user dsgit -- "$B/dsgit" mcp >/dev/null; fi
  echo "   Claude Code: servidor MCP 'dsgit' registrado (escopo de usuario; o token e lido do cofre a cada inicio)"
else echo "   AVISO: Claude Code nao encontrado; MCP nao registrado (instale e rode de novo)"; fi

passo "(g) variavel DSGIT_URL e bloco no perfil do shell"
[ $SO != windows ] || setx DSGIT_URL "$URL" >/dev/null
bloco(){ # arquivo de perfil: tira o bloco antigo e poe o novo no fim
  local f="$1" t; [ -f "$f" ] || : > "$f"; t="$(mktemp)"
  sed '/^# >>> dsgit /,/^# <<< dsgit <<<$/d' "$f" > "$t"
  { cat "$t"; echo "# >>> dsgit (posto por entrar.sh; tirar: sair.sh) >>>"
    echo "export DSGIT_URL=\"$URL\"; case \":\$PATH:\" in *\":\$HOME/.dsgit/bin:\"*) ;; *) PATH=\"\$HOME/.dsgit/bin:\$PATH\";; esac"
    echo "alias dsgit-prs='dsgit prs' dsgit-runs='dsgit runs' dsgit-log='dsgit log' dsgit-rerun='dsgit rerun' dsgit-api='dsgit api'"
    echo "# <<< dsgit <<<"; } > "$f"; rm -f "$t"; }
bloco "$HOME/.bashrc"
[ ! -f "$HOME/.zshrc" ] && [ "${SHELL##*/}" != zsh ] || bloco "$HOME/.zshrc"
unset tok EU

passo "(h) autoteste"
DSGIT_URL="$URL" DSGIT_USER="$LOGIN" bash "$B/dsgit" teste
echo "Pronto. Abra um terminal novo (ou: source ~/.bashrc) e use: dsgit-prs, dsgit-runs, dsgit-log <run>, tea, dsgit api /user"
