install.sh

#!/bin/bash

#------------------------------------------------------------------------------
# INTERNATIONALIZATION SYSTEM
#------------------------------------------------------------------------------
# Determine the script directory
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

#------------------------------------------------------------------------------
# GLOBAL VARIABLES
#------------------------------------------------------------------------------
# GitHub branch for downloads
BRANCH="main"

# Interactive interface with gum
USE_GUM=false

# Initial configuration
EXECUTE_INITIAL_CONFIG=true

# Detailed output
VERBOSE=false

# Variables for Debian PRoot
PROOT_USERNAME=""
PROOT_PASSWORD=""

#------------------------------------------------------------------------------
# SELECTORS OF MODULES
#------------------------------------------------------------------------------
# Shell selection
SHELL_CHOICE=false

# Additional packages installation
PACKAGES_CHOICE=false

# Custom fonts installation
FONT_CHOICE=false

# Desktop environment installation
DESKTOP_CHOICE=false
DESKTOP_ENV=""

# Debian Proot installation
PROOT_CHOICE=false

# Termux-X11 installation
X11_CHOICE=false

# AI Tools installation
AI_TOOLS_CHOICE=false

# Full installation without interactions
FULL_INSTALL=false

# Preset name argument
PRESET_NAME_ARG=""

# Use gum for interactions
ONLY_GUM=true

#------------------------------------------------------------------------------
# CONFIGURATION FILES
#------------------------------------------------------------------------------
BASHRC="$HOME/.bashrc"
ZSHRC="$HOME/.zshrc"
FISHRC="$HOME/.config/fish/config.fish"

#------------------------------------------------------------------------------
# BOOTSTRAP - Load i18n and lib systems
#------------------------------------------------------------------------------
OHMYTERMUX_REPO_URL="${OHMYTERMUX_REPO_URL:-https://raw.githubusercontent.com/devohmycode/OhMyTermux}"
_loader_url="$OHMYTERMUX_REPO_URL/$BRANCH/lib/i18n_loader.sh"
mkdir -p "$SCRIPT_DIR/lib"
# Always try to refresh i18n_loader.sh; fall back to cached version if download fails
_loader_tmp=$(mktemp 2>/dev/null || echo "$SCRIPT_DIR/lib/i18n_loader.sh.tmp")
if curl -fL -s -o "$_loader_tmp" "$_loader_url" 2>/dev/null && head -1 "$_loader_tmp" 2>/dev/null | grep -q "^#!/bin/bash"; then
    mv "$_loader_tmp" "$SCRIPT_DIR/lib/i18n_loader.sh"
else
    rm -f "$_loader_tmp" 2>/dev/null
    if [ ! -f "$SCRIPT_DIR/lib/i18n_loader.sh" ]; then
        echo "Warning: Could not download i18n_loader.sh and no cached version available" >&2
    fi
fi
I18N_DEFER_INIT=true
source "$SCRIPT_DIR/lib/i18n_loader.sh"

# Configure error handler keys for this script
ERROR_MSG_KEY="MSG_ERROR_INSTALL"
ERROR_REFER_KEY="MSG_ERROR_REFER_MESSAGES"

# Download presets if not available locally
if [ ! -d "$SCRIPT_DIR/presets" ] || [ -z "$(ls "$SCRIPT_DIR/presets/"*.sh 2>/dev/null)" ]; then
    type download_presets &>/dev/null && download_presets
fi

# Initialize plugin system (discover manifests, resolve order)
type init_plugin_system &>/dev/null && init_plugin_system

# Configure banner title (uses i18n key)
BANNER_TITLE=""  # Will be set after i18n init via t()

#------------------------------------------------------------------------------
# UNINSTALL PROOT
#------------------------------------------------------------------------------
uninstall_proot() {
    if [ "$MESSAGES_LOADED" != "true" ]; then
        init_i18n "$OVERRIDE_LANG" >/dev/null 2>&1
    fi

    if ! command -v proot-distro &>/dev/null; then
        echo "proot-distro is not installed." >&2
        exit 1
    fi

    if [ ! -d "$PROOT_DEBIAN_ROOT" ]; then
        echo "Debian PRoot is not installed." >&2
        exit 1
    fi

    echo "This will remove the Debian PRoot installation and all its data."
    printf "Are you sure? (y/N): "
    read -r CONFIRM
    if [[ ! "$CONFIRM" =~ ^[yYoO]$ ]]; then
        echo "Uninstall cancelled."
        exit 0
    fi

    # Remove proot-distro installation
    proot-distro remove debian || {
        echo "Error: Failed to remove Debian PRoot." >&2
        exit 1
    }

    # Remove helper scripts
    for CMD in prun zrun zrunhud cp2menu; do
        rm -f "$PREFIX/bin/$CMD"
    done

    # Remove related desktop files
    rm -f "$PREFIX/share/applications/cp2menu.desktop"
    rm -f "$PREFIX/share/applications/kill_termux_x11.desktop"

    echo "Debian PRoot has been successfully uninstalled."
}

#------------------------------------------------------------------------------
# DISPLAY HELP
#------------------------------------------------------------------------------
show_help() {
    # Initialiser le système i18n si pas encore fait
    if [ "$MESSAGES_LOADED" != "true" ]; then
        init_i18n "$OVERRIDE_LANG" >/dev/null 2>&1
    fi

    clear
    echo "$(t MSG_HELP_TITLE)"
    echo
    echo "$(t MSG_HELP_USAGE)"
    echo "$(t MSG_HELP_OPTIONS)"
    echo "  --gum | -g        $(t MSG_OPT_GUM)"
    echo "  --verbose | -v    $(t MSG_OPT_VERBOSE)"
    echo "  --lang | -l       $(t MSG_OPT_LANG)"
    echo "  --shell | -sh     $(t MSG_OPT_SHELL)"
    echo "  --package | -pk   $(t MSG_OPT_PACKAGE)"
    echo "  --ai | -ai        $(t MSG_OPT_AI)"
    echo "  --font | -f       $(t MSG_OPT_FONT)"
    echo "  --xfce | -x       $(t MSG_OPT_XFCE)"
    echo "  --desktop | -de   $(t MSG_OPT_DESKTOP)"
    echo "  --proot | -pr     $(t MSG_OPT_PROOT)"
    echo "  --x11             $(t MSG_OPT_X11)"
    echo "  --preset | -ps    $(t MSG_OPT_PRESET)"
    echo "  --skip            $(t MSG_OPT_SKIP)"
    echo "  --uninstall       $(t MSG_OPT_UNINSTALL)"
    echo "  --full            $(t MSG_OPT_FULL)"
    echo "  --help | -h       $(t MSG_OPT_HELP)"
    echo
    echo "$(t MSG_HELP_EXAMPLES)"
    echo "  $(t MSG_EXAMPLE_GUM)"
    echo "  $(t MSG_EXAMPLE_FULL)"
    type show_plugin_help &>/dev/null && show_plugin_help
}

#------------------------------------------------------------------------------
# ARGUMENTS MANAGEMENT
#------------------------------------------------------------------------------
# Pre-parse plugin CLI flags
if type parse_plugin_args &>/dev/null; then
    parse_plugin_args "$@"
    set -- "${REMAINING_ARGS[@]}"
fi

while [[ $# -gt 0 ]]; do
    case $1 in
        --gum|-g)
            USE_GUM=true
            shift
            ;;
        --shell|-sh)
            SHELL_CHOICE=true
            ONLY_GUM=false
            shift
            ;;
        --package|-pk)
            PACKAGES_CHOICE=true
            ONLY_GUM=false
            shift
            ;;
        --ai|-ai)
            AI_TOOLS_CHOICE=true
            ONLY_GUM=false
            shift
            ;;
        --font|-f)
            FONT_CHOICE=true
            ONLY_GUM=false
            shift
            ;;
        --xfce|-x)
            DESKTOP_CHOICE=true
            DESKTOP_ENV="xfce"
            ONLY_GUM=false
            shift
            ;;
        --desktop|-de)
            DESKTOP_CHOICE=true
            ONLY_GUM=false
            shift
            if [ -n "$1" ] && [[ "$1" =~ ^(xfce|lxqt|mate)$ ]]; then
                DESKTOP_ENV="$1"
                shift
            fi
            ;;
        --proot|-pr)
            PROOT_CHOICE=true
            ONLY_GUM=false
            shift
            ;;
        --x11)
            X11_CHOICE=true
            ONLY_GUM=false
            shift
            ;;
        --preset|-ps)
            shift
            if [ -n "$1" ]; then
                PRESET_NAME_ARG="$1"
                PACKAGES_CHOICE=true
                ONLY_GUM=false
                shift
            else
                echo "$(t MSG_ERROR_PRESET_ARGUMENT)" >&2
                exit 1
            fi
            ;;
        --skip)
            EXECUTE_INITIAL_CONFIG=false
            shift
            ;;
        --uninstall)
            uninstall_proot
            exit 0
            ;;
        --verbose|-v)
            VERBOSE=true
            REDIRECT=""
            shift
            ;;
        --lang|-l)
            shift
            if [ -n "$1" ]; then
                OVERRIDE_LANG="$1"
                shift
            else
                echo "$(t MSG_ERROR_LANG_ARGUMENT)" >&2
                exit 1
            fi
            ;;
        --full)
            FULL_INSTALL=true
            SHELL_CHOICE=true
            PACKAGES_CHOICE=true
            AI_TOOLS_CHOICE=true
            FONT_CHOICE=true
            DESKTOP_CHOICE=true
            DESKTOP_ENV="xfce"
            PROOT_CHOICE=true
            X11_CHOICE=true
            SCRIPT_CHOICE=true
            ONLY_GUM=false
            type enable_all_plugins &>/dev/null && enable_all_plugins
            shift
            ;;
        --help|-h)
            show_help
            exit 0
            ;;
        *)
            # Get the username and password if provided
            if [ -z "$PROOT_USERNAME" ]; then
                PROOT_USERNAME="$1"
            elif [ -z "$PROOT_PASSWORD" ]; then
                PROOT_PASSWORD="$1"
            else
                break
            fi
            shift
            ;;
    esac
done

# If in FULL_INSTALL mode and identifiers are not provided, ask for them
if $FULL_INSTALL; then
    if [ -z "$PROOT_USERNAME" ]; then
        if $USE_GUM; then
            PROOT_USERNAME=$(gum input --placeholder "$(t MSG_INFO_ENTER_USERNAME_PROOT)")
        else
            printf "${COLOR_BLUE}$(t MSG_INFO_ENTER_USERNAME_PROOT) ${COLOR_RESET}"
            read -r PROOT_USERNAME
        fi
    fi

    if [ -z "$PROOT_PASSWORD" ]; then
        while true; do
            if $USE_GUM; then
                PROOT_PASSWORD=$(gum input --password --prompt "Password: " --placeholder "$(t MSG_INFO_PASSWORD)")
                PASSWORD_CONFIRM=$(gum input --password --prompt "Confirm password: " --placeholder "$(t MSG_INFO_CONFIRM_PASSWORD)")
            else
                printf "${COLOR_BLUE}$(t MSG_INFO_PASSWORD) ${COLOR_RESET}"
                read -r -s PROOT_PASSWORD
                echo
                printf "${COLOR_BLUE}$(t MSG_INFO_CONFIRM_PASSWORD) ${COLOR_RESET}"
                read -r -s PASSWORD_CONFIRM
                echo
            fi

            if [ "$PROOT_PASSWORD" = "$PASSWORD_CONFIRM" ]; then
                break
            else
                if $USE_GUM; then
                    gum style --foreground 196 "$(t MSG_ERROR_PASSWORD_MISMATCH)"
                else
                    echo -e "${COLOR_RED}$(t MSG_ERROR_PASSWORD_MISMATCH)${COLOR_RESET}"
                fi
            fi
        done
    fi
fi

# Activate all modules if --gum is the only argument
if $ONLY_GUM; then
    SHELL_CHOICE=true
    PACKAGES_CHOICE=true
    AI_TOOLS_CHOICE=true
    FONT_CHOICE=true
    DESKTOP_CHOICE=true
    PROOT_CHOICE=true
    X11_CHOICE=true
    SCRIPT_CHOICE=true
fi

# Initialisation du système d'internationalisation
if ! init_i18n "$OVERRIDE_LANG"; then
    echo "Warning: Problem during i18n system initialization. Using default messages." >&2
fi

# Fallback: force-load messages if i18n system failed
if [ "$MESSAGES_LOADED" != "true" ]; then
    for _msg_path in "$SCRIPT_DIR/i18n/messages" "$(dirname "${BASH_SOURCE[0]}")/i18n/messages"; do
        if [ -f "$_msg_path/en.sh" ]; then
            source "$_msg_path/en.sh"
            MESSAGES_LOADED=true
            CURRENT_LANGUAGE="en"
            break
        fi
    done
    # Redefine t() to use indirect variable lookup if the fallback t() is active
    if [ "$MESSAGES_LOADED" = "true" ]; then
        t() {
            local key="$1"
            local default="$2"
            local val="${!key}"
            echo "${val:-${default:-$key}}"
        }
    fi
fi

# Set banner title now that i18n is initialized
BANNER_TITLE="$(t MSG_BANNER_TITLE)"

# Load plugin translations and resolve dependencies
type load_all_plugin_i18n &>/dev/null && load_all_plugin_i18n
type check_plugin_dependencies &>/dev/null && check_plugin_dependencies

#------------------------------------------------------------------------------
# GUM INSTALLATION
#------------------------------------------------------------------------------
check_and_install_gum() {
    if $USE_GUM && ! command -v gum &> /dev/null; then
        bash_banner
        echo -e "${COLOR_BLUE}$(t MSG_INSTALL_GUM)${COLOR_RESET}"
        pkg update -y > /dev/null 2>&1 && pkg install gum -y > /dev/null 2>&1
    fi
}

check_and_install_gum

trap finish EXIT

# Show interactive plugin selection if no plugin was pre-selected via CLI
if ! $FULL_INSTALL; then
    type show_plugin_selection_gum &>/dev/null && show_plugin_selection_gum
fi

#------------------------------------------------------------------------------
# GRAPHIC BANNER (override for install.sh - uses i18n title)
#------------------------------------------------------------------------------
show_banner() {
    # Initialiser le système i18n si pas encore fait
    if [ "$MESSAGES_LOADED" != "true" ]; then
        init_i18n "$OVERRIDE_LANG" >/dev/null 2>&1
    fi

    clear
    if $USE_GUM; then
        gum style \
            --foreground 33 \
            --border-foreground 33 \
            --border double \
            --align center \
            --width 42 \
            --margin "1 1 1 0" \
            "" "$(t MSG_BANNER_TITLE)" ""
    else
        bash_banner
    fi
}

#------------------------------------------------------------------------------
# FILE BACKUP
#------------------------------------------------------------------------------
create_backups() {
    local BACKUP_DIR="$OHMYTERMUX_CONFIG_DIR/backups"

    # Create the backup directory
    execute_command "mkdir -p \"$BACKUP_DIR\"" "$(t MSG_PROGRESS_CREATE_BACKUP_DIR)"

    # List of files to backup
    local FILES_TO_BACKUP=(
        "$HOME/.bashrc"
        "$HOME/.termux/colors.properties"
        "$HOME/.termux/termux.properties"
        "$HOME/.termux/font.ttf"
        #"$0"
    )

    # Copy files to backup directory
    for FILE in "${FILES_TO_BACKUP[@]}"; do
        if [ -f "$FILE" ]; then
            execute_command "cp \"$FILE\" \"$BACKUP_DIR/\"" "$(t MSG_PROGRESS_BACKUP_FILE) $(basename "$FILE")"
        fi
    done
}

#------------------------------------------------------------------------------
# COMMON ALIAS CONFIGURATION
#------------------------------------------------------------------------------
common_alias() {
    # Create the centralized alias file
    if [ ! -d "$OHMYTERMUX_CONFIG_DIR" ]; then
        execute_command "mkdir -p \"$OHMYTERMUX_CONFIG_DIR\"" "$(t MSG_PROGRESS_CREATE_CONFIG_FOLDER)"
    fi

    ALIASES_FILE="$OHMYTERMUX_CONFIG_DIR/aliases"

    cat > "$ALIASES_FILE" << 'EOL'
# Navigation
alias ..="cd .."
alias ...="cd ../.."
alias ....="cd ../../.."
alias .....="cd ../../../.."

# Base commands
alias h="history"
alias q="exit"
alias c="clear"
alias md="mkdir"
alias rm="rm -rf"
alias s="source"
alias n="nano"
alias cm="chmod +x"

# Configuration
alias bashrc="nano $HOME/.bashrc"
alias zshrc="nano $HOME/.zshrc"
alias aliases="nano $OHMYTERMUX_CONFIG_DIR/aliases"
alias help="cat $OHMYTERMUX_CONFIG_DIR/help.md"

# Git
alias g="git"
alias gs="git status"
alias ga="git add"
alias gc="git commit -m"
alias gp="git push"
alias gl="git pull"
alias gd="git diff"
alias gb="git branch"
alias gco="git checkout"
alias gcl="git clone"
alias push="git pull && git add . && git commit -m 'mobile push' && git push"

# Termux
alias termux="termux-reload-settings"
alias storage="termux-setup-storage"
alias share="termux-share"
alias open="termux-open"
alias url="termux-open-url"
alias clip="termux-clipboard-set"
alias notification="termux-notification"
alias vibrate="termux-vibrate"
alias battery="termux-battery-status"
alias torch="termux-torch"
alias volume="termux-volume"
alias wifi="termux-wifi-connectioninfo"
alias tts="termux-tts-speak"
alias call="termux-telephony-call"
alias contact="termux-contact-list"
alias sms="termux-sms-send"
alias location="termux-location"

EOL

    # Add the sourcing .bashrc
    echo -e "\n# Source of custom aliases\n[ -f \"$ALIASES_FILE\" ] && . \"$ALIASES_FILE\"" >> "$BASHRC"
    # The sourcing .zshrc is done in update_zshrc()
}

#------------------------------------------------------------------------------
# DOWNLOAD AND EXECUTE FUNCTION
#------------------------------------------------------------------------------
download_and_execute() {
    local URL="$1"
    local SCRIPT_NAME=$(basename "$URL")
    local DESCRIPTION="${2:-$SCRIPT_NAME}"
    shift 2
    local EXEC_ARGS="$@"

    # Use local file if available in SCRIPT_DIR, otherwise download
    if [ -f "$SCRIPT_DIR/$SCRIPT_NAME" ] && head -1 "$SCRIPT_DIR/$SCRIPT_NAME" 2>/dev/null | grep -q "^#!/bin/bash"; then
        cp "$SCRIPT_DIR/$SCRIPT_NAME" "$SCRIPT_NAME"
    else
        # Check if the file already exists and delete it
        [ -f "$SCRIPT_NAME" ] && rm "$SCRIPT_NAME"

        # Download with curl in silent mode
        if ! curl -fL -o "$SCRIPT_NAME" "$URL" 2>/dev/null; then
            error_msg "$(t MSG_ERROR_DOWNLOAD_SCRIPT) $DESCRIPTION"
            return 1
        fi
    fi

    # Check if the file has been downloaded
    if [ ! -f "$SCRIPT_NAME" ]; then
        error_msg "$(t MSG_ERROR_FILE_NOT_CREATED_GENERIC) $SCRIPT_NAME"
        return 1
    fi

    # Make the script executable
    if ! chmod +x "$SCRIPT_NAME"; then
        error_msg "$(t MSG_ERROR_MAKE_EXECUTABLE) $DESCRIPTION"
        return 1
    fi

    # Execute the script with the arguments, passing --lang if set
    local LANG_ARG=""
    if [ -n "$OVERRIDE_LANG" ]; then
        LANG_ARG="--lang $OVERRIDE_LANG"
    fi

    if ! ./"$SCRIPT_NAME" $LANG_ARG $EXEC_ARGS; then
        error_msg "$(t MSG_ERROR_SCRIPT_EXECUTION) $DESCRIPTION"
        return 1
    fi

    return 0
}

#------------------------------------------------------------------------------
# REPOSITORY CHANGE
#------------------------------------------------------------------------------
change_repo() {
    show_banner
    if $USE_GUM; then
        if gum_confirm "$(t MSG_CONFIRM_CHANGE_REPO)"; then
            termux-change-repo
        fi
    else
        read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_CHANGE_REPO) (O/n) : ")" -i "o" CHOICE
        [[ "$CHOICE" =~ ^[oO]$ ]] && termux-change-repo
    fi
}

#------------------------------------------------------------------------------
# STORAGE CONFIGURATION
#------------------------------------------------------------------------------
setup_storage() {
    if [ ! -d "$HOME/storage" ]; then
        show_banner
        if $USE_GUM; then
            if gum_confirm "$(t MSG_CONFIRM_ALLOW_STORAGE)"; then
                termux-setup-storage
            fi
        else
            read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_ALLOW_STORAGE) (O/n) : ")" -i "n" CHOICE
            [[ "$CHOICE" =~ ^[oO]$ ]] && termux-setup-storage
        fi
    fi
}

#------------------------------------------------------------------------------
# TERMUX CONFIGURATION
#------------------------------------------------------------------------------
configure_termux() {
    title_msg "$(t MSG_CONFIG_TERMUX)"
    # Backup existing files
    create_backups
    TERMUX_DIR="$HOME/.termux"

    # Colors.properties configuration
    FILE_PATH="$TERMUX_DIR/colors.properties"
    if [ ! -f "$FILE_PATH" ]; then
        mkdir -p "$TERMUX_DIR"
        cat > "$FILE_PATH" << 'EOL'
# https://github.com/Mayccoll/Gogh/blob/master/themes/argonaut.sh
background=#0e1019
foreground=#fffaf4
cursor=#fffaf4
color0=#232323
color1=#ff000f
color2=#8ce10b
color3=#ffb900
color4=#008df8
color5=#6d43a6
color6=#00d8eb
color7=#ffffff
color8=#444444
color9=#ff2740
color10=#abe15b
color11=#ffd242
color12=#0092ff
color13=#9a5feb
color14=#67fff0
color15=#ffffff
EOL
        success_msg "$(t MSG_SUCCESS_ARGONAUT)"
    fi

    # Common alias configuration
    common_alias

    # Termux.properties configuration
    FILE_PATH="$TERMUX_DIR/termux.properties"
    if [ ! -f "$FILE_PATH" ]; then
        execute_command "cat > \"$FILE_PATH\" << 'EOL'
allow-external-apps = true
use-black-ui = true
bell-character = ignore
fullscreen = true
EOL" "$(t MSG_PROGRESS_TERMUX_PROPERTIES_CONFIG)"
    else
        execute_command "sed -i 's/^# allow-external-apps = true/allow-external-apps = true/' \"$FILE_PATH\" && \
        sed -i 's/^# use-black-ui = true/use-black-ui = true/' \"$FILE_PATH\" && \
        sed -i 's/^# bell-character = ignore/bell-character = ignore/' \"$FILE_PATH\" && \
        sed -i 's/^# fullscreen = true/fullscreen = true/' \"$FILE_PATH\"" "$(t MSG_CONFIG_TERMUX_PROPS)"
    fi
    # Suppression of the login banner
    execute_command "touch $HOME/.hushlogin" "$(t MSG_PROGRESS_SUPPRESS_LOGIN_BANNER)"
}

#------------------------------------------------------------------------------
# INITIAL CONFIGURATION
#------------------------------------------------------------------------------
initial_config() {
    # Si on est en mode FULL_INSTALL, demander les identifiants au début
    if $FULL_INSTALL; then
        title_msg "$(t MSG_CONFIG_PROOT)"
        if [ -z "$PROOT_USERNAME" ]; then
            if $USE_GUM; then
                PROOT_USERNAME=$(gum input --placeholder "$(t MSG_INFO_ENTER_USERNAME_PROOT)")
                PROOT_PASSWORD=$(gum input --password --placeholder "$(t MSG_INFO_ENTER_PASSWORD_PROOT)")
            else
                printf "${COLOR_BLUE}$(t MSG_INFO_ENTER_USERNAME_PROOT) ${COLOR_RESET}"
                read -r PROOT_USERNAME
                printf "${COLOR_BLUE}$(t MSG_INFO_ENTER_PASSWORD_PROOT) ${COLOR_RESET}"
                read -r -s PROOT_PASSWORD
                echo
            fi
        fi
    fi

    change_repo

    # Update and upgrade packages preserving existing configurations
    clear
    show_banner
    execute_command "pkg update -y -o Dpkg::Options::=\"--force-confold\"" "$(t MSG_PROGRESS_UPDATE_REPOS)"
    execute_command "pkg upgrade -y -o Dpkg::Options::=\"--force-confold\"" "$(t MSG_PROGRESS_UPGRADE_PACKAGES)"

    setup_storage

    if $USE_GUM; then
        show_banner
        if gum_confirm "$(t MSG_CONFIRM_ACTIVATE_CONFIG)"; then
            configure_termux
        fi
    else
        show_banner
        read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_ACTIVATE_CONFIG) (O/n) : ")" -i "o" CHOICE
        # Clear the previous line
        tput cuu1  # Move up one line
        tput el    # Clear to the end of the line
        [[ "$CHOICE" =~ ^[oO]$ ]] && configure_termux
    fi
}

#------------------------------------------------------------------------------
# INSTALLATION OF THE SHELL
#------------------------------------------------------------------------------
install_shell() {
    if $SHELL_CHOICE; then
        title_msg "$(t MSG_SHELL_CONFIG_TITLE)"
        if $USE_GUM; then
            SHELL_CHOICE=$(gum_choose "$(t MSG_CHOOSE_SHELL_PROMPT)" --selected="zsh" --height=5 "bash" "zsh" "fish")
        else
            echo -e "${COLOR_BLUE}$(t MSG_CHOOSE_SHELL_PROMPT)${COLOR_RESET}"
            echo
            echo -e "${COLOR_BLUE}$(t MSG_BASH_OPTION)${COLOR_RESET}"
            echo -e "${COLOR_BLUE}$(t MSG_ZSH_OPTION)${COLOR_RESET}"
            echo -e "${COLOR_BLUE}$(t MSG_FISH_OPTION)${COLOR_RESET}"
            echo
            read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_SHELL_CHOICE) " "${COLOR_INPUT}")" -i "2" CHOICE
            tput sgr0

            # Clear the selection menu
            tput cuu 7  # Move up 7 lines
            tput ed     # Clear to the end of the screen

            case $CHOICE in
                1) SHELL_CHOICE="bash" ;;
                2) SHELL_CHOICE="zsh" ;;
                3) SHELL_CHOICE="fish" ;;
                *) SHELL_CHOICE="bash" ;;
            esac
        fi

        case $SHELL_CHOICE in
            "bash")
                success_msg "$(t MSG_BASH_SELECTED)"
                install_prompt
                ;;
            "zsh")
                if ! command -v zsh &> /dev/null; then
                    execute_command "pkg install -y zsh" "$(t MSG_INSTALL_ZSH)"
                else
                    success_msg "$(t MSG_ZSH_ALREADY_INSTALLED)"
                fi
                # Installation de Oh My Zsh et autres configurations ZSH
                title_msg "$(t MSG_ZSH_CONFIG_TITLE)"
                if [ ! -d "$HOME/.oh-my-zsh" ]; then
                    if $USE_GUM; then
                        if gum_confirm "$(t MSG_CONFIRM_INSTALL_OHMYZSH)"; then
                            execute_command "pkg install -y wget curl git unzip" "$(t MSG_INSTALL_DEPENDENCIES)"
                            execute_command "git clone https://github.com/ohmyzsh/ohmyzsh.git \"$HOME/.oh-my-zsh\"" "$(t MSG_INSTALL_OHMYZSH_PROGRESS)"
                            cp "$HOME/.oh-my-zsh/templates/zshrc.zsh-template" "$ZSHRC"
                        fi
                    else
                        read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_INSTALL_OHMYZSH) (O/n) : ")" -i "o" CHOICE
                        tput cuu1
                        tput el
                        if [[ "$CHOICE" =~ ^[oO]$ ]]; then
                            execute_command "pkg install -y wget curl git unzip" "$(t MSG_INSTALL_DEPENDENCIES)"
                            execute_command "git clone https://github.com/ohmyzsh/ohmyzsh.git \"$HOME/.oh-my-zsh\"" "$(t MSG_INSTALL_OHMYZSH_PROGRESS)"
                            cp "$HOME/.oh-my-zsh/templates/zshrc.zsh-template" "$ZSHRC"
                        fi
                    fi
                else
                    success_msg "$(t MSG_OHMYZSH_ALREADY_INSTALLED)"
                fi

                execute_command "curl -fLo \"$ZSHRC\" $OHMYTERMUX_REPO_URL/$BRANCH/src/zshrc" "$(t MSG_DEFAULT_CONFIG_PROGRESS)" || error_msg "$(t MSG_ERROR_DEFAULT_CONFIG)"

                if command -v zsh &> /dev/null; then
                    install_zsh_plugins
                    install_prompt
                else
                    echo -e "${COLOR_RED}$(t MSG_ZSH_NOT_INSTALLED_ERROR)${COLOR_RESET}"
                fi
                chsh -s zsh
                ;;
            "fish")
                title_msg "$(t MSG_FISH_CONFIG_TITLE)"
                execute_command "pkg install -y fish" "$(t MSG_FISH_INSTALLATION)"
                execute_command "mkdir -p $HOME/.config/fish/functions" "$(t MSG_CREATE_FISH_DIR)"
                # Installation of Fisher in non-interactive mode
                execute_command "curl -sL https://raw.githubusercontent.com/jorgebucaran/fisher/main/functions/fisher.fish -o $HOME/.config/fish/functions/fisher.fish" "$(t MSG_DOWNLOAD_FISHER)"
                # Installation of Tide via Fisher in non-interactive mode
                execute_command "fish -c 'source $HOME/.config/fish/functions/fisher.fish && fisher install IlanCosman/tide@v5'" "$(t MSG_TIDE_INSTALLATION)"
                chsh -s fish
                ;;
        esac
    fi
}

#------------------------------------------------------------------------------
# INSTALLATION OF THE PROMPT
#------------------------------------------------------------------------------
install_prompt() {
    local PROMPT_CHOICE
    local CURRENT_SHELL="${SHELL_CHOICE:-zsh}"

    if [ "$CURRENT_SHELL" = "bash" ]; then
        if $USE_GUM; then
            PROMPT_CHOICE=$(gum_choose "$(t MSG_CHOOSE_PROMPT_BASH)" --height=4 --selected="Oh-My-Posh" "Oh-My-Posh" "Starship")
        else
            echo -e "${COLOR_BLUE}$(t MSG_CHOOSE_PROMPT_BASH)${COLOR_RESET}"
            echo
            echo -e "${COLOR_BLUE}$(t MSG_OHMYPOSH_OPTION_BASH)${COLOR_RESET}"
            echo -e "${COLOR_BLUE}$(t MSG_STARSHIP_OPTION_BASH)${COLOR_RESET}"
            echo
            read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_PROMPT_CHOICE_BASH) " "${COLOR_INPUT}")" -i "1" CHOICE
            tput sgr0
            tput cuu 5
            tput ed

            case $CHOICE in
                1) PROMPT_CHOICE="Oh-My-Posh" ;;
                2) PROMPT_CHOICE="Starship" ;;
                *) PROMPT_CHOICE="Oh-My-Posh" ;;
            esac
        fi
    else
        if $USE_GUM; then
            PROMPT_CHOICE=$(gum_choose "$(t MSG_CHOOSE_PROMPT)" --height=5 --selected="PowerLevel10k" "PowerLevel10k" "Oh-My-Posh" "Starship")
        else
            echo -e "${COLOR_BLUE}$(t MSG_CHOOSE_PROMPT)${COLOR_RESET}"
            echo
            echo -e "${COLOR_BLUE}$(t MSG_POWERLEVEL10K_OPTION)${COLOR_RESET}"
            echo -e "${COLOR_BLUE}$(t MSG_OHMYPOSH_OPTION)${COLOR_RESET}"
            echo -e "${COLOR_BLUE}$(t MSG_STARSHIP_OPTION)${COLOR_RESET}"
            echo
            read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_PROMPT_CHOICE) " "${COLOR_INPUT}")" -i "1" CHOICE
            tput sgr0
            tput cuu 7
            tput ed

            case $CHOICE in
                1) PROMPT_CHOICE="PowerLevel10k" ;;
                2) PROMPT_CHOICE="Oh-My-Posh" ;;
                3) PROMPT_CHOICE="Starship" ;;
                *) PROMPT_CHOICE="PowerLevel10k" ;;
            esac
        fi
    fi

    case $PROMPT_CHOICE in
        "PowerLevel10k")
            if $USE_GUM; then
                if gum_confirm "$(t MSG_CONFIRM_POWERLEVEL10K)"; then
                    execute_command "git clone --depth=1 https://github.com/romkatv/powerlevel10k.git \"$HOME/.oh-my-zsh/custom/themes/powerlevel10k\" || true" "$(t MSG_INSTALL_POWERLEVEL10K_PROGRESS)"
                    sed -i 's/ZSH_THEME="robbyrussell"/ZSH_THEME="powerlevel10k\/powerlevel10k"/' "$ZSHRC"

                    if gum_confirm "$(t MSG_CONFIRM_INSTALL_CUSTOM_PROMPT)"; then
                        execute_command "curl -fLo \"$HOME/.p10k.zsh\" $OHMYTERMUX_REPO_URL/$BRANCH/src/p10k.zsh" "$(t MSG_INSTALL_CUSTOM_PROMPT)" || error_msg "$(t MSG_ERROR_CUSTOM_PROMPT)"
                        echo -e "\n$(t MSG_CUSTOM_PROMPT_COMMENT)" >> "$ZSHRC"
                        echo "[[ ! -f ~/.p10k.zsh ]] || source ~/.p10k.zsh" >> "$ZSHRC"
                    else
                        echo -e "${COLOR_BLUE}$(t MSG_CUSTOMIZE_P10K_INFO)${COLOR_RESET}"
                    fi
                fi
            else
                read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_POWERLEVEL10K) (O/n) : ")" -i "o" CHOICE
                tput cuu1
                tput el
                if [[ "$CHOICE" =~ ^[oO]$ ]]; then
                    execute_command "git clone --depth=1 https://github.com/romkatv/powerlevel10k.git \"$HOME/.oh-my-zsh/custom/themes/powerlevel10k\" > /dev/null 2>&1 || true" "$(t MSG_INSTALL_POWERLEVEL10K_PROGRESS)"
                    sed -i 's/ZSH_THEME="robbyrussell"/ZSH_THEME="powerlevel10k\/powerlevel10k"/' "$ZSHRC"

                    read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_INSTALL_CUSTOM_PROMPT) (O/n) : ")" -i "o" CHOICE
                    tput cuu1
                    tput el
                    if [[ "$CHOICE" =~ ^[oO]$ ]]; then
                        execute_command "curl -fLo \"$HOME/.p10k.zsh\" $OHMYTERMUX_REPO_URL/$BRANCH/src/p10k.zsh" "$(t MSG_INSTALL_CUSTOM_PROMPT)" || error_msg "$(t MSG_ERROR_CUSTOM_PROMPT)"
                        echo -e "\n$(t MSG_CUSTOM_PROMPT_COMMENT)" >> "$ZSHRC"
                        echo "[[ ! -f ~/.p10k.zsh ]] || source ~/.p10k.zsh" >> "$ZSHRC"
                    else
                        echo -e "${COLOR_BLUE}$(t MSG_CUSTOMIZE_P10K_INFO)${COLOR_RESET}"
                    fi
                fi
            fi
            ;;

        "Oh-My-Posh")
            execute_command "pkg install -y oh-my-posh" "$(t MSG_INSTALL_OHMYPOSH_PROGRESS)"

            # Optional installation of a Nerd font
            if [ ! -f "$HOME/.termux/font.ttf" ]; then
                execute_command "curl -fLo \"$HOME/.termux/font.ttf\" --create-dirs https://raw.githubusercontent.com/termux/termux-styling/master/app/src/main/assets/fonts/DejaVu-Sans-Mono.ttf" "$(t MSG_INSTALL_NERD_FONT)"
            fi

            # Retrieving the complete list of themes
            THEMES_DIR="/data/data/com.termux/files/usr/share/oh-my-posh/themes"
            if [ -d "$THEMES_DIR" ]; then
                # Creating an array with all available themes
                mapfile -t AVAILABLE_THEMES < <(find "$THEMES_DIR" -name "*.omp.json" -exec basename {} .omp.json \; | sort)
            else
                error_msg "Oh-My-Posh themes directory not found"
                return 1
            fi

            # Theme selection
            if $USE_GUM; then
                THEME=$(printf '%s\n' "${AVAILABLE_THEMES[@]}" | gum_choose \
                    "$(t MSG_CHOOSE_OHMYPOSH_THEME)" \
                    --height=25)
            else
                # Displaying the numbered list of themes
                echo -e "${COLOR_BLUE}$(t MSG_CHOOSE_OHMYPOSH_THEME)${COLOR_RESET}"
                echo
                for i in "${!AVAILABLE_THEMES[@]}"; do
                    # Formatting the number for alignment (3 characters)
                    NUM=$(printf "%3d" $((i+1)))
                    if [ "${AVAILABLE_THEMES[$i]}" = "jandedobbeleer" ]; then
                        echo -e "${COLOR_BLUE}${NUM}) ${AVAILABLE_THEMES[$i]} $(t MSG_DEFAULT_THEME)${COLOR_RESET}"
                    else
                        echo -e "${COLOR_BLUE}${NUM}) ${AVAILABLE_THEMES[$i]}${COLOR_RESET}"
                    fi
                done
                echo
                # Calculating the number of lines to clear (number of themes + 3 lines for additional text)
                LINES_TO_CLEAR=$((${#AVAILABLE_THEMES[@]}+3))
                read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_123) " "${COLOR_INPUT}")" -i "1" CHOICE
                tput sgr0
                # Clearing the menu
                tput cuu $LINES_TO_CLEAR
                tput ed

                # Validating the choice
                if [[ "$CHOICE" =~ ^[0-9]+$ ]] && [ "$CHOICE" -ge 1 ] && [ "$CHOICE" -le "${#AVAILABLE_THEMES[@]}" ]; then
                    THEME="${AVAILABLE_THEMES[$((CHOICE-1))]}"
                else
                    THEME="jandedobbeleer"
                fi
            fi

            # Configuration for ZSH
            if [ ! -f "$ZSHRC" ]; then
                touch "$ZSHRC"
            fi
            sed -i '/# Initialize oh-my-posh/d' "$ZSHRC"
            sed -i '/eval "$(oh-my-posh init/d' "$ZSHRC"
            cat >> "$ZSHRC" << EOF

# Initialize oh-my-posh
eval "\$(oh-my-posh init zsh --config /data/data/com.termux/files/usr/share/oh-my-posh/themes/${THEME}.omp.json)"
EOF

            # Configuration for Bash
            if [ ! -f "$HOME/.bashrc" ]; then
                touch "$HOME/.bashrc"
            fi
            sed -i '/# Initialize oh-my-posh/d' "$HOME/.bashrc"
            sed -i '/eval "$(oh-my-posh init/d' "$HOME/.bashrc"
            cat >> "$HOME/.bashrc" << EOF

# Initialize oh-my-posh
eval "\$(oh-my-posh init bash --config /data/data/com.termux/files/usr/share/oh-my-posh/themes/${THEME}.omp.json)"
EOF
            ;;
        "Starship")
            execute_command "pkg install -y starship" "$(t MSG_INSTALL_STARSHIP_PROGRESS)"

            # Optional installation of a Nerd font
            if [ ! -f "$HOME/.termux/font.ttf" ]; then
                execute_command "curl -fLo \"$HOME/.termux/font.ttf\" --create-dirs https://raw.githubusercontent.com/termux/termux-styling/master/app/src/main/assets/fonts/DejaVu-Sans-Mono.ttf" "$(t MSG_INSTALL_NERD_FONT)"
            fi

            # Creating the configuration directory if it doesn't exist
            mkdir -p "$HOME/.config"

            # Preset selection
            if $USE_GUM; then
                PRESET=$(gum_choose "$(t MSG_CHOOSE_STARSHIP_PRESET)" --height=15 --selected="$(t PRESET_CUSTOM)" \
                    "$(t PRESET_CUSTOM)" \
                    "$(t PRESET_NERD_FONT_SYMBOLS)" \
                    "$(t PRESET_BRACKETED_SEGMENTS)" \
                    "$(t PRESET_NO_EMPTY_ICONS)" \
                    "$(t PRESET_NO_RUNTIME_VERSIONS)" \
                    "$(t PRESET_PLAIN_TEXT_SYMBOLS)" \
                    "$(t PRESET_PASTEL_POWERLINE)" \
                    "$(t PRESET_TOKYO_NIGHT)" \
                    "$(t PRESET_PURE_PRESET)" \
                    "$(t PRESET_GRUVBOX_RAINBOW)" \
                    "$(t PRESET_JETPACK)" \
                    "$(t PRESET_NO_NERD_FONT)" \
                    "$(t PRESET_RICE)" \
                    "$(t PRESET_SOLARIZED)")
            else
                echo -e "${COLOR_BLUE}$(t MSG_CHOOSE_STARSHIP_PRESET)${COLOR_RESET}"
                echo
                echo -e "${COLOR_BLUE}1)  $(t PRESET_CUSTOM)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}2)  $(t PRESET_NERD_FONT_SYMBOLS)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}3)  $(t PRESET_BRACKETED_SEGMENTS)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}4)  $(t PRESET_NO_EMPTY_ICONS)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}5)  $(t PRESET_NO_RUNTIME_VERSIONS)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}6)  $(t PRESET_PLAIN_TEXT_SYMBOLS)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}7)  $(t PRESET_PASTEL_POWERLINE)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}8)  $(t PRESET_TOKYO_NIGHT)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}9)  $(t PRESET_PURE_PRESET)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}10) $(t PRESET_GRUVBOX_RAINBOW)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}11) $(t PRESET_JETPACK)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}12) $(t PRESET_NO_NERD_FONT)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}13) $(t PRESET_RICE)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}14) $(t PRESET_SOLARIZED)${COLOR_RESET}"
                echo
                read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_123) " "${COLOR_INPUT}")" -i "1" CHOICE
                tput sgr0
                tput cuu 18
                tput ed

                case $CHOICE in
                    1) PRESET="$(t PRESET_CUSTOM)" ;;
                    2) PRESET="$(t PRESET_NERD_FONT_SYMBOLS)" ;;
                    3) PRESET="$(t PRESET_BRACKETED_SEGMENTS)" ;;
                    4) PRESET="$(t PRESET_NO_EMPTY_ICONS)" ;;
                    5) PRESET="$(t PRESET_NO_RUNTIME_VERSIONS)" ;;
                    6) PRESET="$(t PRESET_PLAIN_TEXT_SYMBOLS)" ;;
                    7) PRESET="$(t PRESET_PASTEL_POWERLINE)" ;;
                    8) PRESET="$(t PRESET_TOKYO_NIGHT)" ;;
                    9) PRESET="$(t PRESET_PURE_PRESET)" ;;
                    10) PRESET="$(t PRESET_GRUVBOX_RAINBOW)" ;;
                    11) PRESET="$(t PRESET_JETPACK)" ;;
                    12) PRESET="$(t PRESET_NO_NERD_FONT)" ;;
                    13) PRESET="$(t PRESET_RICE)" ;;
                    14) PRESET="$(t PRESET_SOLARIZED)" ;;
                    *) PRESET="$(t PRESET_CUSTOM)" ;;
                esac
            fi

            case $PRESET in
                "$(t PRESET_NERD_FONT_SYMBOLS)")
                    starship preset nerd-font-symbols -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_BRACKETED_SEGMENTS)")
                    starship preset bracketed-segments -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_NO_EMPTY_ICONS)")
                    starship preset no-empty-icons -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_NO_RUNTIME_VERSIONS)")
                    starship preset no-runtime-versions -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_PLAIN_TEXT_SYMBOLS)")
                    starship preset plain-text-symbols -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_PASTEL_POWERLINE)")
                    starship preset pastel-powerline -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_TOKYO_NIGHT)")
                    starship preset tokyo-night -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_PURE_PRESET)")
                    starship preset pure -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_GRUVBOX_RAINBOW)")
                    starship preset gruvbox-rainbow -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_JETPACK)")
                    starship preset jetpack -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_NO_NERD_FONT)")
                    starship preset no-nerd-font -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_RICE)")
                    starship preset rice -o "$HOME/.config/starship.toml"
                    ;;
                "$(t PRESET_SOLARIZED)")
                    starship preset solarized -o "$HOME/.config/starship.toml"
                    ;;
                *)
                    # Default custom configuration
                    cat > "$HOME/.config/starship.toml" << 'EOF'
# Get help on configuration: https://starship.rs/config/
format = """$username$hostname$directory$git_branch$git_status$cmd_duration$line_break$character"""

# Disable default new line
add_newline = false

[directory]
style = "blue bold"
truncation_length = 3
truncate_to_repo = true

[character]
success_symbol = "[❯](purple bold)"
error_symbol = "[❯](red bold)"
vimcmd_symbol = "[❮](green bold)"

[git_branch]
format = "[$branch]($style)"
style = "bright-black"

[git_status]
format = "[[(*$conflicted$untracked$modified$staged$renamed$deleted)](218) ($ahead_behind$stashed)]($style)"
style = "cyan"
conflicted = "​"
untracked = "​"
modified = "​"
staged = "​"
renamed = "​"
deleted = "​"
stashed = "≡"

[git_state]
format = '\([$state( $progress_current/$progress_total)]($style)\) '
style = "bright-black"

[cmd_duration]
format = "[$duration]($style) "
style = "yellow"

[python]
format = "[$virtualenv]($style) "
style = "bright-black"

[username]
style_user = "white bold"
style_root = "black bold"
format = "[$user]($style) "
disabled = false
show_always = true

[hostname]
ssh_only = false
format = "on [$hostname](bold red) "
disabled = false
EOF
                    ;;
            esac

            # ZSH configuration
            if [ ! -f "$ZSHRC" ]; then
                touch "$ZSHRC"
            fi
            sed -i '/# Initialize Starship/d' "$ZSHRC"
            sed -i '/eval "$(starship init/d' "$ZSHRC"
            echo -e "\n# Initialize Starship\neval \"\$(starship init zsh)\"" >> "$ZSHRC"

            # Bash configuration
            if [ ! -f "$HOME/.bashrc" ]; then
                touch "$HOME/.bashrc"
            fi
            sed -i '/# Initialize Starship/d' "$HOME/.bashrc"
            sed -i '/eval "$(starship init/d' "$HOME/.bashrc"
            echo -e "\n# Initialize Starship\neval \"\$(starship init bash)\"" >> "$HOME/.bashrc"
            ;;
    esac
}

#------------------------------------------------------------------------------
# ZSH PLUGINS SELECTION
#------------------------------------------------------------------------------
install_zsh_plugins() {
    local PLUGINS_TO_INSTALL=()

    subtitle_msg "$(t MSG_PLUGINS_SUBTITLE)"

    if $USE_GUM; then
        mapfile -t PLUGINS_TO_INSTALL < <(gum_choose_multi "$(t MSG_SELECT_PLUGINS_GUM)" --height=8 --selected="$(t MSG_PLUGIN_ALL)" "zsh-autosuggestions" "zsh-syntax-highlighting" "zsh-completions" "you-should-use" "zsh-alias-finder" "$(t MSG_PLUGIN_ALL)")
        if [[ " ${PLUGINS_TO_INSTALL[*]} " == *" $(t MSG_PLUGIN_ALL) "* ]]; then
            PLUGINS_TO_INSTALL=("zsh-autosuggestions" "zsh-syntax-highlighting" "zsh-completions" "you-should-use" "zsh-alias-finder")
        fi
    else
        echo "$(t MSG_SELECT_PLUGINS_TEXT)"
        echo
        info_msg "$(t MSG_PLUGIN_1)"
        info_msg "$(t MSG_PLUGIN_2)"
        info_msg "$(t MSG_PLUGIN_3)"
        info_msg "$(t MSG_PLUGIN_4)"
        info_msg "$(t MSG_PLUGIN_5)"
        info_msg "$(t MSG_PLUGIN_6)"
        echo
        read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_PLUGIN_NUMBERS_INPUT) " "${COLOR_INPUT}")" -i "6" PLUGIN_CHOICES
        tput sgr0
        tput cuu 10
        tput ed
        for CHOICE in $PLUGIN_CHOICES; do
            case $CHOICE in
                1) PLUGINS_TO_INSTALL+=("zsh-autosuggestions") ;;
                2) PLUGINS_TO_INSTALL+=("zsh-syntax-highlighting") ;;
                3) PLUGINS_TO_INSTALL+=("zsh-completions") ;;
                4) PLUGINS_TO_INSTALL+=("you-should-use") ;;
                5) PLUGINS_TO_INSTALL+=("zsh-alias-finder") ;;
                6) PLUGINS_TO_INSTALL=("zsh-autosuggestions" "zsh-syntax-highlighting" "zsh-completions" "you-should-use" "zsh-alias-finder")
                break
                ;;
            esac
        done
    fi

    for PLUGIN in "${PLUGINS_TO_INSTALL[@]}"; do
        install_plugin "$PLUGIN"
    done

    # Define necessary variables
    local ZSHRC="$HOME/.zshrc"
    local SELECTED_PLUGINS="${PLUGINS_TO_INSTALL[*]}"
    local HAS_COMPLETIONS=false
    local HAS_OHMYTERMIX=true

    # Check if zsh-completions is installed
    if [[ " ${PLUGINS_TO_INSTALL[*]} " == *" zsh-completions "* ]]; then
        HAS_COMPLETIONS=true
    fi

    update_zshrc "$ZSHRC" "$SELECTED_PLUGINS" "$HAS_COMPLETIONS" "$HAS_OHMYTERMIX"
}

#------------------------------------------------------------------------------
# INSTALLATION OF ZSH PLUGINS
#------------------------------------------------------------------------------
install_plugin() {
    local PLUGIN_NAME=$1
    local PLUGIN_URL=""

    case $PLUGIN_NAME in
        "zsh-autosuggestions") PLUGIN_URL="https://github.com/zsh-users/zsh-autosuggestions.git" ;;
        "zsh-syntax-highlighting") PLUGIN_URL="https://github.com/zsh-users/zsh-syntax-highlighting.git" ;;
        "zsh-completions") PLUGIN_URL="https://github.com/zsh-users/zsh-completions.git" ;;
        "you-should-use") PLUGIN_URL="https://github.com/MichaelAquilina/zsh-you-should-use.git" ;;
        "zsh-alias-finder") PLUGIN_URL="https://github.com/akash329d/zsh-alias-finder.git" ;;
    esac

    if [ ! -d "$HOME/.oh-my-zsh/custom/plugins/$PLUGIN_NAME" ]; then
        execute_command "git clone '$PLUGIN_URL' '$HOME/.oh-my-zsh/custom/plugins/$PLUGIN_NAME' --quiet" "$(t MSG_PLUGIN_INSTALLATION_OF) $PLUGIN_NAME"
    else
        info_msg "  $PLUGIN_NAME $(t MSG_PLUGIN_ALREADY_INSTALLED)"
    fi
}

#------------------------------------------------------------------------------
# UPDATE OF ZSH CONFIGURATION
#------------------------------------------------------------------------------
update_zshrc() {
    local ZSHRC="$1"
    local SELECTED_PLUGINS="$2"
    local HAS_COMPLETIONS="$3"

    # Delete existing configuration
    sed -i '/fpath.*zsh-completions\/src/d' "$ZSHRC"
    sed -i '/source \$ZSH\/oh-my-zsh.sh/d' "$ZSHRC"
    sed -i '/# Source defined aliases/d' "$ZSHRC"
    sed -i '/\[ -f.*aliases.*/d' "$ZSHRC"

    # Création du contenu de la section plugins
    local DEFAULT_PLUGINS="git command-not-found copyfile node npm timer vscode web-search z"
    local FILTERED_PLUGINS=$(echo "$SELECTED_PLUGINS" | sed 's/zsh-completions//g')
    local ALL_PLUGINS="$DEFAULT_PLUGINS $FILTERED_PLUGINS"

    local PLUGINS_SECTION="plugins=(\n"
    for PLUGIN in $ALL_PLUGINS; do
        PLUGINS_SECTION+="    $PLUGIN\n"
    done
    PLUGINS_SECTION+=")\n"

    # Delete and replace the plugins section
    sed -i '/^plugins=(/,/)/d' "$ZSHRC"
    echo -e "$PLUGINS_SECTION" >> "$ZSHRC"

    # Add configuration by section
    if [ "$HAS_COMPLETIONS" = "true" ]; then
        echo -e "\n# Initialize zsh-completions\nfpath+=\${ZSH_CUSTOM:-\${ZSH:-~/.oh-my-zsh}/custom}/plugins/zsh-completions/src" >> "$ZSHRC"
    fi

    echo -e "\n# Initialize oh-my-zsh\nsource \$ZSH/oh-my-zsh.sh" >> "$ZSHRC"

    # Sourcing defined aliases
    echo -e "\n# Source defined aliases\n[ -f \"$OHMYTERMUX_CONFIG_DIR/aliases\" ] && . \"$OHMYTERMUX_CONFIG_DIR/aliases\"" >> "$ZSHRC"
}

#------------------------------------------------------------------------------
# PRESET HELPERS
#------------------------------------------------------------------------------

# Built-in preset definitions
declare -A BUILTIN_PRESET_DESCRIPTIONS=(
    ["Minimal"]="Essential tools only"
    ["Python Development"]="Python development environment"
    ["Web Development"]="Web/Node.js development environment"
    ["C/C++ Development"]="C/C++ development environment"
    ["Android Development"]="Android development environment"
    ["SysAdmin"]="System administration tools"
)
declare -A BUILTIN_PRESET_PACKAGES=(
    ["Minimal"]="nala eza bat fzf"
    ["Python Development"]="python neovim fzf bat eza nala glow lazygit"
    ["Web Development"]="nodejs nodejs-lts python neovim fzf bat eza nala lazygit glow"
    ["C/C++ Development"]="clang cmake make neovim fzf bat eza nala lazygit"
    ["Android Development"]="python nodejs-lts neovim git fzf bat eza nala open-ssh"
    ["SysAdmin"]="nala tmux open-ssh tsu fzf bat eza vim lazygit"
)
BUILTIN_PRESET_ORDER=("Minimal" "Python Development" "Web Development" "C/C++ Development" "Android Development" "SysAdmin")

# Load all available presets into arrays
load_available_presets() {
    AVAILABLE_PRESETS=()
    AVAILABLE_PRESET_DESCRIPTIONS=()
    AVAILABLE_PRESET_PACKAGES_MAP=()

    # Load from external files if available
    local found_files=false
    for preset_file in "$SCRIPT_DIR"/presets/*.sh; do
        [ -f "$preset_file" ] || continue
        found_files=true
        source "$preset_file"
        [ -n "$PRESET_NAME" ] || continue
        AVAILABLE_PRESETS+=("$PRESET_NAME")
        AVAILABLE_PRESET_DESCRIPTIONS+=("$PRESET_DESCRIPTION")
        AVAILABLE_PRESET_PACKAGES_MAP+=("${PRESET_PACKAGES[*]}")
    done

    # Fallback to built-in presets if no files found
    if ! $found_files; then
        for preset_name in "${BUILTIN_PRESET_ORDER[@]}"; do
            AVAILABLE_PRESETS+=("$preset_name")
            AVAILABLE_PRESET_DESCRIPTIONS+=("${BUILTIN_PRESET_DESCRIPTIONS[$preset_name]}")
            AVAILABLE_PRESET_PACKAGES_MAP+=("${BUILTIN_PRESET_PACKAGES[$preset_name]}")
        done
    fi
}

# Load a specific preset by name and set PRESET_PACKAGES
load_preset_packages() {
    local preset_name="$1"
    local idx
    for idx in "${!AVAILABLE_PRESETS[@]}"; do
        if [ "${AVAILABLE_PRESETS[$idx]}" = "$preset_name" ]; then
            IFS=' ' read -r -a PRESET_PACKAGES <<< "${AVAILABLE_PRESET_PACKAGES_MAP[$idx]}"
            PRESET_NAME="$preset_name"
            PRESET_DESCRIPTION="${AVAILABLE_PRESET_DESCRIPTIONS[$idx]}"
            return 0
        fi
    done
    return 1
}

# Load a specific preset by file name (without extension) - CLI usage
load_preset() {
    local preset_id="$1"
    local preset_file="$SCRIPT_DIR/presets/${preset_id}.sh"
    if [ -f "$preset_file" ]; then
        source "$preset_file"
        return 0
    fi
    # Fallback: try built-in presets by matching id
    for preset_name in "${BUILTIN_PRESET_ORDER[@]}"; do
        local normalized="${preset_name,,}"
        normalized="${normalized// /-}"
        if [ "$normalized" = "$preset_id" ]; then
            IFS=' ' read -r -a PRESET_PACKAGES <<< "${BUILTIN_PRESET_PACKAGES[$preset_name]}"
            PRESET_NAME="$preset_name"
            PRESET_DESCRIPTION="${BUILTIN_PRESET_DESCRIPTIONS[$preset_name]}"
            return 0
        fi
    done
    return 1
}

#------------------------------------------------------------------------------
# INSTALLATION OF ADDITIONAL PACKAGES
#------------------------------------------------------------------------------
install_packages() {
    if $PACKAGES_CHOICE; then
        title_msg "$(t MSG_CONFIG_PACKAGES "❯ Package configuration")"
        local DEFAULT_PACKAGES=("nala" "eza" "bat" "lf" "fzf")

        # All available packages
        local ALL_PKG_LIST=("nala" "eza" "colorls" "lsd" "bat" "lf" "fzf" "glow" "tmux" "python" \
                "nodejs" "nodejs-lts" "micro" "vim" "neovim" "lazygit" "open-ssh" "tsu" \
                "clang" "cmake" "make")

        # Determine preset packages (if any)
        local PRESET_LOADED=false
        local -a PRESET_PKG_LIST=()

        if [ -n "$PRESET_NAME_ARG" ]; then
            # --preset provided via CLI
            if load_preset "$PRESET_NAME_ARG"; then
                PRESET_PKG_LIST=("${PRESET_PACKAGES[@]}")
                PRESET_LOADED=true
                info_msg "$(t MSG_PRESET_APPLYING "Applying preset:") $PRESET_NAME"
            else
                echo "$(t MSG_ERROR_PRESET_NOT_FOUND "Error: Preset not found:") $PRESET_NAME_ARG" >&2
                exit 1
            fi
        fi

        if $USE_GUM; then
            if $FULL_INSTALL; then
                if $PRESET_LOADED; then
                    PACKAGES=("${PRESET_PKG_LIST[@]}")
                else
                    PACKAGES=("${DEFAULT_PACKAGES[@]}")
                fi
            else
                # If no preset loaded via CLI, show preset selection menu
                if ! $PRESET_LOADED; then
                    load_available_presets
                    if [ ${#AVAILABLE_PRESETS[@]} -gt 0 ]; then
                        local PRESET_OPTIONS=()
                        for i in "${!AVAILABLE_PRESETS[@]}"; do
                            PRESET_OPTIONS+=("${AVAILABLE_PRESETS[$i]} - ${AVAILABLE_PRESET_DESCRIPTIONS[$i]}")
                        done
                        local CUSTOM_LABEL
                        CUSTOM_LABEL="$(t MSG_PRESET_CUSTOM_SELECTION "Custom selection")"
                        PRESET_OPTIONS+=("$CUSTOM_LABEL")

                        local PRESET_SELECTION
                        PRESET_SELECTION=$(printf '%s\n' "${PRESET_OPTIONS[@]}" | gum choose \
                            --selected.foreground="33" \
                            --header.foreground="33" \
                            --cursor.foreground="33" \
                            --header="$(t MSG_SELECT_PRESET_OR_MANUAL "Select an installation preset:")")

                        if [ "$PRESET_SELECTION" != "$CUSTOM_LABEL" ] && [ -n "$PRESET_SELECTION" ]; then
                            # Extract preset name (before " - ")
                            local SELECTED_PRESET_NAME="${PRESET_SELECTION%% - *}"
                            if load_preset_packages "$SELECTED_PRESET_NAME"; then
                                PRESET_PKG_LIST=("${PRESET_PACKAGES[@]}")
                                PRESET_LOADED=true
                                info_msg "$(t MSG_PRESET_APPLYING "Applying preset:") $PRESET_NAME"
                            fi
                        fi
                    fi
                fi

                # Build --selected flags for gum choose
                local GUM_SELECTED_ARGS=()
                if $PRESET_LOADED; then
                    for pkg in "${PRESET_PKG_LIST[@]}"; do
                        GUM_SELECTED_ARGS+=(--selected="$pkg")
                    done
                else
                    GUM_SELECTED_ARGS=(--selected="nala" --selected="eza" --selected="bat" --selected="lf" --selected="fzf")
                fi

                # Convert output of gum to array
                local ALL_PKG_LABEL
                ALL_PKG_LABEL="$(t MSG_ALL_INSTALL "Install all")"

                IFS=$'\n' read -r -d '' -a PACKAGES < <(gum choose --no-limit \
                    --selected.foreground="33" \
                    --header.foreground="33" \
                    --cursor.foreground="33" \
                    --height=21 \
                    --header="$(t MSG_SELECT_PACKAGES_GUM "Select packages to install:")" \
                    "${GUM_SELECTED_ARGS[@]}" \
                    "nala" "eza" "colorls" "lsd" "bat" "lf" "fzf" "glow" "tmux" "python" \
                    "nodejs" "nodejs-lts" "micro" "vim" "neovim" "lazygit" "open-ssh" "tsu" \
                    "clang" "cmake" "make" \
                    "$ALL_PKG_LABEL")

                if [[ " ${PACKAGES[*]} " == *" $ALL_PKG_LABEL "* ]]; then
                    PACKAGES=("${ALL_PKG_LIST[@]}")
                fi
            fi
        else
            # Text mode - show preset selection first
            if ! $PRESET_LOADED; then
                load_available_presets
                if [ ${#AVAILABLE_PRESETS[@]} -gt 0 ]; then
                    echo "$(t MSG_PRESET_AVAILABLE "Available presets:")"
                    echo
                    local idx=1
                    for i in "${!AVAILABLE_PRESETS[@]}"; do
                        echo -e "${COLOR_BLUE}${idx}) ${AVAILABLE_PRESETS[$i]} - ${AVAILABLE_PRESET_DESCRIPTIONS[$i]}${COLOR_RESET}"
                        idx=$((idx + 1))
                    done
                    echo -e "${COLOR_BLUE}${idx}) $(t MSG_PRESET_CUSTOM_SELECTION "Custom selection")${COLOR_RESET}"
                    echo
                    local TOTAL_OPTIONS=$idx
                    read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_123 "Enter your choice:" "${COLOR_INPUT}") ")" -i "$TOTAL_OPTIONS" PRESET_CHOICE
                    tput sgr0
                    # Clear the preset menu
                    tput cuu $((TOTAL_OPTIONS + 3))
                    tput ed

                    if [ "$PRESET_CHOICE" -ge 1 ] 2>/dev/null && [ "$PRESET_CHOICE" -lt "$TOTAL_OPTIONS" ] 2>/dev/null; then
                        local CHOSEN_IDX=$((PRESET_CHOICE - 1))
                        if load_preset_packages "${AVAILABLE_PRESETS[$CHOSEN_IDX]}"; then
                            PRESET_PKG_LIST=("${PRESET_PACKAGES[@]}")
                            PRESET_LOADED=true
                            info_msg "$(t MSG_PRESET_APPLYING "Applying preset:") $PRESET_NAME"
                        fi
                    fi
                fi
            fi

            if $PRESET_LOADED; then
                # Show preset packages and ask for confirmation or editing
                echo -e "${COLOR_BLUE}$(t MSG_PRESET_PACKAGES) ${PRESET_PKG_LIST[*]}${COLOR_RESET}"
                echo
                read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_PRESET_CONFIRM_SELECTION) " "${COLOR_INPUT}")" -i "Y" CONFIRM_CHOICE
                tput sgr0
                tput cuu 3
                tput ed

                if [[ "$CONFIRM_CHOICE" =~ ^[yYoO]$ ]]; then
                    PACKAGES=("${PRESET_PKG_LIST[@]}")
                elif [[ "$CONFIRM_CHOICE" == "edit" ]]; then
                    # Fall through to manual selection with preset defaults
                    PRESET_LOADED=false
                else
                    PACKAGES=()
                fi
            fi

            if ! $PRESET_LOADED && [ ${#PACKAGES[@]} -eq 0 ]; then
                echo "$(t MSG_SELECT_PACKAGES_TEXT "Select packages to install (space-separated):")"
                echo
                echo -e "${COLOR_BLUE}1)  nala${COLOR_RESET}"
                echo -e "${COLOR_BLUE}2)  eza${COLOR_RESET}"
                echo -e "${COLOR_BLUE}3)  colorls${COLOR_RESET}"
                echo -e "${COLOR_BLUE}4)  lsd${COLOR_RESET}"
                echo -e "${COLOR_BLUE}5)  bat${COLOR_RESET}"
                echo -e "${COLOR_BLUE}6)  lf${COLOR_RESET}"
                echo -e "${COLOR_BLUE}7)  fzf${COLOR_RESET}"
                echo -e "${COLOR_BLUE}8)  glow${COLOR_RESET}"
                echo -e "${COLOR_BLUE}9)  tmux${COLOR_RESET}"
                echo -e "${COLOR_BLUE}10) python${COLOR_RESET}"
                echo -e "${COLOR_BLUE}11) nodejs${COLOR_RESET}"
                echo -e "${COLOR_BLUE}12) nodejs-lts${COLOR_RESET}"
                echo -e "${COLOR_BLUE}13) micro${COLOR_RESET}"
                echo -e "${COLOR_BLUE}14) vim${COLOR_RESET}"
                echo -e "${COLOR_BLUE}15) neovim${COLOR_RESET}"
                echo -e "${COLOR_BLUE}16) lazygit${COLOR_RESET}"
                echo -e "${COLOR_BLUE}17) open-ssh${COLOR_RESET}"
                echo -e "${COLOR_BLUE}18) tsu${COLOR_RESET}"
                echo -e "${COLOR_BLUE}19) clang${COLOR_RESET}"
                echo -e "${COLOR_BLUE}20) cmake${COLOR_RESET}"
                echo -e "${COLOR_BLUE}21) make${COLOR_RESET}"
                echo "22) $(t MSG_ALL_INSTALL "Install all")"
                echo
                read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_PACKAGE_NUMBERS_PROMPT) " "${COLOR_INPUT}")" -i "1 2 5 6 7" PACKAGE_CHOICES
                tput sgr0
                tput cuu 26
                tput ed

                if [[ "$PACKAGE_CHOICES" == *"22"* ]]; then
                    PACKAGES=("${ALL_PKG_LIST[@]}")
                else
                    PACKAGES=()
                    for CHOICE in $PACKAGE_CHOICES; do
                        case $CHOICE in
                            1) PACKAGES+=("nala") ;;
                            2) PACKAGES+=("eza") ;;
                            3) PACKAGES+=("colorls") ;;
                            4) PACKAGES+=("lsd") ;;
                            5) PACKAGES+=("bat") ;;
                            6) PACKAGES+=("lf") ;;
                            7) PACKAGES+=("fzf") ;;
                            8) PACKAGES+=("glow") ;;
                            9) PACKAGES+=("tmux") ;;
                            10) PACKAGES+=("python") ;;
                            11) PACKAGES+=("nodejs") ;;
                            12) PACKAGES+=("nodejs-lts") ;;
                            13) PACKAGES+=("micro") ;;
                            14) PACKAGES+=("vim") ;;
                            15) PACKAGES+=("neovim") ;;
                            16) PACKAGES+=("lazygit") ;;
                            17) PACKAGES+=("open-ssh") ;;
                            18) PACKAGES+=("tsu") ;;
                            19) PACKAGES+=("clang") ;;
                            20) PACKAGES+=("cmake") ;;
                            21) PACKAGES+=("make") ;;
                        esac
                    done
                fi
            fi
        fi

        if [ ${#PACKAGES[@]} -gt 0 ]; then
            for PACKAGE in "${PACKAGES[@]}"; do
                execute_command "pkg install -y $PACKAGE" "$(t MSG_INSTALLATION_OF) $PACKAGE"

                # Add specific aliases after installation
                case $PACKAGE in
                    eza|bat|nala)
                        add_aliases_to_rc "$PACKAGE"
                        ;;
                esac
            done

            # Reload aliases to make them available immediately
            if [ -f "$OHMYTERMUX_CONFIG_DIR/aliases" ]; then
                source "$OHMYTERMUX_CONFIG_DIR/aliases"
            fi
        else
            echo -e "${COLOR_BLUE}$(t MSG_NO_PACKAGE_SELECTED)${COLOR_RESET}"
        fi
    fi
}

#------------------------------------------------------------------------------
# CONFIGURATION OF SPECIFIC ALIASES
#------------------------------------------------------------------------------
add_aliases_to_rc() {
    local PACKAGE=$1
    local ALIASES_FILE="$OHMYTERMUX_CONFIG_DIR/aliases"

    case $PACKAGE in
        eza)
            cat >> "$ALIASES_FILE" << 'EOL'
# Alias eza
alias l="eza --icons"
alias ls="eza -1 --icons"
alias ll="eza -lF -a --icons --total-size --no-permissions --no-time --no-user"
alias la="eza --icons -lgha --group-directories-first"
alias lt="eza --icons --tree"
alias lta="eza --icons --tree -lgha"
alias dir="eza -lF --icons"

EOL
            ;;
        bat)
            cat >> "$ALIASES_FILE" << 'EOL'
# Alias bat
alias cat="bat"

EOL
            ;;
        nala)
            cat >> "$ALIASES_FILE" << 'EOL'
# Alias nala
alias install="nala install -y"
alias uninstall="nala remove -y"
alias update="nala update"
alias upgrade="nala upgrade -y"
alias search="nala search"
alias list="nala list --upgradeable"
alias show="nala show"

EOL
            ;;
    esac
}

#------------------------------------------------------------------------------
# INSTALLATION OF AI TOOLS
#------------------------------------------------------------------------------
install_ai_tools() {
    if $AI_TOOLS_CHOICE; then
        title_msg "$(t MSG_CONFIG_AI_TOOLS "❯ Configuration of AI Tools")"

        # Define AI tools with their npm package names
        local -A AI_TOOL_PACKAGES=(
            ["Claude Code"]="@anthropic-ai/claude-code"
            ["Codex"]="@openai/codex"
            ["Amp"]="@sourcegraph/amp"
        )
        local AI_TOOL_NAMES=("Claude Code" "Codex" "Amp")
        local ALL_AI_LABEL
        ALL_AI_LABEL="$(t MSG_ALL_AI_TOOLS_INSTALL "Install all")"

        if $USE_GUM; then
            if $FULL_INSTALL; then
                AI_TOOLS=("${AI_TOOL_NAMES[@]}")
            else
                IFS=$'\n' read -r -d '' -a AI_TOOLS < <(gum choose --no-limit \
                    --selected.foreground="33" \
                    --header.foreground="33" \
                    --cursor.foreground="33" \
                    --height=5 \
                    --header="$(t MSG_SELECT_AI_TOOLS_GUM "Select AI tools to install:")" \
                    "Claude Code" "Codex" "Amp" \
                    "$ALL_AI_LABEL")

                if [[ " ${AI_TOOLS[*]} " == *" $ALL_AI_LABEL "* ]]; then
                    AI_TOOLS=("${AI_TOOL_NAMES[@]}")
                fi
            fi
        else
            # Text mode
            echo "$(t MSG_SELECT_AI_TOOLS_TEXT "Select AI tools to install (space-separated):")"
            echo
            echo -e "${COLOR_BLUE}1) Claude Code${COLOR_RESET}"
            echo -e "${COLOR_BLUE}2) Codex${COLOR_RESET}"
            echo -e "${COLOR_BLUE}3) Amp${COLOR_RESET}"
            echo "4) $ALL_AI_LABEL"
            echo
            read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_AI_TOOLS_NUMBERS_PROMPT "Enter AI tools numbers:" "${COLOR_INPUT}") ")" AI_TOOL_CHOICES
            tput sgr0
            tput cuu 9
            tput ed

            if [[ "$AI_TOOL_CHOICES" == *"4"* ]]; then
                AI_TOOLS=("${AI_TOOL_NAMES[@]}")
            else
                AI_TOOLS=()
                for CHOICE in $AI_TOOL_CHOICES; do
                    case $CHOICE in
                        1) AI_TOOLS+=("Claude Code") ;;
                        2) AI_TOOLS+=("Codex") ;;
                        3) AI_TOOLS+=("Amp") ;;
                    esac
                done
            fi
        fi

        # Install selected AI tools
        if [ ${#AI_TOOLS[@]} -gt 0 ]; then
            # Auto-install nodejs-lts if not already installed
            if ! command -v node &>/dev/null; then
                echo -e "${COLOR_BLUE}$(t MSG_AI_TOOLS_NODEJS_AUTO)${COLOR_RESET}"
                execute_command "pkg install -y nodejs-lts" "$(t MSG_INSTALLATION_OF) nodejs-lts"
            fi

            for TOOL in "${AI_TOOLS[@]}"; do
                local NPM_PACKAGE="${AI_TOOL_PACKAGES[$TOOL]}"
                execute_command "npm install -g $NPM_PACKAGE" "$(t MSG_INSTALLATION_OF) $TOOL"
            done
        else
            echo -e "${COLOR_BLUE}$(t MSG_NO_AI_TOOL_SELECTED)${COLOR_RESET}"
        fi
    fi
}

#------------------------------------------------------------------------------
# INSTALLATION OF THE FONT
#------------------------------------------------------------------------------
install_font() {
    if $FONT_CHOICE; then
        title_msg "$(t MSG_CONFIG_FONT)"
        if $USE_GUM; then
            FONT=$(gum_choose "$(t MSG_SELECT_FONT_GUM)" --height=13 --selected="Default font" "Default font" "CaskaydiaCove Nerd Font" "FiraMono Nerd Font" "JetBrainsMono Nerd Font" "Mononoki Nerd Font" "VictorMono Nerd Font" "RobotoMono Nerd Font" "DejaVuSansMono Nerd Font" "UbuntuMono Nerd Font" "AnonymousPro Nerd Font" "Terminus Nerd Font")
        else
            echo "$(t MSG_SELECT_FONT_TEXT)"
            echo
            echo -e "${COLOR_BLUE}1)  Default font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}2)  CaskaydiaCove Nerd Font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}3)  FiraCode Nerd Font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}4)  Hack Nerd Font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}5)  JetBrainsMono Nerd Font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}6)  Meslo Nerd Font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}7)  RobotoMono Nerd Font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}8)  SourceCodePro Nerd Font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}9)  UbuntuMono Nerd Font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}10) AnonymousPro Nerd Font${COLOR_RESET}"
            echo -e "${COLOR_BLUE}11) Terminus Nerd Font${COLOR_RESET}"
            echo
            read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_FONT_NUMBER) : " "${COLOR_INPUT}")" -i "1" CHOICE
            tput sgr0
            tput cuu 15
            tput ed
            case $CHOICE in
                1) FONT="Default font" ;;
                2) FONT="CaskaydiaCove Nerd Font" ;;
                3) FONT="FiraCode Nerd Font" ;;
                4) FONT="Hack Nerd Font" ;;
                5) FONT="JetBrainsMono Nerd Font" ;;
                6) FONT="Meslo Nerd Font" ;;
                7) FONT="RobotoMono Nerd Font" ;;
                8) FONT="SourceCodePro Nerd Font" ;;
                9) FONT="UbuntuMono Nerd Font" ;;
                10) FONT="AnonymousPro Nerd Font" ;;
                11) FONT="Terminus Nerd Font" ;;
                *) FONT="Default font" ;;
            esac
        fi

        case $FONT in
            "Default font")
                execute_command "curl -fLo \"$HOME/.termux/font.ttf\" 'https://github.com/romkatv/powerlevel10k-media/raw/master/MesloLGS%20NF%20Regular.ttf'" "$(t MSG_INSTALLATION_DEFAULT_FONT)"
                termux-reload-settings
                ;;
            *)
                FONT_URL="https://github.com/ryanoasis/nerd-fonts/raw/master/patched-fonts/${FONT// /}/Regular/complete/${FONT// /}%20Regular%20Nerd%20Font%20Complete%20Mono.ttf"
                execute_command "curl -L -o $HOME/.termux/font.ttf \"$FONT_URL\"" "$(t MSG_INSTALLATION_FONT) $FONT"
                termux-reload-settings
                ;;
        esac
    fi
}

#------------------------------------------------------------------------------
# INSTALLATION OF THE DESKTOP ENVIRONMENT
#------------------------------------------------------------------------------
install_desktop() {
    if $DESKTOP_CHOICE; then
        # If DESKTOP_ENV not set, prompt user to choose
        if [ -z "$DESKTOP_ENV" ]; then
            if $USE_GUM; then
                DESKTOP_ENV=$(gum_choose "$(t MSG_SELECT_DESKTOP)" --height=5 --selected="XFCE" "XFCE" "LXQt" "MATE")
                DESKTOP_ENV=$(echo "$DESKTOP_ENV" | tr '[:upper:]' '[:lower:]')
            else
                echo -e "${COLOR_BLUE}$(t MSG_SELECT_DESKTOP)${COLOR_RESET}"
                echo
                echo "1) $(t MSG_DESKTOP_XFCE)"
                echo "2) $(t MSG_DESKTOP_LXQT)"
                echo "3) $(t MSG_DESKTOP_MATE)"
                echo
                read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_123) : " "${COLOR_INPUT}")" -i "1" CHOICE
                tput sgr0
                tput cuu 7
                tput ed
                case $CHOICE in
                    1) DESKTOP_ENV="xfce" ;;
                    2) DESKTOP_ENV="lxqt" ;;
                    3) DESKTOP_ENV="mate" ;;
                    *) DESKTOP_ENV="xfce" ;;
                esac
            fi
        fi

        # Save the desktop session choice
        mkdir -p "$OHMYTERMUX_CONFIG_DIR"
        echo "DESKTOP_SESSION=$DESKTOP_ENV" > "$OHMYTERMUX_CONFIG_DIR/desktop.conf"

        case "$DESKTOP_ENV" in
            xfce) _install_xfce ;;
            lxqt) _install_lxqt ;;
            mate) _install_mate ;;
        esac
    fi
}

_install_xfce() {
    title_msg "$(t MSG_CONFIG_XFCE)"
    local XFCE_VERSION="recommended"
    local BROWSER_CHOICE="chromium"

    if ! $FULL_INSTALL; then
        if $USE_GUM; then
            if gum_confirm "$(t MSG_CONFIRM_INSTALL_XFCE)"; then
                XFCE_VERSION=$(gum_choose "$(t MSG_SELECT_XFCE_VERSION)" --height=5 --selected="recommended" \
                "minimal" \
                "recommended" \
                "customized")

                if [ "$XFCE_VERSION" != "minimal" ]; then
                    BROWSER_CHOICE=$(gum_choose "$(t MSG_SELECT_BROWSER)" --height=5 --selected="chromium" "chromium" "firefox" "none")
                fi
            else
                return
            fi
        else
            read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_INSTALL_XFCE) (O/n) : ")" -i "o" CHOICE
            if [[ "$CHOICE" =~ ^[oO]$ ]]; then
                echo -e "${COLOR_BLUE}$(t MSG_SELECT_XFCE_VERSION)${COLOR_RESET}"
                echo
                echo "$(t MSG_XFCE_MINIMAL)"
                echo "$(t MSG_XFCE_RECOMMENDED)"
                echo "$(t MSG_XFCE_CUSTOMIZED)"
                echo
                read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_123) : " "${COLOR_INPUT}")" -i "2" CHOICE
                tput sgr0
                tput cuu 7
                tput ed
                case $CHOICE in
                    1) XFCE_VERSION="minimal" ;;
                    2) XFCE_VERSION="recommended" ;;
                    3) XFCE_VERSION="customized" ;;
                    *) XFCE_VERSION="recommended" ;;
                esac

                if [ "$XFCE_VERSION" != "minimal" ]; then
                    echo -e "${COLOR_BLUE}$(t MSG_SELECT_BROWSER)${COLOR_RESET}"
                    echo
                    echo "$(t MSG_BROWSER_CHROMIUM)"
                    echo "$(t MSG_BROWSER_FIREFOX)"
                    echo "$(t MSG_BROWSER_NONE)"
                    echo
                    read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_BROWSER) " "${COLOR_INPUT}")" -i "1" CHOICE
                    tput sgr0
                    tput cuu 7
                    tput ed
                    case $CHOICE in
                        1) BROWSER_CHOICE="chromium" ;;
                        2) BROWSER_CHOICE="firefox" ;;
                        3) BROWSER_CHOICE="none" ;;
                        *) BROWSER_CHOICE="chromium" ;;
                    esac
                fi
            else
                return
            fi
        fi
    fi

    execute_command "pkg install ncurses-ui-libs && pkg uninstall dbus -y" "$(t MSG_INSTALL_DEPENDENCIES)"

    PACKAGES=('wget' 'x11-repo' 'tur-repo' 'pulseaudio')

    for PACKAGE in "${PACKAGES[@]}"; do
        execute_command "pkg install -y $PACKAGE" "$(t MSG_INSTALLATION_OF) $PACKAGE"
    done

    if $USE_GUM; then
        download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/xfce.sh" "XFCE" --gum --version="$XFCE_VERSION" --browser="$BROWSER_CHOICE"
    else
        download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/xfce.sh" "XFCE" --version="$XFCE_VERSION" --browser="$BROWSER_CHOICE"
    fi
}

_install_lxqt() {
    title_msg "$(t MSG_CONFIG_LXQT)"
    local LXQT_VERSION="recommended"
    local BROWSER_CHOICE="chromium"

    if ! $FULL_INSTALL; then
        if $USE_GUM; then
            if gum_confirm "$(t MSG_CONFIRM_INSTALL_LXQT)"; then
                LXQT_VERSION=$(gum_choose "$(t MSG_SELECT_LXQT_VERSION)" --height=4 --selected="recommended" \
                "minimal" \
                "recommended")

                if [ "$LXQT_VERSION" != "minimal" ]; then
                    BROWSER_CHOICE=$(gum_choose "$(t MSG_SELECT_BROWSER)" --height=5 --selected="chromium" "chromium" "firefox" "none")
                fi
            else
                return
            fi
        else
            read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_INSTALL_LXQT) (O/n) : ")" -i "o" CHOICE
            if [[ "$CHOICE" =~ ^[oO]$ ]]; then
                echo -e "${COLOR_BLUE}$(t MSG_SELECT_LXQT_VERSION)${COLOR_RESET}"
                echo
                echo "$(t MSG_LXQT_MINIMAL)"
                echo "$(t MSG_LXQT_RECOMMENDED)"
                echo
                read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_12) : " "${COLOR_INPUT}")" -i "2" CHOICE
                tput sgr0
                tput cuu 6
                tput ed
                case $CHOICE in
                    1) LXQT_VERSION="minimal" ;;
                    2) LXQT_VERSION="recommended" ;;
                    *) LXQT_VERSION="recommended" ;;
                esac

                if [ "$LXQT_VERSION" != "minimal" ]; then
                    echo -e "${COLOR_BLUE}$(t MSG_SELECT_BROWSER)${COLOR_RESET}"
                    echo
                    echo "$(t MSG_BROWSER_CHROMIUM)"
                    echo "$(t MSG_BROWSER_FIREFOX)"
                    echo "$(t MSG_BROWSER_NONE)"
                    echo
                    read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_BROWSER) " "${COLOR_INPUT}")" -i "1" CHOICE
                    tput sgr0
                    tput cuu 7
                    tput ed
                    case $CHOICE in
                        1) BROWSER_CHOICE="chromium" ;;
                        2) BROWSER_CHOICE="firefox" ;;
                        3) BROWSER_CHOICE="none" ;;
                        *) BROWSER_CHOICE="chromium" ;;
                    esac
                fi
            else
                return
            fi
        fi
    fi

    execute_command "pkg install ncurses-ui-libs && pkg uninstall dbus -y" "$(t MSG_INSTALL_DEPENDENCIES)"

    PACKAGES=('wget' 'x11-repo' 'tur-repo' 'pulseaudio')

    for PACKAGE in "${PACKAGES[@]}"; do
        execute_command "pkg install -y $PACKAGE" "$(t MSG_INSTALLATION_OF) $PACKAGE"
    done

    if $USE_GUM; then
        download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/lxqt.sh" "LXQt" --gum --version="$LXQT_VERSION" --browser="$BROWSER_CHOICE"
    else
        download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/lxqt.sh" "LXQt" --version="$LXQT_VERSION" --browser="$BROWSER_CHOICE"
    fi
}

#------------------------------------------------------------------------------
# INSTALLATION OF MATE
#------------------------------------------------------------------------------
_install_mate() {
    title_msg "$(t MSG_CONFIG_MATE)"
    local MATE_VERSION="recommended"
    local BROWSER_CHOICE="chromium"

    if ! $FULL_INSTALL; then
        if $USE_GUM; then
            if gum_confirm "$(t MSG_CONFIRM_INSTALL_MATE)"; then
                MATE_VERSION=$(gum_choose "$(t MSG_SELECT_MATE_VERSION)" --height=4 --selected="recommended" \
                "minimal" \
                "recommended")

                if [ "$MATE_VERSION" != "minimal" ]; then
                    BROWSER_CHOICE=$(gum_choose "$(t MSG_SELECT_BROWSER)" --height=5 --selected="chromium" "chromium" "firefox" "none")
                fi
            else
                return
            fi
        else
            read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_INSTALL_MATE) (O/n) : ")" -i "o" CHOICE
            if [[ "$CHOICE" =~ ^[oO]$ ]]; then
                echo -e "${COLOR_BLUE}$(t MSG_SELECT_MATE_VERSION)${COLOR_RESET}"
                echo
                echo "$(t MSG_MATE_MINIMAL)"
                echo "$(t MSG_MATE_RECOMMENDED)"
                echo
                read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_12) : " "${COLOR_INPUT}")" -i "2" CHOICE
                tput sgr0
                tput cuu 6
                tput ed
                case $CHOICE in
                    1) MATE_VERSION="minimal" ;;
                    2) MATE_VERSION="recommended" ;;
                    *) MATE_VERSION="recommended" ;;
                esac

                if [ "$MATE_VERSION" != "minimal" ]; then
                    echo -e "${COLOR_BLUE}$(t MSG_SELECT_BROWSER)${COLOR_RESET}"
                    echo
                    echo "$(t MSG_BROWSER_CHROMIUM)"
                    echo "$(t MSG_BROWSER_FIREFOX)"
                    echo "$(t MSG_BROWSER_NONE)"
                    echo
                    read -r -e -p "$(rl_prompt "${COLOR_GOLD}" "$(t MSG_ENTER_CHOICE_BROWSER) " "${COLOR_INPUT}")" -i "1" CHOICE
                    tput sgr0
                    tput cuu 7
                    tput ed
                    case $CHOICE in
                        1) BROWSER_CHOICE="chromium" ;;
                        2) BROWSER_CHOICE="firefox" ;;
                        3) BROWSER_CHOICE="none" ;;
                        *) BROWSER_CHOICE="chromium" ;;
                    esac
                fi
            else
                return
            fi
        fi
    fi

    execute_command "pkg install ncurses-ui-libs -y" "$(t MSG_INSTALL_DEPENDENCIES)"

    PACKAGES=('wget' 'x11-repo' 'tur-repo' 'pulseaudio')

    for PACKAGE in "${PACKAGES[@]}"; do
        execute_command "pkg install -y $PACKAGE" "$(t MSG_INSTALLATION_OF) $PACKAGE"
    done

    if $USE_GUM; then
        download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/mate.sh" "MATE" --gum --version="$MATE_VERSION" --browser="$BROWSER_CHOICE"
    else
        download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/mate.sh" "MATE" --version="$MATE_VERSION" --browser="$BROWSER_CHOICE"
    fi
}

#------------------------------------------------------------------------------
# INSTALLATION OF THE DESKTOP SCRIPTS
#------------------------------------------------------------------------------
install_desktop_scripts() {
    local de_name="XFCE"
    local msg_config_key="MSG_CONFIG_XFCE_SCRIPTS"

    # Read desktop config
    if [ -f "$OHMYTERMUX_CONFIG_DIR/desktop.conf" ]; then
        source "$OHMYTERMUX_CONFIG_DIR/desktop.conf"
    fi

    case "${DESKTOP_SESSION:-xfce}" in
        lxqt)
            de_name="LXQt"
            msg_config_key="MSG_CONFIG_LXQT_SCRIPTS"
            ;;
    esac

    title_msg "$(t "$msg_config_key")"

    # Installation of the start script
    cat <<EOF > start
#!/bin/bash

# Read desktop configuration
DESKTOP_SESSION="${DESKTOP_SESSION:-xfce}"

# Activate PulseAudio on the network
pulseaudio --start --load="module-native-protocol-tcp auth-ip-acl=127.0.0.1 auth-anonymous=1" --exit-idle-time=-1 > /dev/null 2>&1

XDG_RUNTIME_DIR=\${TMPDIR} termux-x11 :1.0 & > /dev/null 2>&1
sleep 1

am start --user 0 -n com.termux.x11/com.termux.x11.MainActivity > /dev/null 2>&1
sleep 1

MESA_NO_ERROR=1 MESA_GL_VERSION_OVERRIDE=4.3COMPAT MESA_GLES_VERSION_OVERRIDE=3.2 virgl_test_server_android --angle-gl & > /dev/null 2>&1

case "\$DESKTOP_SESSION" in
    lxqt)
        env DISPLAY=:1.0 GALLIUM_DRIVER=virpipe dbus-launch --exit-with-session startlxqt & > /dev/null 2>&1
        ;;
    *)
        env DISPLAY=:1.0 GALLIUM_DRIVER=virpipe dbus-launch --exit-with-session xfce4-session & > /dev/null 2>&1
        ;;
esac

# Set the audio server
export PULSE_SERVER=127.0.0.1 > /dev/null 2>&1

sleep 5

case "\$DESKTOP_SESSION" in
    xfce|"")
        process_id=\$(ps -aux | grep '[x]fce4-screensaver' | awk '{print \$2}')
        [ -n "\$process_id" ] && kill "\$process_id" > /dev/null 2>&1
        ;;
esac
EOF

    execute_command "chmod +x start && mv start $PREFIX/bin" "$(t MSG_INSTALL_START_SCRIPT)"

    # Installation of the stop script
    cat <<EOF > "$PREFIX/bin/kill_termux_x11"
#!/bin/bash

# Read desktop configuration
CONFIG_FILE="$OHMYTERMUX_CONFIG_DIR/desktop.conf"
DESKTOP_SESSION="xfce"
[ -f "\$CONFIG_FILE" ] && source "\$CONFIG_FILE"

# Check the execution of the processes in Termux or Proot
if pgrep -f 'apt|apt-get|dpkg|nala' > /dev/null; then
    zenity --info --text="A software is being installed in Termux or Proot. Please wait for these processes to finish before continuing."
    exit 1
fi

# Get the identifiers of the Termux-X11 and DE processes
termux_x11_pid=\$(pgrep -f /system/bin/app_process.*com.termux.x11.Loader)

case "\$DESKTOP_SESSION" in
    lxqt)
        de_pid=\$(pgrep -f "lxqt-session")
        de_name="LXQt"
        ;;
    *)
        de_pid=\$(pgrep -f "xfce4-session")
        de_name="XFCE"
        ;;
esac

# Stop the processes only if they exist
if [ -n "\$termux_x11_pid" ]; then
    kill -9 "\$termux_x11_pid" 2>/dev/null
fi

if [ -n "\$de_pid" ]; then
    kill -9 "\$de_pid" 2>/dev/null
fi

# Display dynamic message
if [ -n "\$termux_x11_pid" ] || [ -n "\$de_pid" ]; then
    zenity --info --text="Termux-X11 and \$de_name sessions closed."
else
    zenity --info --text="Termux-X11 or \$de_name session not found."
fi

# Stop the Termux application only if the PID exists
info_output=\$(termux-info)
if pid=\$(echo "\$info_output" | grep -o 'TERMUX_APP_PID=[0-9]\+' | awk -F= '{print \$2}') && [ -n "\$pid" ]; then
    kill "\$pid" 2>/dev/null
fi

exit 0
EOF

    execute_command "chmod +x $PREFIX/bin/kill_termux_x11" "$(t MSG_INSTALL_STOP_SCRIPT)"

    # Creation of the shortcut
    mkdir -p "$PREFIX/share/applications"
    cat <<'EOF' > "$PREFIX/share/applications/kill_termux_x11.desktop"
[Desktop Entry]
Version=1.0
Type=Application
Name=Stop
Comment=
Exec=kill_termux_x11
Icon=shutdown
Categories=System;
Path=
StartupNotify=false
EOF

    execute_command "chmod +x $PREFIX/share/applications/kill_termux_x11.desktop" "$(t MSG_CREATE_SHORTCUT)"
}

#------------------------------------------------------------------------------
# INSTALLATION DE DEBIAN PROOT
#------------------------------------------------------------------------------
install_proot() {
    if $PROOT_CHOICE; then
        title_msg "$(t MSG_CONFIG_PROOT)"

        execute_command "curl -O $OHMYTERMUX_REPO_URL/$BRANCH/proot.sh" "$(t MSG_DOWNLOAD_PROOT_SCRIPT)" || error_msg "$(t MSG_ERROR_DOWNLOAD_PROOT)"
        execute_command "chmod +x proot.sh" "$(t MSG_EXECUTE_PROOT_SCRIPT)"

        # If the identifiers are already provided
        if [ -n "$PROOT_USERNAME" ] && [ -n "$PROOT_PASSWORD" ]; then
            if $USE_GUM; then
                execute_command "pkg install proot-distro -y" "$(t MSG_INSTALL_PROOT_DISTRO)"
                download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/proot.sh" "PRoot" --gum --username="$PROOT_USERNAME" --password="$PROOT_PASSWORD"
                install_utils
            else
                execute_command "pkg install proot-distro -y" "$(t MSG_INSTALL_PROOT_DISTRO)"
                download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/proot.sh" "PRoot" --username="$PROOT_USERNAME" --password="$PROOT_PASSWORD"
                install_utils
            fi
        else
            if $USE_GUM; then
                if gum_confirm "$(t MSG_CONFIRM_INSTALL_PROOT)"; then
                    execute_command "pkg install proot-distro -y" "$(t MSG_INSTALL_PROOT_DISTRO)"
                    download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/proot.sh" "PRoot" --gum
                    install_utils
                fi
            else
                read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_INSTALL_PROOT) (O/n) : ")" -i "o" CHOICE
                tput cuu1
                tput el
                if [[ "$CHOICE" =~ ^[oO]$ ]]; then
                    execute_command "pkg install proot-distro -y" "$(t MSG_INSTALL_PROOT_DISTRO)"
                    ./proot.sh
                    install_utils
                fi
            fi
        fi
    fi
}

#------------------------------------------------------------------------------
# GETTING THE USERNAME
#------------------------------------------------------------------------------
get_username() {
    local USER_DIR="$PROOT_DEBIAN_ROOT/home"
    local USERNAME
    USERNAME=$(ls -1 "$USER_DIR" 2>/dev/null | grep -v '^$' | head -n 1)
    if [ -z "$USERNAME" ]; then
        echo "$(t MSG_ERROR_NO_USER_FOUND)" >&2
        return 1
    fi
    echo "$USERNAME"
}

#------------------------------------------------------------------------------
# INSTALLATION OF THE UTILITIES
#------------------------------------------------------------------------------
install_utils() {
    title_msg "$(t MSG_CONFIG_UTILS)"
    download_and_execute "$OHMYTERMUX_REPO_URL/$BRANCH/utils.sh" "Utils"

    if ! USERNAME=$(get_username); then
        error_msg "$(t MSG_ERROR_GET_USERNAME)"
        return 1
    fi

    BASHRC_PROOT="${PREFIX}/var/lib/proot-distro/installed-rootfs/debian/home/${USERNAME}/.bashrc"
    if [ ! -f "$BASHRC_PROOT" ]; then
        error_msg "$(t MSG_ERROR_BASHRC_NOT_EXISTS) $USERNAME."
        execute_command "proot-distro login debian --shared-tmp --env DISPLAY=:1.0 -- touch \"$BASHRC_PROOT\"" "$(t MSG_CONFIG_BASH_DEBIAN)"
    fi

    cat << "EOL" >> "$BASHRC_PROOT"

export DISPLAY=:1.0

alias zink="MESA_LOADER_DRIVER_OVERRIDE=zink TU_DEBUG=noconform"
alias hud="GALLIUM_HUD=fps"
alias ..="cd .."
alias l="ls -CF"
alias ll="ls -l"
alias la="ls -A"
alias q="exit"
alias s="source"
alias c="clear"
alias cat="bat"
alias apt="sudo nala"
alias install="sudo nala install -y"
alias update="sudo nala update"
alias upgrade="sudo nala upgrade -y"
alias remove="sudo nala remove -y"
alias list="nala list --upgradeable"
alias show="nala show"
alias search="nala search"
alias start='echo "Please run from Termux and not Debian proot."'
alias cm="chmod +x"
alias clone="git clone"
alias push="git pull && git add . && git commit -m 'mobile push' && git push"
alias g="git"
alias n="nano"
alias bashrc="nano \$HOME/.bashrc"
EOL

    USERNAME=$(get_username)

    TMP_FILE="${TMPDIR}/rc_content"
    touch "$TMP_FILE"

    cat << EOL >> "$TMP_FILE"

# Alias to connect to Debian Proot
alias debian="proot-distro login debian --shared-tmp --user ${USERNAME}"
EOL

    if [ -f "$BASHRC" ]; then
        cat "$TMP_FILE" >> "$BASHRC"
        success_msg "$(t MSG_CONFIG_BASH_TERMUX)"
    else
        touch "$BASHRC"
        cat "$TMP_FILE" >> "$BASHRC"
        success_msg "$(t MSG_CREATE_CONFIG_BASH_TERMUX)"
    fi
    if [ -f "$ZSHRC" ]; then
        cat "$TMP_FILE" >> "$ZSHRC"
        success_msg "$(t MSG_CONFIG_ZSH_TERMUX)"
    else
        touch "$ZSHRC"
        cat "$TMP_FILE" >> "$ZSHRC"
        success_msg "$(t MSG_CREATE_CONFIG_ZSH_TERMUX)"
    fi
    rm "$TMP_FILE"
}

#------------------------------------------------------------------------------
# INSTALLATION OF TERMUX-X11
#------------------------------------------------------------------------------
install_termux_x11() {
    if $X11_CHOICE; then
        title_msg "$(t MSG_CONFIG_TERMUX_X11)"
        local FILE_PATH="$HOME/.termux/termux.properties"

        if [ ! -f "$FILE_PATH" ]; then
            mkdir -p "$HOME/.termux"
            cat <<EOL > "$FILE_PATH"
allow-external-apps = true
EOL
        else
            sed -i 's/^# allow-external-apps = true/allow-external-apps = true/' "$FILE_PATH"
        fi
    fi

    local INSTALL_X11=false

    if $X11_CHOICE; then
        if $USE_GUM; then
            if gum_confirm "$(t MSG_CONFIRM_INSTALL_TERMUX_X11)"; then
                INSTALL_X11=true
            fi
        else
            read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_INSTALL_TERMUX_X11) (O/n) : ")" -i "n" choice
            tput cuu1
            tput el
            if [[ "$choice" =~ ^[oO]$ ]]; then
                INSTALL_X11=true
            fi
        fi

        if $INSTALL_X11; then
            local APK_URL="https://github.com/termux/termux-x11/releases/download/nightly/app-arm64-v8a-debug.apk"
            local APK_FILE="$HOME/storage/downloads/termux-x11.apk"

            execute_command "wget \"$APK_URL\" -O \"$APK_FILE\"" "$(t MSG_DOWNLOAD_TERMUX_X11)"

            if [ -f "$APK_FILE" ]; then
                termux-open "$APK_FILE"
                echo -e "${COLOR_BLUE}$(t MSG_INSTALL_APK_MANUALLY)${COLOR_RESET}"
                echo -e "${COLOR_BLUE}$(t MSG_INSTALL_COMPLETE_PRESS_ENTER)${COLOR_RESET}"
                read -r
                rm "$APK_FILE"
            else
                error_msg "$(t MSG_ERROR_TERMUX_X11_INSTALL)"
            fi
        fi
    fi
}

#------------------------------------------------------------------------------
# MAIN FUNCTION
#------------------------------------------------------------------------------

show_banner

# Checking and installing the necessary dependencies
# type -P ignores the ANSI fallback function defined in lib/colors.sh
if ! type -P tput &> /dev/null; then
    if $USE_GUM; then
        execute_command "pkg install -y ncurses-utils" "Installation of the dependencies"
    else
        info_msg "Installation of the dependencies"
        pkg install -y ncurses-utils >/dev/null 2>&1
    fi
    # Drop the fallback as soon as the real binary is available
    type -P tput &> /dev/null && unset -f tput
fi

# Checking if specific arguments have been provided
type run_hook &>/dev/null && run_hook "pre_install"

if [ "$SHELL_CHOICE" = true ] || [ "$PACKAGES_CHOICE" = true ] || [ "$AI_TOOLS_CHOICE" = true ] || [ "$FONT_CHOICE" = true ] || [ "$DESKTOP_CHOICE" = true ] || [ "$PROOT_CHOICE" = true ] || [ "$X11_CHOICE" = true ]; then
    if $EXECUTE_INITIAL_CONFIG; then
        type run_hook &>/dev/null && run_hook "pre_initial_config"
        initial_config
        type run_hook &>/dev/null && run_hook "post_initial_config"
    fi
    if [ "$SHELL_CHOICE" = true ]; then
        type run_hook &>/dev/null && run_hook "pre_shell"
        install_shell
        type run_hook &>/dev/null && run_hook "post_shell"
    fi
    if [ "$PACKAGES_CHOICE" = true ]; then
        type run_hook &>/dev/null && run_hook "pre_packages"
        install_packages
        type run_hook &>/dev/null && run_hook "post_packages"
    fi
    if [ "$AI_TOOLS_CHOICE" = true ]; then
        install_ai_tools
    fi
    if [ "$FONT_CHOICE" = true ]; then
        type run_hook &>/dev/null && run_hook "pre_font"
        install_font
        type run_hook &>/dev/null && run_hook "post_font"
    fi
    if [ "$DESKTOP_CHOICE" = true ]; then
        type run_hook &>/dev/null && run_hook "pre_xfce"
        install_desktop
        type run_hook &>/dev/null && run_hook "post_xfce"
    fi
    if [ "$DESKTOP_CHOICE" = true ] && [ "$PROOT_CHOICE" = false ]; then
        install_desktop_scripts
    fi
    if [ "$PROOT_CHOICE" = true ]; then
        type run_hook &>/dev/null && run_hook "pre_proot"
        install_proot
        type run_hook &>/dev/null && run_hook "post_proot"
    fi
    if [ "$X11_CHOICE" = true ]; then
        type run_hook &>/dev/null && run_hook "pre_x11"
        install_termux_x11
        type run_hook &>/dev/null && run_hook "post_x11"
    fi
else
    # Execute the complete installation if no specific argument is provided
    if $EXECUTE_INITIAL_CONFIG; then
        type run_hook &>/dev/null && run_hook "pre_initial_config"
        initial_config
        type run_hook &>/dev/null && run_hook "post_initial_config"
    fi
    type run_hook &>/dev/null && run_hook "pre_shell"
    install_shell
    type run_hook &>/dev/null && run_hook "post_shell"
    common_alias
    type run_hook &>/dev/null && run_hook "pre_packages"
    install_packages
    type run_hook &>/dev/null && run_hook "post_packages"
    install_ai_tools
    type run_hook &>/dev/null && run_hook "pre_font"
    install_font
    type run_hook &>/dev/null && run_hook "post_font"
    type run_hook &>/dev/null && run_hook "pre_xfce"
    install_desktop
    type run_hook &>/dev/null && run_hook "post_xfce"
    type run_hook &>/dev/null && run_hook "pre_proot"
    install_proot
    type run_hook &>/dev/null && run_hook "post_proot"
    type run_hook &>/dev/null && run_hook "pre_x11"
    install_termux_x11
    type run_hook &>/dev/null && run_hook "post_x11"
fi

# Execute all enabled plugins after core modules
type execute_all_plugins &>/dev/null && execute_all_plugins

type run_hook &>/dev/null && run_hook "post_install"

# Cleaning and end message
type run_hook &>/dev/null && run_hook "pre_cleanup"

title_msg "❯ Saving the installation scripts"
mkdir -p $OHMYTERMUX_CONFIG_DIR >/dev/null 2>&1
mv -f xfce.sh lxqt.sh proot.sh utils.sh install.sh $OHMYTERMUX_CONFIG_DIR/ >/dev/null 2>&1
rm -f xfce.sh lxqt.sh proot.sh utils.sh install.sh >/dev/null 2>&1

# Clean up downloaded i18n and lib files if they were downloaded during installation
if [ -d "$SCRIPT_DIR/i18n" ] && [ "$MESSAGES_LOADED" != "fallback" ]; then
    mv -f "$SCRIPT_DIR/i18n" "$OHMYTERMUX_CONFIG_DIR/" >/dev/null 2>&1
fi
if [ -d "$SCRIPT_DIR/lib" ]; then
    mv -f "$SCRIPT_DIR/lib" "$OHMYTERMUX_CONFIG_DIR/" >/dev/null 2>&1
fi

# Copy plugins to config directory
if [ -d "$SCRIPT_DIR/plugins" ]; then
    cp -rf "$SCRIPT_DIR/plugins" "$OHMYTERMUX_CONFIG_DIR/" >/dev/null 2>&1
fi

# Copy presets to config directory
if [ -d "$SCRIPT_DIR/presets" ]; then
    cp -rf "$SCRIPT_DIR/presets" "$OHMYTERMUX_CONFIG_DIR/" >/dev/null 2>&1
fi

type run_hook &>/dev/null && run_hook "post_cleanup"

# Rechargement du shell
if $USE_GUM; then
    if gum_confirm "Execute OhMyTermux ?"; then
        clear
        if [ "$SHELL_CHOICE" = "zsh" ]; then
            exec zsh -l
        else
            exec $SHELL_CHOICE
        fi
    else
        echo -e "${COLOR_BLUE}$(t MSG_TO_USE_ALL_FEATURES)${COLOR_RESET}"
        echo -e "${COLOR_BLUE}$(t MSG_ENTER_EXEC_ZSH)${COLOR_RESET}"
        echo -e "${COLOR_BLUE}$(t MSG_OR_RESTART_TERMUX)${COLOR_RESET}"
    fi
else
    read -r -e -p "$(rl_prompt "${COLOR_BLUE}" "$(t MSG_CONFIRM_EXECUTE_OHMYTERMUX) ")" -i "o" choice
    if [[ "$choice" =~ ^[oO]$ ]]; then
        clear
        if [ "$SHELL_CHOICE" = true ]; then
            exec zsh -l
        else
            exec $SHELL_CHOICE
        fi
    else
        tput cuu1
        tput el
        echo -e "${COLOR_BLUE}$(t MSG_TO_USE_ALL_FEATURES)${COLOR_RESET}"
        echo -e "${COLOR_BLUE}$(t MSG_ENTER_EXEC_ZSH)${COLOR_RESET}"
        echo -e "${COLOR_BLUE}$(t MSG_OR_RESTART_TERMUX)${COLOR_RESET}"
    fi
fi