#!/usr/bin/bash
#
# google-gpg-key-updater.sh
# Automatikus GPG kulcs importáló script blackPanther OS -re
# blackPanther Project & 2025
# info @ blackpanther.hu

# cat linux_signing_key.pub | gpg --show-keys --keyid-format LONG 
# curl -s https://dl.google.com/linux/linux_signing_key.pub | gpg --show-keys --keyid-format LONG

# HASZNÁLAT:
#   ./google-gpg-key-updater.sh              # Normál futtatás
#   ./google-gpg-key-updater.sh --dry-run    # Csak szimuláció
#   ./google-gpg-key-updater.sh --list-keys  # Összes GPG kulcs listázása
#   ./google-gpg-key-updater.sh --list-google # Csak Google kulcsok listázása
#   ./google-gpg-key-updater.sh --verbose    # Részletes debug kimenet
#   ./google-gpg-key-updater.sh --force      # Kényszerített import (mindig)
#   ./google-gpg-key-updater.sh --help       # Súgó megjelenítése
#

set -euo pipefail

# ============================================================================
# KONFIGURÁCIÓ
# ============================================================================
KEY_URL="https://dl.google.com/linux/linux_signing_key.pub"
KEY_FILE="/tmp/linux_signing_key.pub.$$"
CURRENT_KEYS_FILE="/tmp/current_google_keys.$$"
MAX_RETRIES=3
TIMEOUT_SECONDS=10
LOG_PREFIX="google-chrrome-keyupdater"

# Naplózási szintek
declare -r LOG_LEVEL_ERROR=0
declare -r LOG_LEVEL_WARN=1
declare -r LOG_LEVEL_INFO=2
declare -r LOG_LEVEL_DEBUG=3

# Alapértelmezett beállítások
DRY_RUN=false
VERBOSE=true
FORCE_UPDATE=false
MODE="update"
NON_INTERACTIVE=true
CURRENT_LOG_LEVEL=$LOG_LEVEL_INFO
#CURRENT_LOG_LEVEL=$LOG_LEVEL_DEBUG

logger -t "$LOG_PREFIX" "Google Key Updater Started..." 2>/dev/null || true

# ============================================================================
# KÖRNYEZET ÉSZLELÉS
# ============================================================================

detect_non_interactive() {
    if [[ ! -t 0 ]]; then
        return 0
    fi
    if [[ -n "${CRON:-}" ]] || [[ -n "${RUN_CRON_JOB:-}" ]]; then
        return 0
    fi
    if [[ -n "${INVOCATION_ID:-}" ]]; then
        return 0
    fi
    if [[ -f /proc/self/cgroup ]] && grep -q "systemd" /proc/self/cgroup 2>/dev/null; then
        return 0
    fi
    local ppid_cmd
    ppid_cmd=$(ps -o comm= -p "$PPID" 2>/dev/null | tr -d ' ')
    if [[ "$ppid_cmd" =~ ^(cron|crond|systemd)$ ]]; then
        return 0
    fi
    return 1
}

init_logging() {
    if [[ "$VERBOSE" == "true" ]]; then
        CURRENT_LOG_LEVEL=$LOG_LEVEL_DEBUG
        return
    fi
    if [[ "$NON_INTERACTIVE" == "true" ]]; then
        CURRENT_LOG_LEVEL=$LOG_LEVEL_WARN
        return
    fi
    CURRENT_LOG_LEVEL=$LOG_LEVEL_INFO
}

# ============================================================================
# NAPLÓZÁS
# ============================================================================

log_to_journal() {
    local priority="$1"
    local message="$2"
    if command -v logger >/dev/null 2>&1; then
        #logger -t "$LOG_PREFIX" -p "user.$priority" "$message" 2>/dev/null || true
        logger -t "$LOG_PREFIX" "$message" 2>/dev/null || true
    fi
}

_log() {
    local level="$1"
    local level_num="$2"
    local message="$3"
    local timestamp
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    if [[ $level_num -gt $CURRENT_LOG_LEVEL ]]; then
        return
    fi
    
    local formatted_msg="[$level] $message"
    
    if [[ "$NON_INTERACTIVE" == "true" ]]; then
        case "$level" in
            ERROR) log_to_journal "err" "$formatted_msg" ;;
            WARN)  log_to_journal "warning" "$formatted_msg" ;;
            INFO)  log_to_journal "info" "$formatted_msg" ;;
            DEBUG) log_to_journal "debug" "$formatted_msg" ;;
        esac
        if [[ $level_num -le $LOG_LEVEL_WARN ]]; then
            echo "$timestamp $LOG_PREFIX $formatted_msg" >&2
        fi
    else
        echo "$timestamp $LOG_PREFIX $formatted_msg"
    fi
}

log_error() { _log "ERROR" $LOG_LEVEL_ERROR "$*"; }
log_warn()  { _log "WARN"  $LOG_LEVEL_WARN  "$*"; }
log_info()  { _log "INFO"  $LOG_LEVEL_INFO  "$*"; }
log_debug() { _log "DEBUG" $LOG_LEVEL_DEBUG "$*"; }

log_info_dry() {
    if [[ "$DRY_RUN" == "true" ]]; then
        log_info "[DRY-RUN] $*"
    else
        log_info "$*"
    fi
}

# ============================================================================
# SEGÉDFÜGGVÉNYEK
# ============================================================================

cleanup() {
    for file in "$KEY_FILE" "$CURRENT_KEYS_FILE"; do
        if [[ -f "$file" ]]; then
            rm -f "$file"
            log_debug "Tisztítás: $file törölve"
        fi
    done
}
trap cleanup EXIT

show_help() {
    cat << EOF
Google GPG Key Updater - RPM rendszerekhez

HASZNÁLAT:
    $0 [OPCIÓK]

OPCIÓK:
    -n, --dry-run           Szimulált futtatás: nem végez módosításokat
    -l, --list-keys         Összes importált GPG kulcs listázása
    -g, --list-google       Csak a Google kulcsok listázása
    -v, --verbose           Részletes debug kimenet (felülírja a csendes módot)
    -f, --force             Kényszerített import (mindig letölt és importál)
    -h, --help              Ez a súgó megjelenítése

MŰKÖDÉS:
    * A script letölti az aktuális Google kulcsot
    * Összehasonlítja a rendszerben lévő Google kulcsokkal
    * CSAK AKKOR importál, ha a kulcs eltér a jelenlegitől
    * --force esetén mindig végrehajtja az importot

PÉLDÁK:
    # Normál futtatás (csak ha változott a kulcs)
    $0

    # Tesztelés módosítások nélkül
    $0 --dry-run --verbose

    # Kényszerített frissítés (mindig)
    $0 --force

    # Google kulcsok ellenőrzése
    $0 --list-google

CRON PÉLDA:
    0 3 * * 1 /usr/local/bin/google-gpg-key-updater.sh

EOF
}

check_internet() {
    log_debug "Internet kapcsolat ellenőrzése..."
    
    if command -v ping >/dev/null 2>&1; then
        if ping -c 1 -W 5 8.8.8.8 >/dev/null 2>&1; then
            log_debug "Ping sikeres: 8.8.8.8"
            return 0
        fi
    fi
    
    if command -v curl >/dev/null 2>&1; then
        if curl -s --connect-timeout 5 --max-time 10 https://www.google.com >/dev/null 2>&1; then
            log_debug "HTTP kapcsolat sikeres: google.com"
            return 0
        fi
    fi
    
    log_debug "Internet kapcsolat ellenőrzése sikertelen"
    return 1
}

download_key() {
    local attempt=1
    while [[ $attempt -le $MAX_RETRIES ]]; do
        log_info_dry "Letöltés kísérlet $attempt/$MAX_RETRIES: $KEY_URL"
        log_debug "Timeout: ${TIMEOUT_SECONDS}s, Fájl: $KEY_FILE"
        
        if [[ "$DRY_RUN" == "true" ]]; then
            log_info_dry "Letöltés szimulálva: $KEY_URL -> $KEY_FILE"
            touch "$KEY_FILE"
            echo "DRY_RUN_KEY_CONTENT" > "$KEY_FILE"
            return 0
        fi
        
        if wget --timeout="$TIMEOUT_SECONDS" --tries=1 --quiet --output-document="$KEY_FILE" "$KEY_URL" 2>/dev/null; then
            if [[ -s "$KEY_FILE" ]]; then
                local size
                size=$(wc -c < "$KEY_FILE")
                log_info "Sikeres letöltés: $KEY_FILE ($size bájt)"
                log_debug "Letöltött fájl ellenőrzése: OK"
                return 0
            fi
        fi
        
        log_warn "Kísérlet $attempt sikertelen, várakozás 2 másodperc..."
        log_debug "wget visszatérési kód: $?"
        sleep 2
        ((attempt++))
    done
    
    log_error "Nem sikerült letölteni a kulcsot $MAX_RETRIES kísérlet után"
    return 1
}

get_google_keys2() {
    log_debug "Google kulcsok keresése az RPM adatbázisban..."
    
    rpm -q gpg-pubkey --queryformat='%{NAME}-%{VERSION}-%{RELEASE}\n' 2>/dev/null | while read -r key; do
        local summary
        summary=$(rpm -q "$key" --queryformat='%{SUMMARY}\n' 2>/dev/null || true)
        if echo "$summary" | grep -qi 'google'; then
            log_debug "Talált Google kulcs: $key"
            echo "$key"
        fi
    done
}



# ============================================================================
# GOOGLE KULCS KEZELÉS - JAVÍTOTT VERZIÓ
# ============================================================================
# ============================================================================
# GOOGLE KULCS KEZELÉS - PIPEFAIL-KOMPATIBILIS VERZIÓ
# ============================================================================

get_google_keys() {
    local -a results=()
    local keyid summary

    while IFS='|' read -r keyid summary; do
        [[ -z "$keyid" ]] && continue
        if [[ "$summary" =~ [Gg]oogle ]]; then
            results+=("$keyid")
        fi
    done < <(rpm -q gpg-pubkey --queryformat='%{NAME}-%{VERSION}-%{RELEASE}|%{SUMMARY}\n' 2>/dev/null || true)

    printf '%s\n' "${results[@]}"
    return 0
}

# =============================================================================
# list_all_keys – az összes gpg-pubkey listázása (a kért függvény)
# =============================================================================
list_all_keys() {
    echo ""
    echo "=== Összes importált GPG kulcs az RPM adatbázisban ==="
    echo ""

    if ! rpm -q gpg-pubkey >/dev/null 2>&1; then
        echo "Nincs egyetlen gpg-pubkey sem importálva."
        return 0
    fi

    # Terminál szélesség lekérése
    read -r lines cols < <(stty size 2>/dev/null || echo "24 80")
    cols=${cols:-80}

    # Dinamikus oszlopszélességek
    id_width=38          # gpg-pubkey-XXXXXXXX-YYYYYYYY
    short_width=12       # rövid ID
    desc_width=$((cols - id_width - short_width - 8))
    (( desc_width < 40 )) && desc_width=40
    (( desc_width > 100 )) && desc_width=100

    # Fejléc
    printf "%-${id_width}s %-${short_width}s %-${desc_width}s\n" \
           "Kulcs ID" "Short ID" "Leírás / Packager"
    printf "%s\n" "$(printf '%.0s-' $(seq 1 $((cols-5))))"

    # Helyes query: NAME VERSION RELEASE SUMMARY|PACKAGER
    rpm -q gpg-pubkey --qf '%{NAME} %{VERSION} %{RELEASE} %{SUMMARY}|%{PACKAGER}\n' 2>/dev/null \
    | awk -v idw="$id_width" -v sw="$short_width" -v dw="$desc_width" '
        {
            # Mezők: $1=NAME, $2=VERSION, $3=RELEASE, $4-től SUMMARY-ig, majd | PACKAGER
            name     = $1
            version  = $2
            release  = $3
            short_id = tolower(version)

            # A maradék sor: SUMMARY|PACKAGER
            rest = substr($0, index($0,$4))

            # Split az utolsó | -nél
            n = split(rest, arr, "|")
            summary  = arr[1]
            packager = (n >= 2) ? arr[2] : ""

            # Teljes leírás
            full_desc = summary " (" packager ")"
            if (length(full_desc) > dw) {
                desc = substr(full_desc, 1, dw-3) "..."
            } else {
                desc = full_desc
            }

            # Kimenet
            printf "%-" idw "s %-" sw "s %-" dw "s\n", name "-" version "-" release, short_id, desc
        }'

    echo ""
    echo "Összesen: $(rpm -q gpg-pubkey | wc -l) db kulcs"
}



# Google kulcsok részletes listázása - pipefail-kompatibilis
list_google_keys() {
    echo "=== Google GPG kulcsok ==="
    echo ""
    
    # EGYSÉGES lekérdezés tömbbe gyűjtéssel
    local -a google_entries=()
    local keyid summary
    
    while IFS='|' read -r keyid summary; do
        [[ -z "$keyid" ]] && continue
        if [[ "$summary" =~ [Gg]oogle ]]; then
            google_entries+=("$keyid|$summary")
        fi
    done < <(rpm -q gpg-pubkey --queryformat='%{NAME}-%{VERSION}-%{RELEASE}|%{SUMMARY}\n' 2>/dev/null || true)
    
    if [[ ${#google_entries[@]} -eq 0 ]]; then
        echo "Nem található Google kulcs az RPM adatbázisban."
        log_warn "Nem található Google kulcs az RPM adatbázisban"
        return 0  # Nem hiba, csak nincs találat
    fi
    
    printf "%-40s | %s\n" "KULCS AZONOSÍTÓ" "LEÍRÁS"
    printf "%s\n" "$(printf '=%.0s' {1..80})"
    
    local count=0
    for entry in "${google_entries[@]}"; do
        IFS='|' read -r keyid summary <<< "$entry"
        printf "%-40s | %s\n" "$keyid" "$summary"
        ((count++)) || true  # pipefail miatt || true
    done
    
    echo ""
    echo "Talált Google kulcsok: $count db"
    log_info "Google kulcsok listázva: $count db"
    return 0
}

# Jelenlegi Google kulcsok exportálása - pipefail-kompatibilis
export_current_keys() {
    log_debug "Jelenlegi Google kulcsok exportálása (RAW armored formátumban)..."

    local -a google_keys=()
    local keyid summary

    while IFS='|' read -r keyid summary; do
        [[ -z "$keyid" ]] && continue
        if [[ "$summary" =~ [Gg]oogle ]]; then
            google_keys+=("$keyid")
        fi
    done < <(rpm -q gpg-pubkey --queryformat='%{NAME}-%{VERSION}-%{RELEASE}|%{SUMMARY}\n' 2>/dev/null || true)

    if [[ ${#google_keys[@]} -eq 0 ]]; then
        touch "$CURRENT_KEYS_FILE"
        log_debug "Nincs Google kulcs → üres fájl létrehozva"
        return 0
    fi

    log_debug "Google kulcsok (${#google_keys[@]} db) exportálása: ${google_keys[*]}"

    # RAW DESCRIPTION export
    rpm -q --qf '%{DESCRIPTION}\n' "${google_keys[@]}" 2>/dev/null > "$CURRENT_KEYS_FILE"

    # Erős tisztítás: 
    # - eltávolítjuk az RPM Version sort
    # - eltávolítjuk az összes üres sort (beleértve a dupla sortöréseket)
    # - normalizáljuk a sortöréseket Unix-stílusra
    sed -i '/^Version: rpm/d' "$CURRENT_KEYS_FILE"
    sed -i '/^$/d' "$CURRENT_KEYS_FILE"
    # Extra: trim trailing whitespace és normalizálás
    sed -i 's/[ \t]*$//' "$CURRENT_KEYS_FILE"   # trailing space/tab eltávolítás
    tr -d '\r' < "$CURRENT_KEYS_FILE" > "${CURRENT_KEYS_FILE}.tmp" && mv "${CURRENT_KEYS_FILE}.tmp" "$CURRENT_KEYS_FILE"

    local cleaned_size
    cleaned_size=$(wc -c < "$CURRENT_KEYS_FILE")
    log_debug "Tisztított jelenlegi kulcsok exportálva: $CURRENT_KEYS_FILE ($cleaned_size bájt)"

if [[ $CURRENT_LOG_LEVEL -ge $LOG_LEVEL_DEBUG ]]; then
    log_debug "Tisztított export első 10 sora:"
    head -10 "$CURRENT_KEYS_FILE" | while read -r line; do log_debug "  $line"; done
    log_debug "Letöltött pub első 10 sora:"
    head -10 "$KEY_FILE" | while read -r line; do log_debug "  $line"; done
fi

    return 0
}

compare_keys_old2() {
    log_info "Kulcsok összehasonlítása (beleértve az alulcsúcsokat is)..."

    if [[ ! -f "$KEY_FILE" ]]; then
        log_error "A kulcsfájl nem található: $KEY_FILE"
        return 2
    fi

    # 1. Kinyerjük az ÖSSZES érvényes (nem lejárt) Short ID-t a fájlból (pub és sub sorokból)
    # A --with-colons kimenet 5. mezője a teljes Fingerprint vagy Long ID
    local valid_ids
    valid_ids=$(gpg --with-colons --import-options show-only --import "$KEY_FILE" 2>/dev/null \
                | awk -F: '
                    /^pub:|^sub:/ { 
                        # Csak ha nincs "e" (expired) a 2. mezőben (validity)
                        if ($2 !~ /e/) { 
                            print substr($5, length($5)-7) 
                        } 
                    }' \
                | tr '[:upper:]' '[:lower:]' | sort -u)

    if [[ -z "$valid_ids" ]]; then
        log_error "Nem sikerült érvényes kulcsazonosítót kinyerni a fájlból: $KEY_FILE"
        return 2
    fi

    # 2. Lekérjük az összes jelenleg importált RPM kulcs verzióját (Short ID-t)
    local rpm_short_ids
    rpm_short_ids=$(rpm -q --qf "%{VERSION}\n" gpg-pubkey 2>/dev/null | tr '[:upper:]' '[:lower:]')

    log_debug "Keresett érvényes ID-k: $(echo $valid_ids | tr '\n' ' ')"

    # 3. Összehasonlítás: Megnézzük, hogy az ÖSSZES talált érvényes ID benne van-e az RPM-ben
    local missing_key=0
    for id in $valid_ids; do
        if ! echo "$rpm_short_ids" | grep -q "^${id}$"; then
            log_debug "Hiányzó kulcs azonosítva: $id"
            missing_key=1
            break
        fi
    done

    if [[ $missing_key -eq 0 ]]; then
        log_info "Minden érvényes Google kulcs (és alulcsúcs) szerepel az RPM adatbázisban."
        return 0  # Egyezik -> nincs szükség importra
    else
        log_info "Új vagy frissített kulcs szükséges az RPM adatbázisba."
        return 1  # Különbözik/Hiányzik -> kell importálni
    fi
}

compare_keys() {
    log_info "A legfrissebb Google aláíró kulcs ellenőrzése..."

    log_debug "1. Google kulcsok letöltése és elemzése..."
    # Letöltjük a kulcsot, és kikeressük az összes érvényes (nem 'expired') alulcsúcs ID-t
    # A GPG kimenetéből a 16 karakteres LONG ID-kat gyűjtjük ki
    MAP_KEYS=$(curl -s "$KEY_URL" | gpg --show-keys --keyid-format LONG 2>/dev/null | awk '
	/sub/ && !/expired/ { print toupper(substr($2, index($2, "/")+1)) }
        /pub/ && !/expired/ { print toupper(substr($2, index($2, "/")+1)) }
    ')

    if [ -z "$MAP_KEYS" ]; then
        echo "Hiba: Nem sikerült kinyerni érvényes kulcsazonosítót az URL-ről."
	exit 1
    fi

    log_debug "2. Összehasonlítás az RPM adatbázissal..."
    FOUND_ALL=false
    log_debug "A letöltött fájl legfrissebb kulcsa: $(echo $MAP_KEYS)"

    for KEY in $MAP_KEYS; do
        # Az RPM adatbázisban a gpg-pubkey név alatt szerepelnek a kulcsok. 
        # A verzió/release rész tartalmazza a Key ID végét kisbetűvel.
        SHORT_ID=$(echo "${KEY: -8}" | tr '[:upper:]' '[:lower:]' )

        if rpm -q "gpg-pubkey-$SHORT_ID" &>/dev/null; then
	    log_debug "[OK] A(z) $KEY kulcs már importálva van."
            #return 0
            FOUND_ALL=true
        #else
	#    echo "[HIÁNYZIK] A(z) $KEY kulcs nincs az RPM adatbázisban!"
        #    FOUND_ALL=false
        fi
    done

    if [ "$FOUND_ALL" = true ]; then
	log_info "Minden aktuális Google kulcs rendben van a rendszeren."
        return 0
    else
	log_warn "Van olyan érvényes kulcs, ami hiányzik. Futtasd az ellenőrzést!"
        return 1
    fi

}


import_key() {
    log_info_dry "Kulcs importálása RPM adatbázisba: $KEY_FILE"
    log_debug "Import parancs: rpm --import $KEY_FILE"
    
    if [[ "$DRY_RUN" == "true" ]]; then
        log_info_dry "rpm --import $KEY_FILE (nem végrehajtva)"
        return 0
    fi
    
    if rpm --import "$KEY_FILE" 2>/dev/null; then
        log_info "Kulcs importálva: $KEY_FILE"
        return 0
    else
        local exit_code=$?
        log_error "rpm --import sikertelen (kód: $exit_code)"
        return 1
    fi
}


verify_import() {
    log_info "Import ellenőrzése..."

    local google_keys
    google_keys=$(get_google_keys | tr '\n' ' ' | xargs)

    if [[ -z "$google_keys" ]]; then
        log_error "Nincs Google kulcs az RPM adatbázisban import után sem!"
        return 1
    fi

    log_debug "Talált Google kulcs(ok): $google_keys"

    local imported_size
    imported_size=$(rpm -q --qf '%{DESCRIPTION}\n' $google_keys 2>/dev/null | wc -c)

    local expected_size
    expected_size=$(wc -c < "$KEY_FILE")

    log_debug "Importált DESCRIPTION méret: $imported_size bájt | Várt méret: $expected_size bájt"

    if [[ $imported_size -ge $((expected_size - 1500)) && $imported_size -le $((expected_size + 1500)) ]]; then
        log_info "ELLENŐRZÉS: Google kulcs bent van és mérete ésszerűen egyezik → import sikeres"
        return 0
    else
        log_error "ELLENŐRZÉS: Importált kulcs mérete nem egyezik (várható ~$expected_size, van $imported_size)"
        log_debug "Javasolt: megnézni rpm -qi $google_keys | grep -A 30 'Description :'"
        #return 1
    fi
}

verify_import_fast() {
    log_info "Import ellenőrzése..."

    local google_keys=$(get_google_keys | tr '\n' ' ' | xargs)
    if [[ -z "$google_keys" ]]; then
        log_error "Nincs Google kulcs import után sem!"
        return 1
    fi

    log_info "ELLENŐRZÉS: Google kulcs bent van az RPM adatbázisban → sikeres"
    return 0
}


remove_old_google_keys() {
    log_info "Régi Google kulcsok keresése és eltávolítása..."

    local google_keys
    google_keys=$(get_google_keys | tr '\n' ' ' | xargs)

    if [[ -z "$google_keys" ]]; then
        log_info "Nem található régi Google kulcs az eltávolításhoz"
        return 0
    fi

    log_debug "Eltávolításra jelölt Google kulcsok: $google_keys"

    if [[ "$DRY_RUN" == "true" ]]; then
        log_info_dry "rpm -e $google_keys (nem végrehajtva)"
        return 0
    fi

    # Erőltetett törlés (blackPanther OS-on néha kell)
    if rpm -e --allmatches --nodeps $google_keys 2>/dev/null; then
        log_info "Régi Google kulcsok sikeresen eltávolítva"
        return 0
    else
        log_warn "rpm -e sikertelen, próbálkozás egyenként..."
        for key in $google_keys; do
            rpm -e --nodeps "$key" 2>/dev/null || true
        done
        return 0
    fi
}

# ============================================================================
# PARAMÉTER FELDOLGOZÁS
# ============================================================================
parse_args() {
    while [[ $# -gt 0 ]]; do
        case "$1" in
            -n|--dry-run)
                DRY_RUN=true
                shift
                ;;
            -l|--list-keys)
                MODE="list-keys"
                shift
                ;;
            -g|--list-google)
                MODE="list-google"
                shift
                ;;
            -v|--verbose)
                VERBOSE=true
                shift
                ;;
            -f|--force)
                FORCE_UPDATE=true
                shift
                ;;
            -h|--help)
                MODE="help"
                shift
                ;;
            -*)
                echo "Ismeretlen opció: $1" >&2
                echo "Használd a --help opciót a súgóhoz." >&2
                exit 1
                ;;
            *)
                shift
                ;;
        esac
    done
}

# ============================================================================
# FŐ LOGIKA
# ============================================================================
run_update() {
    log_info "=== Google GPG kulcs frissítés indítása ==="
    [[ "$DRY_RUN" == "true" ]] && log_info "[DRY-RUN MODE]"
    [[ "$FORCE_UPDATE" == "true" ]] && log_info "[FORCE MODE - mindig importál]"
    log_debug "Konfiguráció: MAX_RETRIES=$MAX_RETRIES, TIMEOUT=${TIMEOUT_SECONDS}s"
 
    # 1. Internet kapcsolat ellenőrzése
    if ! check_internet; then
        log_warn "Nincs internet kapcsolat, kihagyás."
        exit 0
    fi
    log_info "Internet kapcsolat elérhető"
 
    # 2. Kulcs letöltése retry logikával
    if ! download_key; then
        log_error "Kulcs letöltése sikertelen, kilépés"
        exit 1
    fi
 
    # 3. Kényszerített mód esetén ugornunk kell az összehasonlítást
    if [[ "$FORCE_UPDATE" == "true" ]]; then
        log_warn "Force mód: összehasonlítás kihagyása, importálás kötelező"
        local needs_import=1
    else
        # 4. Kulcsok összehasonlítása
        if compare_keys; then
            # Kulcsok egyeznek - nincs teendő
            log_info "=== Nincs változás, importálás NEM SZÜKSÉGES ==="
	    logger -t "$LOG_PREFIX" "Google Key Updater Finished..." 2>/dev/null || true
            exit 0
        else
            # Kulcsok különböznek - importálni kell
            local needs_import=1
        fi
    fi
 
    # 5. Kulcs importálása (csak ha szükséges)

    if [[ "${needs_import:-0}" -eq 1 || "$FORCE_UPDATE" == "true" ]]; then
        remove_old_google_keys

        if ! import_key; then
            log_error "Import sikertelen törlés után is"
            exit 1
        fi

        if verify_import; then
            log_info "=== Google GPG kulcs frissítés SIKERES ==="
            exit 0
        else
            log_error "Ellenőrzés bukott törlés + import után"
            exit 1
        fi
    fi
    

    if [[ "${xyz}" ]]; then
        if import_key && verify_import; then
            log_info "=== X Google GPG kulcs frissítés SIKERES ==="
            exit 0
        else
            if [[ ! $import_key ]]; then
                log_warn "Kulcs importálása sikertelen, próbálkozás régi kulcsok törlésével..."
            else
                log_warn "Import ellenőrzése sikertelen, próbálkozás régi kulcsok törlésével..."
            fi
            if remove_old_google_keys && import_key && verify_import; then
                log_info "Sikeres import régi Google kulcsok eltávolítása után"
                log_info "=== Google GPG kulcs frissítés SIKERES ==="
                exit 0
            else
                log_error "Import második kísérlet is sikertelen"
                exit 1
            fi
        fi
    fi


}


main() {
    parse_args "$@"
    
    if [[ "$VERBOSE" != "true" ]] && detect_non_interactive; then
        NON_INTERACTIVE=true
        log_debug "Nem-interaktív mód észlelve (cron/systemd)"
    fi
    
    init_logging
    log_debug "Naplózási szint beállítva: $CURRENT_LOG_LEVEL (VERBOSE=$VERBOSE, NON_INTERACTIVE=$NON_INTERACTIVE, FORCE=$FORCE_UPDATE)"
    
    case "$MODE" in
        help)
            show_help
            exit 0
            ;;
        list-keys)
            list_all_keys
            exit 0
            ;;
        list-google)
            list_google_keys
            exit 0
            ;;
        update)
            run_update
            ;;
    esac
}

main "$@"
