#!/bin/bash

# =============================================================================
# COLECȚIE DE SCRIPTURI BASH PENTRU DEVOPS JUNIOR
# Exemple practice cu explicații pentru învățare
# =============================================================================

echo "Alege un script pentru a-l rula:"
echo "1. Monitor disk space (verificare spațiu)"
echo "2. Backup automat fișiere"
echo "3. Verificare status servere"
echo "4. Curățare fișiere vechi"
echo "5. Calculator simplu"
echo "6. Monitor procese"
echo ""
read -p "Alege opțiunea (1-6): " optiune

case $optiune in
    1)
        # =============================================================================
        # SCRIPT 1: MONITOR DISK SPACE
        # Verifică spațiul pe disk și avertizează dacă e plin
        # CONCEPTE: while loop, if-else, aritmetică
        # =============================================================================
        
        echo ""
        echo "=== MONITOR SPAȚIU DISK ==="
        echo ""
        
        # Setează pragul de alertă (în procente)
        PRAG_ALERTA=80
        
        # df = disk free (afișează spațiul pe disk)
        # -h = human readable (MB, GB în loc de bytes)
        # awk = procesare text (extrage coloane)
        
        echo "Verificare partitii..."
        echo ""
        
        # while read = citește linie cu linie
        # IFS= păstrează spațiile
        df -h | grep -E '^/dev/' | while read linie; do
            # Extrage utilizarea (coloana 5, ex: 45%)
            utilizare=$(echo $linie | awk '{print $5}' | sed 's/%//')
            partitie=$(echo $linie | awk '{print $1}')
            punct_montare=$(echo $linie | awk '{print $6}')
            
            echo "Partitie: $partitie ($punct_montare)"
            echo "Utilizare: $utilizare%"
            
            # Compară numerele (utilizare cu pragul)
            if [ $utilizare -gt $PRAG_ALERTA ]; then
                echo "⚠️  ALERTA! Spatiu critic!"
            else
                echo "✓ OK"
            fi
            echo ""
        done
        ;;
        
    2)
        # =============================================================================
        # SCRIPT 2: BACKUP AUTOMAT
        # Creează backup pentru un director specificat
        # CONCEPTE: funcții, date, comprimare, validare input
        # =============================================================================
        
        echo ""
        echo "=== BACKUP AUTOMAT ==="
        echo ""
        
        # Funcție pentru backup
        # Funcțiile fac codul reutilizabil
        face_backup() {
            local sursa=$1
            local destinatie=$2
            local data=$(date +%Y%m%d_%H%M%S)
            local nume_backup="backup_${data}.tar.gz"
            
            echo "Creez backup pentru: $sursa"
            echo "Destinatie: $destinatie/$nume_backup"
            
            # tar = arhivare fișiere
            # -czf = compress (gzip), create, file
            tar -czf "$destinatie/$nume_backup" "$sursa" 2>/dev/null
            
            if [ $? -eq 0 ]; then
                echo "✓ Backup creat cu succes!"
                echo "Dimensiune: $(du -h "$destinatie/$nume_backup" | cut -f1)"
            else
                echo "✗ Eroare la crearea backup-ului"
                return 1
            fi
        }
        
        # Exemplu de utilizare
        read -p "Introdu directorul pentru backup (ex: /home/user/documente): " dir_sursa
        
        if [ ! -d "$dir_sursa" ]; then
            echo "Eroare: Directorul nu există!"
            exit 1
        fi
        
        read -p "Director destinatie backup (ex: /home/user/backups): " dir_dest
        
        # Creează directorul de destinație dacă nu există
        mkdir -p "$dir_dest"
        
        face_backup "$dir_sursa" "$dir_dest"
        ;;
        
    3)
        # =============================================================================
        # SCRIPT 3: VERIFICARE STATUS SERVERE
        # Verifică dacă serverele sunt online (ping)
        # CONCEPTE: array-uri, for loop, exit codes
        # =============================================================================
        
        echo ""
        echo "=== VERIFICARE STATUS SERVERE ==="
        echo ""
        
        # Array simplu cu liste de servere
        # () = array în bash
        servere=(
            "google.com"
            "github.com"
            "stackoverflow.com"
            "localhost"
        )
        
        echo "Verific ${#servere[@]} servere..."  # ${#array[@]} = număr elemente
        echo ""
        
        # for loop prin array
        for server in "${servere[@]}"; do
            echo -n "Verific $server... "
            
            # ping -c 2 = trimite 2 pachete
            # -W 2 = timeout 2 secunde
            # &>/dev/null = ascunde output-ul
            if ping -c 2 -W 2 "$server" &>/dev/null; then
                echo "✓ ONLINE"
            else
                echo "✗ OFFLINE"
            fi
        done
        
        echo ""
        echo "Verificare completată!"
        ;;
        
    4)
        # =============================================================================
        # SCRIPT 4: CURĂȚARE FIȘIERE VECHI
        # Șterge fișiere mai vechi de X zile dintr-un director
        # CONCEPTE: find, confirmări utilizator, numărare
        # =============================================================================
        
        echo ""
        echo "=== CURĂȚARE FIȘIERE VECHI ==="
        echo ""
        
        read -p "Director de curățat (ex: /tmp): " director
        
        if [ ! -d "$director" ]; then
            echo "Eroare: Directorul nu există!"
            exit 1
        fi
        
        read -p "Șterge fișiere mai vechi de câte zile? (ex: 30): " zile
        
        # Verifică dacă e un număr valid
        if ! [[ "$zile" =~ ^[0-9]+$ ]]; then
            echo "Eroare: Trebuie să introduci un număr!"
            exit 1
        fi
        
        echo ""
        echo "Căutare fișiere mai vechi de $zile zile în $director..."
        
        # find = caută fișiere
        # -type f = doar fișiere (nu directoare)
        # -mtime +N = modificat acum N+ zile
        fisiere_vechi=$(find "$director" -type f -mtime +$zile 2>/dev/null)
        
        numar_fisiere=$(echo "$fisiere_vechi" | grep -v '^$' | wc -l)
        
        if [ $numar_fisiere -eq 0 ]; then
            echo "Nu am găsit fișiere mai vechi de $zile zile."
            exit 0
        fi
        
        echo "Am găsit $numar_fisiere fișiere vechi:"
        echo "$fisiere_vechi" | head -10  # Arată primele 10
        
        if [ $numar_fisiere -gt 10 ]; then
            echo "... și alte $((numar_fisiere - 10)) fișiere"
        fi
        
        echo ""
        read -p "Vrei să ștergi aceste fișiere? (da/nu): " confirmare
        
        if [ "$confirmare" = "da" ]; then
            # Loop prin fișiere și șterge-le
            while IFS= read -r fisier; do
                if [ -n "$fisier" ]; then
                    rm -f "$fisier"
                    echo "Șters: $fisier"
                fi
            done <<< "$fisiere_vechi"
            
            echo ""
            echo "✓ Curățare completă!"
        else
            echo "Operațiune anulată."
        fi
        ;;
        
    5)
        # =============================================================================
        # SCRIPT 5: CALCULATOR SIMPLU
        # Calculator cu operații matematice de bază
        # CONCEPTE: case, operații aritmetice, loop infinit
        # =============================================================================
        
        echo ""
        echo "=== CALCULATOR SIMPLU ==="
        echo ""
        
        # Loop infinit (until break)
        while true; do
            echo "Operații disponibile:"
            echo "1. Adunare (+)"
            echo "2. Scădere (-)"
            echo "3. Înmulțire (*)"
            echo "4. Împărțire (/)"
            echo "5. Ieșire"
            echo ""
            
            read -p "Alege operația (1-5): " op
            
            # break = ieșire din loop
            [ "$op" = "5" ] && break
            
            read -p "Primul număr: " num1
            read -p "Al doilea număr: " num2
            
            # case = switch statement
            case $op in
                1)
                    rezultat=$((num1 + num2))
                    echo "Rezultat: $num1 + $num2 = $rezultat"
                    ;;
                2)
                    rezultat=$((num1 - num2))
                    echo "Rezultat: $num1 - $num2 = $rezultat"
                    ;;
                3)
                    rezultat=$((num1 * num2))
                    echo "Rezultat: $num1 * $num2 = $rezultat"
                    ;;
                4)
                    if [ $num2 -eq 0 ]; then
                        echo "Eroare: Împărțire la zero!"
                    else
                        # bc = calculator pentru operații cu virgulă
                        rezultat=$(echo "scale=2; $num1 / $num2" | bc)
                        echo "Rezultat: $num1 / $num2 = $rezultat"
                    fi
                    ;;
                *)
                    echo "Operație invalidă!"
                    ;;
            esac
            echo ""
        done
        
        echo "La revedere!"
        ;;
        
    6)
        # =============================================================================
        # SCRIPT 6: MONITOR PROCESE
        # Afișează procesele care consumă cele mai multe resurse
        # CONCEPTE: ps, sort, top procese
        # =============================================================================
        
        echo ""
        echo "=== MONITOR PROCESE ==="
        echo ""
        
        echo "Top 10 procese după utilizare CPU:"
        echo ""
        
        # ps = process status
        # aux = all users, user-oriented, include processes without terminal
        # --sort = sortează după o coloană
        # head = primele N linii
        
        ps aux --sort=-%cpu | head -11
        
        echo ""
        echo "---"
        echo ""
        echo "Top 10 procese după utilizare memorie:"
        echo ""
        
        ps aux --sort=-%mem | head -11
        
        echo ""
        read -p "Vrei să oprești vreun proces? (da/nu): " raspuns
        
        if [ "$raspuns" = "da" ]; then
            read -p "Introdu PID-ul procesului: " pid
            
            # Verifică dacă procesul există
            if ps -p $pid > /dev/null 2>&1; then
                echo "Opresc procesul $pid..."
                kill $pid
                echo "✓ Procesul a fost oprit"
            else
                echo "Procesul cu PID $pid nu există"
            fi
        fi
        ;;
        
    *)
        echo "Opțiune invalidă!"
        exit 1
        ;;
esac

# =============================================================================
# REZUMAT CONCEPTE BASH ÎNVĂȚATE:
# =============================================================================
# 
# 1. LOOP-URI:
#    - while read: citește linie cu linie
#    - for in: iterează prin liste/array-uri
#    - while true: loop infinit (până la break)
#
# 2. CONDIȚII:
#    - if [ conditie ]; then ... fi
#    - case variabila in ... esac (switch)
#    - Operatori: -eq (egal), -gt (mai mare), -lt (mai mic)
#    - Operatori fișiere: -d (director), -f (fișier), -e (există)
#
# 3. ARRAY-URI:
#    - Declarare: arr=(val1 val2 val3)
#    - Acces: ${arr[0]}
#    - Toate elementele: ${arr[@]}
#    - Lungime: ${#arr[@]}
#
# 4. FUNCȚII:
#    - Declarare: function_name() { ... }
#    - Parametri: $1, $2, $3...
#    - Variabile locale: local var=value
#
# 5. COMENZI UTILE:
#    - df: disk free (spațiu)
#    - du: disk usage (mărime fișiere)
#    - ps: process status
#    - find: caută fișiere
#    - grep: filtrează text
#    - awk: procesare coloane
#    - sed: editare text
#
# 6. OPERATORI:
#    - Aritmetică: $((expresie))
#    - Strings: -z (gol), -n (nu e gol)
#    - Comparații: -eq, -ne, -gt, -lt, -ge, -le
#
# 7. REDIRECTĂRI:
#    - > : scrie în fișier (suprascrie)
#    - >> : append la fișier
#    - 2>&1 : redirectează error la output
#    - &>/dev/null : ascunde tot output-ul
#
# =============================================================================