# /compile — Compila la app actual y la copia al escritorio de Windows

Compila una app del registry para los targets que soporte (Windows via MinGW, Android via Gradle/NDK si esta configurado) y deja el resultado en `/mnt/c/Users/lucas/Desktop/apps/<app>/`, listo para usar desde Windows.

Pensado para apps C++ del workspace `cpp/` (donde ya hay toolchain `mingw-w64.cmake` y build dir `cpp/build/windows/`). Si en el futuro hay apps Android (Gradle wrapper o NDK), tambien las detecta.

## Argumento

`$ARGUMENTS` — opcional. Nombre de la app a compilar (ej: `chart_demo`, `registry_dashboard`).

- Sin argumento: detectar la app desde `pwd` (si estas dentro de `cpp/apps/<X>/` o `projects/*/apps/<X>/`).
- Si no hay app deducible y no se pasa argumento → listar apps disponibles y pedir nombre.
- Si se pasa argumento, usarlo directamente.

## Pasos

### 1. Resolver la app y su directorio fuente

```bash
ROOT=/home/lucas/fn_registry
APP_ARG="$ARGUMENTS"

# Detectar desde CWD si no hay argumento
if [ -z "$APP_ARG" ]; then
  CWD="$(pwd)"
  case "$CWD" in
    "$ROOT"/cpp/apps/*|"$ROOT"/projects/*/apps/*)
      APP_ARG="$(basename "$CWD")" ;;
  esac
fi

# Si sigue vacio, listar apps y abortar
if [ -z "$APP_ARG" ]; then
  echo "Apps disponibles:"
  ls "$ROOT"/cpp/apps/ 2>/dev/null
  ls "$ROOT"/projects/*/apps/ 2>/dev/null
  echo "Uso: /compile <app_name>"
  exit 1
fi

# Buscar el directorio real
APP_DIR=""
for cand in "$ROOT/cpp/apps/$APP_ARG" "$ROOT"/projects/*/apps/"$APP_ARG"; do
  [ -d "$cand" ] && APP_DIR="$cand" && break
done

if [ -z "$APP_DIR" ]; then
  echo "No encuentro app '$APP_ARG' en cpp/apps/ ni projects/*/apps/"
  exit 1
fi
echo "App: $APP_ARG"
echo "Dir: $APP_DIR"
```

### 2. Detectar targets soportados

Examinar el `app.md` y los archivos del directorio para decidir que se puede compilar:

- **Windows (MinGW)**: si la app tiene `CMakeLists.txt` y se registra en `cpp/CMakeLists.txt` (es decir, aparece como subdirectorio en `cpp/build/windows/apps/<APP>/`). Default para apps C++.
- **Android**: si existe `AndroidManifest.xml`, `build.gradle`, `build.gradle.kts` o carpeta `android/` dentro de `$APP_DIR`. (Hoy no hay ninguna; saltar silenciosamente.)
- **Linux** (opcional, no por defecto): el build dir `cpp/build/` ya genera el binario para Linux. Solo se hace si el usuario lo pide explicitamente.

```bash
TARGETS=()
[ -f "$APP_DIR/CMakeLists.txt" ] && TARGETS+=("windows")

if [ -f "$APP_DIR/AndroidManifest.xml" ] || \
   [ -f "$APP_DIR/build.gradle" ] || \
   [ -f "$APP_DIR/build.gradle.kts" ] || \
   [ -d "$APP_DIR/android" ]; then
  TARGETS+=("android")
fi

if [ ${#TARGETS[@]} -eq 0 ]; then
  echo "No se detecta ningun target compilable en $APP_DIR"
  exit 1
fi
echo "Targets: ${TARGETS[*]}"
```

### 3. Compilar Windows (cross-compile MinGW)

Solo si `windows` esta en TARGETS.

```bash
BUILD_WIN="$ROOT/cpp/build/windows"

# Configurar build dir si no existe
if [ ! -f "$BUILD_WIN/CMakeCache.txt" ]; then
  mkdir -p "$BUILD_WIN"
  cmake -S "$ROOT/cpp" -B "$BUILD_WIN" \
    -DCMAKE_TOOLCHAIN_FILE="$ROOT/cpp/toolchains/mingw-w64.cmake" \
    -DCMAKE_BUILD_TYPE=Release
fi

# Compilar SOLO el target de la app (no todo el arbol)
cmake --build "$BUILD_WIN" --target "$APP_ARG" -j"$(nproc)"
```

Si el target no existe en CMake (porque la app no esta registrada en `cpp/CMakeLists.txt`), reportar y proponer registrarla siguiendo `cpp_apps.md` §5. NO autoregistrarla sin confirmacion del usuario.

### 4. Copiar a `/mnt/c/Users/lucas/Desktop/apps/<APP>/`

Replica el flujo documentado en memoria (`feedback_no_adminlocal.md`): el `.exe` + las TTFs de fuentes que el shell ImGui necesita. NO usar `AdminLocal`.

```bash
DEST="/mnt/c/Users/lucas/Desktop/apps/$APP_ARG"
mkdir -p "$DEST"

EXE_SRC="$BUILD_WIN/apps/$APP_ARG/$APP_ARG.exe"
if [ ! -f "$EXE_SRC" ]; then
  echo "ERROR: no se ha generado $EXE_SRC"
  exit 1
fi

cp -v "$EXE_SRC" "$DEST/"

# TTFs (estan junto al exe tras el build, copiados por add_imgui_app)
for ttf in "$BUILD_WIN/apps/$APP_ARG"/*.ttf; do
  [ -f "$ttf" ] && cp -v "$ttf" "$DEST/"
done

# Assets opcionales (carpeta assets/ junto al exe del build)
if [ -d "$BUILD_WIN/apps/$APP_ARG/assets" ]; then
  rsync -a --delete "$BUILD_WIN/apps/$APP_ARG/assets/" "$DEST/assets/"
fi

echo "OK: $APP_ARG -> $DEST"
```

### 5. Compilar Android (solo si TARGETS contiene `android`)

Hoy no hay apps Android en el registry, asi que esta rama no se ejecuta. Cuando se anada la primera, este es el patron previsto:

```bash
if [[ " ${TARGETS[*]} " == *" android "* ]]; then
  ANDROID_DIR="$APP_DIR"
  [ -d "$APP_DIR/android" ] && ANDROID_DIR="$APP_DIR/android"

  cd "$ANDROID_DIR"
  if [ -x "./gradlew" ]; then
    ./gradlew assembleRelease
    APK="$(find "$ANDROID_DIR/app/build/outputs/apk/release" -name '*.apk' | head -n1)"
    [ -n "$APK" ] && cp -v "$APK" "/mnt/c/Users/lucas/Desktop/apps/$APP_ARG/"
  else
    echo "android: no hay ./gradlew en $ANDROID_DIR — saltando."
  fi
fi
```

Cuando llegue la primera app Android, este bloque puede ampliarse (firma, ABI splits, etc.).

### 6. Resumen

Imprime al final una linea por target con:
- Tamano del binario (`ls -lh`)
- Path final en `/mnt/c/Users/lucas/Desktop/apps/<APP>/`
- Nombre del exe/apk

## Notas

- El build de Windows usa `cpp/build/windows/` (no `cpp/build/`). El de Linux es `cpp/build/`. Coexisten sin conflicto.
- El toolchain `mingw-w64.cmake` ya configura linkado estatico (`-static-libgcc -static-libstdc++ -lwinpthread`) — el `.exe` resultante es self-contained y no necesita DLLs en el escritorio.
- Si se pasa una app que vive en `projects/<proj>/apps/<APP>/`, el target CMake sigue siendo `<APP>` (registrado en `cpp/CMakeLists.txt` con `add_subdirectory(${PROJ_DIR}/apps/<APP> ${CMAKE_BINARY_DIR}/apps/<APP>)`).
- NO tocar `AdminLocal` ni instalar nada en `Program Files` — solo el escritorio del usuario.