#!/bin/bash

#####    ##### ##### #####
#
# Script de customisation d'une machine Debian/Buster
#
# on doir avoir dans /root/bin :
# → le theme gnome-shell-theme.gresource
# → la liste des paquets à installer : liste-applis-perso.txt
#
# version du 20190807
#
#####    ##### ##### #####

#####
# quelques variables
ladate=$(date +%Y%m%d%H%M%S)
gdm="$(cat /etc/X11/default-display-manager | cut -d / -f4)"
compte_rendu=/var/log/sambaedu/compte_rendu_post-install_${ladate}.txt



#####
# Les dépôts à utiliser
#
DEPOT_debian="deb.debian.org"
DEPOT_security="security.debian.org"
DEPOT_geogebra="www.geogebra.net/linux"
cle_geogebra="office@geogebra.org.gpg.key"
DEPOT_virtualbox="download.virtualbox.org"
cle_virtualbox="oracle_vbox_2016.asc"

#####
# script pour Debian/Buster
version="buster"

#####
# paramètres pour grub
#
fond_ecran_grub="desktop-grub.png"
nbre_secondes_simple_boot="3"
dem_grub="0"
mdp_grub="erty91"

#####
# quelques couleurs ;-)
#
rouge='\e[0;31m'
rose='\e[1;31m'
orange='\e[0;33m'
jaune='\e[1;33m'
vert='\e[0;32m'
bleu='\e[1;34m'
neutre='\e[0;m'


#####
# quelques infos sur la machine
# 
PROCESSEUR=$(lscpu | grep bit | grep 64 | cut -d" " -f6)    # détection du processeur 64 bits
ARCHITECTURE=$(uname -r | cut -d"-" -f3)                    # détection de l'architecture amd64
CARTE_RESEAU=$(lspci | grep -i ethernet | cut -d" " -f4)       # constructeur de la carte réseau
CARTE_WIFI=$(lspci | grep -i wireless | cut -d" " -f4) # constructeur de la carte wifi Qualcomm
# il faudrait quelque chose de mieux pour info carte graphique ; temporaire pour Realtek
CARTE_GRAPHIQUE=$(lspci | grep -i vga | cut -d" " -f5)         # détection de la carte graphique Realtek
CARTE_SON=$(lspci | grep -i audio | cut -d" " -f4 | sed q)
NOMCODE=$(lsb_release --codename | cut -f2)                # version de Debian

#####
# nom de la machine
#
NOMHOTE=$(hostname)

#####
# variable de sortie pour ne pas encombrer l'affichage
# >$sortie 2>&1
# 
#exec &> Sortie.log
sortie="/dev/null"

#=====
# Les fonctions
#=====

message_debut()
{
    # un message en début d'exécution du script
    #
    echo "Compte-rendu de customisation : $ladate" > $compte_rendu
    # message de début de script
    echo -e "" | tee -a $compte_rendu
    echo -e "##### #####"
    echo -e "Customisation de la machine ${bleu}$NOMHOTE${neutre}"
    echo "Customisation de la machine $NOMHOTE" >> $compte_rendu
    echo -e "##### #####" | tee -a $compte_rendu
}

repertoire_root_bin()
{
    # on se postionne dans le répertoire /root/bin/
    #
    if [ ! -e "/root/bin" ]
    then
        # il n'existe pas : on le crée
        echo -e ""
        echo -e "on crée le répertoire /root/bin" | tee -a $compte_rendu
        echo -e "" | tee -a $compte_rendu
        mkdir -p /root/bin
    fi
    cd /root/bin
}

test_version()
{
    # tester si on est sur la bonne version de Debian
    #
    if [ "$NOMCODE" != "$version" ]
    then
        echo -e "${rouge}"
        echo -e "vous n'êtes pas sur une Debian/$version !"
        echo -e "test de début de script"
        echo -e ""
        echo -e "${orange}arrêt du script…"
        echo -e "${bleu}==========${neutre}"
        echo -e ""
        exit 1
    fi
    echo -e ""
    echo -e "on est sur une Debian/$version" | tee -a $compte_rendu
}

verifier_aptget_update()
{
    # on vérifie la commande apt-get update
    #
    echo -e ""
    echo -e "0. Vérification de la commande apt-get update…" | tee -a $compte_rendu
    echo -e "${bleu}----- -----${neutre}" | tee -a $compte_rendu
    # on teste le bon déroulement de la commande apt-get update
    #
    if [ $(apt-get -q2 update | wc -l) -gt 0 ]
    then
        echo -e "${rouge}la commande apt-get update ne fonctionne pas !" | tee -a $compte_rendu
        echo -e ""
        echo -e "${orange}arrêt du script…" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}" | tee -a $compte_rendu
        exit 1
    fi
    echo -e "OK" | tee -a $compte_rendu
    sleep 3s
}

recharger_paquets()
{
    # on met à jour la liste des paquets depuis les dépôts
    #
    echo -e "on recharge la liste des paquets" | tee -a $compte_rendu
    echo -e "${bleu}==========${neutre}"
    apt-get -q2 update
    if [ "$?" != "0" ]
    then
        echo -e "${rouge}"
        echo -e "le rechargement de la liste des paquets ne s'est pas fait correctement" | tee -a $compte_rendu
        echo -e "${orange}arrêt du script !" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}" | tee -a $compte_rendu
        echo -e ""
        exit 1
    fi
}

installer_paquet()
{
    # installation d'un paquet
    # 1 paramètre
    # $1 → le nom du paquet à installer
    #
    paquet="$1"
    # on vérifie si le paquet est déjà installé
    if ! dpkg --get-selections | grep ^${paquet} | grep install | cut -f1 | grep -q ^${paquet}$
    then
        echo -e "${vert}on installe $paquet" | tee -a $compte_rendu
        echo -e "==========${neutre}" | tee -a $compte_rendu
        DEBIAN_FRONTEND=noninteractive apt-get -q2 install "$paquet" #>/dev/null #2>&1
        # on vérifie si l'installation s'est bien déroulée
        if [ "$?" != "0" ]
        then
            echo -e "${rouge}"
            echo -e "un problème a eu lieu lors de l'installation de $paquet" | tee -a $compte_rendu
            echo -e "==========${neutre}" | tee -a $compte_rendu
        fi
    else
        echo -e "${orange}$paquet est déjà installé…" | tee -a $compte_rendu
        echo -e "==========${neutre}" | tee -a $compte_rendu
        return 1
    fi
}

remplacer_sources_list()
{
    # tester si le fichier /etc/apt/sources.list contient déjà ce qu'il faut
    # 
    # ancienne méthode : on récupère la fin de la 2ème ligne du fichier /etc/apt/sources.list
    # $test doit contenir $DEPOT_debian sinon, on modifie /etc/apt/sources.list
    #test=$(echo $(sed -n '2p' /etc/apt/sources.list) | rev | cut -d" " -f1 | rev)
    
    # on récupère la fin de l'avant-dernière ligne plutôt que la 2ème…
    test=$(tail -2 /etc/apt/sources.list | sed -e '$d' | rev | cut -d" " -f1 | rev)
    #
    # si la fin de l'avant-dernière ligne n'est pas $DEPOT_debian alors on sauvegarde le fichier et on l'écrase par le nouveau
    if [ "$test" != "$DEPOT_debian" ]
    then
        # on sauvegarde le fichier existant avec la date avant de l'écraser
        cp /etc/apt/sources.list /etc/apt/sources.list_sauve_$DATE
        echo -e "on remplace le fichier sources.list" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        cat > /etc/apt/sources.list << END
#############################################
## sources.list complet pour le dépot ${DEPOT_debian}
## 
## fichier /etc/apt/sources.list
###############################
### $version
deb http://${DEPOT_debian}/debian/ ${version} main contrib non-free

### ### $version-updates
deb http://${DEPOT_debian}/debian/ ${version}-updates main contrib non-free

### ### ### ### $version-backports
deb http://${DEPOT_debian}/debian/ ${version}-backports main contrib non-free

### ### ### ### ### $version security
deb http://${DEPOT_security}/debian-security ${version}/updates main contrib non-free

################################################
## Autres dépots : à ne pas mettre dans ce fichier (recommandation)
## créer un fichier spécifique nom_spécifique.list (un fichier par dépôt) dans /etc/apt/sources.list.d/

## fin du sources.list complet pour le dépot ${DEPOT_debian}
################################################
END
        recharger_paquets
    else
        echo -e "${orange}fichier sources.list conforme${neutre}" | tee -a $compte_rendu
        echo -e "${orange}==========${neutre}" | tee -a $compte_rendu
    fi
}

cles_depots_debian()
{
    # Installation des clefs des dépots si elle ne sont pas installées
    # clés pour debian-keyring
    # est-ce utile ?
    #
    installer_paquet debian-keyring
    if [ "$?" = "0" ]
    then
        recharger_paquets
    fi
}

sources_list()
{
    # Mise en place d'un fichier sources.list complet
    #
    # On lance la mise en place du fichier sources.list
    echo -e ""
    echo -e "1. Configuration des dépôts avec le fichier sources.list" | tee -a $compte_rendu
    echo -e "${bleu}----- -----${neutre}"
    remplacer_sources_list
    #cles_depots_debian ← est-ce utile ?
    echo -e "${jaune}pour ajouter d'autres dépôts," | tee -a $compte_rendu
    echo -e "créer un fichier spécifique nom_spécifique.list (un fichier par dépôt)" | tee -a $compte_rendu
    echo -e "dans le répertoire /etc/apt/sources.list.d/${neutre}" | tee -a $compte_rendu
}

mise_a_jour()
{
    # mise à jour des paquets avec les nouveaux dépôts
    #
    echo -e "mise à jour des paquets" | tee -a $compte_rendu
    echo -e "${bleu}==========${neutre}"
    apt-get -q2 -y upgrade #>$sortie # on met à jour les paquets installés
    if [ "$?" != "0" ]
    then
        echo -e ""
        echo -e "${rouge}un problème a eu lieu lors de la mise à jour des paquets" | tee -a $compte_rendu
        echo -e ""
        echo -e "${orange}Arrêt du script !" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}" | tee -a $compte_rendu
        exit 1
    else
        echo -e "OK" | tee -a $compte_rendu
    fi
    sleep 3s
}

temporisation_grub()
{
    # Pour temporiser le lancement du système d'exploitation avec un nombre de secondes
    # la variable nbre_secondes est le nombre de secondes (paramètre du script)
    # s'il n'y a pas la ligne GRUB_TIMEOUT=$nbre_secondes
    # alors on remplace la ligne contenant GRUB_TIMEOUT par GRUB_TIMEOUT=$nbre_secondes
    #
    # on recherche GRUB_TIMEOUT et si on a bien $nbre_secondes
    # si c'est le cas, $test1 n'est pas vide et contient GRUB_TIMEOUT=$nbre_secondes
    test_timeout=$(grep "GRUB_TIMEOUT" "/etc/default/grub" | grep "$nbre_secondes")
    #
    # si $test_timeout est vide, on remplace la ligne par GRUB_TIMEOUT=$nbre_secondes
    if [ -z "$test_timeout" ]
    then
        # on sauvegarde éventuellement le fichier /etc/default/grub avant de le modifier
        if [ "$date" = "" ]
        then
            cp /etc/default/grub /etc/default/grub_sauve_$DATE
            date="1"
        fi
        # on remplace la ligne contenant GRUB_TIMEOUT par GRUB_TIMEOUT=$nbre_secondes
        echo -e "temporisation de $nbre_secondes secondes pour grub" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        sed -i '/GRUB_TIMEOUT/ s/.*/GRUB_TIMEOUT='"$nbre_secondes"'/' /etc/default/grub
        test_grub="grub"    # demande de lancement de update-grub puisque changement
    fi
}

supprimer_entree_secours()
{
    # Pour supprimer l'entrée de secours
    # si la ligne GRUB_DISABLE_RECOVERY n'est pas décommentée
    # alors on supprime le signe # au début de cette ligne
    #
    # on recherche la ligne commençant par #GRUB_DISABLE_RECOVERY
    # si c'est le cas, $test2 n'est pas vide et contient #GRUB_DISABLE_RECOVERY="true"
    test_recovery=$(grep "^#GRUB_DISABLE_RECOVERY" "/etc/default/grub")
    #
    # si la ligne est commentée, $test_recovery n'est pas vide et on la décommente
    if [ -n "$test_recovery" ]
    then
        # on sauvegarde éventuellement le fichier /etc/default/grub avant de le modifier
        if [ "$date" = "" ]
        then
            cp /etc/default/grub /etc/default/grub_sauve_$DATE
            date="1"
        fi
        # décommenter la ligne #GRUB_DISABLE_RECOVERY="true"
        echo -e "suppression de l'entrée de secours dans grub" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        sed -i '/GRUB_DISABLE_RECOVERY/ s/^#//' /etc/default/grub
        test_grub="grub"    # demande de lancement de update-grub puisque changement
    fi
}

SE_defaut()
{
    # Pour choisir le système à lancer au démarrage si cela est nécessaire
    # la variable DEM est le numéro de l'entrée à lancer (à modifier si nécessaire)
    # en principe, DEM = 0 pour Debian $version et DEM = 2 pour Windows (à adapter sinon)
    #
    # on recherche la ligne GRUB_DEFAULT et si elle contient ${dem_grub}
    # si c'est le cas, $test_default n'est pas vide et contient GRUB_DEFAULT=${dem_grub}
    test_default=$(grep "GRUB_DEFAULT" "/etc/default/grub" | grep "${dem_grub}")
    #
    # si $test_default est vide, on remplace la ligne car elle ne contient pas GRUB_DEFAULT=${dem_grub}
    if [ -z "$test_default" ]
    then
        # on sauvegarde éventuellement le fichier /etc/default/grub avant de le modifier
        if [ "$date" = "" ]
        then
            cp /etc/default/grub /etc/default/grub_sauve_$DATE
            date="1"
        fi
        # on remplace la ligne contenant GRUB_DEFAULT par GRUB_DEFAULT=${dem_grub}
        echo -e "choix du système d'exploitation lancé par défaut" | tee -a $compte_rendu
        echo -e "c'est Debian/$version" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        sed -i '/GRUB_DEFAULT/ s/.*/GRUB_DEFAULT='"${dem_grub}"'/' /etc/default/grub
        test_grub="grub"    # demande de lancement de update-grub puisque changement
    fi
}

hash_grub_pwd()
{
    # Fonction qui permet d'obtenir le hachage version Grub2 d'un mot de passe donné.
    # La fonction prend un argument qui est le mot de passe en question.
    #
    { echo "$1"; echo "$1"; }                                          \
        | LC_ALL=C grub-mkpasswd-pbkdf2 -c 30 -l 30 -s 30 2>>"$sortie" \
        | grep 'PBKDF2'                                                \
        | sed 's/^.* is //'
}

gestion_mdp_grub()
{
    # gestion du mot de passe pour accéder à l'éditeur Grub
    #
    # Dans le fichier /etc/grub.d/40_custom,
    # on ajoute 2 lignes : admin et son mdp
    # sauf si cela a déjà été fait
    pattern="set superusers"
    if ! grep -q -- "$pattern" /etc/grub.d/40_custom
    then
        echo -e "on ajoute un identifiant/mot_de_passe pour Grub" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        printf 'set superusers="admin"\n' >>/etc/grub.d/40_custom
        test_grub="grub"    # demande de lancement de update-grub puisque changement
        fi
    fi
    pattern="password_pbkdf2"
    if ! grep -q -- "$pattern" /etc/grub.d/40_custom
    then
        hached_grub_pwd=$(hash_grub_pwd "$mdp_grub")
        printf 'password_pbkdf2 admin %s\n' "$hached_grub_pwd" >>/etc/grub.d/40_custom
        test_grub="grub"    # demande de lancement de update-grub puisque changement
    fi
    # les droits restreints à root
    chmod 750 /etc/grub.d/40_custom
    #
    # Dans le fichier /etc/grub.d/10_linux, il faut chercher une ligne
    # spécifique qui va générer les entrées de boot Grub dite "simples"
    # (typiquement l'entrée de boot par défaut qui va lancer Jessie).
    # Au niveau de cette ligne, il faudra ajouter « --unrestricted ».
    # En effet, sans cela, par défaut avec seulement le compte "admin"
    # créé, aucun boot ne sera possible sans les identifiants du compte
    # admin (par exemple si on laisse le compteur de temps défiler, Grub
    # lancera le boot par défaut mais il demandera des identifiants pour
    # autoriser le boot ce qui n'est franchement pas pratique).
    # Si, au niveau de la ligne, l'option est déjà présente alors
    # on ne modifie pas le fichier. Sinon on le modifie.
    pattern="'gnulinux-simple-\$boot_device_id'"
    if ! grep -- "$pattern" /etc/grub.d/10_linux | grep -q -- '--unrestricted'
    then
        # Ajout de l'option « --unrestricted ».
        sed -i "s/$pattern/& --unrestricted/" /etc/grub.d/10_linux
        test_grub="grub"    # demande de lancement de update-grub puisque changement
    fi
    #
    # Dans le cas d'un double-boot,
    # on fait de même dans le fichier /etc/grub.d/30_os-prober
    # et cela pour tous les systèmes présents
    pattern="\"\${DEVICE}\")'"
    if ! grep -- "$pattern" /etc/grub.d/30_os-prober | grep -q -- '--unrestricted'
    then
        # Ajout de l'option « --unrestricted ».
        sed -i "s/$pattern/& --unrestricted/" /etc/grub.d/30_os-prober
        test_grub="grub"    # demande de lancement de update-grub puisque changement
    fi
    # y compris les systèmes GNU/Linux
    pattern="'osprober-gnulinux-simple-\$boot_device_id'"
    if ! grep -- "$pattern" /etc/grub.d/30_os-prober | grep -q -- '--unrestricted'
    then
        # Ajout de l'option « --unrestricted ».
        sed -i "s/$pattern/& --unrestricted/" /etc/grub.d/30_os-prober
        test_grub="grub"    # demande de lancement de update-grub puisque changement
    fi
}

gerer_fond_ecran_grub()
{
    # Pour une image de fond d'écran pour grub
    # cette image doit se trouver dans le répertoire /root/bin
    # copier l'image desktop-grub.png dans le répertoire /usr/share/images/desktop-base/
    # puis décommenter la ligne #GRUB_GFXMODE=640x480 du fichier /etc/default/grub
    # changer 640x480 en 1024x768 (par exemple) → à faire évoluer ?
    #
    chemin_background="/usr/share/images/desktop-base"
    image_grub="desktop-grub.png"
    image_grub_root="/root/bin/$image_grub"
    image_presente="$chemin_background/$image_grub"
    #
    # on teste la présence de l'image $image_grub_root
    if [ ! -e $image_grub_root ]
    then
        # l'image n'est pas dans /root/bin/
        echo -e "${jaune}pas de fichier $image_grub_root dans /root/bin/" | tee -a $compte_rendu
        echo -e "le fond d'écran pour grub n'est pas mis en place" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}" | tee -a $compte_rendu
        test_image="image"
        return 1
    else
        # l'image desktop-grub.png est dans /root/bin/
        # et il devrait y en avoir une dans /usr/share/images/desktop-base
        # on compare les 2 images : identiques → 0, différentes → 1, autre → >1
        cmp $image_presente $image_grub_root 1>/dev/null 2>&1; comparaison=$?
        # on teste, dans le fichier /etc/default/grub,
        # si la ligne contenant GRUB_GFXMODE est commentée
        # recherche de la ligne commençant par #GRUB_GFXMODE=640x480
        # si elle existe, test_gfxmode ne sera pas vide et contiendra #GRUB_GFXMODE=640x480 par exemple
        test_gfxmode=$(grep "^#GRUB_GFXMODE=" "/etc/default/grub")
    fi
    if [ "$comparaison" -ne "0" -o -n "$test_gfxmode" ]
    then
        # cas possibles : image pas en place ou/et ligne commentée
        echo -e "mise en place du fond d'écran pour grub" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        if [ $comparaison -ne 0 ]
        then
            # copier l'image desktop-grub.png dans le répertoire /usr/share/images/desktop-base/
            # on met en place l'image
            cp $image_grub_root $chemin_background/
            echo -e "mise en place de l'image" | tee -a $compte_rendu
        fi
        if [ -n "$test_gfxmode" ]
        then
            # décommenter #GRUB_GFXMODE= dans le fichier /etc/default/grub
            sed -i '/GRUB_GFXMODE=/ s/^#//' /etc/default/grub
            # changer 640x480 en 1024x768 ← à modifier ?
            sed -i '/GRUB_GFXMODE=/ s/GRUB_GFXMODE=.*/GRUB_GFXMODE=1024x768/' /etc/default/grub
            echo -e "Paramétrage de grub" | tee -a $compte_rendu
        fi
        test_grub="grub"    # demande de lancement de update-grub puisque changement
    else
        echo -e "Grub est bien configuré" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
    fi
    
    # autre solution ? → stade ébauche, non testée
    # mettre une image grub_background.png dans /usr/share/images/desktop-base/
    # à rajouter dans le fichier /etc/default/grub la ligne suivante :
    #GRUB_BACKGROUND=/usr/share/images/desktop-base/grub_background.png
    #test_grub="grub"    # demande de lancement de update-grub puisque changement
}

recharger_grub()
{
    # Pour charger les nouveaux paramètres de grub s'il y a eu des changements
    #
    if [ "$test_grub" = "grub" ]
    then
        echo -e "on recharge la configuration du Grub" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        update-grub # on recharge la configuration de grub si elle a changé
    else
        echo -e "${orange}paramétrage de grub conforme${neutre}" | tee -a $compte_rendu
        echo -e "${orange}==========${neutre}" | tee -a $compte_rendu
    fi
}

gestion_grub()
{
    # Le grub sans entrée de secours avec temporisation
    # → 3s pour les simple-boot
    #
    echo -e ""
    echo -e "2. Paramétrage de Grub" | tee -a $compte_rendu
    echo -e "${bleu}----- -----${neutre}" | tee -a $compte_rendu
    nbre_secondes="$nbre_secondes_simple_boot"
    temporisation_grub
    supprimer_entree_secours
    SE_defaut
    # les 2 fonctions commentées ci-dessous n'ont pas été vérifiées pour buster [TODO]
    #gestion_mdp_grub
    #gerer_fond_ecran_grub
    recharger_grub
    sleep 3s
}

pilote_carte_reseau()
{
    # Mise en place du pilote en fonction de la carte réseau
    #
    echo -e ""
    echo -e "la carte réseau est une $CARTE_RESEAU" | tee -a $compte_rendu
    echo -e "${bleu}==========${neutre}" | tee -a $compte_rendu
    case "$CARTE_RESEAU" in
        Realtek)
            installer_paquet firmware-realtek
        ;;
        *)
            echo -e "${jaune}gestion non prise en compte"| tee -a $compte_rendu
            echo -e "il faudra compléter le script si nécessaire" | tee -a $compte_rendu
            echo -e "mais il se peut que le paquet firmware-non-free soit suffisant${neutre}" | tee -a $compte_rendu
            echo -e "${orange}informations :" | tee -a $compte_rendu
            echo "$(lspci | grep -i ethernet)" | tee -a $compte_rendu
            echo -e "----- -----${neutre}" | tee -a $compte_rendu
        ;;
    esac
    # carte wifi ? (cas des portables…)
    if [ ! "$CARTE_WIFI" = "" ]
    then
        echo -e ""
        echo -e "il y a une carte wifi : $CARTE_WIFI" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        case "$CARTE_WIFI" in
            Qualcomm)
                # Qualcomm → Atheros
                installer_paquet firmware-atheros
            ;;
            *)
                echo -e "${jaune}gestion non prise en compte"| tee -a $compte_rendu
                echo -e "il faudra compléter le script si nécessaire" | tee -a $compte_rendu
                echo -e "mais il se peut que le paquet firmware-non-free soit suffisant${neutre}" | tee -a $compte_rendu
                echo -e "${orange}informations :" | tee -a $compte_rendu
                echo "$(lspci | grep -i wireless)" | tee -a $compte_rendu
                echo -e "----- -----${neutre}" | tee -a $compte_rendu
            ;;
        esac
    fi
}

pilote_carte_graphique()
{
    # gestion du pilote de la carte graphique
    #
    echo -e ""
    echo -e "la carte graphique est une $CARTE_GRAPHIQUE" | tee -a $compte_rendu
    echo -e "${bleu}==========${neutre}" | tee -a $compte_rendu
    case "$CARTE_GRAPHIQUE" in
        Intel)
            installer_paquet xserver-xorg-video-intel
        ;;
        *)
            echo -e "${jaune}gestion non prise en compte"| tee -a $compte_rendu
            echo -e "il faudra compléter le script si nécessaire" | tee -a $compte_rendu
            echo -e "mais il se peut que le paquet firmware-non-free soit suffisant${neutre}" | tee -a $compte_rendu
            echo -e "${orange}informations :" | tee -a $compte_rendu
            echo "$(lspci | grep -i vga)" | tee -a $compte_rendu
            echo -e "----- -----${neutre}"
        ;;
    esac
}

pilote_carte_son()
{
    # gestion du pilote de la carte son
    #
    echo -e ""
    echo -e "la carte son est une $CARTE_SON" | tee -a $compte_rendu
    echo -e "${bleu}==========${neutre}" | tee -a $compte_rendu
    case "$CARTE_SON" in
        Intel)
            installer_paquet firmware-intel-sound
            #apt-get -q2 install -t buster-backports firmware-intel-sound # utile ?
        ;;
        *)
            echo -e "${jaune}gestion non prise en compte"| tee -a $compte_rendu
            echo -e "il faudra compléter le script si nécessaire" | tee -a $compte_rendu
            echo -e "mais il se peut que le paquet firmware-non-free soit suffisant${neutre}" | tee -a $compte_rendu
            echo -e "${orange}informations :" | tee -a $compte_rendu
            echo "$(lspci | grep -i audio)" | tee -a $compte_rendu
            echo -e "----- -----${neutre}" | tee -a $compte_rendu
        ;;
    esac
}

installer_pilotes()
{
    # quelques pilotes pour le système
    #
    echo -e ""
    echo -e "3. Les pilotes système" | tee -a $compte_rendu
    echo -e "${bleu}==========${neutre}" | tee -a $compte_rendu
    # on installe les firmware linux, free et nonfree
    installer_paquet firmware-linux
    pilote_carte_reseau
    pilote_carte_graphique
    pilote_carte_son
    sleep 3s
}

installer_fond_ecran_gdm3()
{
    # L'écran de connexion selon les parcs de machines
    # depuis gnome 3.16, la configuration se fait dans le fichier binaire :
    # /usr/share/gnome-shell/gnome-shell-theme.gresource
    # ce fichier doit être préparé une bonne fois pour toute
    # et placé dans /root/bin
    #
    # script pour sa préparation à partir d'une image :
    # changer_ecran_connexion.sh
    #
    # on détermine le theme à installer à l'invite de connexion
    # on récupère le theme "gnome-shell-theme.gresource"
    # qui doit être placé dans /root/bin
    #
    gresource_fichier_usr=/usr/share/gnome-shell/gnome-shell-theme.gresource
    gresource_fichier_root=/root/bin/gnome-shell-theme.gresource
    if [ -e ${gresource_fichier_root} ]
    then
        echo -e "on installe le fond d'écran à l'invite de connexion" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        if [ ! -e "${gresource_fichier_usr}.initial" ]
        then
            # on sauvegarde le fichier avant de la modifier
            cp ${gresource_fichier_usr} ${gresource_fichier_usr}.initial
        fi
        cp ${gresource_fichier_root} ${gresource_fichier_usr}
        mv ${gresource_fichier_root} ${gresource_fichier_root}.save
    else
        if [ -e ${gresource_fichier_root}.save ]
        then
            echo -e "${orange}fond d'écran de connexion conforme${neutre}" | tee -a $compte_rendu
            echo -e "${orange}==========${neutre}" | tee -a $compte_rendu
        else
            # le theme n'est pas disponible dans /root/bin
            # on laisse donc le theme présent
            echo -e "le fichier ${jaune}${gresource_fichier_root}${neutre} n'est pas présent" | tee -a $compte_rendu
        fi
    fi
    sleep 3s
}

gestion_ecran_connexion()
{
    # gestion de l'écran de connexion selon le gestionnaire de connexion
    #
    echo -e ""
    echo -e "4. Paramétrage de l'écran de connexion" | tee -a $compte_rendu
    echo -e "${bleu}----- -----${neutre}" | tee -a $compte_rendu
    echo "le gestionnaire de connexion est ${bleu}${gdm}${neutre}"
    case ${gdm} in
        gdm3)
            installer_fond_ecran_gdm3
        ;;
        *)
            echo "${jaune}rien n'est prévu actuellement pour le fond d'écran…${neutre}"
        ;;
    esac
}

gestion_pave_numerique()
{
    # Activation du pavé numérique avant l'invite de connexion
    # ne fonctionne pas avec buster
    # est-ce dû au passage à Weyland au lieu de Xorg ?
    # ce qui fonctionne est l'activation du pavé numérique pour les consoles tty
    #
    # on installe le paquet numlockx ? [TODO]
    #installer_paquet numlockx
    # on met en place un script numlock
    cat > /usr/bin/numlock << END
#!/bin/bash
# Turn Numlock on for the TTYs:
INITTY=/dev/tty[1-6]
for tty in $INITTY
do
    /usr/bin/setleds -D +num < $tty
done
# activation de numlockx en position on
if [ -x /usr/bin/numlockx ]
then
    exec /usr/bin/numlockx on
fi
END
    # on le rend exécutable
    chmod +x /usr/bin/numlock
    # on met en place un service numlock.service pour le lancer au démarrage de la machine
    cat > /etc/systemd/system/numlock.service << END
[Unit]
Description=numlock

[Service]
Type=simple
ExecStart=/usr/bin/numlock
StandardInput=tty
RemainAfterExit=yes
Restart=on-failure
# Configures the time to wait before service is stopped forcefully.
TimeoutStopSec=300

[Install]
WantedBy=multi-user.target
END
    # activation pour le démarrage
    systemctl enable numlock.service
}

gerer_liste_applis()
{
    # gestion de la liste des paquets à installer_liste_paquets#
    # 1 argument
    # $1 → le fichier contenant la liste des paquets à installer
    #
    # le paquet tofrodos contient la commande fromdos
    # pour convertir les formats DOS au format UNIX
    # ce paquet est normalement déjà installé via le preseed
    # on vérifie que tofrodos est bien installé…
    installer_paquet tofrodos
    fromdos $1
    # on élimine les espaces en début de ligne et les commentaires
    liste_paquet=$(grep -Ev '^[[:space:]]*(#|$)' $1 | cut -d# -f1)
    test_liste=$(echo "$liste_paquet")
    if [ ! -z "$test_liste" ]
    then
        echo -e "${jaune}installation des paquets définis dans ${bleu}$1${neutre}" | tee -a $compte_rendu
        for i in $liste_paquet
        do
            installer_paquet $i
        done
     else
        echo -e "${rouge}pas de paquets à installer dans $1 ?${neutre}" | tee -a $compte_rendu
     fi
}

gestion_dvd()
{
    # pour la gestion des dvd, il faut installer le paquet libdvdcss2
    #
    echo -e ""
    # → installation du paquet libdvdcss2 dans les dépôts debian
    installer_paquet libdvdcss2:amd64
    # configuration du paquet libdvd-pkg
    DEBIAN_FRONTEND=noninteractive dpkg-reconfigure libdvd-pkg | tee -a $compte_rendu
}

cle_depot_geogebra()
{
    # on installe les clés du dépôt si elles ne sont pas installées
    #
    if [ -e /etc/apt/trusted.gpg ]
    then
        verification_cle=$(cat /etc/apt/trusted.gpg | grep -i geogebra)
    else
        verification_cle=""
    fi
    if [ -z "$verification_cle" ]
    then
        echo -e "installation des clefs du dépôt http://$DEPOT_geogebra/" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        wget -q --show-progress -O- http://$DEPOT_geogebra/$cle_geogebra | apt-key add -
        if [ "$?" != "0" ]
        then
            echo -e "l'installation des clefs du dépôt geogebra ne s'est pas fait correctement" | tee -a $compte_rendu
            #echo -e "${orange}Arrêt du script !"
            echo -e "${rouge}==========${neutre}"
            #exit 1
        fi
    else
        echo -e "${orange}clé $cle_geogebra déjà en place"
        echo -e "${orange}==========${neutre}"
    fi
}

gestion_depot_geogebra()
{
    # on met en place les dépots geogebra
    # dans le fichier /etc/apt/sources.list.d/geogebra.list
    #
    fichier_source=/etc/apt/sources.list.d/geogebra.list
    if [ ! -f ${fichier_source} ]
    then
        echo -e "mise en place du dépôt $DEPOT_geogebra" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        echo "deb http://$DEPOT_geogebra/ stable main" >> ${fichier_source}
        recharger_paquets
    else
        echo -e "${orange}dépôt $DEPOT_geogebra déjà en place" | tee -a $compte_rendu
        echo -e "==========${neutre}" | tee -a $compte_rendu
    fi
}

gestion_geogebra5()
{
    # gestion de l'installation de la version 5 de geogebra
    #
    echo -e ""
    # installation de la clé du dépôt
    cle_depot_geogebra
    # mise en place du source.list pour geogebra5
    gestion_depot_geogebra
    # on installe geogebra5 (géométrie dynamique en 3D)
    installer_paquet geogebra5
}

cle_depot_virtualbox()
{
    # on installe les clés du dépôt si elles ne sont pas installées
    #
    if [ -e /etc/apt/trusted.gpg ]
    then
        verification_cle=$(cat /etc/apt/trusted.gpg | grep -i virtualbox)
    else
        verification_cle=""
    fi
    if [ -z "$verification_cle" ]
    then
        echo -e "installation des clefs du dépôt http://$DEPOT_virtualbox/" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        wget -q --show-progress -O- http://$DEPOT_virtualbox/virtualbox/debian/$cle_virtualbox | apt-key add -
        if [ "$?" != "0" ]
        then
            echo -e "l'installation des clefs du dépôt virtualbox ne s'est pas fait correctement" | tee -a $compte_rendu
            #echo -e "${orange}Arrêt du script !"
            echo -e "${rouge}==========${neutre}"
            #exit 1
        fi
    else
        echo -e "${orange}clé $cle_virtualbox déjà en place" | tee -a $compte_rendu
        echo -e "${orange}==========${neutre}"
    fi
}

gestion_depot_virtualbox()
{
    # on met en place les dépots virtualbox
    # dans le fichier /etc/apt/sources.list.d/virtualbox.list
    #
    fichier_source=/etc/apt/sources.list.d/virtualbox.list
    if [ ! -f ${fichier_source} ]
    then
        echo -e "mise en place du dépôt $DEPOT_virtualbox" | tee -a $compte_rendu
        echo -e "${bleu}==========${neutre}"
        echo "deb http://$DEPOT_virtualbox/virtualbox/debian buster contrib non-free" >> ${fichier_source}
        recharger_paquets
    else
        echo -e "${orange}dépôt $DEPOT_virtualbox déjà en place" | tee -a $compte_rendu
        echo -e "==========${neutre}" | tee -a $compte_rendu
    fi
}

gestion_virtualbox()
{
    # gestion de l'installation de virtualbox
    #
    echo -e ""
    # installation de la clé du dépôt
    cle_depot_virtualbox
    # mise en place du source.list pour virtualbox
    gestion_depot_virtualbox
    # on installe virtualbox
    installer_paquet virtualbox-6.0
    #installer_paquet virtualbox-guest-additions-iso
}

message_fin_paquets()
{
    # on a fini :-)
    #
    echo -e ""
    echo -e "fin de l'installation des paquets" | tee -a $compte_rendu
    echo -e "${jaune}==========${neutre}" | tee -a $compte_rendu
}

installer_liste_paquets()
{
    # divers paquets à installer
    # dans la liste liste-applis-perso.txt
    #
    echo -e ""
    echo -e "5. Installation des paquets" | tee -a $compte_rendu
    echo -e "${bleu}----- -----${neutre}" | tee -a $compte_rendu
    # la liste des paquets à installer doit être disponible…
    if [ -e /root/bin/liste-applis-perso.txt ]
    then
        gerer_liste_applis /root/bin/liste-applis-perso.txt
    else
        # la liste n'est pas disponible
        echo -e "${orange}la liste des paquets à installer ${jaune}/root/bin/liste-applis-perso.txt${orange} n'est pas présente…${neutre}" | tee -a $compte_rendu
    fi
    gestion_dvd
    gestion_geogebra5
    gestion_virtualbox
    message_fin_paquets
    sleep 3s
}

nettoyage()
{
    # on supprime les paquets inutiles en archive
    #
    apt-get -q2 autoremove
    apt-get -q2 clean
}


redemarrage()
{
    # cas d'une utilisation après une installation automatique
    # à réviser pour se4 [TODO]
    #
    echo "redémarrage dans 5 s pour finaliser la post-installation" | tee -a $compte_rendu
    echo "------------------------------"
    echo -e "${neutre}" | tee -a $compte_rendu
    read -t 5 dummy
}

message_fin()
{
    # Fin du script : message final
    #
    cd ..
    echo -e ""
    echo -e "La customisation est terminée" | tee -a $compte_rendu
    echo -e "##### #####"
    echo -e ""
    # quelques infos sur la machine
    echo -e "${bleu}la carte graphique :${neutre} $CARTE_GRAPHIQUE ${bleu}"
    echo -e "la carte graphique : $CARTE_GRAPHIQUE" >> $compte_rendu
    echo -e "${bleu}la carte réseau :${neutre} $CARTE_RESEAU ${bleu}"
    echo -e "la carte réseau : $CARTE_RESEAU" >> $compte_rendu
    echo -e "${bleu}la carte wifi :${neutre} $CARTE_WIFI ${bleu}"
    echo -e "la carte wifi : $CARTE_WIFI" >> $compte_rendu
    echo -e "${bleu}la carte son :${neutre} ${CARTE_SON} ${bleu}"
    echo -e "la carte son : $CARTE_SON" >> $compte_rendu
    echo -e "${bleu}le processeur :${neutre} $PROCESSEUR ${bleu}"
    echo -e "le processeur : $PROCESSEUR" >> $compte_rendu
    echo -e "${bleu}l'architecture :${neutre} $ARCHITECTURE ${bleu}"
    echo -e "l'architecture : $ARCHITECTURE" >> $compte_rendu
    echo -e "pour mettre à jour : ${neutre}apt update && apt upgrade"
    echo -e "${neutre}"
    #echo -e "------------------------------"
    #echo -e ""
    #redemarrage
}

#####
# Début du programme de customisation
#
message_debut
repertoire_root_bin
test_version
verifier_aptget_update
sources_list
mise_a_jour
gestion_grub
installer_pilotes
gestion_ecran_connexion
gestion_pave_numerique
installer_liste_paquets
nettoyage
message_fin
#reboot
exit 0
#
# fin du programme de customisation
#####
