#!/bin/bash
DIR=/opt/grabber/
SUCCESS_LOG=/var/log/grabber/grabber-success.log
ERROR_LOG=/var/log/grabber/grabber-error.log
SUM="$DIR/summary.txt"

#lspci -nn > $DIR/lspci.cmd
#lsusb > $DIR/lsusb.cmd
#apt list --installed > $DIR/apt.cmd
#systemd-analyze > $DIR/systemd-analyze.cmd
#systemd-analyze blame | head -n 10 > $DIR/systemd-blame.cmd
#lscpu > $DIR/lscpu.cmd
#lshw-gtk > $DIR/lshw-gtk.cmd
#inxi > $DIR/inxi.cmd
#lsmem > $DIR/lsmem.cmd

HOSTNAME=$(hostname)
CPU=$(lscpu | grep 'Nom de modèle' | awk -F: '{print $2}' | xargs)
MEM=$(free -m | awk '/Mem:/ {print $2}')
OS=$(lsb_release -a |grep Description |cut -f2)
CPU_ID=$(sudo dmidecode -t processor |grep ID |cut -d: -f2)
RAM_SIZE=$(lsmem |grep "Mémoire partagée" |cut -d: -f2 |sed 's/\ //g')
RAM_GEN=$(sudo dmidecode -t memory |grep Type: |grep -v Unknown |tail -n1 |cut -d: -f2 |sed 's/\ //')
SIZES=$(lsblk -dnb | grep -v loop | grep -v boot | tr -s " " | cut -d' ' -f4)
MB_SERIAL=$(sudo dmidecode | grep -A 4 "Base Board" | tail -n1 | cut -d: -f2 | sed 's/\ //')
CPU_FREQUENCY_MIN=$(lscpu | grep MHz | cut -d: -f2 | sed -n '3p' | tr -s " " | sed 's/\ //' | cut -d, -f1)
CPU_FREQUENCY_CUR=$(sudo dmidecode | grep "MHz" | cut -d: -f2 | sed -n '3p' | sed 's/\ //')
CPU_FREQUENCY_MAX=$(sudo dmidecode | grep "MHz" | cut -d: -f2 | sed -n '2p' | sed 's/\ //')
GPU_MODEL=$(inxi | grep -o 'Radeon [^ ]* Graphics')
CHASSIS_SERIAL=$(sudo dmidecode | grep -A 5 "Chassis" | tail -n1 | cut -d: -f2 | sed 's/\ //')
CPU_CORES_NUMBER=$(inxi | grep core | cut -d' ' -f2 | sed 's/-core//')
CPU_THREADS_NUMBER=$(nproc)
RAM_NUMBER=$(sudo dmidecode --type memory | grep 'Rank' | wc -l)
RAM_SLOTS_NUMBER=$(sudo dmidecode --type memory | grep "Number Of Devices" | cut -d: -f2 | sed 's/\ //')
ARCH=$(uname -m)
DESKTOP=$XDG_CURRENT_DESKTOP
WM=$XDG_SESSION_TYPE
KERNEL=$(uname -r)
MAC_ADRESSE=$(ip link | awk '/ether/ {print $2; exit}')
##########SIMPLELOCAL####################

# Construire le JSON
json_data=$(jq -n \
  --arg host "$HOSTNAME" \
  --arg cpu "$CPU" \
  --arg cpu_id "$CPU_ID" \
  --arg mem "$MEM" \
  --arg ram_size "$RAM_SIZE" \
  --arg ram_gen "$RAM_GEN" \
  --arg sizes "$SIZES" \
  --arg mb_serial "$MB_SERIAL" \
  --arg cpu_freq_min "$CPU_FREQUENCY_MIN" \
  --arg cpu_freq_cur "$CPU_FREQUENCY_CUR" \
  --arg cpu_freq_max "$CPU_FREQUENCY_MAX" \
  --arg gpu_model "$GPU_MODEL" \
  --arg chassis_serial "$CHASSIS_SERIAL" \
  --arg cpu_cores_nb "$CPU_CORES_NUMBER" \
  --arg cpu_threads_nb "$CPU_THREADS_NUMBER" \
  --arg ram_number "$RAM_NUMBER" \
  --arg ram_slots_nb "$RAM_SLOTS_NUMBER" \
  --arg os "$OS" \
  --arg arch "$ARCH" \
  --arg desktop "$DESKTOP" \
  --arg wm "$WM" \
  --arg kernel "$KERNEL" \
  --arg mac_adresse "$MAC_ADRESSE" \
  '{
    HARDWARE: {
      hostname:$host,
      cpu:$cpu,
      cpu_id:$cpu_id,
      memory_mb:$mem,
      ram_size:$ram_size,
      ram_gen: $ram_gen,
      sizes:$sizes,
      mb_serial:$mb_serial,
      cpu_freq_min:$cpu_freq_min,
      cpu_freq_cur:$cpu_freq_cur,
      cpu_freq_max:$cpu_freq_max,
      gpu_model:$gpu_model,
      chassis_serial:$chassis_serial,
      cpu_cores_nb:$cpu_cores_nb,
      cpu_threads_nb:$cpu_threads_nb,
      ram_number:$ram_number,
      ram_slots_nb:$ram_slots_nb
     },
   SOFTWARE: {
    os:$os,
    arch:$arch,
    desktop:$desktop,
    wm:$wm,
    kernel:$kernel,
    mac_adresse:$mac_adresse
   }
}')


echo "arg1=$1"
curl -X POST http://$1:8000/endpoint \
     -H "Content-Type: application/json" \
     -d "$json_data"

########################################

# Affichage du texte de démarrage
echo " "
echo "   ++++++++++++++++++++++++++++++++++"
echo "    +      Welcome to Grabber      +"
echo "   ++++++++++++++++++++++++++++++++++"
echo " "
echo "Hello $USER !"
echo ". . ."
echo "Tout les fichiers crées se trouveront dans le dossier /opt/grabber"
echo " "

#Array File
declare -a DEVICES
mapfile -t DEVICES < <(lsblk -dn -o NAME |grep -v loop)

declare -A FILES
FILES=(
	"sources_list.file" "/etc/apt/sources.list"
	"passwd.file" "/etc/passwd"
	"group.file" "/etc/group"
	"ssh_config.file" "/etc/ssh/ssh_config"
)

declare -A COMMANDES
COMMANDES=(
	[lspci.cmd]="lspci -nn"
	[lsusb.cmd]="lsusb"
	[apt.cmd]="apt list --installed"
	[systemd-analyze.cmd]="systemd-analyze"
	[systemd-blame.cmd]="systemd-analyze blame"
	[lscpu.cmd]="lscpu"
	[inxi.cmd]="inxi"
	[lsmem.cmd]="lsmem"
)

treat_cmd() {
   echo "Création fichier: $@"
   $2 >$DIR/$1
   if [ $? -eq 0 ]; then
     echo "[OK]: Fichier $1 généré" > $SUCCESS_LOG
   else 
     echo "[ECHEC]: Erreur à la génération de $1 => Code de sortie $?" > $ERROR_LOG
   fi
}


treat_file() {
   echo "Copie de fichier: $@"
   cat $2 |grep -v '^#' |grep -v '^$' >$DIR/$1
   if [ $? -eq 0 ]; then
     echo "[OK]: Fichier $1 généré" >> $SUCCESS_LOG
   else
     echo "[ECHEC]: Erreur à la génération de $1 => Code de sortie $?" >> $ERROR_LOG
   fi
}

for cmd in "${!COMMANDES[@]}"; do
    treat_cmd $cmd "${COMMANDES[$cmd]}"
done

for file in "${!FILES[@]}"; do
    treat_file $file "${FILES[$file]}"
done


declare -A PARTITIONS_BY_DISK
for disk in ${DEVICES[@]}; do
    disk_path=$(printf '/dev/%s' "$disk")
    disk_parts=$(lsblk -nr -o PKNAME,PATH $disk_path |grep -vE "^ " |cut -d \  -f2)
    PARTITIONS_BY_DISK[$disk]=${disk_parts[@]}
done

echo " "
echo "Combien de disques sur l'ordinateur ? ${#DEVICES[@]}"
echo "keys: ${!PARTITIONS_BY_DISK[@]}"
echo "values: ${PARTITIONS_BY_DISK[@]}"



hardware() {
	echo " " 
	echo "[HARDWARE]"
	echo "CPU=$CPU"
	echo "CPU_ID=$CPU_ID"
	echo "RAM=$RAM_SIZE $RAM_GEN" 
	echo "RAM_SIZE=$RAM_SIZE" 
	echo "RAM_GEN=$RAM_GEN"
	echo "SIZES=$SIZES"
	echo "MB_SERIAL=$MB_SERIAL"
	echo "CPU_FREQUENCY_MIN=$CPU_FREQUENCY_MIN"
	echo "CPU_FREQUENCY_CUR=$CPU_FREQUENCY_CUR"
	echo "CPU_FREQUENCY_MAX=$CPU_FREQUENCY_MAX"
	echo "GPU_MODEL=$GPU_MODEL"
	echo "CHASSIS_SERIAL=$CHASSIS_SERIAL"
	echo "CPU_CORES_NUMBER=$CPU_CORES_NUMBER"
	echo "CPU_THREADS_NUMBER=$CPU_THREADS_NUMBER"
	echo "RAM_NUMBER=$RAM_NUMBER"
	echo "RAM_SLOTS_NUMBER=$RAM_SLOTS_NUMBER"

	sizes=$(lsblk -dnb |grep -v loop |grep -v boot |tr -s " " |cut -d \  -f4) 
	STOCKAGE_TOTAL=0
	for SIZE in ${sizes[@]};do
	    STOCKAGE_TOTAL+=$SIZE
	done
	STOCKAGE_TOTAL=$(numfmt --to iec $STOCKAGE_TOTAL)
	echo "STOCKAGE_TOTAL=$STOCKAGE_TOTAL"
} >$SUM


software() {
	echo " " 
	echo "[SOFTWARE]"
	echo "OS=$(lsb_release -a |grep Description |cut -f2)"
	echo "ARCH=$(uname -m)"
	echo "DESKTOP=$XDG_CURRENT_DESKTOP"
	echo "WM=$XDG_SESSION_TYPE"
	echo "KERNEL=$(uname -r)"
	echo "MAC_ADRESSE=$MAC_ADRESSE"
} >>$SUM

hardware
software
echo " "
echo "Le fichier summary.txt contient les infos hardware et software du système"
echo "À bientôt"
echo " "
echo $json_data