#!/bin/sh
# sceptre-user-setup: le arma al usuario sus propios archivos, para que no
# tenga que tocar la instalacion (paso 6 del PLAN). Reubicable, como los
# demas launchers.
#
#   uso: sceptre-user-setup [DIR-DATOS] [DIR-CONFIG] [DIR-EJEMPLOS]
#   por defecto:  ~/.local/share/sceptre  ~/.config/sceptre  ~/sceptre-ejemplos
set -eu
PAQUETE=sceptresimusol
PRG=$0
case "$PRG" in
  */*) : ;;
  *)   PRG=`command -v "$PRG" 2>/dev/null || printf '%s' "$0"` ;;
esac
while [ -h "$PRG" ]; do
   DESTINO=`ls -ld "$PRG" | sed 's/^.*-> //'`
   case "$DESTINO" in
     /*) PRG=$DESTINO ;;
     *)  PRG=`dirname "$PRG"`/$DESTINO ;;
   esac
done
BINDIR=`CDPATH= cd -- "\`dirname -- "$PRG"\`" && pwd`
BASEDIR=${SCEPTRE_HOME:-`CDPATH= cd -- "$BINDIR/.." && pwd`}

busca () {
   cual=$1; shift
   for d in "$@"; do
      if [ -f "$d/$cual" ]; then printf '%s\n' "$d/$cual"; return 0; fi
   done
   return 1
}
DIRLIB="$BASEDIR/lib $BASEDIR/lib/$PAQUETE $BINDIR/../lib/$PAQUETE"
DIRDAT="$BASEDIR/lib $BASEDIR/share/$PAQUETE $BINDIR/../share/$PAQUETE"
DIRETC="$BASEDIR/etc $BASEDIR/share/$PAQUETE $BINDIR/../share/$PAQUETE"

DATOS=${1:-${XDG_DATA_HOME:-$HOME/.local/share}/sceptre}
CONFIG=${2:-${XDG_CONFIG_HOME:-$HOME/.config}/sceptre}
EJEMPLOS=${3:-$HOME/sceptre-ejemplos}
FUNCIONES=$CONFIG/funciones
MODELOS=$CONFIG/modelos

mkdir -p "$DATOS/lib" "$CONFIG" "$EJEMPLOS" "$FUNCIONES" "$MODELOS"

# YA NO SE COPIA NINGUNA BIBLIOTECA (05/11/2026, decision del autor):
#  - modellib.dat, la de modelos, porque copiarla era justamente el problema:
#    sceptre.conf apuntaba MODELLIB a la copia, y entonces los modelos nuevos
#    que trajera una version del paquete no llegaban nunca. Ahora la instalada
#    se usa donde esta --sc1 la busca cada vez-- y lo propio va en el
#    directorio de modelos, que sc1 junta con ella en el texto del deck.
#  - usrlib.a, porque ni se instala: sus funciones son fuentes del proyecto y
#    se compilan con la fase 2. Lo que el usuario quiera agregar va en el
#    directorio de funciones propias, o en su propia biblioteca estatica (-u).
# Lo que se copia es la configuracion y los ejemplos, y se crean los dos
# directorios propios. $DATOS/lib sigue haciendo falta: ahi deja sc1 la
# biblioteca dinamica de las funciones propias.
SDRC=`busca sdrc $DIRETC` && cp -f "$SDRC" "$CONFIG/sdrc" || true

if [ -e "$CONFIG/sceptre.conf" ]; then
   echo "sceptre-user-setup: $CONFIG/sceptre.conf ya existe, no lo toco"
else
   cat > "$CONFIG/sceptre.conf" <<CFG
# Configuracion de SCEPTRE por usuario. La lee bin/sc1; las opciones de la
# linea de comando (-m, -u, -o) le ganan a lo que diga este archivo, y
# SCEPTRE_NO_CONF=1 lo saltea del todo.
OUTDIR=.
# MODELLIB= otra biblioteca de modelos, si queres una en lugar de la instalada
#           (es opcional: los modelos propios van en $MODELOS y sc1 los junta
#           con la instalada; esto la REEMPLAZA)
# USRLIB=  biblioteca estatica propia, si tenes una (es opcional; las funciones
#          propias no la necesitan, van en $FUNCIONES)
# FC=gfortran -std=gnu
# FFLAGS=-fno-automatic -ggdb -fbacktrace -fdollar-ok -Wno-line-truncation
CFG
fi

for d in "$BASEDIR/samples" "$BASEDIR/share/$PAQUETE/samples"; do
   if [ -d "$d" ]; then cp -f "$d"/*.d "$EJEMPLOS" 2>/dev/null || true; break; fi
done

# LOS ICONOS EN EL ESCRITORIO (05/11/2026, pedido del autor). Las entradas
# .desktop las instala el paquete en share/applications --de ahi las toma el
# menu de aplicaciones solo--; lo que hace falta hacer por usuario es ponerlas
# en SU escritorio. El directorio lo dice xdg-user-dir si esta; si no, se
# prueban los nombres de siempre. En GNOME un lanzador en el escritorio tiene
# que estar marcado como de confianza (gio metadata::trusted), y no en todos
# los escritorios hace falta: si no hay gio, no es un error.
ESCRITORIO=
if command -v xdg-user-dir > /dev/null 2>&1; then
   ESCRITORIO=`xdg-user-dir DESKTOP 2>/dev/null`
fi
if [ -z "$ESCRITORIO" ] || [ "$ESCRITORIO" = "$HOME" ] || [ ! -d "$ESCRITORIO" ]; then
   for d in "$HOME/Escritorio" "$HOME/Desktop"; do
      if [ -d "$d" ]; then ESCRITORIO=$d; break; fi
   done
fi
ICONOS=0
if [ -n "$ESCRITORIO" ] && [ -d "$ESCRITORIO" ]; then
   DIRAPP="$BASEDIR/share/applications $BINDIR/../share/applications"
   for n in sceptresimusol-sd2 sceptresimusol-manual sceptresimusol-ejemplos; do
      f=`busca "$n.desktop" $DIRAPP` || continue
      if [ "$n" = sceptresimusol-ejemplos ]; then
         # la carpeta de ejemplos de ESTE usuario, que puede no ser la de omision
         sed "s|\$HOME/sceptre-ejemplos|$EJEMPLOS|" "$f" > "$ESCRITORIO/$n.desktop" || continue
      else
         cp -f "$f" "$ESCRITORIO/$n.desktop" || continue
      fi
      chmod +x "$ESCRITORIO/$n.desktop" 2>/dev/null || true
      if command -v gio > /dev/null 2>&1; then
         gio set "$ESCRITORIO/$n.desktop" metadata::trusted true 2>/dev/null || true
      fi
      ICONOS=`expr $ICONOS + 1`
   done
fi

# EL LUGAR DE LOS MODELOS DEL USUARIO (05/11/2026, pedido del autor): sus .dat
# van aca y sc1 los manda en el texto del deck, junto con los de la biblioteca
# instalada, que no hay que copiar ni tocar.
if [ ! -e "$MODELOS/LEEME" ]; then
   cat > "$MODELOS/LEEME" <<'FIN'
Los modelos propios van ACA, como archivos .dat. La biblioteca instalada no se
toca ni se copia: sc1 mira que modelos usa el deck, los busca PRIMERO aca y
despues en la instalada, y los manda en el texto del deck. En el listado queda
anotado de que archivo salio cada modelo, asi que siempre se puede ver cual
corrio.

UN MODELO. Lo mismo que iria en la MODEL DESCRIPTION de un deck: el renglon
MODEL con el nombre y los nodos, y abajo sus secciones. Por ejemplo, en
mis-modelos.dat:

    MODEL MIDIODO (PERM) (A-K)
    ELEMENTS
      JD, A-K = X1 ( MAX(0.,VJD**5) )
      CD, A-K = 1.E-9

En un archivo puede haber varios, uno atras del otro. El (PERM) sc1 lo cambia
a (TEMP) al mandarlo --en un deck, (PERM) quiere decir "guardalo en la
biblioteca permanente"--, asi que da igual como se escriba.

COMO SE USA DESDE EL DECK, como cualquier modelo:

    ELEMENTS
      D1, 2-0 = MODEL MIDIODO

SI EL NOMBRE YA EXISTE en la biblioteca instalada, gana el de aca: es la
manera de corregir un modelo que viene con el paquete sin tocar la
instalacion. Y si el deck define un modelo con ese nombre en su propia MODEL
DESCRIPTION, gana el del deck.

Un modelo de aca puede usar otro modelo: sc1 va a buscarlo tambien.

El directorio se elige con SCEPTRE_MODELOS_DIR, y 'sc1 --sin-modelos' corre
sin mirar nada de esto, con la biblioteca instalada sola, como antes.
FIN
   echo "sceptre-user-setup: $MODELOS/LEEME"
fi

# EL LUGAR DE LAS FUNCIONES DEL USUARIO (05/11/2026, pedido del autor): un
# directorio donde pone sus .f90, y si hay alguno sc1 arma solo la biblioteca
# dinamica y la usa. Aca solo se crea el directorio y se deja dicho como es.
if [ ! -e "$FUNCIONES/LEEME" ]; then
   cat > "$FUNCIONES/LEEME" <<'FIN'
Las funciones propias que un deck quiera llamar van ACA, como archivos .f90.

Una funcion es Fortran de toda la vida: real*8, los argumentos por referencia
y el nombre de hasta seis caracteres. Por ejemplo, en mis-funciones.f90:

    real*8 function miramp (x, pendiente)
    implicit none
    real*8, intent(in) :: x, pendiente
       if (x .gt. 0.d0) then
          miramp = pendiente * x
       else
          miramp = 0.d0
       end if
    end function miramp

COMO SE LLAMA DESDE EL DECK. No se pone la funcion directamente como valor de
un elemento: va adentro de una instruccion aritmetica (EQUATION o EXPRESSION),
que es lo que el manual llama "external function" --las instrucciones
aritmeticas pueden llamar a los subprogramas FORTRAN propios--:

    ELEMENTS
      E1, 1-0 = EQUATION 1 (2.5, TIME)
      R1, 1-2 = 10.
      C1, 2-0 = 1.E-3
    FUNCTIONS
      EQUATION 1 (A,B) = (MIRAMP(A,B))

Ojo con dos cosas del lenguaje de SCEPTRE: las constantes numericas llevan
punto decimal (10. y no 10) y los nombres son de hasta seis caracteres.

NO HAY QUE COMPILAR NADA A MANO. La proxima vez que corra sc1, si hay algun
.f90 mas nuevo que la biblioteca, la rehace (funciones-usuario.so, al lado de
las otras cosas del usuario) y la usa, en el modo estatico y en el dinamico.
El .so entra en la huella del caso, asi que cambiar una funcion obliga a
rehacer el circuito: no queda una corrida con la version vieja.

Para no usarlas por una vez: sc1 --sin-funciones. Y si se vacia el
directorio, todo vuelve a ser como antes.
FIN
fi

cat <<MSG
Listo. Los archivos propios del usuario quedaron en:
  configuracion de sc1  : $CONFIG/sceptre.conf
  configuracion de sd2  : $CONFIG/sdrc
  ejemplos              : $EJEMPLOS
  funciones propias     : $FUNCIONES (ver su LEEME)
  modelos propios       : $MODELOS (ver su LEEME)
  iconos en el escritorio: ${ICONOS} en ${ESCRITORIO:-(no encontre el escritorio)}

Se pueden editar sin tocar la instalacion. Para probar:
  cd $EJEMPLOS && sc1 a01
MSG
