#!/bin/bash
mv /usr/local/bin/progs/3progs.sh.desktop /etc/xdg/autostart/
rm -rf /usr/lib/calamares
rm -rf /usr/share/calamares
rm -rf /usr/include/libcalamares
rm -rf /usr/bin/calamares
rm -rf /etc/calamares
rm -rf /usr/share/applications/calamares.desktop
rm -rf /etc/xdg/autostart/calamares.desktop
ldconfig
# GPU detektálás
AMD_GPU=$(lspci -P | grep -iE "AMD|ATI" -c)
NVIDIA_GPU=$(lspci -P | grep "NVIDIA" -c)
# GPU driverek telepítése
if [[ $AMD_GPU -gt 0 ]]; then
    echo "AMD GPU észlelve, driverek telepítése..."
    pacman -S mesa vulkan-radeon lib32-vulkan-radeon lib32-mesa xf86-video-amdgpu --noconfirm
fi
if [[ $NVIDIA_GPU -gt 0 ]]; then
    echo "NVIDIA GPU észlelve, driverek telepítése..."
    pacman -S nvidia-dkms nvidia-utils nvidia-settings egl-wayland lib32-nvidia-utils --noconfirm
    sed -i 's/MODULES=()/MODULES=(nvidia nvidia_modeset nvidia_uvm nvidia_drm)/' /etc/mkinitcpio.conf
    echo "options nvidia_drm modeset=1 fbdev=1" > /etc/modprobe.d/nvidia.conf
    mkinitcpio -P
fi
# Boot loader telepítése
if [ -d "/sys/firmware/efi" ]; then
    # UEFI rendszer
    echo "UEFI rendszer észlelve, systemd-boot telepítése..."
    
    # LUKS titkosítás ellenőrzése
    ROOT_DEVICE=$(findmnt -n -o SOURCE /)
    ENCRYPTED=false
    CRYPTDEVICE_UUID=""
    CRYPTNAME="cryptroot"
    
    # Ellenőrizzük, van-e titkosított partíció
    if [[ "$ROOT_DEVICE" == "/dev/mapper/"* ]]; then
        ENCRYPTED=true
        #LUKS_DEVICE=$(blkid -t TYPE=crypto_LUKS -o device | head -n1)
        #CRYPTDEVICE_UUID=$(blkid -o value -s UUID "$LUKS_DEVICE")
        
        LUKS_DEVICE="/dev/$(sudo dmsetup deps -o devname cryptroot | grep -o '(.*)'| tr -d '()')"
        CRYPTDEVICE_UUID=$(echo "$ROOT_DEVICE" | sed 's|/dev/mapper/luks-||')
        
        echo "LUKS titkosítás észlelve: $LUKS_DEVICE (UUID: $CRYPTDEVICE_UUID)"
        
        # A fájlrendszer típusának ellenőrzése
        FS_TYPE=$(lsblk -no FSTYPE /dev/mapper/$CRYPTNAME 2>/dev/null || echo "")
        
        if [ -z "$FS_TYPE" ]; then
            # Ha még nincs megnyitva a titkosított eszköz, próbáljuk megnyitni
            echo "Titkosított eszköz nyitása ellenőrzéshez..."
            if [ ! -e "/dev/mapper/$CRYPTNAME" ]; then
                # Próbáljuk meg kinyitni (jelszó nélkül nem fog működni, de megpróbáljuk)
                cryptsetup open "$LUKS_DEVICE" "$CRYPTNAME" || true
            fi
            
            # Ellenőrizzük újra a fájlrendszert
            FS_TYPE=$(lsblk -no FSTYPE /dev/mapper/$CRYPTNAME 2>/dev/null || echo "")
            
            if [ -z "$FS_TYPE" ]; then
                # Ha még mindig nem tudjuk meghatározni, feltételezzük, hogy ext4
                echo "Nem sikerült meghatározni a fájlrendszer típusát, ext4-et feltételezünk"
                FS_TYPE="ext4"
            fi
        fi
        
        echo "Fájlrendszer típusa: $FS_TYPE"
        
        # mkinitcpio.conf módosítása a szükséges modulokkal és hook-okkal
        # Hozzáadjuk a dm-crypt és crypto modulokat
        if ! grep -q "dm[-_]crypt" <<< "$(grep "^MODULES=" /etc/mkinitcpio.conf)"; then
            echo "dm-crypt modul hozzáadása"
            sed -i 's/MODULES=(/MODULES=(dm-crypt /' /etc/mkinitcpio.conf
        fi
        
        if ! grep -q "crypto" <<< "$(grep "^MODULES=" /etc/mkinitcpio.conf)"; then
            echo "crypto modul hozzáadása"
            sed -i 's/MODULES=(/MODULES=(crypto /' /etc/mkinitcpio.conf
        fi
        
        # Használjuk a systemd hookokat a jobb LUKS kezeléshez
        if ! grep -q "sd-encrypt" <<< "$(grep "^HOOKS=" /etc/mkinitcpio.conf)"; then
            echo "sd-encrypt hook hozzáadása"
            sed -i 's/\(HOOKS=.*\)block/\1block sd-encrypt/' /etc/mkinitcpio.conf
        fi
        
        # Biztosítsuk, hogy keyboard és keymap is legyen
        if ! grep -q "keyboard" <<< "$(grep "^HOOKS=" /etc/mkinitcpio.conf)"; then
            echo "keyboard hook hozzáadása"
            sed -i 's/\(HOOKS=.*\)block/\1keyboard block/' /etc/mkinitcpio.conf
        fi
        
        if ! grep -q "keymap" <<< "$(grep "^HOOKS=" /etc/mkinitcpio.conf)"; then
            echo "keymap hook hozzáadása"
            sed -i 's/\(HOOKS=.*keyboard\)/\1 keymap/' /etc/mkinitcpio.conf
        fi
        
        # Hozzunk létre egy crypttab fájlt a titkosított eszköz kezeléséhez
        echo "$CRYPTNAME UUID=$CRYPTDEVICE_UUID none luks,discard" > /etc/crypttab
        echo "Crypttab létrehozva: $CRYPTNAME UUID=$CRYPTDEVICE_UUID"
        
        # Regeneráljuk az initramfs-t
        echo "Initramfs újragenerálása..."
        mkinitcpio -P
    else
        echo "Nem észleltünk LUKS titkosítást"
    fi
    
    # Root UUID és fájlrendszer típus lekérése
    ROOT_UUID=$(awk '$2=="/" {print $1}' /etc/fstab | grep -o 'UUID=.*' | cut -d'=' -f2)
    FS_TYPE=$(awk '$2=="/" {print $3}' /etc/fstab)
    
    # CPU microcode detect és a változó beállítása
    CPU=$(lscpu | grep "AMD" -c)
    if [[ $CPU -gt 0 ]]; then
        CPU_UCODE="initrd /amd-ucode.img"
	pacman -Rs intel-ucode --noconfirm
    elif [[ $(lscpu | grep "Intel" -c) -gt 0 ]]; then
        CPU_UCODE="initrd /intel-ucode.img"
	pacman -Rs amd-ucode --noconfirm
    else
        CPU_UCODE=""
    fi
    
    # Systemd-boot konfiguráció
    mkdir -p /boot/loader/entries
    
    # Időtúllépés és editor beállítása
    cat > /boot/loader/loader.conf << EOF
default raveos.conf
timeout 5
console-mode max
editor yes
EOF
    
    # Konfigurációs bejegyzések létrehozása
    if [ "$ENCRYPTED" = true ]; then
        if [ "$FS_TYPE" = "btrfs" ]; then
            echo "BTRFS esetén csak a sima (nem titkosított) mód támogatott"
            # Nem kezeljük a BTRFS + LUKS kombinációt, áttérünk a nem titkosított btrfs kezelésre
            
            cat > /boot/loader/entries/raveos.conf << EOF
title RaveOS GNOME Gaming 1.0
linux /vmlinuz-linux-zen
$CPU_UCODE
initrd /initramfs-linux-zen.img
options root=UUID=$ROOT_UUID rootflags=subvol=@ rw rootfstype=btrfs quiet
EOF
        else
            # Ez csak ext4 vagy más fájlrendszer + LUKS esetén fut le
            echo "EXT4 + LUKS konfiguráció létrehozása"
            cat > /boot/loader/entries/raveos.conf << EOF
title RaveOS GNOME Gaming 1.0 - LUKS+EXT4
linux /vmlinuz-linux-zen
$CPU_UCODE
initrd /initramfs-linux-zen.img
options cryptdevice=UUID=$CRYPTDEVICE_UUID:$CRYPTNAME root=/dev/mapper/$CRYPTNAME rw rootfstype=ext4 quiet
EOF
        fi
    else
        # Nem titkosított rendszer esetén
        if [ "$FS_TYPE" = "btrfs" ]; then
            echo "BTRFS konfiguráció létrehozása (nem titkosított)"
            cat > /boot/loader/entries/raveos.conf << EOF
title RaveOS GNOME Gaming 1.0
linux /vmlinuz-linux-zen
$CPU_UCODE
initrd /initramfs-linux-zen.img
options root=UUID=$ROOT_UUID rootflags=subvol=@ rw rootfstype=btrfs quiet
EOF
        else
            echo "Alapértelmezett konfiguráció létrehozása (nem titkosított)"
            cat > /boot/loader/entries/raveos.conf << EOF
title RaveOS GNOME Gaming 1.0
linux /vmlinuz-linux-zen
$CPU_UCODE
initrd /initramfs-linux-zen.img
options root=UUID=$ROOT_UUID rw quiet
EOF
        fi
    fi
    
    # EFI partíció és a partíció száma
    EFI_DISK=$(findmnt -n -o SOURCE /boot | sed 's/[0-9]*$//')
    EFI_PART=$(findmnt -n -o SOURCE /boot | grep -o '[0-9]*$')
    
    # Bootentry létrehozása
    echo "Bootentry létrehozása az EFI firmware-ben: $EFI_DISK, partíció: $EFI_PART"
    efibootmgr --create --disk "$EFI_DISK" --part "$EFI_PART" \
               --loader /EFI/systemd/systemd-bootx64.efi --label "RaveOS GNOME Gaming" \
               --verbose
    
    echo "Systemd-boot telepítése sikeres"
else
    # BIOS rendszer
    echo "BIOS rendszer észlelve, GRUB telepítése..."
    
    # LUKS titkosítás ellenőrzése
    ROOT_DEVICE=$(findmnt -n -o SOURCE /)
    LUKS_DEVICE=""
    CRYPTDEVICE_UUID=""
    CRYPTNAME="cryptroot"
    
    if [[ "$ROOT_DEVICE" == "/dev/mapper/"* ]]; then
        #LUKS_DEVICE=$(blkid -t TYPE=crypto_LUKS -o device | head -n1)
        #CRYPTDEVICE_UUID=$(blkid -o value -s UUID "$LUKS_DEVICE")
        
        LUKS_DEVICE="/dev/$(sudo dmsetup deps -o devname cryptroot | grep -o '(.*)'| tr -d '()')"
        CRYPTDEVICE_UUID=$(echo "$ROOT_DEVICE" | sed 's|/dev/mapper/luks-||')
        
        echo "LUKS titkosítás észlelve: $LUKS_DEVICE (UUID: $CRYPTDEVICE_UUID)"
        
        # A fájlrendszer típusának ellenőrzése
        FS_TYPE=$(lsblk -no FSTYPE /dev/mapper/$CRYPTNAME 2>/dev/null || echo "")
        
        if [ -z "$FS_TYPE" ]; then
            # Ha még nincs megnyitva a titkosított eszköz, feltételezzük, hogy ext4
            echo "Nem sikerült meghatározni a fájlrendszer típusát, ext4-et feltételezünk"
            FS_TYPE="ext4"
        fi
        
        echo "Fájlrendszer típusa: $FS_TYPE"
        
        # Modulok és hook-ok hozzáadása a mkinitcpio.conf-hoz
        if ! grep -q "dm[-_]crypt" <<< "$(grep "^MODULES=" /etc/mkinitcpio.conf)"; then
            echo "dm-crypt modul hozzáadása"
            sed -i 's/MODULES=(/MODULES=(dm-crypt /' /etc/mkinitcpio.conf
        fi
        
        if ! grep -q "crypto" <<< "$(grep "^MODULES=" /etc/mkinitcpio.conf)"; then
            echo "crypto modul hozzáadása"
            sed -i 's/MODULES=(/MODULES=(crypto /' /etc/mkinitcpio.conf
        fi
        
        # Használjuk a hagyományos encrypt hookot GRUB esetén
        if ! grep -q "encrypt" <<< "$(grep "^HOOKS=" /etc/mkinitcpio.conf)"; then
            echo "encrypt hook hozzáadása"
            sed -i 's/\(HOOKS=.*\)block/\1block encrypt/' /etc/mkinitcpio.conf
        fi
        
        # Biztosítsuk, hogy keyboard és keymap is legyen
        if ! grep -q "keyboard" <<< "$(grep "^HOOKS=" /etc/mkinitcpio.conf)"; then
            echo "keyboard hook hozzáadása"
            sed -i 's/\(HOOKS=.*\)block/\1keyboard block/' /etc/mkinitcpio.conf
        fi
        
        if ! grep -q "keymap" <<< "$(grep "^HOOKS=" /etc/mkinitcpio.conf)"; then
            echo "keymap hook hozzáadása"
            sed -i 's/\(HOOKS=.*keyboard\)/\1 keymap/' /etc/mkinitcpio.conf
        fi
        
        # Crypttab létrehozása
        echo "$CRYPTNAME UUID=$CRYPTDEVICE_UUID none luks,discard" > /etc/crypttab
        echo "Crypttab létrehozva: $CRYPTNAME UUID=$CRYPTDEVICE_UUID"
        
        # Regeneráljuk az initramfs-t
        echo "Initramfs újragenerálása..."
        mkinitcpio -P
        
        # GRUB konfiguráció módosítása
        # Csak ext4 + LUKS kombinációt támogatunk
        echo "GRUB konfiguráció frissítése alapértelmezett LUKS beállításokkal"
        sed -i "s|^GRUB_CMDLINE_LINUX=\"\"|GRUB_CMDLINE_LINUX=\"cryptdevice=UUID=$CRYPTDEVICE_UUID:$CRYPTNAME root=/dev/mapper/$CRYPTNAME\"|" /etc/default/grub
    else
        # Fájlrendszer típus lekérése
        ROOT_UUID=$(awk '$2=="/" {print $1}' /etc/fstab | grep -o 'UUID=.*' | cut -d'=' -f2)
        FS_TYPE=$(awk '$2=="/" {print $3}' /etc/fstab)
        
        # btrfs esetén speciális kernel paraméterek hozzáadása
        if [ "$FS_TYPE" = "btrfs" ]; then
            echo "GRUB konfiguráció frissítése BTRFS beállításokkal"
            sed -i "s|^GRUB_CMDLINE_LINUX=\"\"|GRUB_CMDLINE_LINUX=\"root=UUID=$ROOT_UUID rootflags=subvol=@ rootfstype=btrfs\"|" /etc/default/grub
        fi
    fi
    
    # GRUB telepítése és konfiguráció generálása
    echo "GRUB telepítése..."
    pacman -S grub --noconfirm
    grub-install --target=i386-pc --recheck /dev/sda
    sed -i 's/GRUB_DISTRIBUTOR=.*$/GRUB_DISTRIBUTOR="RaveOS GNOME Gaming Linux"/' /etc/default/grub
    
    # GRUB konfiguráció generálása
    echo "GRUB konfiguráció generálása..."
    grub-mkconfig -o /boot/grub/grub.cfg
    
    echo "GRUB telepítése sikeres"
fi

# /boot ellenőrzés és javítás függvény
check_boot_directory() {
    echo "A /boot mappa tartalmának ellenőrzése..."
    
    # Ellenőrizzük, hogy a /boot mappa tartalmazza-e a szükséges fájlokat
    if [ -z "$(ls -A /boot)" ] || ! ls /boot/vmlinuz-linux-zen &> /dev/null || ! ls /boot/initramfs-linux-zen.img &> /dev/null; then
        echo "HIBA: A /boot mappa üres vagy hiányoznak a kernel fájlok!"
        
        # Ellenőrizzük, hogy a fájlok léteznek-e a rendszeren
        if [ -f /usr/lib/modules/*/vmlinuz ]; then
            echo "Kernel fájl megtalálva, másolás a /boot mappába..."
            cp /usr/lib/modules/*/vmlinuz /boot/vmlinuz-linux-zen
        else
            echo "KRITIKUS HIBA: Kernel fájl nem található a rendszeren!"
            echo "Próbáljuk telepíteni a linux-zen csomagot..."
            pacman -S linux-zen --noconfirm
        fi
        
        # Regeneráljuk a initramfs-t, ha szükséges
        echo "Initramfs újragenerálása..."
        mkinitcpio -p linux-zen
        
        # Ellenőrizzük, hogy a CPU microcode telepítve van-e
        if [ -f /boot/amd-ucode.img ] || [ -f /boot/intel-ucode.img ]; then
            echo "CPU microcode már telepítve."
        else
            # Ha nincs, akkor telepítsük újra a megfelelőt
            if [[ $(lscpu | grep "AMD" -c) -gt 0 ]]; then
                echo "AMD CPU észlelve, microcode telepítése..."
                pacman -S amd-ucode --noconfirm
            elif [[ $(lscpu | grep "Intel" -c) -gt 0 ]]; then
                echo "Intel CPU észlelve, microcode telepítése..."
                pacman -S intel-ucode --noconfirm
            fi
        fi
        
        # UEFI esetén próbáljuk újratelepíteni a bootloader-t
        if [ -d "/sys/firmware/efi" ]; then
            echo "UEFI rendszer, systemd-boot újratelepítése..."
            bootctl install
            
            # Ellenőrizzük, hogy a kernelt és initramfs-t kimásoltuk-e
            if [ ! -f /boot/vmlinuz-linux-zen ]; then
                echo "Kernel másolása a /boot mappába..."
                find /usr/lib/modules/ -name "vmlinuz*" -exec cp {} /boot/vmlinuz-linux-zen \;
            fi
            
            if [ ! -f /boot/initramfs-linux-zen.img ]; then
                echo "Initramfs újragenerálása..."
                mkinitcpio -p linux-zen
            fi
            
            # EFI partíció ellenőrzése
            EFI_PART=$(findmnt -n -o SOURCE /boot)
            if [ -z "$EFI_PART" ]; then
                echo "KRITIKUS HIBA: EFI partíció nem található!"
                echo "Próbáljuk megkeresni a megfelelő EFI partíciót..."
                
                # Keressük az EFI partíciót, ha nincs csatolva
                EFI_PART=$(lsblk -o NAME,FSTYPE | grep vfat | head -n1 | awk '{print $1}')
                
                if [ -n "$EFI_PART" ]; then
                    echo "EFI partíció található: $EFI_PART, csatolás a /boot könyvtárhoz..."
                    mount /dev/$EFI_PART /boot
                    
                    # Újra próbáljuk a bootloader telepítését
                    bootctl install
                    
                    # A fstab bejegyzést is frissítsük, hogy újraindításkor is megmaradjon
                    if ! grep -q "/boot" /etc/fstab; then
                        UUID=$(blkid -s UUID -o value /dev/$EFI_PART)
                        echo "UUID=$UUID /boot vfat defaults 0 2" >> /etc/fstab
                    fi
                fi
            fi
        fi
        
        # Ellenőrizzük újra, hogy minden szükséges fájl megvan-e
        if [ -z "$(ls -A /boot)" ] || ! ls /boot/vmlinuz-linux-zen &> /dev/null || ! ls /boot/initramfs-linux-zen.img &> /dev/null; then
            echo "KRITIKUS HIBA: Nem sikerült helyreállítani a /boot mappát!"
            return 1
        else
            echo "A /boot mappa sikeresen helyreállítva."
        fi
    else
        echo "A /boot mappa rendben van."
    fi
    
    return 0
}

echo "CPU microcode külön ellenőrzése és telepítése..."
if [[ $(lscpu | grep "AMD" -c) -gt 0 ]]; then
    echo "AMD CPU észlelve, microcode telepítése és ellenőrzése..."
    pacman -S amd-ucode --noconfirm
    # Ellenőrizzük, hogy az ucode fájl létezik-e a /boot mappában
    if [ ! -f /boot/amd-ucode.img ]; then
        echo "amd-ucode.img másolása a /boot mappába..."
        cp /usr/lib/firmware/amd-ucode.img /boot/ 2>/dev/null || echo "FIGYELEM: Nem sikerült az amd-ucode.img másolása"
        # Ha nem sikerült másolni, próbáljuk újratelepíteni
        if [ ! -f /boot/amd-ucode.img ]; then
            echo "amd-ucode újratelepítése és másolása a /boot mappába..."
            pacman -S amd-ucode --noconfirm
            cp /usr/lib/firmware/amd-ucode.img /boot/ 2>/dev/null || echo "HIBA: Nem sikerült az amd-ucode.img másolása"
        fi
    fi
elif [[ $(lscpu | grep "Intel" -c) -gt 0 ]]; then
    echo "Intel CPU észlelve, microcode telepítése és ellenőrzése..."
    pacman -S intel-ucode --noconfirm
    # Ellenőrizzük, hogy az ucode fájl létezik-e a /boot mappában
    if [ ! -f /boot/intel-ucode.img ]; then
        echo "intel-ucode.img másolása a /boot mappába..."
        cp /usr/lib/firmware/intel-ucode.img /boot/ 2>/dev/null || echo "FIGYELEM: Nem sikerült az intel-ucode.img másolása"
        # Ha nem sikerült másolni, próbáljuk újratelepíteni
        if [ ! -f /boot/intel-ucode.img ]; then
            echo "intel-ucode újratelepítése és másolása a /boot mappába..."
            pacman -S intel-ucode --noconfirm
            cp /usr/lib/firmware/intel-ucode.img /boot/ 2>/dev/null || echo "HIBA: Nem sikerült az intel-ucode.img másolása"
        fi
    fi
fi

# Hívjuk meg az ellenőrző függvényt a bootloader telepítése után
check_boot_directory || echo "FIGYELMEZTETÉS: A /boot helyreállítása sikertelen. A rendszer talán nem tud majd elindulni."

# Calamares eltávolítása
echo "Calamares eltávolítása..."
pacman -Rs calamares --noconfirm

echo "Telepítés befejezve!"