#!/usr/bin/env bash
# sp-subir: sube un proyecto al servidor de descargas (lo llama "sp subir").
# Pedido del autor, 18/10/2026: que funcione solo desde donde esta el .summa
# del proyecto, que verifique que hay svn y que todo esta comiteado, y que se
# llame "sp subir calcula" parado en el proyecto, o "sp subir LUGAR/calcula".
#
#   sp paquete [LUGAR/]NOMBRE         arma (hacer-pkg)
#   sp subir [--prueba] [--tipo T,...] [LUGAR/]NOMBRE  sube, como UNSTABLE
#   sp estable [--prueba] [LUGAR/]NOMBRE  lo subido pasa a estable
#   sp subir --bootstrap [--prueba] [LUGAR/]summapack   la raiz de descargas:
#                       0-README-como-instalar, el sp autonomo, el
#                       diccionario y fuentesexternas (antes: make
#                       subir-bootstrap)
#   sp subir --comunes-fuentes [--prueba] [LUGAR/]summapack   las fuentes
#                       externas (distros/espejo-fuentes) a comunes/fuentes/
#                       (antes: make subir-comunes-fuentes)
#
# Adonde: el campo SUBIR_A del .summa (pedido del autor, 18/10/2026):
#   SUBIR_A="simusol"   un nombre generico; usuario, servidor y camino salen
#                       de ~/.config/sp/destinos, un renglon por nombre:
#                       simusol publicador@simusol.org:/var/www/.../downloads
#                       (asi el .summa, que es publico, no los muestra)
#   SUBIR_A=""          lo configurado para subir-paquetes
#                       (~/.config/simusol/subir)
#   SUBIR_A="usuario@servidor:/camino"  tal cual, como en scp; esa misma
#                       cadena, literal, es la plantilla que va en lo
#                       publicado (hacer-pkg la pone): sp subir pide cambiarla
# Antes de subir se comprueba que se entra por ssh a usuario@servidor sin
# contrasena (clave); si no, no se sube nada. Las variables SUBIR_SERVIDOR,
# SUBIR_USUARIO y SUBIR_DIR del entorno mandan sobre el .summa (pruebas:
# SUBIR_SERVIDOR=local).
#
# 1. LUGAR/NOMBRE.summa tiene que existir (LUGAR por omision: aca).
# 2. LUGAR tiene que ser una copia de trabajo de svn sin cambios sin comitear
#    (svn status; lo que svn no conoce, "?", no cuenta).
# 3. "sp paquete" arma con LUGAR/hacer-pkg el tar.gz de las fuentes, el
#    .summa con version y los paquetes (si hay cambios sin comitear avisa,
#    pero arma: sirve para probar). "sp subir" usa lo ya armado; si no esta
#    la version actual, llama antes a "sp paquete".
# 4. Sube esos dos con subir-paquetes, como UNSTABLE. "sp estable NOMBRE"
#    lo pasa a estable (subir-paquetes --estable; pedido del autor,
#    18/10/2026). Los binarios (deb, rpm, tgz) no: salen de las bases viejas
#    (summapack/distros) por otro camino.
# 5. Que sube: sin --tipo, todo lo de esa version, de todos los paquetes del
#    .summa (PACKAGES): fuentes (tar.gz), .deb, .rpm y .tgz; con --tipo,
#    solo esos (fuentes, deb, rpm, tgz; separados por coma). El .summa va
#    siempre. Los binarios salen SOLO de lo armado en las bases viejas:
#    summapack/distros/salida/viejas/DISTRIBUCION/ (o $SP_BINARIOS); lo que
#    hacer-pkg arma en esta maquina no se sube (decision del autor,
#    18/10/2026: un .deb de Ubuntu 24.04 no anda en 22.04 ni en Debian 12).
# --prueba: dice que haria (subir-paquetes --prueba), sin subir.
set -euo pipefail
PROGRAMA="sp subir"
AQUI=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
prueba=0 modo=subir tipos=fuentes,deb,rpm,tgz raiz=''
case "${1:-}" in
    --estable-modo) modo=estable; shift ;;
    --paquete-modo) modo=paquete; PROGRAMA="sp paquete"; shift ;;
esac
fallar() { echo "$PROGRAMA: $*" >&2; exit 1; }
while [ $# -gt 0 ]; do
    case "$1" in
        --prueba) prueba=1 ;;
        --bootstrap) raiz=bootstrap ;;
        --comunes-fuentes) raiz=comunes-fuentes ;;
        --tipo) [ $# -ge 2 ] || fallar "--tipo necesita fuentes, deb, rpm o tgz"; tipos=$2; shift ;;
        --tipo=*) tipos=${1#*=} ;;
        -h|--help) sed -n '2,53s/^# \{0,1\}//p' "$0"; exit 0 ;;
        -*) fallar "opcion desconocida: $1 (--help)" ;;
        *) break ;;
    esac
    shift
done
subir=$AQUI/subir-paquetes
[ -x "$subir" ] || subir=$(command -v subir-paquetes || true)
[ -n "$subir" ] || fallar "falta subir-paquetes (de summapack)"
opc=(); [ $prueba = 0 ] || opc=(--prueba)
[ $modo != estable ] || PROGRAMA="sp estable"
[ $# = 1 ] || fallar "uso: sp $modo [--prueba] [--tipo T,...] [LUGAR/]NOMBRE"
objetivo=$1
nombre=$(basename "$objetivo")
case "$objetivo" in */*) lugar=$(dirname "$objetivo") ;; *) lugar=. ;; esac
lugar=$(cd "$lugar" 2>/dev/null && pwd) || fallar "no existe la carpeta de $objetivo"
summa=$lugar/$nombre.summa

# 1. el .summa
[ -f "$summa" ] || fallar "no esta $summa: correr desde la carpeta del proyecto (la que tiene $nombre.summa) o dar LUGAR/$nombre"
# la version completa, AÑO.MAYOR.MENOR.rREV-N (sp-version): la revision de
# svn va en el nombre, asi lo armado antes de un commit no se confunde
sv=$AQUI/sp-version; [ -x "$sv" ] || sv=$(command -v sp-version || true)
[ -n "$sv" ] || fallar "falta sp-version (de summapack)"
version=$("$sv" "$lugar") || fallar "no se pudo saber la version de $nombre"
[ -n "$version" ] || fallar "$summa no dice VERSION"
# la plantilla de lo publicado: hay que poner el destino propio
if [ $modo != paquete ] && grep -qx 'SUBIR_A="usuario@servidor:/camino"' "$summa"; then
    fallar "SUBIR_A en $summa es la plantilla (usuario@servidor:/camino): cambiar SUBIR_A en el .summa por el destino real (usuario@servidor:/camino) o por un nombre de ~/.config/sp/destinos"
fi

# adonde se sube: SUBIR_A del .summa, y que se entre por ssh sin contrasena
destino_de_summa() {
    local a
    a=$(sed -n 's/^SUBIR_A="\(.*\)"$/\1/p' "$summa" | tail -1)
    if [ -n "${SUBIR_SERVIDOR:-}" ]; then
        echo "adonde: el del entorno (SUBIR_SERVIDOR=$SUBIR_SERVIDOR${SUBIR_DIR:+, SUBIR_DIR=$SUBIR_DIR})"
        return 0
    fi
    [ "$a" != "usuario@servidor:/camino" ] || fallar "SUBIR_A en $summa es la plantilla (usuario@servidor:/camino): cambiar SUBIR_A en el .summa por el destino real (usuario@servidor:/camino) o por un nombre de ~/.config/sp/destinos"
    grep -q '^SUBIR_A=' "$summa" || fallar "$summa no dice SUBIR_A (adonde se sube): agregar SUBIR_A=\"simusol\" (o \"\")"
    if [ -z "$a" ]; then
        # lo de subir-paquetes: su configuracion (o sus valores por omision)
        local c=${XDG_CONFIG_HOME:-$HOME/.config}/simusol/subir u='' sv='' d=''
        if [ -f "$c" ]; then
            u=$(sed -n 's/^SUBIR_USUARIO=//p' "$c" | tail -1 | tr -d '"'"'"); sv=$(sed -n 's/^SUBIR_SERVIDOR=//p' "$c" | tail -1 | tr -d '"'"'"); d=$(sed -n 's/^SUBIR_DIR=//p' "$c" | tail -1 | tr -d '"'"'")
        fi
        [ -n "$u" ] && [ -n "$sv" ] && [ -n "$d" ] || fallar "SUBIR_A vacio y falta SUBIR_USUARIO, SUBIR_SERVIDOR o SUBIR_DIR en $c"
        a="$u@$sv:$d"
    fi
    case "$a" in
        *@*:/*) ;;
        *)  # nombre generico: ~/.config/sp/destinos
            local f=${XDG_CONFIG_HOME:-$HOME/.config}/sp/destinos r
            r=$(sed -n "s/^$a[[:space:]]\{1,\}//p" "$f" 2>/dev/null | tail -1 || true)
            [ -n "$r" ] || fallar "SUBIR_A=\"$a\": falta un renglon \"$a usuario@servidor:/camino\" en $f"
            a=$r
            case "$a" in *@*:/*) ;; *) fallar "en $f, $a tiene que ser usuario@servidor:/camino" ;; esac ;;
    esac
    export SUBIR_USUARIO=${a%%@*} SUBIR_SERVIDOR=${a#*@}; SUBIR_SERVIDOR=${SUBIR_SERVIDOR%%:*}
    export SUBIR_DIR=${a#*:}
    echo "adonde: $SUBIR_USUARIO@$SUBIR_SERVIDOR:$SUBIR_DIR"
    if ! ssh -o BatchMode=yes -o ConnectTimeout=15 "$SUBIR_USUARIO@$SUBIR_SERVIDOR" true 2>/dev/null; then
        fallar "no se puede entrar por ssh a $SUBIR_USUARIO@$SUBIR_SERVIDOR sin contrasena desde esta maquina; habilitarlo (ssh-copy-id $SUBIR_USUARIO@$SUBIR_SERVIDOR) y volver a probar"
    fi
}
# Comprobar la vista estable del servidor incluyendo el .summa que se quiere
# subir/activar. Una dependencia nueva debe estar publicada antes que su uso.
comprobar_compatibilidad() {   # CANDIDATO.summa
    local candidato=$1 tmp orden
    tmp=$(mktemp -d)
    if [ "${SUBIR_SERVIDOR:-}" = local ]; then
        for orden in "$SUBIR_DIR"/*.summa; do [ -f "$orden" ] && cp "$orden" "$tmp/"; done
    else
        printf -v orden 'cd %q && tar -cf - -- *.summa' "$SUBIR_DIR"
        ssh "$SUBIR_USUARIO@$SUBIR_SERVIDOR" "$orden" | tar -xf - -C "$tmp" || { rm -rf "$tmp"; fallar "no se pudieron consultar los .summa estables"; }
    fi
    "$AQUI/sp-comprobar-repo" "$tmp" "$candidato" || { rm -rf "$tmp"; fallar "publicar primero las dependencias compatibles"; }
    rm -rf "$tmp"
}
# la raiz de descargas (solo summapack): archivos sueltos, sin version
if [ -n "$raiz" ]; then
    [ "$nombre" = summapack ] || fallar "--$raiz es de summapack"
    destino_de_summa
    if [ $raiz = bootstrap ]; then
        "$lugar/distros/armar-sp"
        sub='' archivos=("$lugar/doc/0-README-como-instalar" "$lugar/distros/salida/sp"
            "$lugar/share/summapack/data/diccionariodepaquetes" "$lugar/share/summapack/data/fuentesexternas")
    else
        [ -f "$lugar/distros/salida/comunes/fuentes/SHA256SUMS" ] || fallar "falta correr distros/espejo-fuentes"
        sub=comunes/fuentes/ archivos=("$lugar"/distros/salida/comunes/fuentes/*)
    fi
    echo "se sube a ${SUBIR_DIR:-?}/$sub:"; for f in "${archivos[@]}"; do echo "  ${f##*/}"; done
    [ $prueba = 0 ] || { echo "(--prueba: no se subio nada)"; exit 0; }
    if [ "${SUBIR_SERVIDOR:-}" = local ]; then
        mkdir -p "$SUBIR_DIR/$sub" && cp "${archivos[@]}" "$SUBIR_DIR/$sub"
    else
        [ -z "$sub" ] || ssh "$SUBIR_USUARIO@$SUBIR_SERVIDOR" "mkdir -p '$SUBIR_DIR/$sub'"
        scp "${archivos[@]}" "$SUBIR_USUARIO@$SUBIR_SERVIDOR:$SUBIR_DIR/$sub"
    fi
    echo "listo"
    exit 0
fi
if [ $modo = estable ]; then
    destino_de_summa
    if [ "${SUBIR_SERVIDOR:-}" = local ]; then
        pendiente="$SUBIR_DIR/$nombre/otros/${nombre}_UNSTABLE.summa"
    else
        pendiente_tmp=$(mktemp -d)
        pendiente="$pendiente_tmp/${nombre}_UNSTABLE.summa"
        printf -v orden 'cat %q' "$SUBIR_DIR/$nombre/otros/${nombre}_UNSTABLE.summa"
        if ! ssh "$SUBIR_USUARIO@$SUBIR_SERVIDOR" "$orden" > "$pendiente" 2>/dev/null; then pendiente=''; fi
    fi
    if [ -n "$pendiente" ] && [ -f "$pendiente" ]; then comprobar_compatibilidad "$pendiente"; fi
    [ "${SUBIR_SERVIDOR:-}" = local ] || rm -rf "$pendiente_tmp"
    "$subir" "${opc[@]}" --estable "$nombre"
    [ $prueba = 1 ] || echo "$nombre: lo subido quedo estable"
    exit 0
fi

# lo primero: el sistema de versiones se sincroniza con el MANIFIESTO (lo que
# este ahi y no versionado se agrega, sin comitear; pedido del autor,
# 20/10/2026); asi sp subir ve esos agregados como cambios sin comitear
if [ -f "$lugar/MANIFIESTO" ]; then
    m=$AQUI/sp-manifiesto; [ -x "$m" ] || m=$(command -v sp-manifiesto || true)
    [ -n "$m" ] || fallar "falta sp-manifiesto (de summapack)"
    "$m" sincronizar "$lugar" || fallar "el MANIFIESTO de $lugar no coincide con la carpeta"
fi

# 2. svn, y todo comiteado
command -v svn >/dev/null || fallar "hace falta svn"
svn info "$lugar" > /dev/null 2>&1 || fallar "$lugar no es una copia de trabajo de svn"
cambios=$(svn status -q "$lugar" 2>/dev/null || true)
if [ -n "$cambios" ]; then
    echo "$cambios" >&2
    [ $modo = paquete ] || fallar "hay cambios sin comitear en $lugar: comitear antes de subir"
    echo "$PROGRAMA: aviso: hay cambios sin comitear; se arma igual (para subir hay que comitear)" >&2
fi
echo "$nombre $version, de $lugar (svn r$(svn info --show-item last-changed-revision "$lugar"), sin cambios sin comitear)"

# 3. armar (sp paquete; sp subir tambien, si no esta armada la version
# actual: pedido del autor, 18/10/2026)
armado() {
    # armado y no mas viejo que el ultimo commit del proyecto (si no, se
    # subiria algo que no es lo comiteado)
    local f d ultimo
    # el commit mas reciente de cualquier archivo del proyecto (el de la
    # carpeta sola no cambia hasta un svn update)
    ultimo=$(date -d "$(svn info -R --show-item last-changed-date "$lugar" 2>/dev/null | cut -d' ' -f1 | sort | tail -1)" +%s 2>/dev/null || echo 0)
    for f in "${nombre}_$version.tar.gz" "${nombre}_$version.summa"; do
        for d in "$lugar" "$(dirname "$lugar")"; do
            [ -f "$d/$f" ] && [ "$(stat -c %Y "$d/$f")" -ge "$ultimo" ] && continue 2
        done
        return 1
    done
}
if [ $modo = subir ] && ! armado; then
    echo "$nombre $version no esta armado (o es anterior al ultimo commit): primero sp paquete"
    [ $prueba = 0 ] || { echo "  [prueba] (cd $lugar && ./hacer-pkg)"; exit 0; }
    # solo las fuentes: los binarios que se suben son los de las bases viejas
    HACER_PKG_SOLO_FUENTES=1 "$0" --paquete-modo "$objetivo" || exit 1
fi
if [ $modo = paquete ]; then
    [ -x "$lugar/hacer-pkg" ] || fallar "no esta $lugar/hacer-pkg"
    [ $prueba = 0 ] || { echo "  [prueba] (cd $lugar && ./hacer-pkg)"; exit 0; }
    log=$(mktemp)
    echo "==> armando con hacer-pkg (todo en $log)"
    ( cd "$lugar" && ./hacer-pkg ) > "$log" 2>&1 || { tail -20 "$log"; fallar "hacer-pkg fallo (todo en $log)"; }
    grep -E '^  [^ ].*\(y \.md5\)' "$log" | sed 's/  (y \.md5)//' || true
    echo "$nombre $version armado; para subirlo: sp subir $objetivo"
    exit 0
fi

# los dos archivos: donde los deja hacer-pkg (al lado del proyecto, o en la
# carpeta de arriba: calcula y puyuspa)
archivos=()
for f in "${nombre}_$version.tar.gz" "${nombre}_$version.summa"; do
    encontrado=''
    for d in "$lugar" "$(dirname "$lugar")"; do
        [ -f "$d/$f" ] && { encontrado=$d/$f; break; }
    done
    [ -n "$encontrado" ] || fallar "no esta $f (armarlo con: sp paquete $objetivo)"
    archivos+=("$encontrado")
done

destino_de_summa
comprobar_compatibilidad "${archivos[1]}"

# los binarios de esa version, de las bases viejas
quiere() { case ",$tipos," in *",$1,"*) return 0 ;; *) return 1 ;; esac; }
for t in ${tipos//,/ }; do
    case "$t" in fuentes|deb|rpm|tgz) ;; *) fallar "--tipo desconocido: $t (fuentes, deb, rpm, tgz)" ;; esac
done
quiere fuentes || archivos=("${archivos[1]}")   # sin el tar.gz: solo el .summa
binarios=${SP_BINARIOS:-$AQUI/../distros/salida/viejas}
paquetes=$(sed -n 's/^PACKAGES="\(.*\)"$/\1/p' "$summa" | tail -1)
hay_bin=0
if quiere deb || quiere rpm || quiere tgz; then
    if [ -d "$binarios" ]; then
        for q in $paquetes; do
            for d in "$binarios"/*/; do
                quiere deb && for f in "$d${q}_${version}_"*.deb; do [ -f "$f" ] && { archivos+=("$f"); hay_bin=1; }; done
                quiere rpm && for f in "$d${q}-${version}."*.rpm; do [ -f "$f" ] && { archivos+=("$f"); hay_bin=1; }; done
                quiere tgz && for f in "$d${q}_${version}"[_+]*.tgz; do [ -f "$f" ] && { archivos+=("$f"); hay_bin=1; }; done
            done
        done
    fi
    [ $hay_bin = 1 ] || echo "$PROGRAMA: aviso: no hay binarios de $nombre $version en $binarios (los arma la base vieja de cada distribucion); se suben solo las fuentes y el .summa" >&2
fi
echo "se sube:"; for f in "${archivos[@]}"; do echo "  ${f#$(dirname "$(dirname "$f")")/}"; done

# 4. subir, como UNSTABLE
"$subir" "${opc[@]}" "${archivos[@]}"
[ $prueba = 1 ] || echo "$nombre $version subido como UNSTABLE; para dejarlo estable: sp estable $nombre"
