#!/bin/bash
#Script     	: zettlr_install.sh
#Apps		: MRDEVS TOOLS
#Description	: Instala Zettlr Markdown Editor con soporte multiplataforma
#Author		: Cortana Rosero One <cortana@rosero.one>
#Generated	: Created by Claude Code (claude-3-7-sonnet-20250219)
#Created	: 2025/04/04 12:00:00
#Modified	: 2025/04/04 12:00:00
#Version	: 1.3.1
#Use Notes	: Ejecutar sin parámetros para instalación interactiva
#		  -u para desinstalar
#==============================================================================
# Derechos de Autor 2025 Mauro Rosero P. <mauro@rosero.one>
#==============================================================================
# Este programa es software libre: usted puede redistribuirlo y/o modificarlo
# bajo los términos de la Licencia Pública Affero General de GNU tal como
# lo publica la Free Software Foundation, ya sea la versión 3 de la licencia,
# o (a su elección) cualquier versión posterior.
#
# Este programa se distribuye con la esperanza de que sea útil,
# pero SIN NINGUNA GARANTÍA; sin siquiera la garantía implícita de
# COMERCIABILIDAD o IDONEIDAD PARA UN PROPÓSITO PARTICULAR. Consulte la
# Licencia Pública Affero General de GNU para obtener más detalles.
#
# Debería haber recibido una copia de la Licencia Pública Affero General
# junto con este programa. Si no la recibió, consulte <https://www.gnu.org/licenses/>.

# Configuración inicial
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
BIN_BASE="bin"
BIN_LIBS="lib"
BIN_MESG="msg"
BIN_LANG="head.es"
BIN_CFGS="config"

# Leer DEVSPATH desde el archivo de configuración o usar "devs" por defecto
if [ -f "$SCRIPT_DIR/$BIN_CFGS/devspath.dat" ]; then
  DEVSPATH=$(cat "$SCRIPT_DIR/$BIN_CFGS/devspath.dat")
else
  DEVSPATH="devs"
fi

# Cargar bibliotecas comunes
if [ -f "$SCRIPT_DIR/$BIN_LIBS/base.lib" ]; then
  source "$SCRIPT_DIR/$BIN_LIBS/base.lib"
else
  echo "Error: No se encontró la biblioteca base.lib"
  exit 1
fi

# Cargar biblioteca de consola
if [ -f "$SCRIPT_DIR/$BIN_LIBS/console.lib" ]; then
  source "$SCRIPT_DIR/$BIN_LIBS/console.lib"
else
  echo "Error: No se encontró la biblioteca console.lib"
  exit 1
fi

# Cargar mensajes en español
if [ -f "$SCRIPT_DIR/$BIN_MESG/$BIN_LANG" ]; then
  source "$SCRIPT_DIR/$BIN_MESG/$BIN_LANG"
else
  echo "Error: No se encontraron los archivos de mensajes"
  exit 1
fi

# Configurar título
title="${head_000} ${head_002}"
apps_title="${zl_001}"

# Función para limpiar la pantalla y salir
function finish() {
  clear
  exit
}

# Función para ejecutar comandos con sudo si es necesario
run_cmd() {
  if [ "$EUID" -eq 0 ]; then
    "$@"
  else
    echo "$SUDO_PASS" | sudo -S "$@"
  fi
  
  # Devuelve el código de estado del último comando ejecutado
  return $?
}

# Verificar si se está solicitando la desinstalación
UNINSTALL=0
if [ "$1" = "-u" ]; then
  UNINSTALL=1
fi

# Definir la versión y URLs
ZETTLR_VERSION="3.0.3"
GITHUB_API_URL="https://api.github.com/repos/Zettlr/Zettlr/releases/latest"

# Función para obtener la última versión de Zettlr desde GitHub
get_latest_version() {
  if command -v curl &>/dev/null; then
    ZETTLR_LATEST_VERSION=$(curl -s $GITHUB_API_URL | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/' | cut -c 2-)
    if [ -n "$ZETTLR_LATEST_VERSION" ]; then
      ZETTLR_VERSION=$ZETTLR_LATEST_VERSION
    fi
  fi
  echo "Versión a instalar: $ZETTLR_VERSION"
}

# Función para detectar el sistema operativo
detect_os() {
  if [ -f /etc/os-release ]; then
    . /etc/os-release
    OS=$NAME
    VER=$VERSION_ID
  elif [ -f /etc/lsb-release ]; then
    . /etc/lsb-release
    OS=$DISTRIB_ID
    VER=$DISTRIB_RELEASE
  elif [ -f /etc/debian_version ]; then
    OS="Debian"
    VER=$(cat /etc/debian_version)
  elif [ -f /etc/redhat-release ]; then
    OS=$(cat /etc/redhat-release | cut -d ' ' -f 1)
    VER=$(cat /etc/redhat-release | grep -oE '[0-9]+\.[0-9]+')
  elif [ "$(uname)" == "Darwin" ]; then
    OS="macOS"
    VER=$(sw_vers -productVersion)
  elif [ "$(uname)" == "FreeBSD" ]; then
    OS="FreeBSD"
    VER=$(uname -r)
  else
    OS="Unknown"
    VER="Unknown"
  fi
  
  echo "$OS"
}

# Función para obtener la arquitectura del sistema
get_arch() {
  ARCH=$(uname -m)
  
  # Normalizar la arquitectura
  if [ "$ARCH" = "x86_64" ]; then
    ARCH="amd64"
  elif [[ "$ARCH" == "arm"* ]] || [ "$ARCH" = "aarch64" ]; then
    ARCH="arm64"
  else
    ARCH="i386"
  fi
  
  echo $ARCH
}

# Función para instalar Zettlr en sistemas basados en Debian/Ubuntu
install_zettlr_debian() {
  local arch=$(get_arch)
  
  echo -e "\n${head_info}: Instalando dependencias necesarias..."
  run_cmd apt update
  run_cmd apt install -y wget 
  
  echo -e "\n${head_info}: Descargando Zettlr versión $ZETTLR_VERSION para $arch..."
  
  if [ "$arch" = "amd64" ]; then
    wget -O /tmp/zettlr.deb "https://github.com/Zettlr/Zettlr/releases/download/v${ZETTLR_VERSION}/Zettlr-${ZETTLR_VERSION}-amd64.deb"
  elif [ "$arch" = "arm64" ]; then
    wget -O /tmp/zettlr.deb "https://github.com/Zettlr/Zettlr/releases/download/v${ZETTLR_VERSION}/Zettlr-${ZETTLR_VERSION}-arm64.deb"
  else
    echo -e "\n${head_error}: Arquitectura $arch no soportada para Zettlr."
    return 1
  fi
  
  echo -e "\n${head_info}: Instalando Zettlr..."
  run_cmd apt install -y /tmp/zettlr.deb
  rm -f /tmp/zettlr.deb
  
  # Verificar la instalación
  if command -v zettlr &>/dev/null || [ -f /usr/bin/zettlr ] || [ -f /opt/Zettlr/zettlr ]; then
    echo -e "\n${head_success}: Zettlr ha sido instalado correctamente."
    return 0
  else
    echo -e "\n${head_error}: No se pudo instalar Zettlr."
    return 1
  fi
}

# Función para desinstalar Zettlr en sistemas basados en Debian/Ubuntu
uninstall_zettlr_debian() {
  echo -e "\n${head_info}: Desinstalando Zettlr..."
  run_cmd apt remove --purge -y zettlr
  run_cmd apt autoremove -y
  
  # Eliminar archivos de configuración residuales
  echo -e "\n${head_info}: Limpiando archivos de configuración..."
  rm -rf ~/.config/Zettlr
  
  echo -e "\n${head_success}: Zettlr ha sido desinstalado correctamente."
  return 0
}

# Función para instalar Zettlr en sistemas basados en Red Hat
install_zettlr_redhat() {
  local arch=$(get_arch)
  
  echo -e "\n${head_info}: Instalando dependencias necesarias..."
  run_cmd dnf check-update
  run_cmd dnf install -y wget

  echo -e "\n${head_info}: Descargando Zettlr versión $ZETTLR_VERSION para $arch..."
  
  if [ "$arch" = "amd64" ]; then
    wget -O /tmp/zettlr.rpm "https://github.com/Zettlr/Zettlr/releases/download/v${ZETTLR_VERSION}/Zettlr-${ZETTLR_VERSION}.x86_64.rpm"
  elif [ "$arch" = "arm64" ]; then
    wget -O /tmp/zettlr.rpm "https://github.com/Zettlr/Zettlr/releases/download/v${ZETTLR_VERSION}/Zettlr-${ZETTLR_VERSION}.arm64.rpm"
  else
    echo -e "\n${head_error}: Arquitectura $arch no soportada para Zettlr."
    return 1
  fi
  
  echo -e "\n${head_info}: Instalando Zettlr..."
  run_cmd dnf install -y /tmp/zettlr.rpm
  rm -f /tmp/zettlr.rpm
  
  # Verificar la instalación
  if command -v zettlr &>/dev/null || [ -f /usr/bin/zettlr ] || [ -f /opt/Zettlr/zettlr ]; then
    echo -e "\n${head_success}: Zettlr ha sido instalado correctamente."
    return 0
  else
    echo -e "\n${head_error}: No se pudo instalar Zettlr."
    return 1
  fi
}

# Función para desinstalar Zettlr en sistemas basados en Red Hat
uninstall_zettlr_redhat() {
  echo -e "\n${head_info}: Desinstalando Zettlr..."
  run_cmd dnf remove -y zettlr
  
  # Eliminar archivos de configuración residuales
  echo -e "\n${head_info}: Limpiando archivos de configuración..."
  rm -rf ~/.config/Zettlr
  
  echo -e "\n${head_success}: Zettlr ha sido desinstalado correctamente."
  return 0
}

# Función para instalar Zettlr en Arch Linux
install_zettlr_arch() {
  echo -e "\n${head_info}: Actualizando repositorios..."
  run_cmd pacman -Sy
  
  echo -e "\n${head_info}: Instalando dependencias necesarias..."
  run_cmd pacman -S --needed --noconfirm base-devel git

  # Verificar si yay está instalado
  if ! command -v yay &>/dev/null; then
    echo -e "\n${head_info}: Instalando yay (AUR helper)..."
    TMP_DIR=$(mktemp -d)
    cd "$TMP_DIR"
    git clone https://aur.archlinux.org/yay.git
    cd yay
    makepkg -si --noconfirm
    cd
    rm -rf "$TMP_DIR"
  fi
  
  echo -e "\n${head_info}: Instalando Zettlr desde AUR..."
  yay -S --noconfirm zettlr-bin
  
  # Verificar la instalación
  if command -v zettlr &>/dev/null || [ -f /usr/bin/zettlr ]; then
    echo -e "\n${head_success}: Zettlr ha sido instalado correctamente."
    return 0
  else
    echo -e "\n${head_error}: No se pudo instalar Zettlr."
    return 1
  fi
}

# Función para desinstalar Zettlr en Arch Linux
uninstall_zettlr_arch() {
  echo -e "\n${head_info}: Desinstalando Zettlr..."
  if pacman -Qi zettlr-bin &>/dev/null; then
    run_cmd pacman -R --noconfirm zettlr-bin
  elif pacman -Qi zettlr &>/dev/null; then
    run_cmd pacman -R --noconfirm zettlr
  fi
  
  # Eliminar archivos de configuración residuales
  echo -e "\n${head_info}: Limpiando archivos de configuración..."
  rm -rf ~/.config/Zettlr
  
  echo -e "\n${head_success}: Zettlr ha sido desinstalado correctamente."
  return 0
}

# Función para instalar Zettlr en macOS
install_zettlr_macos() {
  echo -e "\n${head_info}: Verificando si Homebrew está instalado..."
  
  if ! command -v brew &>/dev/null; then
    echo -e "\n${head_info}: Instalando Homebrew..."
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
  fi
  
  echo -e "\n${head_info}: Instalando Zettlr mediante Homebrew..."
  brew install --cask zettlr
  
  # Verificar la instalación
  if [ -d "/Applications/Zettlr.app" ]; then
    echo -e "\n${head_success}: Zettlr ha sido instalado correctamente."
    return 0
  else
    echo -e "\n${head_error}: No se pudo instalar Zettlr."
    return 1
  fi
}

# Función para desinstalar Zettlr en macOS
uninstall_zettlr_macos() {
  echo -e "\n${head_info}: Desinstalando Zettlr..."
  
  if command -v brew &>/dev/null; then
    brew uninstall --cask zettlr
  fi
  
  # Eliminar la aplicación manualmente si brew no funcionó
  if [ -d "/Applications/Zettlr.app" ]; then
    rm -rf "/Applications/Zettlr.app"
  fi
  
  # Eliminar archivos de configuración
  rm -rf ~/Library/Application\ Support/Zettlr
  
  echo -e "\n${head_success}: Zettlr ha sido desinstalado correctamente."
  return 0
}

# Función para instalar Zettlr en FreeBSD
install_zettlr_freebsd() {
  echo -e "\n${head_info}: FreeBSD no tiene soporte oficial para Zettlr."
  echo -e "${head_info}: Se puede intentar utilizar la versión AppImage o la instalación manual."
  
  local arch=$(get_arch)
  if [ "$arch" = "amd64" ]; then
    echo -e "\n${head_info}: Descargando AppImage de Zettlr..."
    fetch -o /tmp/Zettlr.AppImage "https://github.com/Zettlr/Zettlr/releases/download/v${ZETTLR_VERSION}/Zettlr-${ZETTLR_VERSION}-x86_64.AppImage"
    
    chmod +x /tmp/Zettlr.AppImage
    mkdir -p "$HOME/Applications"
    mv /tmp/Zettlr.AppImage "$HOME/Applications/"
    
    echo -e "\n${head_info}: Creando enlace simbólico..."
    mkdir -p "$HOME/bin"
    ln -sf "$HOME/Applications/Zettlr.AppImage" "$HOME/bin/zettlr"
    
    echo -e "\n${head_success}: Zettlr ha sido instalado en $HOME/Applications/Zettlr.AppImage"
    echo -e "${head_info}: Para ejecutar Zettlr, use: $HOME/bin/zettlr"
    return 0
  else
    echo -e "\n${head_error}: Arquitectura $arch no soportada para Zettlr en FreeBSD."
    return 1
  fi
}

# Función para desinstalar Zettlr en FreeBSD
uninstall_zettlr_freebsd() {
  echo -e "\n${head_info}: Desinstalando Zettlr..."
  
  # Eliminar AppImage
  if [ -f "$HOME/Applications/Zettlr.AppImage" ]; then
    rm -f "$HOME/Applications/Zettlr.AppImage"
  fi
  
  # Eliminar enlace simbólico
  if [ -L "$HOME/bin/zettlr" ]; then
    rm -f "$HOME/bin/zettlr"
  fi
  
  # Eliminar archivos de configuración
  rm -rf "$HOME/.config/Zettlr"
  
  echo -e "\n${head_success}: Zettlr ha sido desinstalado correctamente."
  return 0
}

# Función principal para instalar Zettlr
install_zettlr() {
  local os=$(detect_os)
  local result=0
  
  # Obtener la última versión disponible
  get_latest_version
  
  echo -e "\n${head_info}: Sistema operativo detectado: ${os}"
  
  # Instalar según el sistema operativo
  case "$os" in
    *"Ubuntu"*|*"Debian"*|*"Linux Mint"*|*"Pop!_OS"*|*"elementary OS"*)
      install_zettlr_debian
      result=$?
      ;;
    *"Fedora"*|*"Red Hat"*|*"CentOS"*|*"Rocky"*|*"AlmaLinux"*|*"Oracle Linux"*)
      install_zettlr_redhat
      result=$?
      ;;
    *"Arch"*|*"Manjaro"*|*"EndeavourOS"*|*"Garuda"*)
      install_zettlr_arch
      result=$?
      ;;
    *"macOS"*)
      install_zettlr_macos
      result=$?
      ;;
    *"FreeBSD"*)
      install_zettlr_freebsd
      result=$?
      ;;
    *)
      echo -e "\n${head_error}: ${os_nofound}"
      return 1
      ;;
  esac
  
  # Si la instalación fue exitosa, mostrar información adicional
  if [ $result -eq 0 ]; then
    # La información se mostrará después del gauge
    INSTALL_SUCCESS=1
    ZETTLR_INFO="Zettlr es un editor Markdown moderno con enfoque académico\n"
    ZETTLR_INFO+="- Incluye editor Markdown WYSIWYG y soporte para Zettelkasten\n"
    ZETTLR_INFO+="- Integración con Pandoc y LaTeX para exportación de documentos\n"
    ZETTLR_INFO+="- Soporte para Markdown, Citas, Referencias y más\n"
    ZETTLR_INFO+="- Sitio web oficial: https://www.zettlr.com/"
  else
    INSTALL_SUCCESS=0
  fi
  
  return $result
}

# Función principal para desinstalar Zettlr
uninstall_zettlr() {
  local os=$(detect_os)
  local result=0
  
  echo -e "\n${head_info}: Sistema operativo detectado: ${os}"
  
  # Mostrar diálogo de confirmación
  if command -v dialog &>/dev/null; then
    dialog_yesno "¿Está seguro que desea ${head_delete} Zettlr Markdown Editor?"
    if [ $? -ne 0 ]; then
      echo -e "\n${head_info}: ${head_op_error}"
      return 0
    fi
  else
    read -p "¿Está seguro que desea ${head_delete} Zettlr Markdown Editor? (s/n): " CONFIRM
    if [[ ! "$CONFIRM" =~ ^[Ss]$ ]]; then
      echo -e "\n${head_info}: ${head_op_error}"
      return 0
    fi
  fi
  
  # Desinstalar según el sistema operativo
  case "$os" in
    *"Ubuntu"*|*"Debian"*|*"Linux Mint"*|*"Pop!_OS"*|*"elementary OS"*)
      uninstall_zettlr_debian
      result=$?
      ;;
    *"Fedora"*|*"Red Hat"*|*"CentOS"*|*"Rocky"*|*"AlmaLinux"*|*"Oracle Linux"*)
      uninstall_zettlr_redhat
      result=$?
      ;;
    *"Arch"*|*"Manjaro"*|*"EndeavourOS"*|*"Garuda"*)
      uninstall_zettlr_arch
      result=$?
      ;;
    *"macOS"*)
      uninstall_zettlr_macos
      result=$?
      ;;
    *"FreeBSD"*)
      uninstall_zettlr_freebsd
      result=$?
      ;;
    *)
      echo -e "\n${head_error}: ${os_nofound}"
      return 1
      ;;
  esac
  
  return $result
}

# Si no se ejecuta como root, solicitar contraseña para escalamiento vía dialog
if [ "$EUID" -ne 0 ]; then
  dialog_error_box "${head_superuser}" "${zl_011}"
  dialog_input_pass "${npm_002}" "" ""
  if [ $? -ne 0 ]; then
    dialog_error_box "${head_error}" "${npm_003}"
    finish
  fi
  SUDO_PASS="$value"
  
  # Verificar que la contraseña funcione
  echo "$SUDO_PASS" | sudo -S true &> /dev/null
  if [ $? -ne 0 ]; then
    dialog_error_box "${head_error}" "${npm_003}"
    finish
  fi
fi

# Mensaje de bienvenida
clear
dialog_error_box "${zl_001}" "${zl_002}"

# Verificar si Zettlr ya está instalado
ZETTLR_INSTALLED=0
if command -v zettlr &>/dev/null || [ -f /usr/bin/zettlr ] || [ -f /opt/Zettlr/zettlr ] || [ -d "/Applications/Zettlr.app" ]; then
  ZETTLR_INSTALLED=1
fi

# Determinar acción a realizar
if [ $UNINSTALL -eq 1 ]; then
  # Desinstalar si está instalado
  if [ $ZETTLR_INSTALLED -eq 1 ]; then
    dialog_yesno "¿${head_delete} Zettlr Markdown Editor?"
    if [ $? -eq 0 ]; then
        # Limpiar pantalla y ejecutar en consola
      clear
      echo -e "\n=== ${head_delete} Zettlr Markdown Editor ==="
      
      uninstall_zettlr
      UNINSTALL_RESULT=$?
      
      if [ $UNINSTALL_RESULT -eq 0 ]; then
        echo -e "\n=== ${head_success}: Zettlr ha sido desinstalado correctamente ==="
      else
        echo -e "\n=== ${head_error}: No se pudo desinstalar Zettlr ==="
      fi
    else
      dialog_error_box "${head_canceled}" "${head_op_error}"
    fi
  else
    dialog_error_box "${head_info}" "Zettlr no está instalado. Nada que desinstalar."
  fi
else
  # Instalar o reinstalar
  if [ $ZETTLR_INSTALLED -eq 1 ]; then
    # Preguntar si desea reinstalar
    dialog_yesno "Zettlr ${head_version} ya está instalado.\n\n¿Desea reinstalarlo?"
    if [ $? -eq 0 ]; then
      # Limpiar pantalla y ejecutar en consola
      clear
      echo -e "\n=== ${zl_003} ==="
      sleep 1
      echo -e "\n=== ${zl_004} ==="
      sleep 1
      echo -e "\n=== ${zl_005} ==="
      
      # Desinstalar e instalar Zettlr
      uninstall_zettlr && install_zettlr
      INSTALL_RESULT=$?
      
      # Verificar el resultado de la instalación
      if [ $INSTALL_RESULT -eq 0 ]; then
        echo -e "\n=== ${zl_006} ==="
        if [ $INSTALL_SUCCESS -eq 1 ]; then
          echo -e "\n${ZETTLR_INFO}"
        fi
      else
        echo -e "\n=== ${zl_008} ==="
      fi
    fi
  else
    # Preguntar si desea instalar
    dialog_yesno "${zl_009}"
    if [ $? -eq 0 ]; then
      # Limpiar pantalla y ejecutar en consola
      clear
      echo -e "\n=== ${zl_003} ==="
      sleep 1
      echo -e "\n=== ${zl_004} ==="
      sleep 1
      echo -e "\n=== ${zl_005} ==="
      
      # Instalar Zettlr
      install_zettlr
      INSTALL_RESULT=$?
      
      # Verificar el resultado de la instalación
      if [ $INSTALL_RESULT -eq 0 ]; then
        echo -e "\n=== ${zl_006} ==="
        if [ $INSTALL_SUCCESS -eq 1 ]; then
          echo -e "\n${ZETTLR_INFO}"
        fi
      else
        echo -e "\n=== ${zl_008} ==="
      fi
    else
      dialog_error_box "${head_canceled}" "${head_op_error}"
    fi
  fi
fi

# Salir
finish