#!/bin/sh
# import-batch.sh <pkg...>   |   import-batch.sh -f <listfile>   — Etapa G: importa una TANDA a
# escala aplicando la ESCALERA DE FALLBACK (memoria etapa-g): por cada paquete intenta primero nix
# (Rust/Go/CLI moderno, ~100% en musl) y, si el import falla (src no-clasificable, eval error), cae
# a Alpine (que TRAE los parches de musl) probando `main` y luego `community`. Escribe la receta a
# OUTDIR/<pkg>.toml y, al final, MIDE EL YIELD POR TIER (nix / alpine / fallaron) — el dato real que
# decide dónde está la fricción al escalar, sin especular.
#
# Es sólo el IMPORT (barato). El trabajo real es construir: encadená con
#   scripts/pin-recipes.sh "$OUTDIR"/*.toml     (Fase 2: tag→SHA en lote)
#   scripts/build-repo.sh                       (Etapa F: pack --build + repo firmado)
#
# Ej:  scripts/import-batch.sh ripgrep fd bat hyperfine
#      scripts/import-batch.sh -f tandas/cli-rust.txt
#      OUTDIR=recipes/incoming scripts/import-batch.sh sd dust
# Env: OUTDIR (default recipes), PREFER (nix|alpine; default nix — alpine antepone Alpine para tandas
#      C, que necesitan sus parches musl), NIX_STORE (p.ej. $HOME/.nixstore si /nix/store no es
#      escribible), ALPINE_BRANCH (default master), HAMMER (cmd del cli).  Un nombre puede mapear
#      nix→alpine distintos con `nixattr=alpinepkg` (p.ej. `the_silver_searcher=the-silver-searcher`).
set -eu

here=$(dirname "$0")
OUTDIR="${OUTDIR:-recipes}"
export OUTDIR  # alpine-import.sh baja sus .patch acá

# Resolver la lista de paquetes: -f <fichero> (una entrada por línea, '#' comenta) o argumentos.
if [ "${1:-}" = "-f" ]; then
  [ -n "${2:-}" ] || { echo "uso: import-batch.sh -f <listfile>" >&2; exit 1; }
  pkgs=$(sed -e 's/#.*//' -e '/^[[:space:]]*$/d' "$2")
else
  [ "$#" -gt 0 ] || { echo "uso: import-batch.sh <pkg...> | -f <listfile>" >&2; exit 1; }
  pkgs=$(printf '%s\n' "$@")
fi

# Orden de fuentes: PREFER=nix (default, tier-1 Rust/Go) o PREFER=alpine (tier-2 C, trae parches musl).
case "${PREFER:-nix}" in
  alpine) TIERS="alpine-main alpine-community nix" ;;
  nix|*)  TIERS="nix alpine-main alpine-community" ;;
esac

mkdir -p "$OUTDIR"
nix_n=0; alpine_n=0; failed=""; got=""

# IFS=newline para tolerar una entrada por línea; restaurar después no hace falta (sub-shell del for).
OLDIFS=$IFS; IFS='
'
for entry in $pkgs; do
  IFS=$OLDIFS
  # Mapeo opcional nixattr=alpinepkg; si no hay '=', el mismo nombre sirve para ambas fuentes.
  case $entry in
    *=*) nixattr=${entry%%=*}; alpinepkg=${entry#*=} ;;
    *)   nixattr=$entry; alpinepkg=$entry ;;
  esac
  out="$OUTDIR/${nixattr}.toml"

  printf '%-24s ' "$nixattr" >&2
  done_pkg=""
  # Orden de fuentes según PREFER (default nix, ~100% Rust/Go). PREFER=alpine antepone Alpine para
  # tandas C: el import de nix de un C tiene éxito (tarball) pero SIN los parches musl ⇒ rompería al
  # construir; Alpine los TRAE. Cada "tier" es una etiqueta y el comando que produce la receta.
  for tier in $TIERS; do
    case $tier in
      nix)            src="nix";             cmd_out=$("$here/nix-import.sh" "$nixattr" 2>/dev/null) || cmd_out="" ;;
      alpine-main)    src="alpine/main";      cmd_out=$("$here/alpine-import.sh" "$alpinepkg" main 2>/dev/null) || cmd_out="" ;;
      alpine-comm*)   src="alpine/community"; cmd_out=$("$here/alpine-import.sh" "$alpinepkg" community 2>/dev/null) || cmd_out="" ;;
    esac
    if [ -n "$cmd_out" ]; then
      printf '%s\n' "$cmd_out" > "$out"
      case $tier in nix) nix_n=$((nix_n + 1)) ;; *) alpine_n=$((alpine_n + 1)) ;; esac
      got="$got $nixattr"; done_pkg=1
      echo "✓ $src" >&2
      break
    fi
  done
  if [ -z "$done_pkg" ]; then
    failed="$failed $nixattr"
    echo "✗ ninguna fuente" >&2
  fi
done

total=$((nix_n + alpine_n))
echo >&2
echo "yield import: $total/$((total + $(printf '%s' "$failed" | wc -w))) — nix=$nix_n, alpine=$alpine_n.${failed:+ FALLARON:$failed}" >&2
echo "recetas en $OUTDIR/.${got:+ Siguiente: pin + build —} ${got:+scripts/pin-recipes.sh}${got:+ $OUTDIR/*.toml}" >&2
# Salida limpia en stdout: los nombres importados (para encadenar con xargs si se quiere).
printf '%s\n' $got
